declapract-typescript-ehmpathy 0.49.11 → 0.49.13

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

@@ -0,0 +1,103 @@
+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-handlers migration, run through the REAL declapract
+ *   apply pipeline against a genTempDir clone of a consumer repo. per
+ *   rule.require.declapract-integration-tests, a fix that TRANSFORMS a file (regex rewrite + a
+ *   value-rewrite @declapract:review marker) owes a pipeline test — a unit test of the exported
+ *   `fix` never exercises the source-file glob -> file match, nor that the marker lands on disk.
+ * .why = the fix rewrites the `simple-lambda-handlers` import to `sdk-aws-lambda` and prepends a
+ *   loud @declapract:review marker, because the schema+invoke CONTRACT differs between the two
+ *   frameworks and a rename-only migration answers 400 to every request yet typechecks (#594). the
+ *   marker names the two manual edits rather than let a regex guess the contract.
+ * .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
+ *   the @declapract:review marker lands on disk — the glue a mocked-context unit test cannot show.
+ */
+describe('simple-lambda-handlers migration', () => {
+  given('[case1] a repo with a simple-lambda-handlers api-gateway handler', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-simple-lambda-handlers',
+      clone: './src/practices/node-service/bad-practices/simple-lambda-handlers/.test/assets/demo-repo-with-simple-lambda-handlers',
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/node-service/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const targetPath = 'src/contract/handlers/getWidget.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 the simple-lambda-handlers factory + matches snapshot', async () => {
+        const before = await read(targetPath);
+        expect(before).toContain("from 'simple-lambda-handlers'");
+        expect(before).toContain('createApiGatewayHandler(');
+        expect(before).not.toContain('@declapract:review');
+        expect(before).toMatchSnapshot('getWidget.ts — before');
+      });
+    });
+
+    when('[t1] the simple-lambda-handlers fix is applied', () => {
+      useThen('migrate the handler import + call', async () => applyMigrate());
+
+      then(
+        'the import + call are rewritten to sdk-aws-lambda, the review marker lands, and it matches snapshot',
+        async () => {
+          const after = await read(targetPath);
+
+          // the import is rewritten to the sdk
+          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(');
+          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
+          expect(after).toContain('@declapract:review');
+          expect(after).toContain('rawEvent');
+
+          // full content, for the reviewer's eye
+          expect(after).toMatchSnapshot('getWidget.ts — after');
+        },
+      );
+    });
+
+    when('[t2] the fix is applied a second time (idempotency)', () => {
+      // post-rewrite the file imports from sdk-aws-lambda, so the check no longer detects the bad
+      // practice and the fix does not run — the second apply changes zero bytes, and the marker is
+      // never double-prepended (per 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-handlers/.declapract.readme.md

@@ -28,6 +28,14 @@ these patterns require manual migration:
 - `logic: (event) => O` → `invoke: ({ event }, { log }) => O`
 - `log` passed at creation → `log` also received in invoke context
 
+the contract differs in a way a regex cannot get right: the prior framework's schema described the
+WHOLE event, while sdk-aws-lambda's input schema describes the request BODY (the handler then reads
+headers off a separate `rawEvent`). a rename-only rewrite answers 400 to every request yet
+typechecks. so a handler CALL now carries a `@declapract:review` marker that names the two manual
+edits (unwrap the `body` key into the input schema; thread headers via `rawEvent.headers`). the
+codemod does NOT guess the contract — it flags it loud, and the consumer deletes the marker once the
+call is restructured (#594).
+
 ## example
 
 before:

package/dist/practices/node-service/bad-practices/simple-lambda-handlers/.test/assets/demo-repo-with-simple-lambda-handlers/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-handlers/.test/assets/demo-repo-with-simple-lambda-handlers/package.json

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

package/dist/practices/node-service/bad-practices/simple-lambda-handlers/.test/assets/demo-repo-with-simple-lambda-handlers/src/contract/handlers/getWidget.ts

@@ -0,0 +1,13 @@
+import { createApiGatewayHandler } from 'simple-lambda-handlers';
+
+import { log } from '../../utils/logger';
+import { getWidgetSchema } from './getWidget.schema';
+
+// an api-gateway handler CALL — the schema+invoke contract differs between the two
+// frameworks, so the fix cannot rename-only; it must emit a loud review marker.
+export const handler = createApiGatewayHandler({
+  log,
+  schema: getWidgetSchema,
+  logic: async (event) => ({ widget: event.widgetId }),
+  cors: true,
+});

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

@@ -0,0 +1,44 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`simple-lambda-handlers migration given: [case1] a repo with a simple-lambda-handlers api-gateway handler when: [t0] the migration input (before any fix) then: the src file imports + calls the simple-lambda-handlers factory + matches snapshot: getWidget.ts — before 1`] = `
+"import { createApiGatewayHandler } from 'simple-lambda-handlers';
+
+import { log } from '../../utils/logger';
+import { getWidgetSchema } from './getWidget.schema';
+
+// an api-gateway handler CALL — the schema+invoke contract differs between the two
+// frameworks, so the fix cannot rename-only; it must emit a loud review marker.
+export const handler = createApiGatewayHandler({
+  log,
+  schema: getWidgetSchema,
+  logic: async (event) => ({ widget: event.widgetId }),
+  cors: true,
+});
+"
+`;
+
+exports[`simple-lambda-handlers migration given: [case1] a repo with a simple-lambda-handlers api-gateway handler when: [t1] the simple-lambda-handlers fix is applied then: the import + call are rewritten to sdk-aws-lambda, the review marker lands, and it matches snapshot: getWidget.ts — after 1`] = `
+"/**
+ * @declapract:review — auto-migrated to sdk-aws-lambda; the api-gateway handler CONTRACT differs
+ * and MUST be restructured by hand (a rename-only migration answers 400 to every request):
+ *  - schema: the prior single schema described the WHOLE event; the sdk input schema describes the
+ *    request BODY only. split into \`schema: { input, output }\` and unwrap the \`body\` key.
+ *  - invoke: \`logic: (event) => O\` becomes \`invoke: async ({ event, rawEvent }) => O\`. \`event\` is
+ *    the parsed body; thread headers through \`rawEvent.headers\`.
+ * delete this marker once restructured.
+ */
+import { genLambdaEndpoint } from 'sdk-aws-lambda';
+
+import { log } from '../../utils/logger';
+import { getWidgetSchema } from './getWidget.schema';
+
+// an api-gateway handler CALL — the schema+invoke contract differs between the two
+// frameworks, so the fix cannot rename-only; it must emit a loud review marker.
+export const handler = genLambdaEndpoint.for.apiGateway({
+  log,
+  schema: getWidgetSchema,
+  logic: async (event) => ({ widget: event.widgetId }),
+  cors: true,
+});
+"
+`;

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

@@ -14,8 +14,73 @@ export const check: FileCheckFunction = (contents) => {
 };
 
 /**
- * .what = transforms simple-lambda-handlers imports to sdk-aws-lambda
- * .why = automated migration reduces manual toil
+ * .what = a loud marker for an api-gateway handler call, whose schema+invoke CONTRACT differs
+ *         between the two frameworks and cannot be mechanically rewritten.
+ * .why = the prior framework's schema described the WHOLE event and the handler received the whole
+ *        event; the sdk's input schema describes the request BODY and the handler receives the
+ *        parsed body plus a separate rawEvent. a rename-only rewrite leaves a handler that answers
+ *        400 to every request, yet typechecks (#594). the marker flags the two manual edits rather
+ *        than let a regex guess the contract.
+ */
+const apiGatewayReviewMarker = `/**
+ * @declapract:review — auto-migrated to sdk-aws-lambda; the api-gateway handler CONTRACT differs
+ * and MUST be restructured by hand (a rename-only migration answers 400 to every request):
+ *  - schema: the prior single schema described the WHOLE event; the sdk input schema describes the
+ *    request BODY only. split into \`schema: { input, output }\` and unwrap the \`body\` key.
+ *  - invoke: \`logic: (event) => O\` becomes \`invoke: async ({ event, rawEvent }) => O\`. \`event\` is
+ *    the parsed body; thread headers through \`rawEvent.headers\`.
+ * delete this marker once restructured.
+ */
+`;
+
+/**
+ * .what = a loud marker for a standard handler call, whose schema+invoke shape also differs.
+ * .why = the rename does not restructure the args; the sdk splits the schema and passes log in the
+ *        invoke context. the marker flags the manual edits (#594).
+ */
+const standardReviewMarker = `/**
+ * @declapract:review — auto-migrated to sdk-aws-lambda; the handler CONTRACT differs and MUST be
+ * restructured by hand:
+ *  - schema: the prior single schema splits into \`schema: { input, output }\`.
+ *  - invoke: \`logic: (event) => O\` becomes \`invoke: async ({ event }, { log }) => O\`; \`log\` is now
+ *    received in the invoke context, not only at creation.
+ * delete this marker once restructured.
+ */
+`;
+
+/**
+ * .what = parse a comma-separated import clause into its trimmed import names
+ * .why = names the split/trim parse, so the fix orchestrator reads as narrative rather than
+ *        an inline array-manipulation chain (rule.forbid.inline-decode-friction)
+ */
+const asImportNames = (input: { clause: string }): string[] =>
+  input.clause.split(',').map((name) => name.trim());
+
+/**
+ * .what = map one simple-lambda-handlers import name to its sdk-aws-lambda equivalent
+ * .why = both handler-factory names collapse onto `genLambdaEndpoint`; the named map keeps the
+ *        fix orchestrator narrative rather than an inline conditional (rule.forbid.inline-decode-friction)
+ */
+const asTransformedImportName = (input: { name: string }): string => {
+  if (input.name === 'createStandardHandler') return 'genLambdaEndpoint';
+  if (input.name === 'createApiGatewayHandler') return 'genLambdaEndpoint';
+  return input.name;
+};
+
+/**
+ * .what = dedupe import names, first-seen order retained
+ * .why = the two handler factories both map to `genLambdaEndpoint`, so a clause that imports both
+ *        would emit a duplicate; the named dedupe hides the Set semantics from the orchestrator
+ */
+const asDedupedImportNames = (input: { names: string[] }): string[] => [
+  ...new Set(input.names),
+];
+
+/**
+ * .what = transforms simple-lambda-handlers imports to sdk-aws-lambda, with a review marker
+ * .why = automated migration reduces manual toil, but the schema+invoke contract cannot be
+ *        mechanically rewritten — so a handler CALL gets a @declapract:review marker that names the
+ *        manual edits, rather than a silent rename that answers 400 to every request (#594).
  *
  * .note = basic transforms only; complex patterns require manual fix
  *
@@ -26,19 +91,21 @@ export const check: FileCheckFunction = (contents) => {
 export const fix: FileFixFunction = (contents) => {
   if (!contents) return {};
 
-  const updated = contents
+  // detect a handler CALL (name + paren) on the ORIGINAL contents, before the rename
+  const hasApiGatewayCall = /createApiGatewayHandler\s*\(/.test(contents);
+  const hasStandardCall = /createStandardHandler\s*\(/.test(contents);
+
+  const transformed = contents
     // transform imports (dedupe to avoid duplicate genLambdaEndpoint)
     .replace(
       /import\s+\{([^}]*)\}\s+from\s+['"]simple-lambda-handlers['"]/g,
       (match, imports) => {
         // split, replace, dedupe, join
-        const importList = imports.split(',').map((s: string) => s.trim());
-        const transformed = importList.map((name: string) => {
-          if (name === 'createStandardHandler') return 'genLambdaEndpoint';
-          if (name === 'createApiGatewayHandler') return 'genLambdaEndpoint';
-          return name;
-        });
-        const deduped = [...new Set(transformed)];
+        const importNames = asImportNames({ clause: imports });
+        const mapped = importNames.map((name) =>
+          asTransformedImportName({ name }),
+        );
+        const deduped = asDedupedImportNames({ names: mapped });
         return `import { ${deduped.join(', ')} } from 'sdk-aws-lambda'`;
       },
     )
@@ -46,5 +113,18 @@ export const fix: FileFixFunction = (contents) => {
     .replace(/createStandardHandler/g, 'genLambdaEndpoint')
     .replace(/createApiGatewayHandler/g, 'genLambdaEndpoint.for.apiGateway');
 
+  // prepend the review marker for a handler CALL (api-gateway takes precedence), so the
+  // un-rewritable schema+invoke contract is loud. idempotent: the check no longer fires
+  // post-rewrite, and a second pass would find the marker already present.
+  const marker = hasApiGatewayCall
+    ? apiGatewayReviewMarker
+    : hasStandardCall
+      ? standardReviewMarker
+      : '';
+  const updated =
+    marker && !transformed.includes('@declapract:review')
+      ? marker + transformed
+      : transformed;
+
   return { contents: updated };
 };

package/dist/practices/node-service/best-practice/package.json

@@ -1,6 +1,6 @@
 {
   "private": true,
   "dependencies": {
-    "sdk-aws-lambda": "@declapract{check.minVersion('0.0.1')}"
+    "sdk-aws-lambda": "@declapract{check.minVersion('0.4.0')}"
   }
 }

package/dist/practices/package-json-order/best-practice/package.json.declapract.ts

@@ -1,5 +1,6 @@
 import type { FileCheckFunction, FileFixFunction } from 'declapract';
 import expect from 'expect';
+import { ConstraintError } from 'helpful-errors';
 
 /**
  * define the relative key order of keys we care about
@@ -80,6 +81,8 @@ export const desiredRelativeKeyOrder = {
     'prepare:rhachet',
     'prepare',
     'deploy:prune',
+    'deploy:release:ancient',
+    'deploy:release:contemp',
     'deploy:release',
     'deploy:send-notification',
     'deploy:prep',
@@ -212,7 +215,10 @@ const sortPackageJSONObjectKeys = (packageJSONObject: Record<string, any>) => {
 
 // define fix and check
 export const check: FileCheckFunction = (contents) => {
-  if (!contents) throw new Error('file not defined');
+  if (!contents)
+    throw new ConstraintError(
+      'package.json not defined; the repo must carry a package.json for key-order to apply',
+    );
   const packageJSONObject = JSON.parse(contents);
   const sortedPackageJSONObject = sortPackageJSONObjectKeys(packageJSONObject);
   expect(JSON.stringify(packageJSONObject, null, 2)).toEqual(

package/dist/practices/persist-with-dynamodb/.declapract.integration.test.ts

@@ -0,0 +1,92 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+/**
+ * .what = end-to-end proof that the `jest.integration.env.ts` declaration REPAIRS a divergent
+ *         consumer file back to the canonical template, run through the REAL declapract apply
+ *         pipeline against a genTempDir clone of a consumer repo (D39 clamp).
+ * .why  = the declaration was a bare `CONTAINS` with no `fix`, so a whole-env-file divergence was
+ *         invisible to the check AND unclosable by any mechanism — a consumer's drift stood
+ *         forever. the fix REMOVED the `.declapract.ts` companion, so the file defaults to
+ *         `EQUALS`: a byte-exact check whose implicit fix OVERWRITES the consumer's file with the
+ *         template. this test is the clamp that a divergence is now both DETECTED and CLOSED.
+ * .note = the env 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 divergent input carries port `9999` and drops the template's doc comment. a revert
+ *          to the deleted `CONTAINS` companion re-opens the divergence — the check would pass on
+ *          the drifted file (it still `CONTAINS` the assignment line) and no fix would fire, so
+ *          the after-state would keep `9999` and this assertion reddens.
+ */
+const BEST_PRACTICE_ENV = `${__dirname}/best-practice/jest.integration.env.ts`;
+
+describe('persist-with-dynamodb — jest.integration.env divergence repair (D39 clamp)', () => {
+  given('[case1] a repo with a divergent jest.integration.env.ts', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-dynamodb-jest-env',
+      clone: './src/practices/persist-with-dynamodb/.test/assets/demo-repo-with-divergent-jest-env',
+      symlink: [{ at: 'src', to: 'src' }],
+    });
+
+    const envPath = 'jest.integration.env.ts';
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const applyRepair = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'persist-with-dynamodb',
+        file: envPath,
+      });
+
+    when('[t0] the divergent input (before any fix)', () => {
+      then('the env input carries the drifted port and matches snapshot', async () => {
+        const before = await read(envPath);
+        expect(before).toContain('9999');
+        expect(before).toMatchSnapshot('jest.integration.env.ts — before');
+      });
+    });
+
+    when('[t1] the EQUALS repair is applied', () => {
+      useThen('repair the divergent env file', async () => applyRepair());
+
+      then(
+        'the consumer file now byte-equals the canonical template and matches snapshot',
+        async () => {
+          const after = await read(envPath);
+          const canonical = await fs.readFile(BEST_PRACTICE_ENV, 'utf-8');
+          // teeth: the drifted port is gone, the canonical endpoint + doc comment are restored
+          expect(after).not.toContain('9999');
+          expect(after).toContain('http://localhost:7337');
+          expect(after).toContain(
+            'specify that dynamodb should use the local dynamodb database',
+          );
+          // byte-for-byte: EQUALS repairs the WHOLE file, not just the assignment line
+          expect(after).toEqual(canonical);
+          // full content, for the reviewer's eye
+          expect(after).toMatchSnapshot('jest.integration.env.ts — after');
+        },
+      );
+    });
+
+    when('[t2] the repair is applied a second time (idempotency)', () => {
+      // capture the post-first-repair state, apply again, capture again — assert zero
+      // change. a byte-equal file must satisfy the EQUALS check, so a second apply fires
+      // no fix (per rule.require.idempotent-fixes).
+      const passes = useThen(
+        'a second repair over its own output',
+        async () => {
+          const before = await read(envPath); // post-first-repair (canonical)
+          await applyRepair(); // second apply
+          const after = await read(envPath);
+          return { before, after };
+        },
+      );
+
+      then('the second repair is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

package/dist/practices/persist-with-dynamodb/.test/assets/demo-repo-with-divergent-jest-env/declapract.declare.yml

@@ -0,0 +1,4 @@
+declare:
+  examples: src/examples
+  practices: src/practices
+  use-cases: src/useCases.yml

package/dist/practices/persist-with-dynamodb/.test/assets/demo-repo-with-divergent-jest-env/declapract.use.yml

@@ -0,0 +1,2 @@
+declarations: './'
+useCase: lambda-service-with-dynamodb

package/dist/practices/persist-with-dynamodb/.test/assets/demo-repo-with-divergent-jest-env/jest.integration.env.ts

@@ -0,0 +1,4 @@
+import { access } from './src/utils/environment';
+
+if (access === 'test')
+  process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:9999';

package/dist/practices/persist-with-dynamodb/.test/assets/demo-repo-with-divergent-jest-env/package.json

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

package/dist/practices/persist-with-dynamodb/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,20 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`persist-with-dynamodb — jest.integration.env divergence repair (D39 clamp) given: [case1] a repo with a divergent jest.integration.env.ts when: [t0] the divergent input (before any fix) then: the env input carries the drifted port and matches snapshot: jest.integration.env.ts — before 1`] = `
+"import { access } from './src/utils/environment';
+
+if (access === 'test')
+  process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:9999';
+"
+`;
+
+exports[`persist-with-dynamodb — jest.integration.env divergence repair (D39 clamp) given: [case1] a repo with a divergent jest.integration.env.ts when: [t1] the EQUALS repair is applied then: the consumer file now byte-equals the canonical template and matches snapshot: jest.integration.env.ts — after 1`] = `
+"import { access } from './src/utils/environment';
+
+/**
+ * specify that dynamodb should use the local dynamodb database, under the test access
+ */
+if (access === 'test')
+  process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:7337';
+"
+`;

package/dist/practices/persist-with-dynamodb/best-practice/jest.integration.env.ts

@@ -1,7 +1,7 @@
-import { stage } from './src/utils/environment';
+import { access } from './src/utils/environment';
 
 /**
- * specify that dynamodb should use the local dynamodb database, if running in test env
+ * specify that dynamodb should use the local dynamodb database, under the test access
  */
-if (stage === 'test')
+if (access === 'test')
   process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:7337';

package/dist/practices/persist-with-dynamodb/best-practice/package.json

@@ -1,9 +1,9 @@
 {
   "dependencies": {
-    "simple-dynamodb-client": "@declapract{check.minVersion('0.10.0')}"
+    "simple-dynamodb-client": "@declapract{check.minVersion('0.10.4')}"
   },
   "devDependencies": {
-    "dynamodb-dao-generator": "@declapract{check.minVersion('1.0.7')}"
+    "dynamodb-dao-generator": "@declapract{check.minVersion('1.1.0')}"
   },
   "scripts": {
     "generate:dao:dynamodb": "npx dynamodb-dao-generator generate && npm run fix:format",