declapract-typescript-ehmpathy 0.49.14 → 0.50.0

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

@@ -0,0 +1,181 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, useThen, when } from 'test-fns';
+
+import { DYNAMODB_INSERTS as JEST_INSERTS } from '../tests-node/best-practice/jest.integration.env.ts.declapract';
+import { DYNAMODB_INSERTS as TF_INSERTS } from '../terraform-aws/best-practice/provision/aws/environments/test/main.tf.declapract';
+
+/**
+ * .what = end-to-end proof that a persist-with-dynamodb service still gets its local dynamodb
+ *         endpoint, now that tests-node and terraform-aws are the one owner of each file (#630)
+ * .why  = persist-with-dynamodb once redeclared `jest.integration.env.ts` and the test `main.tf`
+ *         beside their owners. the two declarations fought, so each apply left one file manual or
+ *         rewrote it. the dynamodb delta now rides on each owner as a usecase-aware findsert insert;
+ *         this clamp proves the REAL apply pipeline delivers it, keeps it under a narrow scope, and
+ *         converges on a second apply.
+ * .teeth = swap `'persist-with-dynamodb'` in `jest.integration.env.ts.declapract.ts` for any other
+ *          name and case1 reddens: the env is written without the endpoint line.
+ * .note = applies scope by `file` only, never `practice`: a `practice` filter makes
+ *         `projectPractices` hold just that practice, so the dynamodb branch would go dark
+ *         (rule.require.declapract-integration-tests, gotchas).
+ * .note = the fixture declares a local three-practice usecase (the two owners plus
+ *         persist-with-dynamodb), so a `file`-scoped apply evaluates three practices, not dozens.
+ */
+// a `file`-scoped apply evaluates every practice of the usecase, so one apply can outlast the
+// default 90s under a busy host
+jest.setTimeout(15 * 60 * 1000);
+
+const FIXTURE =
+  './src/practices/persist-with-dynamodb/.test/assets/demo-repo-with-dynamodb';
+const JEST_ENV = 'jest.integration.env.ts';
+const TF_TEST = 'provision/aws/environments/test/main.tf';
+const ENDPOINT_LINE =
+  "process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:7337';";
+const TEMPLATE_JEST_ENV = path.join(
+  __dirname,
+  '../tests-node/best-practice',
+  JEST_ENV,
+);
+
+const genRepo = (slug: string) =>
+  genTempDir({ slug, clone: FIXTURE, symlink: [{ at: 'declarations', to: 'src' }] });
+const read = (root: string, rel: string) =>
+  fs.readFile(path.join(root, rel), 'utf-8');
+const apply = (root: string, input: { file: string; practice?: string }) =>
+  executeApply({ config: path.join(root, 'declapract.use.yml'), ...input });
+const strip = (contents: string, inserts: { text: string }[]) =>
+  inserts.reduce((text, insert) => text.split(insert.text).join(''), contents);
+
+describe('persist-with-dynamodb — local dynamodb endpoint via the usecase-aware owners (#630)', () => {
+  given('[case1] a dynamodb service with neither file yet', () => {
+    const root = genRepo('declapract-dynamodb-endpoint-absent');
+
+    when('[t0] the jest integration env is applied', () => {
+      useThen('apply the env', async () => apply(root, { file: JEST_ENV }));
+
+      then('the env sets the local dynamodb endpoint, under the test access', async () => {
+        const after = await read(root, JEST_ENV);
+        expect(after).toContain(ENDPOINT_LINE);
+        expect(after).toContain("if (access === 'test')");
+        expect(after).toContain("import { access } from './src/utils/environment';");
+        expect(after).toMatchSnapshot('jest.integration.env.ts — after');
+      });
+
+      then('the rest of the env is the tests-node template, byte for byte', async () => {
+        const after = await read(root, JEST_ENV);
+        const template = await fs.readFile(TEMPLATE_JEST_ENV, 'utf-8');
+        expect(strip(after, JEST_INSERTS)).toEqual(template);
+      });
+    });
+
+    when('[t1] the test environment main.tf is applied', () => {
+      useThen('apply the main.tf', async () => apply(root, { file: TF_TEST }));
+
+      then('the aws provider points dynamodb at the local container', async () => {
+        const after = await read(root, TF_TEST);
+        expect(after).toContain('dynamodb = "http://localhost:7337/"');
+        expect(after).toMatch(/provider "aws" \{\n {2}endpoints \{/);
+        expect(after).not.toContain('@declapract{');
+        expect(after).toMatchSnapshot('test/main.tf — after');
+      });
+    });
+
+    when('[t2] both files are applied a second time (idempotency)', () => {
+      const passes = useThen('a second apply over its own output', async () => {
+        const before = {
+          env: await read(root, JEST_ENV),
+          tf: await read(root, TF_TEST),
+        };
+        await apply(root, { file: JEST_ENV });
+        await apply(root, { file: TF_TEST });
+        return {
+          before,
+          after: { env: await read(root, JEST_ENV), tf: await read(root, TF_TEST) },
+        };
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+
+  given('[case2] a dynamodb service whose env is the plain tests-node template', () => {
+    const root = genRepo('declapract-dynamodb-endpoint-union');
+    const scene = useBeforeAll(async () => {
+      const template = await fs.readFile(TEMPLATE_JEST_ENV, 'utf-8');
+      await fs.writeFile(path.join(root, JEST_ENV), template);
+      return { template };
+    });
+
+    when('[t0] the env is applied', () => {
+      useThen('apply the env', async () => apply(root, { file: JEST_ENV }));
+
+      then('the endpoint is unioned in and the base stays intact', async () => {
+        const after = await read(root, JEST_ENV);
+        expect(scene.template).not.toContain(ENDPOINT_LINE);
+        expect(after).toContain(ENDPOINT_LINE);
+        expect(strip(after, JEST_INSERTS)).toEqual(scene.template);
+      });
+    });
+
+    when('[t1] a narrow apply scoped to tests-node alone runs over it', () => {
+      const passes = useThen('a narrow-scope apply', async () => {
+        const before = await read(root, JEST_ENV);
+        await apply(root, { file: JEST_ENV, practice: 'tests-node' });
+        return { before, after: await read(root, JEST_ENV) };
+      });
+
+      then('the dynamodb lines are kept, never stripped', () => {
+        expect(passes.after).toContain(ENDPOINT_LINE);
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+
+  given('[case4] a dynamodb service whose endpoint line drifted to another port', () => {
+    // the drift the prior owner repaired: the base strips clean only with the canonical insert,
+    // so a drifted endpoint makes the base differ, and the findsert rewrites from the template
+    const root = genRepo('declapract-dynamodb-endpoint-drift');
+    const scene = useBeforeAll(async () => {
+      const template = await fs.readFile(TEMPLATE_JEST_ENV, 'utf-8');
+      const canonical = JEST_INSERTS.reduce((text, insert) => {
+        const end = text.indexOf(insert.after) + insert.after.length;
+        return `${text.slice(0, end)}${insert.text}${text.slice(end)}`;
+      }, template);
+      const before = canonical.replace('localhost:7337', 'localhost:9999');
+      await fs.writeFile(path.join(root, JEST_ENV), before);
+      return { template, before };
+    });
+
+    when('[t0] the env is applied', () => {
+      const result = useThen('apply the env', async () => {
+        await apply(root, { file: JEST_ENV });
+        return { after: await read(root, JEST_ENV) };
+      });
+
+      then('the drifted port is repaired to the local container', () => {
+        expect(scene.before).toContain('localhost:9999');
+        expect(result.after).not.toContain('9999');
+        expect(result.after).toContain(ENDPOINT_LINE);
+      });
+
+      then('the rest of the env is the tests-node template, byte for byte', () => {
+        expect(strip(result.after, JEST_INSERTS)).toEqual(scene.template);
+      });
+
+      then('before + after match snapshot', () => {
+        expect(scene.before).toMatchSnapshot('jest.integration.env.ts — drifted, before');
+        expect(result.after).toMatchSnapshot('jest.integration.env.ts — drifted, after');
+      });
+    });
+  });
+
+  given('[case3] the terraform insert, against its own declaration', () => {
+    then('the insert sits inside the aws provider block', () => {
+      expect(TF_INSERTS[0]!.after).toEqual('provider "aws" {');
+    });
+  });
+});

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/.test/assets/demo-repo-with-dynamodb/declapract.declare.yml

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

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/.test/assets/demo-repo-with-dynamodb/declapract.use.yml

@@ -0,0 +1,11 @@
+declarations: './'
+useCase: dynamodb-owners
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'
+  infrastructureNamespaceId: 'testns'
+  databaseName: 'testdb'
+  slackWebhookUrl: 'https://hooks.slack.test/webhook'
+  awsAccountId:
+    prep: '123456789012'
+    prod: '123456789012'

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/.test/assets/demo-repo-with-dynamodb/package.json

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

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/.test/assets/demo-repo-with-dynamodb/useCases.yml

@@ -0,0 +1,8 @@
+# a minimal usecase: the two owners of the dynamodb inserts, plus the practice that signals them.
+# the full lambda-service-with-dynamodb usecase evaluates dozens of practices per apply.
+use-cases:
+  dynamodb-owners:
+    practices:
+      - tests-node
+      - terraform-aws
+      - persist-with-dynamodb

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

@@ -0,0 +1,234 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`persist-with-dynamodb — local dynamodb endpoint via the usecase-aware owners (#630) given: [case1] a dynamodb service with neither file yet when: [t0] the jest integration env is applied then: the env sets the local dynamodb endpoint, under the test access: jest.integration.env.ts — after 1`] = `
+"import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import util from 'node:util';
+
+import { jest } from '@jest/globals';
+import { ConstraintError } from 'helpful-errors';
+
+import { useTestdbPortOverride } from './src/.test/assets/database/useTestdbPortOverride';
+import { useWakeOfTestdb } from './src/.test/useWakeOfTestdb';
+import { access } from './src/utils/environment';
+
+jest.setTimeout(90000); // since we're calling downstream apis
+
+// set console.log to not truncate nested objects
+util.inspect.defaultOptions.depth = 5;
+
+/**
+ * .what = verify that we're running from a valid project directory; otherwise, fail fast
+ * .why = prevent confusion and hard-to-debug errors from running tests in the wrong directory
+ */
+if (!existsSync(join(process.cwd(), 'package.json')))
+  throw new ConstraintError(
+    'no package.json found in cwd — run the integration suite from the git root',
+    { cwd: process.cwd() },
+  );
+
+/**
+ * sanity check that unit tests are only run the 'test' environment
+ *
+ * usecases
+ * - prevent polluting prod state with test data
+ * - prevent executing financially impacting mutations
+ */
+if (
+  (process.env.NODE_ENV !== 'test' ||
+    (process.env.CONFIG && process.env.CONFIG !== 'test')) &&
+  process.env.I_KNOW_THE_RISKS !== 'true'
+)
+  throw new ConstraintError(
+    \`integration.test config must be 'test' — set NODE_ENV=test and CONFIG=test (or I_KNOW_THE_RISKS=true to override)\`,
+    { nodeEnv: process.env.NODE_ENV ?? null, config: process.env.CONFIG ?? null },
+  );
+
+/**
+ * .what = declare this checkout's testdb port as TESTDB_PORT, before any test opens a connection.
+ * .why = a worktree's testdb binds a port of its own; the app dials TESTDB_PORT under test access,
+ *        so a worktree's suite reaches its own db, never another checkout's.
+ */
+useTestdbPortOverride();
+
+/**
+ * .what = preflight the LOCAL testdb when this service declares its own db (databaseUserName).
+ * .why = prevent time wasted on a suite that fails deep in a query because the local testdb was never
+ *        provisioned, or was provisioned for a different repo; useWakeOfTestdb fails loud and names
+ *        the fix. it is the LOCAL own-db half; the shared prep cluster its peers query is woken by
+ *        useWakeOfLivedb in globalSetup, since both test and prep access reach the prep peers.
+ */
+useWakeOfTestdb();
+
+/**
+ * .what = point dynamodb at the local dynamodb container, under the test access
+ * .why = a dynamodb suite must never reach a live table
+ */
+if (access === 'test')
+  process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:7337';
+"
+`;
+
+exports[`persist-with-dynamodb — local dynamodb endpoint via the usecase-aware owners (#630) given: [case1] a dynamodb service with neither file yet when: [t1] the test environment main.tf is applied then: the aws provider points dynamodb at the local container: test/main.tf — after 1`] = `
+"provider "aws" {
+  endpoints {
+    dynamodb = "http://localhost:7337/" # the test environment tables live in the local dynamodb
+  }
+
+  region              = "us-east-1"
+  allowed_account_ids = ["123456789012"] # \`test\` environment resources are provisioned in the \`prep\` aws account
+}
+
+terraform {
+  backend "s3" {
+    bucket  = "terraform-state-testns-test"
+    key     = "test-project-test"
+    region  = "us-east-1"
+    encrypt = true
+  }
+}
+
+module "product" {
+  source      = "../../product"
+  environment = "test"
+}
+"
+`;
+
+exports[`persist-with-dynamodb — local dynamodb endpoint via the usecase-aware owners (#630) given: [case4] a dynamodb service whose endpoint line drifted to another port when: [t0] the env is applied then: before + after match snapshot: jest.integration.env.ts — drifted, after 1`] = `
+"import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import util from 'node:util';
+
+import { jest } from '@jest/globals';
+import { ConstraintError } from 'helpful-errors';
+
+import { useTestdbPortOverride } from './src/.test/assets/database/useTestdbPortOverride';
+import { useWakeOfTestdb } from './src/.test/useWakeOfTestdb';
+import { access } from './src/utils/environment';
+
+jest.setTimeout(90000); // since we're calling downstream apis
+
+// set console.log to not truncate nested objects
+util.inspect.defaultOptions.depth = 5;
+
+/**
+ * .what = verify that we're running from a valid project directory; otherwise, fail fast
+ * .why = prevent confusion and hard-to-debug errors from running tests in the wrong directory
+ */
+if (!existsSync(join(process.cwd(), 'package.json')))
+  throw new ConstraintError(
+    'no package.json found in cwd — run the integration suite from the git root',
+    { cwd: process.cwd() },
+  );
+
+/**
+ * sanity check that unit tests are only run the 'test' environment
+ *
+ * usecases
+ * - prevent polluting prod state with test data
+ * - prevent executing financially impacting mutations
+ */
+if (
+  (process.env.NODE_ENV !== 'test' ||
+    (process.env.CONFIG && process.env.CONFIG !== 'test')) &&
+  process.env.I_KNOW_THE_RISKS !== 'true'
+)
+  throw new ConstraintError(
+    \`integration.test config must be 'test' — set NODE_ENV=test and CONFIG=test (or I_KNOW_THE_RISKS=true to override)\`,
+    { nodeEnv: process.env.NODE_ENV ?? null, config: process.env.CONFIG ?? null },
+  );
+
+/**
+ * .what = declare this checkout's testdb port as TESTDB_PORT, before any test opens a connection.
+ * .why = a worktree's testdb binds a port of its own; the app dials TESTDB_PORT under test access,
+ *        so a worktree's suite reaches its own db, never another checkout's.
+ */
+useTestdbPortOverride();
+
+/**
+ * .what = preflight the LOCAL testdb when this service declares its own db (databaseUserName).
+ * .why = prevent time wasted on a suite that fails deep in a query because the local testdb was never
+ *        provisioned, or was provisioned for a different repo; useWakeOfTestdb fails loud and names
+ *        the fix. it is the LOCAL own-db half; the shared prep cluster its peers query is woken by
+ *        useWakeOfLivedb in globalSetup, since both test and prep access reach the prep peers.
+ */
+useWakeOfTestdb();
+
+/**
+ * .what = point dynamodb at the local dynamodb container, under the test access
+ * .why = a dynamodb suite must never reach a live table
+ */
+if (access === 'test')
+  process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:7337';
+"
+`;
+
+exports[`persist-with-dynamodb — local dynamodb endpoint via the usecase-aware owners (#630) given: [case4] a dynamodb service whose endpoint line drifted to another port when: [t0] the env is applied then: before + after match snapshot: jest.integration.env.ts — drifted, before 1`] = `
+"import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import util from 'node:util';
+
+import { jest } from '@jest/globals';
+import { ConstraintError } from 'helpful-errors';
+
+import { useTestdbPortOverride } from './src/.test/assets/database/useTestdbPortOverride';
+import { useWakeOfTestdb } from './src/.test/useWakeOfTestdb';
+import { access } from './src/utils/environment';
+
+jest.setTimeout(90000); // since we're calling downstream apis
+
+// set console.log to not truncate nested objects
+util.inspect.defaultOptions.depth = 5;
+
+/**
+ * .what = verify that we're running from a valid project directory; otherwise, fail fast
+ * .why = prevent confusion and hard-to-debug errors from running tests in the wrong directory
+ */
+if (!existsSync(join(process.cwd(), 'package.json')))
+  throw new ConstraintError(
+    'no package.json found in cwd — run the integration suite from the git root',
+    { cwd: process.cwd() },
+  );
+
+/**
+ * sanity check that unit tests are only run the 'test' environment
+ *
+ * usecases
+ * - prevent polluting prod state with test data
+ * - prevent executing financially impacting mutations
+ */
+if (
+  (process.env.NODE_ENV !== 'test' ||
+    (process.env.CONFIG && process.env.CONFIG !== 'test')) &&
+  process.env.I_KNOW_THE_RISKS !== 'true'
+)
+  throw new ConstraintError(
+    \`integration.test config must be 'test' — set NODE_ENV=test and CONFIG=test (or I_KNOW_THE_RISKS=true to override)\`,
+    { nodeEnv: process.env.NODE_ENV ?? null, config: process.env.CONFIG ?? null },
+  );
+
+/**
+ * .what = declare this checkout's testdb port as TESTDB_PORT, before any test opens a connection.
+ * .why = a worktree's testdb binds a port of its own; the app dials TESTDB_PORT under test access,
+ *        so a worktree's suite reaches its own db, never another checkout's.
+ */
+useTestdbPortOverride();
+
+/**
+ * .what = preflight the LOCAL testdb when this service declares its own db (databaseUserName).
+ * .why = prevent time wasted on a suite that fails deep in a query because the local testdb was never
+ *        provisioned, or was provisioned for a different repo; useWakeOfTestdb fails loud and names
+ *        the fix. it is the LOCAL own-db half; the shared prep cluster its peers query is woken by
+ *        useWakeOfLivedb in globalSetup, since both test and prep access reach the prep peers.
+ */
+useWakeOfTestdb();
+
+/**
+ * .what = point dynamodb at the local dynamodb container, under the test access
+ * .why = a dynamodb suite must never reach a live table
+ */
+if (access === 'test')
+  process.env.USE_CUSTOM_DYNAMODB_ENDPOINT = 'http://localhost:9999';
+"
+`;

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/best-practice/.gitattributes.declapract.ts

@@ -0,0 +1,56 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+import {
+  defineExpectedGitattributesContents,
+  type GitattributesSection,
+} from '../../../utils/defineExpectedGitattributesContents';
+
+/**
+ * .what = the `.gitattributes` section this practice owns: the dao `.generated/` dir folds in pr diffs
+ * .why  = the daos are the internal contracts, so a reviewer reads them open. a `.generated/` dir
+ *         under `src/access/daos` holds derived code that every regen rewrites. github folds a
+ *         file marked `linguist-generated`, one click away
+ * .note = the generator's terraform dir, `provision/aws/product`, also holds hand-written infra,
+ *         and an infra change owes open eyes, so it stays open
+ */
+const sections: readonly GitattributesSection[] = [
+  {
+    header: {
+      latest:
+        '# [persist-with-dynamodb] collapse dao-generator output in pr diffs',
+      retired: [],
+    },
+    entries: {
+      latest: ['src/access/daos/**/.generated/** linguist-generated'],
+      retired: ['src/access/daos/** linguist-generated'],
+    },
+  },
+];
+
+/**
+ * .what = emits the `.gitattributes` this practice declares, given the repo's extant one
+ * .why  = several practices declare this file; they converge only through the shared util
+ */
+const defineExpectedContents = (input: { contents: string | null }): string =>
+  defineExpectedGitattributesContents({
+    contents: input.contents,
+    declarer: 'persist-with-dynamodb',
+    sections,
+  });
+
+/**
+ * .what = throws when the repo's `.gitattributes` differs from what the shared layout emits
+ * .why  = `check` gates `fix` (a throw means violated); exact equality, so `check(x) ⟺ x === fix(x)`
+ */
+export const check: FileCheckFunction = (contents) => {
+  expect(contents).toEqual(defineExpectedContents({ contents }));
+};
+
+/**
+ * .what = sets this practice's section into the repo's `.gitattributes`
+ * .why  = a fixed point: a second fix changes zero, and `check` passes on the output
+ */
+export const fix: FileFixFunction = (contents) => ({
+  contents: defineExpectedContents({ contents }),
+});

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/best-practice/codegen.dynamodb.dao.ts

@@ -0,0 +1,16 @@
+import {
+  DeclaredDaoSpecification,
+  DeclaredDomainObjectIntrospectionPaths,
+  DeclaredOutputDirectories,
+} from 'dynamodb-dao-generator';
+
+export const introspect: DeclaredDomainObjectIntrospectionPaths = [
+  './src/domain.objects/index.ts',
+];
+
+export const directories: DeclaredOutputDirectories = {
+  terraform: `provision/aws/product`,
+  dao: `src/access/daos`,
+};
+
+export const specifications: DeclaredDaoSpecification[] = [];

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/best-practice/package.json

@@ -0,0 +1,16 @@
+{
+  "dependencies": {
+    "simple-dynamodb-client": "@declapract{check.minVersion('0.10.4')}"
+  },
+  "devDependencies": {
+    "dynamodb-dao-generator": "@declapract{check.minVersion('1.1.0')}"
+  },
+  "scripts": {
+    "generate:dao:dynamodb": "dynamodb-dao-generator generate && npm run fix:format",
+    "provision:testdb:docker:up": "docker compose -f ./provision/docker/integration-test-db/docker-compose.yml up -d --force-recreate --build --renew-anon-volumes",
+    "provision:testdb:docker:down": "docker compose -f ./provision/docker/integration-test-db/docker-compose.yml down",
+    "provision:testdb:dynamodb:schema": "terraform -chdir=provision/aws/environments/test apply -auto-approve",
+    "provision:testdb": "npm run provision:testdb:docker:up && npm run provision:testdb:dynamodb:schema",
+    "start:testdb": "npm run provision:testdb"
+  }
+}

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/best-practice/package.json.declapract.ts

@@ -0,0 +1,3 @@
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/git/declarations/practices/persist-with-dynamodb/best-practice/provision/docker/integration-test-db/docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3.8'
+services:
+  dynamodb-local:
+    command: '-jar DynamoDBLocal.jar -sharedDb -inMemory'
+    image: 'amazon/dynamodb-local:latest'
+    container_name: dynamodb-local
+    ports:
+      - '7337:8000'
+    working_dir: /home/dynamodblocal