declapract-typescript-ehmpathy 0.49.14 → 0.50.0

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

@@ -0,0 +1,237 @@
+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 of the persist-with-rds `old-dev-config-location` relocate +
+ *         access-migrate, run through the REAL declapract apply pipeline against a genTempDir
+ *         clone of a consumer repo (the row-4 clamp, rds declarer).
+ * .why  = the config declarer has its own pipeline test; per
+ *         `rule.require.declapract-integration-tests` EACH declarer that relocates a file AND
+ *         transforms blocks owes its own end-to-end test — a unit test of the exported `fix`
+ *         never exercises the glob→file match or the `relativeFilePath` rewrite. the rds
+ *         declarer must also keep the `__CHANG3_ME__` passwords prep users are created with
+ *         (#683), so it needs its own clamp rather than a claim that the config test covers it.
+ * .teeth = the input holds `"access": "dev"` (unambiguous → migrated to `prep`) plus four `.dev`
+ *          hosts the util runs on in a CONSUMER's real config — a `://` URL `https://auth.myapp.dev`,
+ *          a mid-dotted `bastion.dev.example.com`, a terminal `aws.ssmproxy.mydb.dev`, and a FOREIGN
+ *          public host `api.dev.paypal.com` (paypal's own label). a `.dev` label is axis-ambiguous
+ *          WHEREVER it sits, so per guard #3 EVERY host is preserved byte-for-byte — the after-state
+ *          proves all four survive, that none flips to `.prep`, and that NO `@declapract:review`
+ *          bytes ever enter the config. it also proves the `__CHANG3_ME__` passwords survive as-is
+ *          (#683) plus the relocation.
+ */
+// the declarations mount at `declarations/`, never `src/`, so the practice's `src/**` wildcards scan
+// only the demo repo's own files; the whole-practice evaluation still runs long under load
+jest.setTimeout(600_000);
+
+describe('persist-with-rds — old-dev-config-location relocate + access-migrate (row-4 clamp)', () => {
+  given('[case1] an rds repo with a config/dev.json to migrate', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-persist-with-rds-old-dev-config-location',
+      clone: './src/practices/persist-with-rds/.test/assets/demo-repo-with-dev-config',
+      symlink: [{ at: 'declarations', to: 'src' }],
+    });
+
+    const devPath = 'config/dev.json';
+    const prepPath = 'config/prep.json';
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const exists = async (relativePath: string): Promise<boolean> =>
+      fs
+        .access(path.join(tempDir, relativePath))
+        .then(() => true)
+        .catch((error: NodeJS.ErrnoException) => {
+          if (error.code === 'ENOENT') return false; // absent is the probe's answer
+          throw error; // any other read failure is a malfunction, never "absent"
+        });
+    const applyMigrate = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'persist-with-rds',
+        file: devPath,
+      });
+
+    when('[t0] the migration input (before any fix)', () => {
+      then('config/dev.json holds the dev access + the placeholder + matches snapshot', async () => {
+        const before = await read(devPath);
+        expect(before).toContain('"access": "dev"');
+        expect(before).toContain('"__CHANG3_ME__"');
+        expect(before).toMatchSnapshot('config/dev.json — before');
+      });
+    });
+
+    when('[t1] the relocate + migrate fix is applied', () => {
+      useThen('migrate the dev config', async () => applyMigrate());
+
+      then(
+        'config/prep.json now holds the migrated content + config/dev.json is gone + matches snapshot',
+        async () => {
+          // the relocation landed: the new path exists, the old path is unlinked
+          expect(await exists(prepPath)).toBe(true);
+          expect(await exists(devPath)).toBe(false);
+
+          const after = await read(prepPath);
+          // the access itself is the one unambiguous token → migrated
+          expect(after).toContain('"access": "prep"');
+          expect(after).not.toContain('"access": "dev"');
+          // EVERY host survives byte-for-byte — a `.dev` label is axis-ambiguous WHEREVER it sits,
+          // so per guard #3 the util rewrites NO host at all.
+          expect(after).toContain('bastion.dev.example.com');
+          expect(after).toContain('aws.ssmproxy.mydb.dev');
+          expect(after).toContain('https://auth.myapp.dev');
+          // the FOREIGN public host is the decisive corruption case: teeth — the prior mid-dotted
+          // rewrite turned this into `api.prep.paypal.com`, a silent public-endpoint corruption.
+          expect(after).toContain('api.dev.paypal.com');
+          expect(after).not.toContain('api.prep.paypal.com');
+          // no host was flipped to `.prep`, so no wrong-access value ever enters the config
+          expect(after).not.toContain('bastion.prep.example.com');
+          expect(after).not.toContain('aws.ssmproxy.mydb.prep');
+          // the migration never emits a value it cannot verify — no marker bytes in config
+          expect(after).not.toContain('@declapract:review');
+          // the prep password placeholder survives — prep users are created with it (#683)
+          expect(after).toContain('"__CHANG3_ME__"');
+          expect(after).not.toContain('"$.at(aws::param)"');
+          // full content, for the reviewer's eye
+          expect(after).toMatchSnapshot('config/prep.json — after');
+        },
+      );
+    });
+
+    when('[t2] the fix is applied a second time (idempotency)', () => {
+      // config/dev.json is gone after the first relocate, so the EXISTS check no longer
+      // fires and no fix runs — config/prep.json must be untouched (per
+      // rule.require.idempotent-fixes).
+      const passes = useThen(
+        'a second apply over the already-migrated repo',
+        async () => {
+          const before = await read(prepPath);
+          await applyMigrate();
+          const after = await read(prepPath);
+          return { before, after };
+        },
+      );
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});
+
+/**
+ * .what = D55 clamp: `src/utils/config/getConfig.ts` has exactly ONE declarer — the `config`
+ *         practice (the real sdk-config impl). `persist-with-rds` ships NO second copy of that
+ *         path (the old `'placeholder' as any` typed lie).
+ * .why  = `lambda-service-with-rds` extends `lambda-service`, which always supplies `config`, so the
+ *         placeholder was dead weight whose correctness rested on alphabetical apply order
+ *         (`config` < `persist-with-rds`). two declarers of one path, one a typed lie, is a silent
+ *         hazard: a consumer converged to the real file only by accident of that order. one
+ *         declarer removes both the order dependency and the lie — the consumer receives config's
+ *         real getConfig at this exact path, so persist-with-rds's own import resolves.
+ * .teeth = re-add a getConfig.ts under persist-with-rds/best-practice → the sole-declarer assertion
+ *          reddens.
+ * .note = INTEGRATION by `rule.forbid.unit.remote-boundaries`: it reads the filesystem (the
+ *         practice trees). no credential, no network.
+ */
+describe('persist-with-rds — getConfig has a single declarer (D55 clamp)', () => {
+  const configGetConfig =
+    'src/practices/config/best-practice/src/utils/config/getConfig.ts';
+  const rdsGetConfig =
+    'src/practices/persist-with-rds/best-practice/src/utils/config/getConfig.ts';
+  const rdsDbConnection =
+    'src/practices/persist-with-rds/best-practice/src/utils/database/getOneDatabaseConnection.ts';
+  const exists = async (relativePath: string): Promise<boolean> =>
+    fs
+      .access(relativePath)
+      .then(() => true)
+      .catch((error: NodeJS.ErrnoException) => {
+        if (error.code === 'ENOENT') return false; // absent is the probe's answer
+        throw error; // any other read failure is a malfunction, never "absent"
+      });
+
+  given('[case1] the two practices that touch src/utils/config/getConfig.ts', () => {
+    when('[t0] the declarers of that path are read', () => {
+      then('the config practice is the sole declarer (real sdk-config impl)', async () => {
+        expect(await exists(configGetConfig)).toBe(true);
+        const real = await fs.readFile(configGetConfig, 'utf-8');
+        expect(real).toContain("from 'sdk-config'");
+        expect(real).not.toContain("'placeholder' as any");
+      });
+
+      then('persist-with-rds ships NO second copy (no typed-lie placeholder)', async () => {
+        // teeth: re-add a getConfig.ts under persist-with-rds/best-practice and this reddens
+        expect(await exists(rdsGetConfig)).toBe(false);
+      });
+
+      then('persist-with-rds imports getConfig from the config-supplied path', async () => {
+        // the consumer receives config's real getConfig at this exact path, so the import resolves
+        const dbConn = await fs.readFile(rdsDbConnection, 'utf-8');
+        expect(dbConn).toContain("from '@src/utils/config/getConfig'");
+      });
+    });
+  });
+});
+
+/**
+ * .what = config.schema.ts clamp: this path has TWO declarers BY DESIGN — `config` (the base
+ *         shape, for a non-rds `lambda-service`) and `persist-with-rds` (the full shape with the
+ *         database block, for `lambda-service-with-rds`). persist-with-rds declares its full schema
+ *         as a PLAIN overwrite template (EQUALS), NOT a CONTAINS + regex-splice fix.
+ * .why  = a CONTAINS+splice `fix` for this path was dead code: its regex anchored on `});` before
+ *         `export type Config`, but config's base emits `} as const;` there, so on a fresh
+ *         `lambda-service-with-rds` consumer the fix no-oped and the check stayed permanently red —
+ *         no path to green via `declapract fix`. worse, its inline splice string was stale (flat
+ *         `role.cicd.{username,password}` vs the real `for-plan`/`for-apply` split). the later
+ *         declarer (persist-with-rds) shadows config's base for rds consumers, so removal of the
+ *         `.declapract.ts` makes its full `config.schema.ts` a plain EQUALS overwrite (declapract's
+ *         default with no companion) that always converges — rule.prefer.overwrite-over-mutate: do
+ *         not pair an overwrite template with a separate splice fix for the same path.
+ * .teeth = re-add a config.schema.ts.declapract.ts under persist-with-rds/best-practice → the
+ *          "no splice-fix declarer" assertion reddens; strip the `for-plan` split from
+ *          persist-with-rds's full schema → the "full schema declared" assertion reddens.
+ * .note = INTEGRATION by rule.forbid.unit.remote-boundaries: reads the filesystem (practice trees).
+ */
+describe('persist-with-rds — config.schema.ts is a plain overwrite, not a splice-fix (config.schema clamp)', () => {
+  const configSchema =
+    'src/practices/config/best-practice/src/utils/config/config.schema.ts';
+  const rdsSchema =
+    'src/practices/persist-with-rds/best-practice/src/utils/config/config.schema.ts';
+  const rdsSchemaFix =
+    'src/practices/persist-with-rds/best-practice/src/utils/config/config.schema.ts.declapract.ts';
+  const exists = async (relativePath: string): Promise<boolean> =>
+    fs
+      .access(relativePath)
+      .then(() => true)
+      .catch((error: NodeJS.ErrnoException) => {
+        if (error.code === 'ENOENT') return false; // absent is the probe's answer
+        throw error; // any other read failure is a malfunction, never "absent"
+      });
+
+  given('[case1] the two by-design declarers of src/utils/config/config.schema.ts', () => {
+    when('[t0] the declared files are read', () => {
+      then('config declares the BASE shape (no database block) for a non-rds service', async () => {
+        const base = await fs.readFile(configSchema, 'utf-8');
+        expect(base).toContain('const base = z.object(');
+        expect(base).not.toContain('database: z.object(');
+      });
+
+      then('persist-with-rds declares the FULL schema (database + for-plan/for-apply split)', async () => {
+        // teeth: strip the for-plan split from the full schema and this reddens
+        const full = await fs.readFile(rdsSchema, 'utf-8');
+        expect(full).toContain('database: z.object(');
+        expect(full).toContain("'for-plan': z.object(");
+        expect(full).toContain("'for-apply': z.object(");
+      });
+
+      then('persist-with-rds ships NO CONTAINS+splice fix for that path (dead regex gone)', async () => {
+        // teeth: re-add config.schema.ts.declapract.ts and this reddens. the paired full template
+        // is a plain EQUALS overwrite, so a fresh rds consumer converges via overwrite, never a
+        // splice that no-ops on config's `} as const;` base.
+        expect(await exists(rdsSchemaFix)).toBe(false);
+      });
+    });
+  });
+});

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.extensions.sql.declapract.integration.test.ts

@@ -0,0 +1,159 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, useThen, when } from 'test-fns';
+
+import { readFile } from '../../utils/readFile';
+import { fix } from './best-practice/provision/schema/sql/init/.extensions.sql.declapract';
+
+// executeApply evaluates the whole persist-with-rds practice before the `file` filter narrows it
+jest.setTimeout(10 * 60 * 1000);
+
+const EXTENSIONS_SQL = 'provision/schema/sql/init/.extensions.sql';
+
+describe('.extensions.sql fix', () => {
+  it('should be able to fix a file with custom extensions correctly', async () => {
+    const declaredFileContents = await readFile({
+      filePath: `${__dirname}/best-practice/provision/schema/sql/init/.extensions.sql`,
+    }); // grab the declared contents
+    const exampleFoundContents = `
+/**
+ NOTE: because db owner is not allowed to create extensions, these changes are applied manually
+
+  NOTE: for the integration test db, these are applied automatically upon spinning up the docker instance
+*/
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+CREATE EXTENSION IF NOT EXISTS "cube";
+CREATE EXTENSION IF NOT EXISTS "earthdistance";
+    `;
+    const { contents: fixedContents } = await fix(exampleFoundContents, {
+      declaredFileContents,
+    } as any);
+    expect(fixedContents).toContain('CREATE EXTENSION IF NOT EXISTS "cube";');
+    expect(fixedContents).toContain(
+      'CREATE EXTENSION IF NOT EXISTS "earthdistance";',
+    );
+    expect(fixedContents).toMatchSnapshot();
+  });
+  it('should be able to create a new file to fix case where file does not exist yet', async () => {
+    const declaredFileContents = await readFile({
+      filePath: `${__dirname}/best-practice/provision/schema/sql/init/.extensions.sql`,
+    }); // grab the declared contents
+    const { contents: fixedContents } = await fix(null, {
+      declaredFileContents,
+    } as any);
+    expect(fixedContents).toMatchSnapshot();
+  });
+
+  /**
+   * .what = the twice-applied clamp (rule.require.idempotent-fixes)
+   * .why  = the fix rebuilds the file from the template plus the custom lines it finds. a second
+   *         pass must find the same custom lines once, keep them once, and emit the same bytes —
+   *         else each `declapract fix` grows or reorders the custom block. the output must also
+   *         CONTAIN the template, so the CONTAINS check passes and the plan stops to flag it.
+   */
+  it('should be a fixed point — fix(fix(x)) equals fix(x), and the output contains the template', async () => {
+    const declaredFileContents = await readFile({
+      filePath: `${__dirname}/best-practice/provision/schema/sql/init/.extensions.sql`,
+    });
+    const context = { declaredFileContents } as any;
+    const input = `
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+CREATE EXTENSION IF NOT EXISTS "cube";
+CREATE EXTENSION IF NOT EXISTS "earthdistance";
+-- CREATE EXTENSION IF NOT EXISTS ...
+`;
+
+    const { contents: once } = await fix(input, context);
+    const { contents: twice } = await fix(once, context);
+
+    expect(twice).toEqual(once);
+    expect(once).toContain(declaredFileContents.trim());
+    expect(once?.match(/"cube"/g)).toHaveLength(1);
+    expect(once?.match(/"uuid-ossp"/g)).toHaveLength(1);
+  });
+
+  /**
+   * .what = the fix through the real declapract pipeline, on a repo with custom extensions
+   * .why  = the unit cases above prove the fix in isolation; only executeApply proves the
+   *         declared path reaches the target file, the CONTAINS check gates the fix, the
+   *         `declaredFileContents` the fix reads is the template, and a rerun settles
+   *         (rule.require.declapract-integration-tests)
+   */
+  given('[case1] a repo whose .extensions.sql predates the template and holds custom lines', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-persist-with-rds-extensions-sql',
+      clone:
+        './src/practices/persist-with-rds/.test/assets/demo-repo-with-custom-extensions',
+      symlink: [{ at: 'declarations', to: 'src' }],
+    });
+    const read = () =>
+      fs.readFile(path.join(tempDir, EXTENSIONS_SQL), 'utf-8');
+    const apply = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'persist-with-rds',
+        file: EXTENSIONS_SQL,
+      });
+
+    when('[t0] before any apply', () => {
+      then('the input file matches snapshot', async () => {
+        expect(await read()).toMatchSnapshot('.extensions.sql — before');
+      });
+    });
+
+    when('[t1] apply runs', () => {
+      const scene = useThen('apply settles', async () => {
+        await apply();
+        const declared = await readFile({
+          filePath: `${__dirname}/best-practice/${EXTENSIONS_SQL}`,
+        });
+        return { after: await read(), declared };
+      });
+
+      then('the file now contains the whole template', () => {
+        expect(scene.after).toContain(scene.declared.trim());
+      });
+
+      then('each custom extension survives, once', () => {
+        expect(scene.after).toContain('CREATE EXTENSION IF NOT EXISTS "cube";');
+        expect(scene.after).toContain(
+          'CREATE EXTENSION IF NOT EXISTS "earthdistance";',
+        );
+        expect(scene.after.match(/"cube"/g)).toHaveLength(1);
+        expect(scene.after.match(/"earthdistance"/g)).toHaveLength(1);
+      });
+
+      then('each required extension appears once, never duplicated', () => {
+        expect(scene.after.match(/"uuid-ossp"/g)).toHaveLength(1);
+        expect(scene.after.match(/"pgcrypto"/g)).toHaveLength(1);
+      });
+
+      then('the legacy note block is gone', () => {
+        expect(scene.after).not.toContain('NOTE: because db owner');
+      });
+
+      then('no declapract template syntax leaked', () => {
+        expect(scene.after).not.toContain('@declapract{');
+      });
+
+      then('the output matches snapshot', () => {
+        expect(scene.after).toMatchSnapshot('.extensions.sql — after');
+      });
+    });
+
+    when('[t2] apply runs a second time', () => {
+      const before = useBeforeAll(async () => ({ contents: await read() }));
+      const scene = useThen('apply again', async () => {
+        await apply();
+        return { after: await read() };
+      });
+
+      then('the file is byte-identical — the apply is a fixed point', () => {
+        expect(scene.after).toEqual(before.contents);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,20 @@
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service-with-rds
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'
+  infrastructureNamespaceId: 'testns'
+  databaseName: 'testdb'
+  databaseUserName:
+    cicdUser: 'cicd_user'
+    serviceUser: 'service_user'
+  databaseTunnelHost:
+    prep: 'localhost'
+    prod: 'localhost'
+  databaseClusterHost:
+    prep: 'awesomesdb.cluster-abc123.us-east-1.rds.amazonaws.com'
+    prod: 'awesomesdb.cluster-def456.us-east-1.rds.amazonaws.com'
+  slackWebhookUrl: 'https://hooks.slack.test/webhook'
+  awsAccountId:
+    prep: '111111111111'
+    prod: '222222222222'

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

@@ -0,0 +1,6 @@
+# the test symlinks `declarations/practices` -> src/practices and `declarations/useCases.yml` ->
+# src/useCases.yml at genTempDir time, so the temp repo's own `src/` stays its own: the apply writes
+# src/utils/config/config.schema.ts there, never into this repo's src.
+declare:
+  practices: practices
+  use-cases: useCases.yml

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-config-schema/package.json

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-on-a-prior-major/codegen.sql.dao.yml

@@ -0,0 +1,20 @@
+language: postgres
+dialect: 10.7
+generates:
+  daos:
+    to: src/access/daos
+    using:
+      log: src/utils/logger#log
+      DatabaseConnection: src/utils/database/getOneDatabaseConnection#DatabaseConnection
+  schema:
+    config: codegen.sql.schema.yml
+  control:
+    config: provision/schema/control.yml
+  code:
+    config: codegen.sql.types.yml
+for:
+  objects:
+    search:
+      - 'src/domain.objects/*.ts'
+    exclude:
+      - 'SurfReportDraft'

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-on-a-prior-major/declapract.declare.yml

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-on-a-prior-major/declapract.use.yml

@@ -0,0 +1,19 @@
+declarations: './'
+useCase: lambda-service-with-rds
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'
+  databaseName: 'testdb'
+  databaseClusterName: 'testdb'
+  databaseUserName:
+    cicdUser: 'testdb_cicd'
+    serviceUser: 'testdb_service'
+  databaseTunnelHost:
+    prep: 'localhost'
+    prod: 'localhost'
+  databaseClusterHost:
+    prep: 'localhost'
+    prod: 'localhost'
+  awsAccountId:
+    prep: '123456789012'
+    prod: '123456789012'

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-on-a-prior-major/package.json

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-on-a-prior-major/provision/docker/testdb/build-image.dockerfile

@@ -0,0 +1,6 @@
+FROM postgres:17.9
+
+COPY init/ /docker-entrypoint-initdb.d/
+
+ADD wait-for-postgres.sh /root/
+RUN chmod +x /root/wait-for-postgres.sh

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

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

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

@@ -0,0 +1,21 @@
+# .note = apply evaluates the whole persist-with-rds practice, so every
+#         `@declapract{variable.*}` its best-practice dir references is defined here
+declarations: './'
+useCase: lambda-service-with-rds
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'
+  databaseName: 'testdb'
+  databaseClusterName: 'testdb'
+  databaseUserName:
+    cicdUser: 'testdb_cicd'
+    serviceUser: 'testdb_service'
+  databaseTunnelHost:
+    prep: 'localhost'
+    prod: 'localhost'
+  databaseClusterHost:
+    prep: 'localhost'
+    prod: 'localhost'
+  awsAccountId:
+    prep: '123456789012'
+    prod: '123456789012'

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-with-custom-extensions/package.json

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-with-custom-extensions/provision/schema/sql/init/.extensions.sql

@@ -0,0 +1,9 @@
+/**
+ NOTE: because db owner is not allowed to create extensions, these changes are applied manually
+
+  NOTE: for the integration test db, these are applied automatically when the docker instance starts
+*/
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+CREATE EXTENSION IF NOT EXISTS "cube";
+CREATE EXTENSION IF NOT EXISTS "earthdistance";

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-with-dev-config/config/dev.json

@@ -0,0 +1,18 @@
+{
+  "organization": "test-org",
+  "project": "test-project",
+  "environment": {
+    "access": "dev"
+  },
+  "database": {
+    "host": "bastion.dev.example.com",
+    "tunnel": "aws.ssmproxy.mydb.dev",
+    "password": "__CHANG3_ME__"
+  },
+  "upstream": {
+    "paypal": "api.dev.paypal.com"
+  },
+  "auth": {
+    "callbackUrl": "https://auth.myapp.dev"
+  }
+}

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

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

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

@@ -0,0 +1,18 @@
+declarations: './'
+useCase: lambda-service-with-rds
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'
+  databaseName: 'testdb'
+  databaseUserName:
+    cicdUser: 'cicd_user'
+    serviceUser: 'service_user'
+  databaseTunnelHost:
+    prep: 'tunnel.prep.example.com'
+    prod: 'tunnel.prod.example.com'
+  databaseClusterHost:
+    prep: 'cluster.prep.example.com'
+    prod: 'cluster.prod.example.com'
+  awsAccountId:
+    prep: '123456789012'
+    prod: '123456789012'

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/demo-repo-with-dev-config/package.json

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/repo-with-hand-patch/declapract.use.yml

@@ -0,0 +1,4 @@
+# .note = the test writes declarations/ into the temp clone (genDeclarationsOfPackageJsonOnly)
+# .why  = an rds repo that already holds its own exact-version pg-pool hand patch (vision case=2)
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/repo-with-hand-patch/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "repo-with-hand-patch",
+  "version": "1.0.0",
+  "dependencies": {
+    "pg": "8.3.0",
+    "pg-pool": "3.14.0"
+  },
+  "pnpm": {
+    "overrides": {
+      "react-refresh": "0.14.2"
+    },
+    "patchedDependencies": {
+      "pg-pool@3.14.0": "patches/pg-pool@3.14.0.patch",
+      "left-pad@1.3.0": "patches/left-pad@1.3.0.patch"
+    }
+  }
+}

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/repo-with-hand-patch/patches/left-pad@1.3.0.patch

@@ -0,0 +1,6 @@
+diff --git a/index.js b/index.js
+--- a/index.js
++++ b/index.js
+@@ -1,1 +1,1 @@
+-/* This program is free software. It comes without any warranty, to
++/* This program is free software. It comes without any warranty, to (hand patch)

package/dist/.test/assets/git/declarations/practices/persist-with-rds/.test/assets/repo-with-hand-patch/patches/pg-pool@3.14.0.patch

@@ -0,0 +1,12 @@
+diff --git a/index.js b/index.js
+--- a/index.js
++++ b/index.js
+@@ -92,7 +92,7 @@ class Pool extends EventEmitter {
+     this.options.allowExitOnIdle = this.options.allowExitOnIdle || false
+     this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0
+     this.log = this.options.log || function () {}
+-    this.Client = this.options.Client || Client || require('pg').Client
++    this.Client = this.options.Client || Client // hand patch
+     this.Promise = this.options.Promise || global.Promise
+
+     if (typeof this.options.idleTimeoutMillis === 'undefined') {