# AppSync SDL — foundational schema for an e-commerce API

type User {
  id: ID!           # Non-null — resolver guarantees this field is always present
  email: String!    # Non-null — client can depend on this being a string, never null
  name: String      # Nullable — may be absent (e.g., anonymous user with no display name)
  tier: UserTier!   # Enum — constrained to valid values
  orders: [Order!]  # List of non-null orders (list itself may be null — user may have no orders loaded)
  createdAt: AWSDateTime!  # AppSync custom scalar — ISO 8601 datetime, validated by AppSync
}

enum UserTier {
  FREE
  PRO
  ENTERPRISE
}

type Order {
  id: ID!
  userId: ID!
  status: OrderStatus!
  total: Float!
  items: [OrderItem!]!
  createdAt: AWSDateTime!
}

enum OrderStatus {
  PENDING
  CONFIRMED
  SHIPPED
  DELIVERED
  CANCELLED
}

type OrderItem {
  productId: ID!
  quantity: Int!
  unitPrice: Float!
}

type Query {
  getUser(id: ID!): User           # Nullable return — user may not exist
  listOrders(userId: ID!, status: OrderStatus, limit: Int): OrderConnection!
}

type Mutation {
  createOrder(input: CreateOrderInput!): Order!
  updateOrderStatus(orderId: ID!, status: OrderStatus!): Order!
  cancelOrder(orderId: ID!): Order!
}

type Subscription {
  onOrderStatusChanged(userId: ID!): Order
    @aws_subscribe(mutations: ["updateOrderStatus", "cancelOrder"])
}

input CreateOrderInput {
  userId: ID!
  items: [OrderItemInput!]!
}

input OrderItemInput {
  productId: ID!
  quantity: Int!
}

type OrderConnection {
  items: [Order!]!
  nextToken: String   # DynamoDB pagination cursor
}

// APPSYNC_JS resolver runtime constraints:
// ✅ Supported:
//   - ES2022 syntax (arrow functions, destructuring, optional chaining, nullish coalescing)
//   - @aws-appsync/utils package (DynamoDB helpers, HTTP helpers)
//   - Synchronous operations only
//
// ❌ NOT supported:
//   - fetch() or any network calls
//   - npm packages (only @aws-appsync/utils is available)
//   - async/await
//   - setTimeout / setInterval
//   - process, Buffer, fs, or any Node.js built-ins

import { util, runtime } from '@aws-appsync/utils'
// util: encoding, error throwing, type conversion
// runtime: early exit with runtime.earlyReturn()

// Resolver: Query.getUser → DynamoDB GetItem (no Lambda)
// File: resolvers/Query.getUser.js

import { util } from '@aws-appsync/utils'
import { get } from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
  // ctx.args: the GraphQL operation arguments ({ id: "user_42" })
  // ctx.identity: the caller's auth context (Cognito claims, IAM principal, etc.)
  return get({
    key: {
      PK: `USER#${ctx.args.id}`,
      SK: 'PROFILE',
    }
  })
  // The get() helper from @aws-appsync/utils/dynamodb generates the DynamoDB GetItem payload
}

export function response(ctx) {
  // ctx.result: the raw DynamoDB GetItem response
  // ctx.error: set if DynamoDB returned an error
  if (ctx.error) {
    util.error(ctx.error.message, ctx.error.type)
  }
  if (!ctx.result) {
    return null // User not found — returns null since getUser return type is nullable
  }
  // Map DynamoDB item → GraphQL User type
  return {
    id: ctx.result.PK.replace('USER#', ''),
    email: ctx.result.email,
    name: ctx.result.name ?? null,
    tier: ctx.result.tier,
    createdAt: ctx.result.createdAt,
  }
}

// Resolver: Mutation.createOrder → DynamoDB PutItem
// File: resolvers/Mutation.createOrder.js

import { util, runtime } from '@aws-appsync/utils'
import { put } from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
  const { input } = ctx.args
  const orderId = util.autoId() // Generates a UUID — available in @aws-appsync/utils

  // Validate input — util.error() throws and stops resolver execution
  if (!input.items || input.items.length === 0) {
    util.error('Order must contain at least one item', 'ValidationError')
  }

  const total = input.items.reduce(
    (sum, item) => sum + (item.quantity * item.unitPrice), 0
  )

  return put({
    key: {
      PK: `ORDER#${orderId}`,
      SK: 'METADATA',
    },
    item: {
      orderId,
      userId: input.userId,
      status: 'PENDING',
      total,
      items: input.items,
      createdAt: util.time.nowISO8601(),
    },
    condition: { expression: 'attribute_not_exists(PK)' } // Idempotency guard
  })
}

