declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/src/<star><star>/<star>.ts.declapract.ts

@@ -0,0 +1,202 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { getOneSourceScanEnd } from '../../../../../../utils/getOneSourceScanEnd';
+import { withReviewMarkerAbove } from '../../../../../../utils/withReviewMarkerAbove';
+
+/**
+ * .what = the review marker stamped above an sqs handler built on `extractTaskParcelFromSqsEvent`
+ * .why  = the move to `genLambdaEndpoint.forSqs.perRecord` needs a `z.custom` payload schema for
+ *         the task parcel and a `batchSize: 1` event source — a design call, never a regex. so the
+ *         fix flags it and leaves the body alone (#646).
+ */
+const SQS_REVIEW_MARKER =
+  '// @declapract:review — sdk-aws-lambda@0.7.1: move this sqs handler onto genLambdaEndpoint.forSqs.perRecord, with a z.custom task-parcel payload schema and a batchSize: 1 event source';
+
+/**
+ * .what = whether a file imports from sdk-aws-lambda
+ * .why  = every rewrite below targets the sdk's own call forms; a file that does not import the
+ *         sdk holds a same-named symbol of its own, which must stay untouched
+ */
+const isSdkAwsLambdaImported = (input: { contents: string }): boolean =>
+  /from\s+['"]sdk-aws-lambda['"]/.test(input.contents);
+
+/**
+ * .what = whether a file holds a call form that sdk-aws-lambda@0.7 removed
+ * .why  = 0.7 has no bare `genLambdaEndpoint(` (→ `.forAsk(`) and no `.for.apiGateway(`
+ *         (→ `.forApiGateway(`). the rewrite of `({ event })` is gated on these forms, so a
+ *         handler already on 0.7 is never touched
+ */
+const hasPreSevenCallForm = (input: { contents: string }): boolean =>
+  /\bgenLambdaEndpoint\s*\(/.test(input.contents) ||
+  /\bgenLambdaEndpoint\.for\.apiGateway\s*\(/.test(input.contents);
+
+/**
+ * .what = whether a file holds an sqs handler on `extractTaskParcelFromSqsEvent` with no marker
+ * .why  = the marker is the whole fix for that shape, so its presence is what retires the flag
+ */
+const hasUnmarkedSqsTaskParcel = (input: { contents: string }): boolean =>
+  /\bextractTaskParcelFromSqsEvent\s*\(/.test(input.contents) &&
+  /\bgenLambdaEndpoint\b/.test(input.contents) &&
+  !input.contents.includes(SQS_REVIEW_MARKER);
+
+/**
+ * .what = detects a source file still on the sdk-aws-lambda handler contract below 0.7
+ * .why  = the node-service floor is 0.7.1 (#646); a handler on a removed call form fails tsc
+ *         the moment the floor lands, so the practice must move it in the same apply
+ */
+export const check: FileCheckFunction = (contents) => {
+  if (!contents) throw new Error('does not match bad practice');
+  if (!isSdkAwsLambdaImported({ contents }))
+    throw new Error('does not match bad practice');
+  if (hasPreSevenCallForm({ contents })) return; // bad practice detected
+  if (hasUnmarkedSqsTaskParcel({ contents })) return; // bad practice detected
+  throw new Error('does not match bad practice');
+};
+
+/**
+ * .what = the invoke-input keys 0.7 renamed: the validated input, and the raw wire event
+ * .why  = pre-0.7 handed `{ event, rawEvent }`; 0.7 hands `{ headers, payload, event }`. so the
+ *         old `event` is now `payload`, and the old `rawEvent` is now `event`
+ */
+const INVOKE_KEYS_RENAMED: [string, string][] = [
+  ['event', 'payload'],
+  ['rawEvent', 'event'],
+];
+
+/**
+ * .what = rename one identifier within one arrow body
+ * .why  = a body read of a renamed key must follow its param. a property key (`event:`), a member
+ *         (`x.event`), or a string is left alone; a shorthand property (`{ event }`) keeps its key,
+ *         as `{ event: payload }`, so the object it builds keeps its shape
+ */
+const asBodyWithRename = (input: {
+  body: string;
+  from: string;
+  into: string;
+}): string =>
+  input.body
+    // a shorthand property keeps its key, so the object it builds keeps its shape
+    .replace(
+      new RegExp(`([{,]\\s*)${input.from}(\\s*[,}])`, 'g'),
+      (_match, before: string, after: string) =>
+        `${before}${input.from}: ${input.into}${after}`,
+    )
+    // every other identifier read of the old name
+    .replace(
+      new RegExp(`(?<![.\\w$'"\`])${input.from}(?![\\w$'"\`]|\\s*:)`, 'g'),
+      input.into,
+    );
+
+/**
+ * .what = the destructure list with each renamed key moved, plus the body renames it implies
+ * .why  = an aliased key (`event: input`) moves its key alone, since the body reads the alias;
+ *         a shorthand key moves its key and every body read of it
+ */
+const asInvokeKeysRenamed = (input: {
+  list: string;
+}): { list: string; bodyRenames: { from: string; into: string }[] } => {
+  const elements = input.list
+    .split(',')
+    .map((element) => element.trim())
+    .filter((element) => element.length > 0);
+  const moved = elements.map((element) => {
+    const key = element.match(/^[\w$]+/)?.[0] ?? '';
+    const into = INVOKE_KEYS_RENAMED.find(([from]) => from === key)?.[1];
+    if (!into) return { element, rename: null };
+    const isShorthand = !/^[\w$]+\s*:/.test(element);
+    return {
+      element: `${into}${element.slice(key.length)}`,
+      rename: isShorthand ? { from: key, into } : null,
+    };
+  });
+  return {
+    list: `{ ${moved.map(({ element }) => element).join(', ')} }`,
+    // in key order, never list order: `event` must move before `rawEvent` takes its name
+    bodyRenames: INVOKE_KEYS_RENAMED.flatMap(([from]) =>
+      moved.flatMap(({ rename }) => (rename?.from === from ? [rename] : [])),
+    ),
+  };
+};
+
+/**
+ * .what = rewrite each pre-0.7 `invoke: async ({ event, rawEvent? }) => …` onto 0.7's
+ *         `({ payload, event? })`, body included
+ * .why  = 0.7 renamed the invoke input; the param rename alone leaves every body read of `event`
+ *         on the raw wire event, which still exists, so the bug would be quiet (#640). a list
+ *         with `rawEvent` beside it must move too, or tsc fails on a key 0.7 never hands (#646)
+ * .note = idempotent: a list already on `payload` is skipped, so the loop ends once no pre-0.7
+ *         list remains, and a second fix over the output finds no param to rewrite. the renames
+ *         run in key order (`event` first), so the `event` that `rawEvent` becomes is never renamed
+ */
+const asInvokeWithPayload = (input: { contents: string }): string => {
+  const paramPattern =
+    /(invoke\s*:\s*(?:async\s*)?)\(\s*\{(?![^{}]*\bpayload\b)([^{}]*\bevent\b[^{}]*)\}/;
+  const found = paramPattern.exec(input.contents);
+  if (!found) return input.contents;
+
+  // locate the param list, the arrow, and the body that follows it
+  const paramsOpen = found.index + found[1]!.length;
+  const paramsClose = getOneSourceScanEnd({
+    contents: input.contents,
+    from: paramsOpen,
+    mode: 'close',
+  });
+  const arrowAt = input.contents.indexOf('=>', paramsClose);
+  if (arrowAt === -1) return input.contents; // not an arrow fn; leave it be
+  const bodyStart = arrowAt + 2;
+  const bodyEnd = getOneSourceScanEnd({
+    contents: input.contents,
+    from: bodyStart,
+    mode: 'expression',
+  });
+
+  // rebuild: params with each renamed key moved, body with each shorthand read renamed
+  const renamed = asInvokeKeysRenamed({ list: found[2]! });
+  const params = input.contents
+    .slice(paramsOpen, paramsClose + 1)
+    .replace(/\{[^{}]*\}/, renamed.list);
+  const body = renamed.bodyRenames.reduce(
+    (bodyNow, rename) => asBodyWithRename({ body: bodyNow, ...rename }),
+    input.contents.slice(bodyStart, bodyEnd),
+  );
+  const rewritten =
+    input.contents.slice(0, paramsOpen) +
+    params +
+    input.contents.slice(paramsClose + 1, bodyStart) +
+    body +
+    input.contents.slice(bodyEnd);
+  return asInvokeWithPayload({ contents: rewritten });
+};
+
+/**
+ * .what = moves a source file onto the sdk-aws-lambda@0.7.1 handler contract
+ * .why  = `genLambdaEndpoint(` → `.forAsk(`, `.for.apiGateway(` → `.forApiGateway(`, and the
+ *         invoke input `{ event }` → `{ payload }` (#646). an sqs handler on
+ *         `extractTaskParcelFromSqsEvent` is flagged, never rewritten.
+ */
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {};
+
+  // the call forms 0.7 removed, and the invoke input it renamed — only where a removed form sat
+  const callsMoved = hasPreSevenCallForm({ contents })
+    ? asInvokeWithPayload({
+        contents: contents
+          .replace(
+            /\bgenLambdaEndpoint\.for\.apiGateway(\s*\()/g,
+            'genLambdaEndpoint.forApiGateway$1',
+          )
+          .replace(/\bgenLambdaEndpoint(\s*\()/g, 'genLambdaEndpoint.forAsk$1'),
+      })
+    : contents;
+
+  // the sqs task-parcel shape gets a marker, since its move is a design call
+  const marked = /\bgenLambdaEndpoint\b/.test(callsMoved)
+    ? withReviewMarkerAbove({
+        contents: callsMoved,
+        lineMatcher: /\bextractTaskParcelFromSqsEvent\s*\(/,
+        marker: SQS_REVIEW_MARKER,
+      })
+    : callsMoved;
+
+  return { contents: marked };
+};

package/dist/practices/node-service/bad-practices/simple-lambda-client/.declapract.integration.test.ts

@@ -0,0 +1,99 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation), so grant a generous limit
+jest.setTimeout(180_000);
+
+/**
+ * .what = end-to-end proof of the simple-lambda-client migration, run through the REAL declapract
+ *   apply pipeline against a genTempDir clone of a consumer repo.
+ * .why = the src fix rewrites the import AND each `invokeLambdaFunction(…)` call onto
+ *   `sdkAwsLambdaAskAncient(…)` (#631) — a transform, so per rule.require.declapract-integration-tests
+ *   it owes a pipeline test. a unit test of the exported `fix` never exercises the `src/**\/*.ts`
+ *   glob -> file match, nor that the rewrite lands on disk.
+ * .note = the `stage` field in the demo input is the retired simple-lambda-client contract; the
+ *   fix exists to drop it, so the before-state must carry it.
+ */
+describe('simple-lambda-client migration', () => {
+  given('[case1] a repo whose domain operation calls invokeLambdaFunction', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-simple-lambda-client',
+      clone: './src/practices/node-service/bad-practices/simple-lambda-client/.test/assets/demo-repo-with-simple-lambda-client',
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/node-service/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const targetPath = 'src/domain.operations/getWidgetPrice.ts';
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const applyMigrate = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'node-service',
+        file: targetPath,
+      });
+
+    when('[t0] the migration input (before any fix)', () => {
+      then('the src file imports + calls invokeLambdaFunction + matches snapshot', async () => {
+        const before = await read(targetPath);
+        expect(before).toContain("from 'simple-lambda-client'");
+        expect(before).toContain('invokeLambdaFunction(');
+        expect(before).not.toContain('sdkAwsLambdaAskAncient');
+        expect(before).toMatchSnapshot('getWidgetPrice.ts — before');
+      });
+    });
+
+    when('[t1] the simple-lambda-client fix is applied', () => {
+      useThen('migrate the client import + call', async () => applyMigrate());
+
+      then(
+        'the import + call move onto sdkAwsLambdaAskAncient, and it matches snapshot',
+        async () => {
+          const after = await read(targetPath);
+
+          // the import moves onto the ancient ask helper, plus the logger it needs
+          expect(after).not.toContain("from 'simple-lambda-client'");
+          expect(after).toContain(
+            "import { sdkAwsLambdaAskAncient } from '@src/access/sdks/sdkAwsLambdaAskAncient';",
+          );
+          expect(after).toContain("import { log } from '@src/utils/logger';");
+
+          // the call binds address + payload together, and the retired field has no slot
+          expect(after).not.toContain('invokeLambdaFunction(');
+          expect(after).toContain(
+            "which: { service: 'svc-widgets', function: 'getWidgetPrice' },",
+          );
+          expect(after).toContain('event: { widgetUuid: input.widgetUuid },');
+          expect(after).toContain('{ log },');
+          expect(after).not.toContain('stage,\n');
+
+          // full content, for the reviewer's eye
+          expect(after).toMatchSnapshot('getWidgetPrice.ts — after');
+        },
+      );
+    });
+
+    when('[t2] the fix is applied a second time (idempotency)', () => {
+      // post-rewrite the file no longer imports simple-lambda-client, so the check no longer
+      // detects the bad practice — the second apply changes zero bytes (rule.require.idempotent-fixes)
+      const passes = useThen('a second apply over its own output', async () => {
+        const before = await read(targetPath); // post-first-migrate
+        await applyMigrate(); // second apply
+        const after = await read(targetPath);
+        return { before, after };
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

package/dist/practices/node-service/bad-practices/simple-lambda-client/.declapract.readme.md

@@ -15,17 +15,18 @@ sdk-aws-lambda provides modern lambda client patterns:
 
 | old | new |
 |-----|-----|
-| `import { invokeLambdaFunction } from 'simple-lambda-client'` | `import { askLambdaEndpoint } from 'sdk-aws-lambda'` |
-| `invokeLambdaFunction(...)` | `askLambdaEndpoint(...)` |
+| `import { invokeLambdaFunction } from 'simple-lambda-client'` | `import { sdkAwsLambdaAskAncient } from '@src/access/sdks/sdkAwsLambdaAskAncient'` |
+| `invokeLambdaFunction({ service, function, stage, event, cache })` | `sdkAwsLambdaAskAncient({ which: { service, function }, event }, { log, cache: { response: cache } })` |
 
-## limitations
+`sdkAwsLambdaAskAncient` (shipped by node-service) sends what simple-lambda-client sent: a flat
+event, to the peer's `-dev-` name below prod. it binds the ancient address and the ancient payload
+together, so neither can be set alone (#631). once a peer publishes contemp, swap the call for
+`askLambdaEndpoint` with `env.access: sdkAwsLambdaEnvAccessContemp()`.
 
-these patterns require manual migration:
+## limitations
 
-- `{ service, function, stage, event }` → `{ which: { service, function }, event }, context`
-- `stage: string` → `context.env.access: string`
-- `logDebug?: LogMethod` → `context.log: LogMethods` (required)
-- `cache?: SimpleCache<O>` → `context.cache?: { response?, dedupe? }`
+- a call whose argument is not an object literal is renamed only; tsc names the shape to fix
+- `logDebug` is dropped — the logger rides in the context
 
 ## example
 
@@ -41,15 +42,16 @@ const result = await invokeLambdaFunction({
 });
 ```
 
-after (requires manual refinement):
+after:
 ```ts
-import { askLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaAskAncient } from '@src/access/sdks/sdkAwsLambdaAskAncient';
+import { log } from '@src/utils/logger';
 
-const result = await askLambdaEndpoint(
+const result = await sdkAwsLambdaAskAncient(
   {
     which: { service: 'svc-users', function: 'getUser' },
     event: { userId: '123' },
   },
-  { log, env: { access: 'prod' } },
+  { log },
 );
 ```

package/dist/practices/node-service/bad-practices/simple-lambda-client/.test/assets/demo-repo-with-simple-lambda-client/declapract.use.yml

@@ -0,0 +1,5 @@
+# .note = the declarations dir is symlinked by the test (holds declapract.declare.yml + a
+#         practices/node-service symlink to the real practice), so the consumer's own src/ tree
+#         stays free to hold the target .ts file the src/**/*.ts glob matches.
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service

package/dist/practices/node-service/bad-practices/simple-lambda-client/.test/assets/demo-repo-with-simple-lambda-client/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "test-project",
+  "version": "1.0.0"
+}

package/dist/practices/node-service/bad-practices/simple-lambda-client/.test/assets/demo-repo-with-simple-lambda-client/src/domain.operations/getWidgetPrice.ts

@@ -0,0 +1,17 @@
+import { invokeLambdaFunction } from 'simple-lambda-client';
+
+import { stage } from '@src/utils/environment';
+
+/**
+ * .what = asks svc-widgets for the price of one widget
+ * .why = the demo input for the simple-lambda-client migration
+ */
+export const getWidgetPrice = async (input: { widgetUuid: string }) => {
+  const result = await invokeLambdaFunction({
+    service: 'svc-widgets',
+    function: 'getWidgetPrice',
+    stage,
+    event: { widgetUuid: input.widgetUuid },
+  });
+  return result;
+};

package/dist/practices/node-service/bad-practices/simple-lambda-client/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,45 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`simple-lambda-client migration given: [case1] a repo whose domain operation calls invokeLambdaFunction when: [t0] the migration input (before any fix) then: the src file imports + calls invokeLambdaFunction + matches snapshot: getWidgetPrice.ts — before 1`] = `
+"import { invokeLambdaFunction } from 'simple-lambda-client';
+
+import { stage } from '@src/utils/environment';
+
+/**
+ * .what = asks svc-widgets for the price of one widget
+ * .why = the demo input for the simple-lambda-client migration
+ */
+export const getWidgetPrice = async (input: { widgetUuid: string }) => {
+  const result = await invokeLambdaFunction({
+    service: 'svc-widgets',
+    function: 'getWidgetPrice',
+    stage,
+    event: { widgetUuid: input.widgetUuid },
+  });
+  return result;
+};
+"
+`;
+
+exports[`simple-lambda-client migration given: [case1] a repo whose domain operation calls invokeLambdaFunction when: [t1] the simple-lambda-client fix is applied then: the import + call move onto sdkAwsLambdaAskAncient, and it matches snapshot: getWidgetPrice.ts — after 1`] = `
+"import { sdkAwsLambdaAskAncient } from '@src/access/sdks/sdkAwsLambdaAskAncient';
+import { log } from '@src/utils/logger';
+
+import { stage } from '@src/utils/environment';
+
+/**
+ * .what = asks svc-widgets for the price of one widget
+ * .why = the demo input for the simple-lambda-client migration
+ */
+export const getWidgetPrice = async (input: { widgetUuid: string }) => {
+  const result = await sdkAwsLambdaAskAncient(
+    {
+      which: { service: 'svc-widgets', function: 'getWidgetPrice' },
+      event: { widgetUuid: input.widgetUuid },
+    },
+    { log },
+  );
+  return result;
+};
+"
+`;

package/dist/practices/node-service/bad-practices/simple-lambda-client/package.json.declapract.ts

@@ -16,8 +16,7 @@ export const fix: FileFixFunction = (contents) => {
     dependencies: {
       ...packageJSON.dependencies,
       'simple-lambda-client': undefined,
-      'sdk-aws-lambda':
-        packageJSON.dependencies?.['sdk-aws-lambda'] ?? '^0.1.0',
+      'sdk-aws-lambda': packageJSON.dependencies?.['sdk-aws-lambda'] ?? '0.7.2', // the node-service floor (#646), pinned
     },
   };
 

package/dist/practices/node-service/bad-practices/simple-lambda-client/src/<star><star>/<star>.ts.declapract.ts

@@ -1,5 +1,8 @@
 import type { FileCheckFunction, FileFixFunction } from 'declapract';
 
+import { asObjectLiteralProps } from '../../../../../../utils/asObjectLiteralProps';
+import { withEachCallRewritten } from '../../../../../../utils/withEachCallRewritten';
+
 /**
  * .what = detects simple-lambda-client imports in source files
  * .why = simple-lambda-client should be replaced with sdk-aws-lambda
@@ -14,31 +17,82 @@ export const check: FileCheckFunction = (contents) => {
 };
 
 /**
- * .what = transforms simple-lambda-client imports to sdk-aws-lambda
+ * .what = `invokeLambdaFunction({ service, function, stage, event, cache? })` →
+ *         `sdkAwsLambdaAskAncient({ which: { service, function }, event }, { log, cache? })`
+ * .why  = a simple-lambda-client caller sends a flat event to the peer's `-dev-` name below prod —
+ *         the ancient address and the ancient payload together. `sdkAwsLambdaAskAncient` binds
+ *         both, so the move keeps the wire identical (#631). `stage` and `logDebug` have no slot:
+ *         the slug comes from the env helper, the logger from the context.
+ */
+const asAskAncientCall = (input: { argsText: string }): string => {
+  // a non-literal argument cannot be read field by field; rename the callee alone, so tsc names it
+  const objectText = input.argsText.trim();
+  if (!objectText.startsWith('{') || !objectText.endsWith('}'))
+    return `sdkAwsLambdaAskAncient(${input.argsText})`;
+
+  // the props, each read by key; a shorthand prop reads its own name
+  const props = asObjectLiteralProps({ body: objectText.slice(1, -1) });
+  const valueAt = (key: string): string | null => {
+    const prop = props.find((each) => each.key === key);
+    if (!prop) return null;
+    return prop.value ?? key;
+  };
+  const asShifted = (text: string) => text.replace(/\n/g, '\n  ');
+  const cache = valueAt('cache');
+
+  return [
+    'sdkAwsLambdaAskAncient(',
+    '  {',
+    `    which: { service: ${valueAt('service')}, function: ${valueAt('function')} },`,
+    `    event: ${asShifted(valueAt('event') ?? 'undefined')},`,
+    '  },',
+    cache ? `  { log, cache: { response: ${cache} } },` : '  { log },',
+    ')',
+  ].join('\n');
+};
+
+/**
+ * .what = transforms simple-lambda-client usage to sdk-aws-lambda
  * .why = automated migration reduces manual toil
  *
- * .note = basic transforms only; complex patterns require manual fix
- *
- * API map:
- * - invokeLambdaFunction → askLambdaEndpoint
+ * API map (#631):
+ * - invokeLambdaFunction(…) → sdkAwsLambdaAskAncient(…), from the node-service helper
+ * - every other imported name → the same name, from sdk-aws-lambda
  */
 export const fix: FileFixFunction = (contents) => {
   if (!contents) return {};
 
-  const updated = contents
-    // transform imports
-    .replace(
-      /import\s+\{([^}]*)\}\s+from\s+['"]simple-lambda-client['"]/g,
-      (match, imports) => {
-        const updatedImports = imports.replace(
-          /invokeLambdaFunction/g,
-          'askLambdaEndpoint',
-        );
-        return `import {${updatedImports}} from 'sdk-aws-lambda'`;
-      },
-    )
-    // transform function calls
-    .replace(/invokeLambdaFunction/g, 'askLambdaEndpoint');
+  // the import: invokeLambdaFunction moves to the helper; any other name to sdk-aws-lambda
+  const imported = contents.replace(
+    /import\s*\{([^}]*)\}\s*from\s*['"]simple-lambda-client['"];?/g,
+    (_match, clause: string) => {
+      const names = clause
+        .split(',')
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0);
+      const rest = names.filter((name) => name !== 'invokeLambdaFunction');
+      const usesInvoke = names.length !== rest.length;
+      const hasLog = /import\s*\{[^}]*\blog\b[^}]*\}\s*from/.test(contents);
+      return [
+        ...(rest.length
+          ? [`import { ${rest.join(', ')} } from 'sdk-aws-lambda';`]
+          : []),
+        ...(usesInvoke
+          ? [
+              "import { sdkAwsLambdaAskAncient } from '@src/access/sdks/sdkAwsLambdaAskAncient';",
+              ...(hasLog ? [] : ["import { log } from '@src/utils/logger';"]),
+            ]
+          : []),
+      ].join('\n');
+    },
+  );
+
+  // each call, onto the ancient ask helper
+  const updated = withEachCallRewritten({
+    contents: imported,
+    callee: 'invokeLambdaFunction',
+    rewrite: asAskAncientCall,
+  });
 
   return { contents: updated };
 };

package/dist/practices/node-service/bad-practices/simple-lambda-handlers/.declapract.integration.test.ts

@@ -20,7 +20,7 @@ jest.setTimeout(180_000);
  * .note = the target file is snapshotted in full (before AND after), so a reviewer can eyeball the
  *   exact end-state, per rule.require.declapract-integration-tests.
  * .teeth = the input imports + CALLS `createApiGatewayHandler`. the after-state proves the import is
- *   rewritten to `sdk-aws-lambda`, the call is rewritten to `genLambdaEndpoint.for.apiGateway`, and
+ *   rewritten to `sdk-aws-lambda`, the call is rewritten to `genLambdaEndpoint.forApiGateway`, and
  *   the @declapract:review marker lands on disk — the glue a mocked-context unit test cannot show.
  */
 describe('simple-lambda-handlers migration', () => {
@@ -69,14 +69,17 @@ describe('simple-lambda-handlers migration', () => {
           expect(after).toContain("from 'sdk-aws-lambda'");
           expect(after).not.toContain("from 'simple-lambda-handlers'");
 
-          // the api-gateway factory call is rewritten to its sdk equivalent
-          expect(after).toContain('genLambdaEndpoint.for.apiGateway(');
+          // the api-gateway factory call is rewritten to its sdk@0.7.1 equivalent (#646)
+          expect(after).toContain('genLambdaEndpoint.forApiGateway(');
+          expect(after).not.toContain('.for.apiGateway(');
           expect(after).not.toContain('createApiGatewayHandler(');
 
           // the value-rewrite marker lands on disk — the un-rewritable schema+invoke contract
-          // is loud, so a consumer cannot ship a handler that answers 400 to every request
+          // is loud, so a consumer cannot ship a handler that answers 400 to every request.
+          // it teaches the 0.7.1 shape, never the retired `rawEvent` (#640)
           expect(after).toContain('@declapract:review');
-          expect(after).toContain('rawEvent');
+          expect(after).toContain('{ headers, payload, event }');
+          expect(after).not.toContain('rawEvent');
 
           // full content, for the reviewer's eye
           expect(after).toMatchSnapshot('getWidget.ts — after');