@reventlessdev/rescript-pulumi-aws 2.4.0-alpha.43

package/src/AppSync/AppSync_Resolver_Functions.res

@@ -0,0 +1,998 @@
+/** AppSync JS resolver code for the APPSYNC_JS runtime.
+
+    Each value is a Pulumi.Input.t<string> containing a complete ES module with
+    exported `request` and `response` functions, ready to be passed as the `code`
+    field of AppSync_Resolver.makeUnitJsResolver / makePipelineJsResolver.
+*/
+
+// ---------------------------------------------------------------------------
+// Shared response snippets (inlined into each resolver's template literal)
+// ---------------------------------------------------------------------------
+
+let resultResponseCode = `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}`
+
+let firstResultResponseCode = `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result.items[0] ?? null;
+}`
+
+let resultListResponseCode = `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result.items;
+}`
+
+let importUtil = `import { util } from '@aws-appsync/utils';`
+
+// ---------------------------------------------------------------------------
+// Pipeline resolver pass-through (no before/after processing)
+// ---------------------------------------------------------------------------
+
+/** Pipeline resolver code with no pre-processing and a standard error-check response. */
+let pipelinePassThrough =
+  `${importUtil}
+export function request(ctx) { return {}; }
+${resultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// Relay Node resolver — pipeline functions for node(id: ID!) query
+// ---------------------------------------------------------------------------
+
+/** Pipeline function (NONE datasource): decodes global ID and stashes typeName + localId. */
+let nodeDecodeGlobalId =
+  `${importUtil}
+export function request(ctx) {
+  const globalId = ctx.args.id;
+  try {
+    const decoded = util.base64Decode(globalId);
+    const colonIdx = decoded.indexOf(':');
+    if (colonIdx > 0) {
+      ctx.stash.typeName = decoded.substring(0, colonIdx);
+      ctx.stash.localId = decoded.substring(colonIdx + 1);
+    }
+  } catch (e) {
+    ctx.stash.typeName = null;
+    ctx.stash.localId = null;
+  }
+  return { payload: null };
+}
+export function response(ctx) {
+  return ctx.stash;
+}
+`->Pulumi.Input.make
+
+/** Pipeline function (DynamoDB datasource): fetches item if typeName matches, skips otherwise.
+    Generated per entity type at deploy time. */
+let nodeGetItemForType = (~typeName: string): Pulumi.Input.t<string> =>
+  `${importUtil}
+export function request(ctx) {
+  if (ctx.stash.typeName !== '${typeName}') return runtime.earlyReturn(ctx.prev.result);
+  return {
+    operation: 'GetItem',
+    key: { id: util.dynamodb.toDynamoDB(ctx.stash.localId) }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  if (!ctx.result) return null;
+  return { ...ctx.result, __typename: '${typeName}', id: ctx.args.id };
+}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// DynamoDB read — by primary key
+// ---------------------------------------------------------------------------
+
+let getItemById =
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'GetItem',
+    key: { id: util.dynamodb.toDynamoDB(ctx.args.id) }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+let queryById =
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Query',
+    query: {
+      expression: 'id = :id',
+      expressionValues: { ':id': util.dynamodb.toDynamoDB(ctx.args.id) }
+    }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+/** Query by partition key with sort-key conditions and Relay cursor pagination.
+    Reads from `args.filter` object: `prefix`, `from`, `to`, `eq`, `order` (ASC/DESC).
+    Relay pagination: `first`/`after` (forward) or `last`/`before` (backward).
+    Cursor is base64 of the sort key value.
+    Returns a Relay `{ edges, pageInfo }` shape reusing the entity's `Connection` type. */
+let queryItemsWithSortConditions = (sortField: string) =>
+  `${importUtil}
+const encodeCursor = (skValue) => util.base64Encode(skValue);
+const decodeCursor = (cursor) => util.base64Decode(cursor);
+export function request(ctx) {
+  const args = ctx.args;
+  const filter = args.filter ?? {};
+  const isBackward = args.last != null;
+  const expressionNames = { '#id': 'id' };
+  const expressionValues = { ':id': util.dynamodb.toDynamoDB(args.id) };
+  let skCondition;
+  if (filter.eq != null) {
+    expressionValues[':eq'] = util.dynamodb.toDynamoDB(filter.eq);
+    skCondition = '#sk = :eq';
+  } else if (filter.prefix != null) {
+    expressionValues[':prefix'] = util.dynamodb.toDynamoDB(filter.prefix);
+    skCondition = 'begins_with(#sk, :prefix)';
+  } else if (filter.from != null && filter.to != null) {
+    expressionValues[':from'] = util.dynamodb.toDynamoDB(filter.from);
+    expressionValues[':to'] = util.dynamodb.toDynamoDB(filter.to);
+    skCondition = '#sk BETWEEN :from AND :to';
+  } else if (filter.from != null) {
+    expressionValues[':from'] = util.dynamodb.toDynamoDB(filter.from);
+    skCondition = '#sk >= :from';
+  } else if (filter.to != null) {
+    expressionValues[':to'] = util.dynamodb.toDynamoDB(filter.to);
+    skCondition = '#sk <= :to';
+  }
+  if (isBackward && args.before != null) {
+    const beforeKey = decodeCursor(args.before);
+    expressionValues[':cursor'] = util.dynamodb.toDynamoDB(beforeKey);
+    const cursorCond = '#sk < :cursor';
+    skCondition = skCondition ? \`(\${skCondition}) AND \${cursorCond}\` : cursorCond;
+  } else if (!isBackward && args.after != null) {
+    const afterKey = decodeCursor(args.after);
+    expressionValues[':cursor'] = util.dynamodb.toDynamoDB(afterKey);
+    const cursorCond = '#sk > :cursor';
+    skCondition = skCondition ? \`(\${skCondition}) AND \${cursorCond}\` : cursorCond;
+  }
+  if (skCondition) expressionNames['#sk'] = '${sortField}';
+  const expression = skCondition ? \`#id = :id AND \${skCondition}\` : '#id = :id';
+  const orderDesc = filter.order === 'DESC';
+  const scanForward = isBackward ? orderDesc : !orderDesc;
+  const pageSize = isBackward ? (args.last ?? 50) : (args.first ?? 50);
+  return {
+    operation: 'Query',
+    query: { expression, expressionNames, expressionValues },
+    scanIndexForward: scanForward,
+    limit: pageSize + 1,
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  const args = ctx.args;
+  const filter = args.filter ?? {};
+  const isBackward = args.last != null;
+  const pageSize = isBackward ? (args.last ?? 50) : (args.first ?? 50);
+  let items = ctx.result.items ?? [];
+  const hasMore = items.length > pageSize;
+  if (hasMore) items = items.slice(0, pageSize);
+  if (isBackward) items = items.reverse();
+  const edges = items.map(item => ({ node: item, cursor: encodeCursor(item['${sortField}'] ?? '') }));
+  const startCursor = edges.length > 0 ? edges[0].cursor : null;
+  const endCursor = edges.length > 0 ? edges[edges.length - 1].cursor : null;
+  return {
+    edges,
+    pageInfo: {
+      hasNextPage: !isBackward && hasMore,
+      hasPreviousPage: isBackward && hasMore,
+      startCursor,
+      endCursor,
+    },
+  };
+}
+`->Pulumi.Input.make
+
+let queryByIdSort = (sortField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Query',
+    query: {
+      expression: 'id = :id AND #${sortField} = :${sortField}',
+      expressionNames: { '#${sortField}': '${sortField}' },
+      expressionValues: {
+        ':id': util.dynamodb.toDynamoDB(ctx.args.id),
+        ':${sortField}': util.dynamodb.toDynamoDB(ctx.args.${sortField})
+      }
+    }
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// DynamoDB read — by index
+// ---------------------------------------------------------------------------
+
+let queryByIndex = (index: string) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Query',
+    query: {
+      expression: '#${index} = :${index}',
+      expressionNames: { '#${index}': '${index}' },
+      expressionValues: { ':${index}': util.dynamodb.toDynamoDB(ctx.args.${index}) }
+    },
+    index: '${index}'
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+let queryByIndexDeletable = (index: string) =>
+  `${importUtil}
+export function request(ctx) {
+  const req = {
+    operation: 'Query',
+    query: {
+      expression: '#${index} = :${index}',
+      expressionNames: { '#${index}': '${index}' },
+      expressionValues: { ':${index}': util.dynamodb.toDynamoDB(ctx.args.${index}) }
+    },
+    index: '${index}'
+  };
+  if (ctx.args.hideDeleted) {
+    req.filter = {
+      expression: '#deleted = :false',
+      expressionNames: { '#deleted': 'deleted' },
+      expressionValues: { ':false': util.dynamodb.toBoolean(false) }
+    };
+  }
+  return req;
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+let queryByIndexSort = (~index: string, ~idField: string, ~sortField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  const query = ctx.args.${sortField}
+    ? {
+        expression: '#${idField} = :${idField} AND #${sortField} = :${sortField}',
+        expressionNames: { '#${idField}': '${idField}', '#${sortField}': '${sortField}' },
+        expressionValues: {
+          ':${idField}': util.dynamodb.toDynamoDB(ctx.args.${idField}),
+          ':${sortField}': util.dynamodb.toDynamoDB(ctx.args.${sortField})
+        }
+      }
+    : {
+        expression: '#${idField} = :${idField}',
+        expressionNames: { '#${idField}': '${idField}' },
+        expressionValues: { ':${idField}': util.dynamodb.toDynamoDB(ctx.args.${idField}) }
+      };
+  return { operation: 'Query', query, index: '${index}' };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+// AppSync JS runtime restrictions (APPSYNC_JS 1.0.0):
+//   - No `for` loops (for/for-of/for-in all fail validation)
+//   - No String() / .toString() — use '' + value instead
+//   - Object.keys().forEach() works for iteration
+let queryByIndexFiltered = (~index: string, ~idField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  const args = ctx.args;
+  const query = {
+    expression: '#${idField} = :${idField}',
+    expressionNames: { '#${idField}': '${idField}' },
+    expressionValues: { ':${idField}': util.dynamodb.toDynamoDB(args.${idField}) }
+  };
+  let expression = '';
+  const names = {};
+  const values = {};
+  Object.keys(args).forEach(key => {
+    const value = args[key];
+    if (key === '${idField}' || key === 'limit' || key === 'nextToken' || key === 'forward') return;
+    if (value == null || value === '') return;
+    if (expression) expression += ' AND';
+    if (key === 'hideDeleted') {
+      if (value === true) {
+        expression += ' #deleted = :false';
+        names['#deleted'] = 'deleted';
+        values[':false'] = false;
+      }
+    } else {
+      expression += ' contains(#' + key + ', :' + key + ')';
+      names['#' + key] = key;
+      values[':' + key] = '' + value;
+    }
+  });
+  const result = {
+    operation: 'Query',
+    query,
+    index: '${index}',
+    limit: (args.limit ?? 50),
+    nextToken: (args.nextToken ?? null),
+    scanIndexForward: (args.forward ?? true)
+  };
+  if (expression) {
+    result.filter = { expression, expressionNames: names, expressionValues: util.dynamodb.toMapValues(values) };
+  }
+  return result;
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+let queryByIndexSortFiltered = (~index: string, ~idField: string, ~sortField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  const args = ctx.args;
+  const query = args.${sortField}
+    ? {
+        expression: '#${idField} = :${idField} AND #${sortField} = :${sortField}',
+        expressionNames: { '#${idField}': '${idField}', '#${sortField}': '${sortField}' },
+        expressionValues: {
+          ':${idField}': util.dynamodb.toDynamoDB(args.${idField}),
+          ':${sortField}': util.dynamodb.toDynamoDB(args.${sortField})
+        }
+      }
+    : {
+        expression: '#${idField} = :${idField}',
+        expressionNames: { '#${idField}': '${idField}' },
+        expressionValues: { ':${idField}': util.dynamodb.toDynamoDB(args.${idField}) }
+      };
+  let expression = '';
+  const names = {};
+  const values = {};
+  Object.keys(args).forEach(key => {
+    const value = args[key];
+    if (key === '${idField}' || key === '${sortField}' || key === 'limit' || key === 'nextToken' || key === 'forward') return;
+    if (value == null || value === '') return;
+    if (expression) expression += ' AND';
+    if (key === 'hideDeleted') {
+      if (value === true) {
+        expression += ' #deleted = :false';
+        names['#deleted'] = 'deleted';
+        values[':false'] = false;
+      }
+    } else {
+      expression += ' contains(#' + key + ', :' + key + ')';
+      names['#' + key] = key;
+      values[':' + key] = '' + value;
+    }
+  });
+  const result = {
+    operation: 'Query',
+    query,
+    index: '${index}',
+    limit: (args.limit ?? 50),
+    nextToken: (args.nextToken ?? null),
+    scanIndexForward: (args.forward ?? true)
+  };
+  if (expression) {
+    result.filter = { expression, expressionNames: names, expressionValues: util.dynamodb.toMapValues(values) };
+  }
+  return result;
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// DynamoDB read — list all
+// ---------------------------------------------------------------------------
+
+let listAllItems =
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Scan',
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null)
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// DynamoDB read — list all (Relay Connection spec)
+// ---------------------------------------------------------------------------
+
+/**
+ * Scan with optional `filter` arg: `{search?, searchPrefix?, ids?, <field>Eq?, <field>From?, <field>To?}`
+ * and optional `orderBy: {field, direction}`.
+ *
+ * `search`       → `contains(labelField, :v)` — case-sensitive on DynamoDB. Callers that
+ *                  need case-insensitive matching should project a lowercased label column
+ *                  (future Phase 6.1 / external full-text search).
+ * `searchPrefix` → `begins_with(labelField, :v)` — case-sensitive. Scan-only here;
+ *                  Phase 6 `@searchable` provisions a GSI to promote this to a query.
+ * `ids`          → FilterExpression `#id IN (:id0, :id1, …)`. Simple scan-based
+ *                  path; BatchGetItem optimisation is deferred (open question 1).
+ * `<field>Eq`    → FilterExpression `#<field> = :<field>Eq`, one per `~filterFields` entry.
+ * `<field>From`  → FilterExpression `#<field> >= :<field>From`, one per `~rangeFields` entry.
+ * `<field>To`    → FilterExpression `#<field> <= :<field>To`, one per `~rangeFields` entry.
+ * `orderBy`      → JS-runtime sort over the returned page when `orderBy.field` is in
+ *                  `~sortFields`. **Per-page only**, not global — DynamoDB Scan returns
+ *                  items in indeterminate order and `ScanIndexForward` does not apply
+ *                  to Scan. Index-routed Query (v1.5) lifts this caveat for indexed
+ *                  sort fields; `@scanSort` on a non-indexed field is per-page even then.
+ *
+ * Empty-string and null filter values are treated as "no filter" — consistent with the
+ * in-memory adapter so clients don't need to conditionally omit keys.
+ */
+let listAllItemsConnection = (
+  ~labelField: string,
+  ~filterFields: array<string>=[],
+  ~rangeFields: array<string>=[],
+  ~sortFields: array<string>=[],
+) => {
+  let filterClauses =
+    filterFields
+    ->Array.map(f => `
+  if (filter.${f}Eq !== undefined && filter.${f}Eq !== null && filter.${f}Eq !== '') {
+    names['#${f}'] = '${f}';
+    values[':${f}Eq'] = util.dynamodb.toDynamoDB(filter.${f}Eq);
+    parts.push('#${f} = :${f}Eq');
+  }`)
+    ->Array.join("")
+  let rangeClauses =
+    rangeFields
+    ->Array.map(f => `
+  if (filter.${f}From !== undefined && filter.${f}From !== null && filter.${f}From !== '') {
+    names['#${f}'] = '${f}';
+    values[':${f}From'] = util.dynamodb.toDynamoDB(filter.${f}From);
+    parts.push('#${f} >= :${f}From');
+  }
+  if (filter.${f}To !== undefined && filter.${f}To !== null && filter.${f}To !== '') {
+    names['#${f}'] = '${f}';
+    values[':${f}To'] = util.dynamodb.toDynamoDB(filter.${f}To);
+    parts.push('#${f} <= :${f}To');
+  }`)
+    ->Array.join("")
+  let sortFieldsLiteral =
+    sortFields->Array.map(f => `'${f}'`)->Array.join(", ")
+  let sortBlock = if sortFields->Array.length == 0 {
+    ""
+  } else {
+    // APPSYNC_JS 1.0.0 forbids: Array.prototype.sort(comparator), arrow/function
+    // expressions passed to sort, for/while loops, recursion, and ++/--. So we
+    // can't run a comparator-driven sort and we can't write our own loop. Use a
+    // schwartzian transform: encode each item as `<sortKey>\x01<json>`, run the
+    // no-comparator default sort (lexicographic), reverse for DESC, and decode.
+    // Numeric fields get zero-padded so lex order matches numeric order for
+    // non-negative values (typical for IDs, counts, timestamps). Negatives sort
+    // lexicographically — acceptable since DynamoDB sort keys are rarely signed
+    // numbers. Nulls split out and append to the end regardless of direction.
+    `
+  // Per-page sort (Scan returns items in indeterminate order; ScanIndexForward
+  // does not apply to Scan). Global ordering across pages requires v1.5 index
+  // promotion; @scanSort is per-page even then.
+  const orderBy = ctx.args.orderBy;
+  const sortFields = [${sortFieldsLiteral}];
+  if (orderBy && orderBy.field && sortFields.indexOf(orderBy.field) >= 0) {
+    const field = orderBy.field;
+    const nulls = items.filter(it => it[field] === null || it[field] === undefined);
+    const nonNulls = items.filter(it => it[field] !== null && it[field] !== undefined);
+    const encoded = nonNulls.map(it => {
+      const v = it[field];
+      const key = (typeof v === 'number')
+        ? ('0000000000000000000000' + v).slice(-22)
+        : ('' + v);
+      return key + '\\x01' + JSON.stringify(it);
+    });
+    encoded.sort();
+    if (orderBy.direction === 'DESC') encoded.reverse();
+    items = encoded.map(e => JSON.parse(e.split('\\x01')[1])).concat(nulls);
+  }`
+  }
+  `${importUtil}
+export function request(ctx) {
+  const filter = ctx.args.filter ?? {};
+  const names = {};
+  const values = {};
+  const parts = [];
+  if (typeof filter.search === 'string' && filter.search.length > 0) {
+    names['#label'] = '${labelField}';
+    values[':search'] = util.dynamodb.toDynamoDB(filter.search);
+    parts.push('contains(#label, :search)');
+  }
+  if (typeof filter.searchPrefix === 'string' && filter.searchPrefix.length > 0) {
+    names['#label'] = '${labelField}';
+    values[':searchPrefix'] = util.dynamodb.toDynamoDB(filter.searchPrefix);
+    parts.push('begins_with(#label, :searchPrefix)');
+  }
+  if (Array.isArray(filter.ids) && filter.ids.length > 0) {
+    names['#id'] = 'id';
+    const placeholders = filter.ids.map((id, i) => {
+      const key = ':id' + i;
+      values[key] = util.dynamodb.toDynamoDB(id);
+      return key;
+    });
+    parts.push('#id IN (' + placeholders.join(', ') + ')');
+  }${filterClauses}${rangeClauses}
+  const req = {
+    operation: 'Scan',
+    limit: (ctx.args.first ?? 50),
+    nextToken: (ctx.args.after ?? null),
+  };
+  if (parts.length > 0) {
+    req.filter = {
+      expression: parts.join(' AND '),
+      expressionNames: names,
+      expressionValues: values,
+    };
+  }
+  return req;
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  let items = ctx.result?.items ?? [];${sortBlock}
+  const edges = items.map((item, i) => ({
+    node: item,
+    cursor: ctx.args.after ? ctx.args.after + '_' + i : '' + i,
+  }));
+  return {
+    edges,
+    pageInfo: {
+      hasNextPage: !!ctx.result?.nextToken,
+      hasPreviousPage: !!ctx.args.after,
+      startCursor: edges.length > 0 ? edges[0].cursor : null,
+      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null,
+    },
+  };
+}
+`->Pulumi.Input.make
+}
+
+// ---------------------------------------------------------------------------
+// DynamoDB nested resolvers — resolve linked item(s) by ID
+// ---------------------------------------------------------------------------
+
+let resolveId = (~sourceIdField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  if (!ctx.source.${sourceIdField}) return runtime.earlyReturn(null);
+  return {
+    operation: 'Query',
+    query: {
+      expression: '#id = :id',
+      expressionNames: { '#id': 'id' },
+      expressionValues: { ':id': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}) }
+    },
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null),
+    scanIndexForward: (ctx.args.forward ?? true)
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+let resolveIdSort = (~sourceIdField: string, ~sourceSortField: string, ~targetSortField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Query',
+    query: {
+      expression: '#id = :id AND #${targetSortField} = :${targetSortField}',
+      expressionNames: { '#id': 'id', '#${targetSortField}': '${targetSortField}' },
+      expressionValues: {
+        ':id': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}),
+        ':${targetSortField}': util.dynamodb.toDynamoDB(ctx.source.${sourceSortField})
+      }
+    },
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null),
+    scanIndexForward: (ctx.args.forward ?? true)
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+let resolveIdSortArgument = (
+  ~sourceIdField: string,
+  ~sourceSortArgument: string,
+  ~targetSortField: string,
+) =>
+  `${importUtil}
+export function request(ctx) {
+  const query = ctx.args.${sourceSortArgument}
+    ? {
+        expression: '#id = :id AND #${targetSortField} = :${targetSortField}',
+        expressionNames: { '#id': 'id', '#${targetSortField}': '${targetSortField}' },
+        expressionValues: {
+          ':id': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}),
+          ':${targetSortField}': util.dynamodb.toDynamoDB(ctx.args.${sourceSortArgument})
+        }
+      }
+    : {
+        expression: '#id = :id',
+        expressionNames: { '#id': 'id' },
+        expressionValues: { ':id': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}) }
+      };
+  return {
+    operation: 'Query',
+    query,
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null),
+    scanIndexForward: (ctx.args.forward ?? true)
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// DynamoDB nested resolvers — resolve by index
+// ---------------------------------------------------------------------------
+
+let resolveIdByIndex = (~index: string, ~sourceIdField: string, ~targetIdField: string) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Query',
+    query: {
+      expression: '#${targetIdField} = :${targetIdField}',
+      expressionNames: { '#${targetIdField}': '${targetIdField}' },
+      expressionValues: { ':${targetIdField}': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}) }
+    },
+    index: '${index}',
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null),
+    scanIndexForward: (ctx.args.forward ?? true)
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+let resolveIdByIndexSort = (
+  ~index: string,
+  ~sourceIdField: string,
+  ~sourceSortField: string,
+  ~targetIdField: string,
+  ~targetSortField: string,
+) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Query',
+    query: {
+      expression: '#${targetIdField} = :${targetIdField} AND #${targetSortField} = :${targetSortField}',
+      expressionNames: { '#${targetIdField}': '${targetIdField}', '#${targetSortField}': '${targetSortField}' },
+      expressionValues: {
+        ':${targetIdField}': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}),
+        ':${targetSortField}': util.dynamodb.toDynamoDB(ctx.source.${sourceSortField})
+      }
+    },
+    index: '${index}',
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null),
+    scanIndexForward: (ctx.args.forward ?? true)
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+let resolveIdByIndexSortArgument = (
+  ~index: string,
+  ~sourceIdField: string,
+  ~sourceSortArgument: string,
+  ~targetIdField: string,
+  ~targetSortField: string,
+) =>
+  `${importUtil}
+export function request(ctx) {
+  const query = ctx.args.${sourceSortArgument}
+    ? {
+        expression: '#${targetIdField} = :${targetIdField} AND #${targetSortField} = :${targetSortField}',
+        expressionNames: { '#${targetIdField}': '${targetIdField}', '#${targetSortField}': '${targetSortField}' },
+        expressionValues: {
+          ':${targetIdField}': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}),
+          ':${targetSortField}': util.dynamodb.toDynamoDB(ctx.args.${sourceSortArgument})
+        }
+      }
+    : {
+        expression: '#${targetIdField} = :${targetIdField}',
+        expressionNames: { '#${targetIdField}': '${targetIdField}' },
+        expressionValues: { ':${targetIdField}': util.dynamodb.toDynamoDB(ctx.source.${sourceIdField}) }
+      };
+  return {
+    operation: 'Query',
+    query,
+    index: '${index}',
+    limit: (ctx.args.limit ?? 50),
+    nextToken: (ctx.args.nextToken ?? null),
+    scanIndexForward: (ctx.args.forward ?? true)
+  };
+}
+${firstResultResponseCode}
+`->Pulumi.Input.make
+
+// resolveIds — returns a plain string (table name is interpolated by the adapter
+// via Pulumi.Output.apply)
+let resolveIds = (tableName: string, ~idsField: string, ~sortField: option<string>) => {
+  let keysCode = switch sortField {
+  | Some(sf) =>
+    `id => ({ id: util.dynamodb.toString(id.id), ${sf}: util.dynamodb.toString(id.${sf}) })`
+  | None => `id => ({ id: util.dynamodb.toString(id) })`
+  }
+  `${importUtil}
+import { runtime } from '@aws-appsync/utils';
+export function request(ctx) {
+  const idList = ctx.source.${idsField};
+  if (idList && idList.length > 0) {
+    return {
+      operation: 'BatchGetItem',
+      tables: {
+        '${tableName}': {
+          keys: idList.map(${keysCode}),
+          consistentRead: true
+        }
+      }
+    };
+  }
+  return { operation: 'GetItem', key: { id: util.dynamodb.toString(ctx.source.id) } };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`
+}
+
+/** Batched-by-ids — top-level Query resolver reading `ctx.args.ids: [String!]!`
+    and returning the matching items via a single BatchGetItem. Missing ids drop
+    out (BatchGetItem does not preserve cardinality); empty input short-circuits
+    to an empty result without hitting DDB. Table name is interpolated at deploy
+    time, since BatchGetItem's `tables` map keys on the literal table name.
+    Single-key tables only — composite-key BatchGetItem needs both pk + sk per
+    key entry, which this template doesn't construct. */
+let batchGetItemsByIds = (tableName: string) =>
+  `${importUtil}
+import { runtime } from '@aws-appsync/utils';
+export function request(ctx) {
+  const ids = ctx.args.ids ?? [];
+  if (ids.length === 0) return runtime.earlyReturn([]);
+  return {
+    operation: 'BatchGetItem',
+    tables: {
+      '${tableName}': {
+        keys: ids.map(id => ({ id: util.dynamodb.toDynamoDB(id) })),
+        consistentRead: true,
+      }
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  // BatchGetItem returns null in the result array for keys that don't exist
+  // in the table, preserving index correspondence with the input. The SDL
+  // returns this field as \`[T!]!\` (non-null element list), so any single
+  // missing id makes the entire field fail with "Cannot return null for
+  // non-nullable type" and the caller sees data=null. Filter the nulls so
+  // the field returns just the items that were found.
+  return (ctx.result?.data?.['${tableName}'] ?? []).filter(item => item !== null);
+}
+`
+
+// ---------------------------------------------------------------------------
+// DynamoDB write
+// ---------------------------------------------------------------------------
+
+let putItem =
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'PutItem',
+    key: { id: util.dynamodb.toDynamoDB(ctx.args.id) },
+    attributeValues: util.dynamodb.toMapValues(ctx.args)
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+let addItemToList = (~listName: string, ~itemName: string) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'UpdateItem',
+    key: { id: util.dynamodb.toDynamoDB(ctx.args.id) },
+    update: {
+      expression: 'SET #list = list_append(#list, :item)',
+      expressionNames: { '#list': '${listName}' },
+      expressionValues: { ':item': util.dynamodb.toList([util.dynamodb.toDynamoDB(ctx.args.${itemName})]) }
+    }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+let deleteItem =
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'DeleteItem',
+    key: { id: util.dynamodb.toString(ctx.args.id) }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// Lambda invocations
+// ---------------------------------------------------------------------------
+
+/** Invoke a CommandGenerator Lambda. `command` is the Aggregate command name. */
+let invokeCommandGenerator = (command: string) =>
+  `${importUtil}
+export function request(ctx) {
+  const id = ctx.identity;
+  const isCognito = id != null && id.sub != null;
+  return {
+    operation: 'Invoke',
+    payload: {
+      command: '${command}',
+      arguments: ctx.args,
+      meta: {
+        ip: id?.sourceIp ?? null,
+        user: id?.username ?? null,
+        info: ctx.info.parentTypeName + '.' + ctx.info.fieldName
+      },
+      identity: isCognito
+        ? {
+            userId: id.sub,
+            username: id.username,
+            groups: id.claims?.['cognito:groups'] ?? [],
+            claims: id.claims,
+            provider: 'Cognito'
+          }
+        : id != null
+          ? {
+              userArn: id.userArn ?? null,
+              accountId: id.accountId ?? null,
+              username: id.username ?? null,
+              provider: 'IAM'
+            }
+          : null
+    }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+/** Invoke a DCB Lambda. `tag` is the DCB entity tag. */
+let invokeDcbMutation = (tag: string) =>
+  `${importUtil}
+export function request(ctx) {
+  const id = ctx.identity;
+  const isCognito = id != null && id.sub != null;
+  return {
+    operation: 'Invoke',
+    payload: {
+      command: '${tag}',
+      arguments: ctx.args,
+      meta: {
+        ip: id?.sourceIp ?? null,
+        user: id?.username ?? null,
+        info: ctx.info.parentTypeName + '.' + ctx.info.fieldName
+      },
+      identity: isCognito
+        ? {
+            userId: id.sub,
+            username: id.username,
+            groups: id.claims?.['cognito:groups'] ?? [],
+            claims: id.claims,
+            provider: 'Cognito'
+          }
+        : id != null
+          ? {
+              userArn: id.userArn ?? null,
+              accountId: id.accountId ?? null,
+              username: id.username ?? null,
+              provider: 'IAM'
+            }
+          : null
+    }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+/** Invoke an InboundTranslation Lambda. `fieldName` is the mutation field. */
+let invokeInboundTranslation = (fieldName: string) =>
+  `${importUtil}
+export function request(ctx) {
+  return {
+    operation: 'Invoke',
+    payload: {
+      __inboundTranslation: true,
+      fieldName: '${fieldName}',
+      arguments: ctx.args
+    }
+  };
+}
+${resultResponseCode}
+`->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// Authorization (pipeline function fragments)
+// ---------------------------------------------------------------------------
+
+let uncapitalize = str =>
+  switch String.get(str, 0) {
+  | None => ""
+  | Some(first) => String.concat(first->String.toLowerCase, String.slice(str, ~start=1))
+  }
+
+/** Combined pipeline function: checks group membership, fetches the item, and
+    verifies the item's owner matches the requesting user.
+    Replaces the two separate VTL authorizeIndexedAccessRequest/Response templates,
+    which were the request and response halves of the same AppSync Function. */
+let authorizeIndexedAccess = (~index: string, ~group: string) => {
+  let authIdName = group->uncapitalize ++ "Id"
+  `${importUtil}
+import { runtime } from '@aws-appsync/utils';
+export function request(ctx) {
+  const groups = ctx.identity.claims?.['cognito:groups'] ?? [];
+  if (groups.includes('${group}')) {
+    return { operation: 'GetItem', key: { id: util.dynamodb.toDynamoDB(ctx.args.${index}) } };
+  }
+  return runtime.earlyReturn({ ${authIdName}: [ctx.identity.username] });
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  if (ctx.result.${authIdName} === ctx.identity.username) return ctx.result;
+  return util.unauthorized();
+}
+`->Pulumi.Input.make
+}
+
+/** @deprecated Use authorizeIndexedAccess — kept for naming continuity with VTL templates. */
+let authorizeIndexedAccessRequest = authorizeIndexedAccess
+
+/** @deprecated The response check is now part of authorizeIndexedAccess. */
+let authorizeIndexedAccessResponse = (~group as _: string) =>
+  resultResponseCode->Pulumi.Input.make
+
+// ---------------------------------------------------------------------------
+// Response-only helpers
+// (kept for adapter compatibility; these are now embedded in each resolver above)
+// ---------------------------------------------------------------------------
+
+let result = resultResponseCode->Pulumi.Input.make
+let firstResult = firstResultResponseCode->Pulumi.Input.make
+let resultList = resultListResponseCode->Pulumi.Input.make
+
+let resolveIdResult = (tableName: string, ~idField: string) =>
+  `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  if (ctx.source.${idField}) return ctx.result.data['${tableName}'][0] ?? null;
+  return null;
+}
+`->Pulumi.Input.make
+
+let resolveIdResults = (tableName: string, ~idField: string) =>
+  `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  if (ctx.source.${idField}) return ctx.result.data['${tableName}'] ?? null;
+  return null;
+}
+`
+
+let resolveIdsResult = (tableName: string, ~idsField: string) =>
+  `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  const idList = ctx.source.${idsField};
+  return (idList && idList.length > 0) ? ctx.result.data['${tableName}'] : [];
+}
+`
+
+let null = `
+export function response(ctx) { return null; }
+`->Pulumi.Input.make