export function response(ctx) {
  if (ctx.error) util.error(ctx.error.message, ctx.error.type)
  return {
    id: ctx.result.orderId,
    userId: ctx.result.userId,
    status: ctx.result.status,
    total: ctx.result.total,
    items: ctx.result.items,
    createdAt: ctx.result.createdAt,
  }
}

// Lambda data source resolver (calls a Lambda function)
// APPSYNC_JS resolver that invokes Lambda:
export function request(ctx) {
  return {
    operation: 'Invoke',
    payload: {
      field: ctx.info.fieldName,
      arguments: ctx.args,
      identity: ctx.identity,
    }
  }
}

export function response(ctx) {
  if (ctx.error) util.error(ctx.error.message, ctx.error.type)
  return ctx.result
}

// The Lambda handler called by AppSync Lambda data source
export const handler = async (event: {
  field: string
  arguments: { input: { userId: string, items: any[] } }
  identity: { sub: string, claims: Record<string, string> }
}) => {
  // Full Node.js runtime — can call Stripe, send emails, query RDS, etc.
  const charge = await stripe.charges.create({
    amount: calculateTotal(event.arguments.input.items),
    currency: 'usd',
    customer: await getStripeCustomerId(event.arguments.input.userId),
  })
  return { chargeId: charge.id, status: charge.status }
}

// Resolver: Query.getWeather → HTTP data source (OpenWeatherMap API)
export function request(ctx) {
  return {
    method: 'GET',
    resourcePath: `/data/2.5/weather`,
    params: {
      query: {
        q: ctx.args.city,
        appid: ctx.stash.apiKey, // Injected via BeforeMapping in a pipeline resolver
        units: 'metric',
      },
      headers: { 'Content-Type': 'application/json' },
    }
  }
}

export function response(ctx) {
  if (ctx.error) util.error(ctx.error.message, ctx.error.type)
  const data = JSON.parse(ctx.result.body)
  return {
    city: data.name,
    temperature: data.main.temp,
    description: data.weather[0].description,
  }
}

// CDK: GraphQL API with Cognito + API Key dual auth
import { GraphqlApi, SchemaFile, AuthorizationType } from 'aws-cdk-lib/aws-appsync'
import { UserPool } from 'aws-cdk-lib/aws-cognito'

const api = new GraphqlApi(this, 'OrderApi', {
  name: 'order-api',
  schema: SchemaFile.fromAsset('schema.graphql'),
  authorizationConfig: {
    defaultAuthorization: {
      authorizationType: AuthorizationType.USER_POOL,
      userPoolConfig: { userPool },
    },
    additionalAuthorizationModes: [{
      authorizationType: AuthorizationType.API_KEY, // For public read operations
    }]
  },
})

// In a Cognito-authenticated resolver
export function request(ctx) {
  // ctx.identity is populated based on the auth mode:
  const userId = ctx.identity.sub          // Cognito user UUID
  const email = ctx.identity.claims.email
  const groups = ctx.identity.claims['cognito:groups'] // Array of Cognito group names

  // Authorization check: only allow users to fetch their own orders
  if (ctx.args.userId !== userId) {
    util.unauthorized()
  }
  return get({ key: { PK: `USER#${userId}`, SK: 'PROFILE' } })
}

// CDK: complete AppSync API with DynamoDB data source and unit resolver
import {
  GraphqlApi, SchemaFile, AuthorizationType,
  MappingTemplate, Code, FunctionRuntime,
  DynamoDbDataSource, AppsyncFunction, Resolver
} from 'aws-cdk-lib/aws-appsync'
import { Table } from 'aws-cdk-lib/aws-dynamodb'

const table = Table.fromTableName(this, 'OrderTable', 'Orders')
const api = new GraphqlApi(this, 'Api', {
  name: 'order-api',
  schema: SchemaFile.fromAsset('schema.graphql'),
  authorizationConfig: {
    defaultAuthorization: { authorizationType: AuthorizationType.USER_POOL, userPoolConfig: { userPool } }
  }
})

// Data source: DynamoDB (no Lambda in the path)
const dataSource = new DynamoDbDataSource(this, 'OrderDS', { api, table })

// Unit resolver using APPSYNC_JS runtime
new Resolver(this, 'GetUserResolver', {
  api,
  typeName: 'Query',
  fieldName: 'getUser',
  dataSource,
  runtime: FunctionRuntime.JS_1_0_0,
  code: Code.fromAsset('resolvers/Query.getUser.js'),
})