declapract-typescript-ehmpathy 0.49.12 → 0.49.14

package/dist/practices/node-service/bad-practices/adhoc-lambda-clients/.test/assets/demo-repo-with-adhoc-lambda-clients/src/data/clients/svcQuotes.ts

@@ -0,0 +1,10 @@
+import { askLambdaEndpoint, type AskLambdaEndpointContext } from 'sdk-aws-lambda';
+
+export const getQuote = (
+  event: { quoteUuid: string },
+  context: AskLambdaEndpointContext,
+): Promise<{ quote: { uuid: string } | null }> =>
+  askLambdaEndpoint(
+    { which: { service: 'svc-quotes', function: 'getQuote' }, event },
+    context,
+  );

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

@@ -0,0 +1,59 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`adhoc-lambda-clients (#532) given: [case1] a repo with two hand-written clients and one generated client when: [t0] the input, before any fix then: no client carries a review marker: svcJobs.ts — before 1`] = `
+"import { askLambdaEndpoint, type AskLambdaEndpointContext } from 'sdk-aws-lambda';
+
+export const getJob = (
+  event: { jobUuid: string },
+  context: AskLambdaEndpointContext,
+): Promise<{ job: { uuid: string } | null }> =>
+  askLambdaEndpoint(
+    { which: { service: 'svc-jobs', function: 'getJob' }, event },
+    context,
+  );
+"
+`;
+
+exports[`adhoc-lambda-clients (#532) given: [case1] a repo with two hand-written clients and one generated client when: [t0] the input, before any fix then: no client carries a review marker: svcQuotes.ts — before 1`] = `
+"import { askLambdaEndpoint, type AskLambdaEndpointContext } from 'sdk-aws-lambda';
+
+export const getQuote = (
+  event: { quoteUuid: string },
+  context: AskLambdaEndpointContext,
+): Promise<{ quote: { uuid: string } | null }> =>
+  askLambdaEndpoint(
+    { which: { service: 'svc-quotes', function: 'getQuote' }, event },
+    context,
+  );
+"
+`;
+
+exports[`adhoc-lambda-clients (#532) given: [case1] a repo with two hand-written clients and one generated client when: [t1] the node-service practice is applied then: each hand-written client names the codegen for its own peer: svcJobs.ts — after 1`] = `
+"// @declapract:review — a hand-written lambda client drifts from its peer's contract; generate it via \`npx sdk-aws-lambda gen --for svc-jobs --into src/access/svcs/ --env prep\`, move callers onto the generated sdk, then delete this file (declapract-typescript-ehmpathy#532)
+import { askLambdaEndpoint, type AskLambdaEndpointContext } from 'sdk-aws-lambda';
+
+export const getJob = (
+  event: { jobUuid: string },
+  context: AskLambdaEndpointContext,
+): Promise<{ job: { uuid: string } | null }> =>
+  askLambdaEndpoint(
+    { which: { service: 'svc-jobs', function: 'getJob' }, event },
+    context,
+  );
+"
+`;
+
+exports[`adhoc-lambda-clients (#532) given: [case1] a repo with two hand-written clients and one generated client when: [t1] the node-service practice is applied then: each hand-written client names the codegen for its own peer: svcQuotes.ts — after 1`] = `
+"// @declapract:review — a hand-written lambda client drifts from its peer's contract; generate it via \`npx sdk-aws-lambda gen --for svc-quotes --into src/access/svcs/ --env prep\`, move callers onto the generated sdk, then delete this file (declapract-typescript-ehmpathy#532)
+import { askLambdaEndpoint, type AskLambdaEndpointContext } from 'sdk-aws-lambda';
+
+export const getQuote = (
+  event: { quoteUuid: string },
+  context: AskLambdaEndpointContext,
+): Promise<{ quote: { uuid: string } | null }> =>
+  askLambdaEndpoint(
+    { which: { service: 'svc-quotes', function: 'getQuote' }, event },
+    context,
+  );
+"
+`;

package/dist/practices/node-service/bad-practices/adhoc-lambda-clients/src/access/sdks/svc<star>.ts.declapract.ts

@@ -0,0 +1,28 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import {
+  isAdhocLambdaClient,
+  withLambdaClientGenMarker,
+} from '../../../../../withLambdaClientGenMarker';
+
+/**
+ * .what = detect a hand-written lambda client under `src/access/sdks/svc*`
+ * .why  = the codegen emits a client that matches the peer's live contract (#532)
+ */
+export const check: FileCheckFunction = (contents) => {
+  if (contents && isAdhocLambdaClient({ contents })) return; // bad practice detected
+  throw new Error('not a hand-written lambda client');
+};
+
+/**
+ * .what = stamp a review marker that names the codegen command for this peer
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  if (!contents) return {};
+  return {
+    contents: withLambdaClientGenMarker({
+      contents,
+      relativeFilePath: context.relativeFilePath,
+    }),
+  };
+};

package/dist/practices/node-service/bad-practices/adhoc-lambda-clients/src/data/clients/svc<star>.ts.declapract.ts

@@ -0,0 +1,28 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import {
+  isAdhocLambdaClient,
+  withLambdaClientGenMarker,
+} from '../../../../../withLambdaClientGenMarker';
+
+/**
+ * .what = detect a hand-written lambda client under the legacy `src/data/clients/svc*` home
+ * .why  = the codegen emits a client that matches the peer's live contract (#532)
+ */
+export const check: FileCheckFunction = (contents) => {
+  if (contents && isAdhocLambdaClient({ contents })) return; // bad practice detected
+  throw new Error('not a hand-written lambda client');
+};
+
+/**
+ * .what = stamp a review marker that names the codegen command for this peer
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  if (!contents) return {};
+  return {
+    contents: withLambdaClientGenMarker({
+      contents,
+      relativeFilePath: context.relativeFilePath,
+    }),
+  };
+};

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.declapract.integration.test.ts

@@ -0,0 +1,123 @@
+import { existsSync } from 'node:fs';
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// executeApply evaluates the whole practice, so grant a generous limit
+jest.setTimeout(300_000);
+
+/**
+ * .what = end-to-end proof of the sdk-aws-lambda-pre-v07 migration, through the REAL declapract
+ *         apply pipeline against a genTempDir clone of a repo on sdk-aws-lambda 0.6.2
+ * .why  = the fix rewrites handler call forms (#646), drops a below-floor patch key from
+ *         package.json and pnpm-workspace.yaml, and deletes the patch file (#670). a unit test of `fix` never proves the
+ *         `src/**` glob, the `patches/sdk-aws-lambda@*.patch` glob, or the file deletion on disk.
+ */
+describe('sdk-aws-lambda-pre-v07 migration', () => {
+  given('[case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-sdk-aws-lambda-pre-v07',
+      clone:
+        './src/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.test/assets/demo-repo-on-sdk-aws-lambda-0.6',
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/node-service/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const handlerPath = 'src/contract/handlers/getWidget.ts';
+    const patchPath = 'patches/sdk-aws-lambda@0.6.2.patch';
+    const workspacePath = 'pnpm-workspace.yaml';
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const applyAll = async () => {
+      for (const file of [handlerPath, 'package.json', workspacePath, patchPath])
+        await executeApply({
+          config: path.join(tempDir, 'declapract.use.yml'),
+          practice: 'node-service',
+          file,
+        });
+    };
+
+    when('[t0] the input, before any fix', () => {
+      then('the handler, package.json, and patch hold the pre-0.7 shapes', async () => {
+        const handler = await read(handlerPath);
+        const packageJson = await read('package.json');
+        expect(handler).toMatch(/genLambdaEndpoint\(/);
+        expect(handler).toContain('({ event })');
+        expect(packageJson).toContain('"sdk-aws-lambda@0.6.2"');
+        expect(existsSync(path.join(tempDir, patchPath))).toBe(true);
+        expect(handler).toMatchSnapshot('getWidget.ts — before');
+        expect(packageJson).toMatchSnapshot('package.json — before');
+      });
+
+      then('the workspace file also keys the 0.6.2 patch', async () => {
+        const workspace = await read(workspacePath);
+        expect(workspace).toContain('sdk-aws-lambda@0.6.2:');
+        expect(workspace).toMatchSnapshot('pnpm-workspace.yaml — before');
+      });
+    });
+
+    when('[t1] the node-service practice is applied', () => {
+      useThen('apply each target file', async () => applyAll());
+
+      then('the handler moves to .forAsk with a payload input', async () => {
+        const handler = await read(handlerPath);
+        expect(handler).toContain('genLambdaEndpoint.forAsk(');
+        expect(handler).toContain(
+          'invoke: async ({ payload }) => ({ widgetId: payload.widgetId })',
+        );
+        expect(handler).not.toMatch(/genLambdaEndpoint\s*\(/);
+        expect(handler).toMatchSnapshot('getWidget.ts — after');
+      });
+
+      then('the floor lands at 0.7.2, and the stale patch key is gone', async () => {
+        const packageJson = await read('package.json');
+        const parsed = JSON.parse(packageJson);
+        expect(parsed.dependencies['sdk-aws-lambda']).toEqual('0.7.2');
+        expect(packageJson).not.toContain('sdk-aws-lambda@0.6.2');
+        expect(packageJson).not.toContain('@declapract{');
+        expect(packageJson).toMatchSnapshot('package.json — after');
+      });
+
+      then('the stale patch file is deleted', () => {
+        expect(existsSync(path.join(tempDir, patchPath))).toBe(false);
+      });
+
+      then('the workspace drops the stale key and keeps the rest, so no key names a deleted file', async () => {
+        const workspace = await read(workspacePath);
+        expect(workspace).not.toContain('sdk-aws-lambda@0.6.2');
+        expect(workspace).not.toContain('patchedDependencies:');
+        expect(workspace).toContain('onlyBuiltDependencies:');
+        expect(workspace).toContain('# pnpm 10 reads patchedDependencies');
+        expect(workspace).toMatchSnapshot('pnpm-workspace.yaml — after');
+      });
+    });
+
+    when('[t2] the practice is applied a second time (idempotency)', () => {
+      const passes = useThen('a second apply over its own output', async () => {
+        const before = {
+          handler: await read(handlerPath),
+          packageJson: await read('package.json'),
+          workspace: await read(workspacePath),
+        };
+        await applyAll();
+        const after = {
+          handler: await read(handlerPath),
+          packageJson: await read('package.json'),
+          workspace: await read(workspacePath),
+        };
+        return { before, after };
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.declapract.readme.md

@@ -0,0 +1,31 @@
+# sdk-aws-lambda-pre-v07
+
+## what
+
+moves a repo already on sdk-aws-lambda below 0.7 onto the `0.7.2` floor the node-service practice
+declares (#646, #670).
+
+## transforms
+
+| before 0.7 | 0.7.2 |
+|---|---|
+| `genLambdaEndpoint(…)` | `genLambdaEndpoint.forAsk(…)` |
+| `genLambdaEndpoint.for.apiGateway(…)` | `genLambdaEndpoint.forApiGateway(…)` |
+| `invoke: async ({ event }) => … event.x …` | `invoke: async ({ payload }) => … payload.x …` |
+| `pnpm.patchedDependencies["sdk-aws-lambda@0.7.0"]` or `["sdk-aws-lambda@0.7.1"]` + its patch file | deleted (the floor ships the fixes) |
+
+a shorthand property in the body keeps its key: `{ event }` becomes `{ event: payload }`.
+
+a patch at or above the floor is the consumer's own choice and stays.
+
+## what to expect on 0.7.2
+
+on sdk-aws-lambda >= 0.7.2, a cors-configured `forApiGateway` endpoint lists `x-trail-exid` in
+`Access-Control-Allow-Headers`. a test that pins the old list goes red; append `x-trail-exid`, or
+assert with `toContain`.
+
+## limitations
+
+an sqs handler built on `extractTaskParcelFromSqsEvent` gets a `@declapract:review` marker, never a
+rewrite: its move onto `genLambdaEndpoint.forSqs.perRecord` needs a `z.custom` task-parcel schema
+and a `batchSize: 1` event source, which is a design call.

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.test/assets/demo-repo-on-sdk-aws-lambda-0.6/declapract.use.yml

@@ -0,0 +1,4 @@
+# .note = the declarations dir is symlinked by the test (holds declapract.declare.yml + a
+#         practices/node-service symlink to the real practice).
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.test/assets/demo-repo-on-sdk-aws-lambda-0.6/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "sdk-aws-lambda": "0.6.2"
+  },
+  "pnpm": {
+    "patchedDependencies": {
+      "sdk-aws-lambda@0.6.2": "patches/sdk-aws-lambda@0.6.2.patch"
+    }
+  }
+}

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.test/assets/demo-repo-on-sdk-aws-lambda-0.6/patches/sdk-aws-lambda@0.6.2.patch

@@ -0,0 +1,6 @@
+diff --git a/dist/index.js b/dist/index.js
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -1 +1 @@
+-module.exports = {};
++module.exports = { patched: true };

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.test/assets/demo-repo-on-sdk-aws-lambda-0.6/pnpm-workspace.yaml

@@ -0,0 +1,5 @@
+# pnpm 10 reads patchedDependencies from here as well as from package.json
+onlyBuiltDependencies:
+  - esbuild
+patchedDependencies:
+  sdk-aws-lambda@0.6.2: patches/sdk-aws-lambda@0.6.2.patch

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/.test/assets/demo-repo-on-sdk-aws-lambda-0.6/src/contract/handlers/getWidget.ts

@@ -0,0 +1,16 @@
+import { genLambdaEndpoint } from 'sdk-aws-lambda';
+import { z } from 'zod';
+
+import { log } from '@src/utils/logger';
+
+// an ask handler on the pre-0.7 bare call, which reads its input as `event`
+export const handler = genLambdaEndpoint(
+  {
+    schema: {
+      input: z.object({ widgetId: z.string() }),
+      output: z.object({ widgetId: z.string() }),
+    },
+    invoke: async ({ event }) => ({ widgetId: event.widgetId }),
+  },
+  { log },
+);

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,85 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`sdk-aws-lambda-pre-v07 migration given: [case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch when: [t0] the input, before any fix then: the handler, package.json, and patch hold the pre-0.7 shapes: getWidget.ts — before 1`] = `
+"import { genLambdaEndpoint } from 'sdk-aws-lambda';
+import { z } from 'zod';
+
+import { log } from '@src/utils/logger';
+
+// an ask handler on the pre-0.7 bare call, which reads its input as \`event\`
+export const handler = genLambdaEndpoint(
+  {
+    schema: {
+      input: z.object({ widgetId: z.string() }),
+      output: z.object({ widgetId: z.string() }),
+    },
+    invoke: async ({ event }) => ({ widgetId: event.widgetId }),
+  },
+  { log },
+);
+"
+`;
+
+exports[`sdk-aws-lambda-pre-v07 migration given: [case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch when: [t0] the input, before any fix then: the handler, package.json, and patch hold the pre-0.7 shapes: package.json — before 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "sdk-aws-lambda": "0.6.2"
+  },
+  "pnpm": {
+    "patchedDependencies": {
+      "sdk-aws-lambda@0.6.2": "patches/sdk-aws-lambda@0.6.2.patch"
+    }
+  }
+}
+"
+`;
+
+exports[`sdk-aws-lambda-pre-v07 migration given: [case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch when: [t0] the input, before any fix then: the workspace file also keys the 0.6.2 patch: pnpm-workspace.yaml — before 1`] = `
+"# pnpm 10 reads patchedDependencies from here as well as from package.json
+onlyBuiltDependencies:
+  - esbuild
+patchedDependencies:
+  sdk-aws-lambda@0.6.2: patches/sdk-aws-lambda@0.6.2.patch
+"
+`;
+
+exports[`sdk-aws-lambda-pre-v07 migration given: [case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch when: [t1] the node-service practice is applied then: the floor lands at 0.7.2, and the stale patch key is gone: package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "sdk-aws-lambda": "0.7.2"
+  },
+  "private": true
+}
+"
+`;
+
+exports[`sdk-aws-lambda-pre-v07 migration given: [case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch when: [t1] the node-service practice is applied then: the handler moves to .forAsk with a payload input: getWidget.ts — after 1`] = `
+"import { genLambdaEndpoint } from 'sdk-aws-lambda';
+import { z } from 'zod';
+
+import { log } from '@src/utils/logger';
+
+// an ask handler on the pre-0.7 bare call, which reads its input as \`event\`
+export const handler = genLambdaEndpoint.forAsk(
+  {
+    schema: {
+      input: z.object({ widgetId: z.string() }),
+      output: z.object({ widgetId: z.string() }),
+    },
+    invoke: async ({ payload }) => ({ widgetId: payload.widgetId }),
+  },
+  { log },
+);
+"
+`;
+
+exports[`sdk-aws-lambda-pre-v07 migration given: [case1] a repo on sdk-aws-lambda 0.6.2, with a 0.6.2 patch when: [t1] the node-service practice is applied then: the workspace drops the stale key and keeps the rest, so no key names a deleted file: pnpm-workspace.yaml — after 1`] = `
+"# pnpm 10 reads patchedDependencies from here as well as from package.json
+onlyBuiltDependencies:
+  - esbuild
+"
+`;

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/package.json.declapract.ts

@@ -0,0 +1,84 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { asPackageJSON } from '../../../../utils/asPackageJSON';
+import { isVersionBelowFloor } from '../../../../utils/isVersionBelowFloor';
+
+const PRACTICE = 'node-service/sdk-aws-lambda-pre-v07';
+
+/**
+ * .what = the sdk-aws-lambda floor the node-service practice declares (#646)
+ * .why  = a patch keyed below the floor patches a release the repo no longer installs; pnpm then
+ *         refuses the install, since the patch names a version absent from the lockfile (#670)
+ */
+const SDK_AWS_LAMBDA_FLOOR = '0.7.2';
+
+/**
+ * .what = the `pnpm.patchedDependencies` keys that patch sdk-aws-lambda below the floor
+ * .why  = a patch at or above the floor is the consumer's own choice and stays untouched
+ */
+const getAllPatchKeysBelowFloor = (input: {
+  patchedDependencies: Record<string, string> | undefined;
+}): string[] =>
+  Object.keys(input.patchedDependencies ?? {}).filter((key) => {
+    const found = key.match(/^sdk-aws-lambda@(.+)$/);
+    if (!found) return false;
+    return isVersionBelowFloor({
+      version: found[1]!,
+      floor: SDK_AWS_LAMBDA_FLOOR,
+    });
+  });
+
+/**
+ * .what = detects a package.json that patches sdk-aws-lambda below the floor
+ * .why  = once the floor lands, that patch targets a version no longer installed (#670)
+ */
+export const check: FileCheckFunction = (contents) => {
+  if (!contents) throw new Error('does not match bad practice');
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  const keys = getAllPatchKeysBelowFloor({
+    patchedDependencies: packageJSON.pnpm?.patchedDependencies,
+  });
+  if (keys.length) return; // bad practice detected
+  throw new Error('does not match bad practice');
+};
+
+/**
+ * .what = drops each sdk-aws-lambda patch key below the floor, and an empty map left behind
+ * .why  = the patch file itself is deleted by the `patches/` declaration beside this one
+ * .note = an absent file is left absent: every fix must settle on absent input, a contract the
+ *         repo-wide fix-coverage sweep holds (`practiceFixCoverage`, #607)
+ */
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  const patchedDependencies: Record<string, string> | undefined =
+    packageJSON.pnpm?.patchedDependencies;
+  const keysBelow = getAllPatchKeysBelowFloor({ patchedDependencies });
+  if (!keysBelow.length) return { contents };
+
+  // the map without the stale keys
+  const patchedKept = Object.fromEntries(
+    Object.entries(patchedDependencies ?? {}).filter(
+      ([key]) => !keysBelow.includes(key),
+    ),
+  );
+
+  // an empty map is dropped, and so is an empty pnpm block
+  const pnpmKept = {
+    ...packageJSON.pnpm,
+    patchedDependencies: Object.keys(patchedKept).length
+      ? patchedKept
+      : undefined,
+  };
+  const pnpmHasKeys = Object.values(pnpmKept).some(
+    (value) => value !== undefined,
+  );
+
+  return {
+    contents: `${JSON.stringify(
+      { ...packageJSON, pnpm: pnpmHasKeys ? pnpmKept : undefined },
+      null,
+      2,
+    )}\n`,
+  };
+};

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

@@ -0,0 +1,30 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { isVersionBelowFloor } from '../../../../../utils/isVersionBelowFloor';
+
+/**
+ * .what = the version a `patches/sdk-aws-lambda@<version>.patch` file targets, from its path
+ * .why  = pnpm names a patch by the exact version it patches, so the path alone says which
+ */
+const asPatchVersion = (input: { relativeFilePath: string }): string | null =>
+  input.relativeFilePath.match(/sdk-aws-lambda@(.+)\.patch$/)?.[1] ?? null;
+
+/**
+ * .what = detects a sdk-aws-lambda patch below the node-service floor, 0.7.2 (#670)
+ * .why  = a patch below the floor backports fixes the floor ships; once the floor lands it names a
+ *         version the lockfile no longer holds, so pnpm refuses the install
+ */
+export const check: FileCheckFunction = (contents, context) => {
+  if (contents === null) throw new Error('does not match bad practice');
+  const version = asPatchVersion({
+    relativeFilePath: context.relativeFilePath,
+  });
+  if (version && isVersionBelowFloor({ version, floor: '0.7.2' })) return; // bad practice detected
+  throw new Error('does not match bad practice');
+};
+
+/**
+ * .what = deletes the stale patch file
+ * .why  = its `pnpm.patchedDependencies` key is dropped by the package.json declaration beside it
+ */
+export const fix: FileFixFunction = () => ({ contents: null });

package/dist/practices/node-service/bad-practices/sdk-aws-lambda-pre-v07/pnpm-workspace.yaml.declapract.ts

@@ -0,0 +1,61 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import { isMap, isScalar, parseDocument } from 'yaml';
+
+import { isVersionBelowFloor } from '../../../../utils/isVersionBelowFloor';
+
+/**
+ * .what = the sdk-aws-lambda floor the node-service practice declares (#646)
+ * .why  = matches the package.json declaration beside this one; both retire the same keys
+ */
+const SDK_AWS_LAMBDA_FLOOR = '0.7.2';
+
+/**
+ * .what = the `patchedDependencies` keys in a pnpm-workspace.yaml that patch sdk-aws-lambda below the floor
+ * .why  = pnpm 10 reads patchedDependencies from the workspace file as well as from package.json;
+ *         the `patches/` declaration deletes every below-floor patch file, so a key left here
+ *         names a file that is gone, and pnpm refuses the install (#670)
+ */
+const getAllPatchKeysBelowFloor = (input: { contents: string }): string[] => {
+  const patched = parseDocument(input.contents).get('patchedDependencies');
+  if (!isMap(patched)) return [];
+  return patched.items
+    .map((pair) => (isScalar(pair.key) ? String(pair.key.value) : null))
+    .filter((key): key is string => key !== null)
+    .filter((key) => {
+      const found = key.match(/^sdk-aws-lambda@(.+)$/);
+      if (!found) return false;
+      return isVersionBelowFloor({
+        version: found[1]!,
+        floor: SDK_AWS_LAMBDA_FLOOR,
+      });
+    });
+};
+
+/**
+ * .what = detects a pnpm-workspace.yaml that patches sdk-aws-lambda below the floor
+ */
+export const check: FileCheckFunction = (contents) => {
+  if (contents && getAllPatchKeysBelowFloor({ contents }).length) return; // bad practice detected
+  throw new Error('does not match bad practice');
+};
+
+/**
+ * .what = drops each below-floor sdk-aws-lambda patch key, and the map once it is empty
+ * .why  = edits the parsed document in place, so the repo's other keys and comments survive
+ */
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+  const keysBelow = getAllPatchKeysBelowFloor({ contents });
+  if (!keysBelow.length) return { contents };
+
+  // drop the stale keys
+  const document = parseDocument(contents);
+  keysBelow.forEach((key) => document.deleteIn(['patchedDependencies', key]));
+
+  // drop the map once no patch is left in it
+  const patched = document.get('patchedDependencies');
+  if (isMap(patched) && !patched.items.length)
+    document.delete('patchedDependencies');
+
+  return { contents: document.toString() };
+};