declapract-typescript-ehmpathy 0.49.14 → 0.50.0

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/legacy-change-id/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,39 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`legacy-change-id (#530) given: [case1] a repo whose schema definitions use the legacy \`id:\` key when: [t0] the input, before any fix then: init.yml holds \`id:\` on each change, and matches snapshot: init.yml — before 1`] = `
+"- type: change
+  id: init_default_txn_isolation
+  author: declapract
+  path: ./init/default_transaction_isolation.sql
+
+- type: change
+  id: init_service_user
+  author: declapract
+  path: ./init/user.service.sql
+
+# a change the repo added on its own
+- type: change
+  id: init_analyst_user
+  author: surfschool
+  path: ./init/user.analyst.sql
+"
+`;
+
+exports[`legacy-change-id (#530) given: [case1] a repo whose schema definitions use the legacy \`id:\` key when: [t1] apply runs then: each change entry declares \`exid:\`, the repo extra kept, and matches snapshot: init.yml — after 1`] = `
+"- type: change
+  exid: init_default_txn_isolation
+  author: declapract
+  path: ./init/default_transaction_isolation.sql
+
+- type: change
+  exid: init_service_user
+  author: declapract
+  path: ./init/user.service.sql
+
+# a change the repo added on its own
+- type: change
+  exid: init_analyst_user
+  author: surfschool
+  path: ./init/user.analyst.sql
+"
+`;

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/legacy-change-id/provision/schema/<star><star>/<star>.yml.declapract.ts

@@ -0,0 +1,68 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import { isMap, isScalar, parseDocument, visit } from 'yaml';
+
+/**
+ * .what = the `id` key of each sql-schema-control change entry that still uses the legacy key
+ * .why = sql-schema-control@1.8.0 renamed a change's natural key from `id:` to `exid:`. the
+ *        tool still reads `id:`, but nudges on every plan and apply. only the key on a
+ *        `type: change` entry moves; an `id` key anywhere else in the yml is not the tool's.
+ * .note = an entry that already declares `exid` is never a target — whether it also holds an
+ *         `id` (the tool rejects that pair) or not. a rename there would leave two `exid` keys.
+ */
+const getLegacyChangeIdKeyRanges = (input: {
+  contents: string;
+}): { start: number; end: number }[] => {
+  const document = parseDocument(input.contents);
+  const ranges: { start: number; end: number }[] = [];
+  visit(document, {
+    Map: (_key, map) => {
+      if (!isMap(map)) return;
+      const isChange = map.get('type') === 'change';
+      if (!isChange) return;
+      if (map.has('exid')) return;
+      const pair = map.items.find(
+        (item) => isScalar(item.key) && item.key.value === 'id',
+      );
+      if (!pair || !isScalar(pair.key) || !pair.key.range) return;
+      ranges.push({ start: pair.key.range[0], end: pair.key.range[1] });
+    },
+  });
+  return ranges;
+};
+
+/**
+ * .what = the contents with `exid` spliced over each given key range
+ * .why = a splice keeps every other byte — comments, blank lines, quotes — exactly as the repo
+ *        wrote them
+ * .note = applied bottom-up, so the earlier offsets stay valid
+ */
+const withExidOverRanges = (input: {
+  contents: string;
+  ranges: { start: number; end: number }[];
+}): string =>
+  [...input.ranges]
+    .sort((a, b) => b.start - a.start)
+    .reduce(
+      (text, range) =>
+        `${text.slice(0, range.start)}exid${text.slice(range.end)}`,
+      input.contents,
+    );
+
+export const check: FileCheckFunction = (contents) => {
+  if (contents && getLegacyChangeIdKeyRanges({ contents }).length > 0) return; // bad practice detected
+  throw new Error(
+    'does not match bad practice: no sql-schema-control change entry uses the legacy `id:` key',
+  );
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+
+  // splice `exid` over each legacy key
+  return {
+    contents: withExidOverRanges({
+      contents,
+      ranges: getLegacyChangeIdKeyRanges({ contents }),
+    }),
+  };
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/.declapract.readme.md

@@ -0,0 +1,5 @@
+we have several files that are not automatically managed by `sql-schema-control` and must be applied manually with superuser privileges
+
+to make the distinction between these and the files that _are_ managed by `sql-schema-control`, we've adopted the convention that the ones that need to be applied manually with `superuser` privs are prefixed with a `.`
+
+this practice checks for the case where we didn't have the prefix - and fixes it by prefixing the files for us

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/provision/schema/sql/init/database.sql.declapract.ts

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/provision/schema/sql/init/extensions.sql.declapract.ts

@@ -0,0 +1,13 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS;
+
+// for this one, we want to move the file, not just delete it, since it may have had customizations
+export const fix: FileFixFunction = (_, context) => {
+  return {
+    relativeFilePath: context.relativeFilePath.replace(
+      '/extensions.sql',
+      '/.extensions.sql',
+    ),
+  };
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/provision/schema/sql/init/schema.sql.declapract.ts

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/provision/schema/sql/init/user.cicd.sql.declapract.ts

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/provision/schema/sql/init/user.datalakedb.sql.declapract.ts

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-config-file-names/codegen.sql.yml.declapract.ts

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-dev-config-location/config/dev.json.declapract.ts

@@ -0,0 +1,23 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+import { asPrepConfigPath } from '../../../../../utils/asPrepConfigPath';
+import { migrateDevConfigToPrep } from '../../../../../utils/migrateDevConfigToPrep';
+
+export const check = FileCheckType.EXISTS;
+
+/**
+ * .what = move config/dev.json → config/prep.json and migrate the access tokens (dev → prep)
+ * .why  = both halves are shared utils (one source for both declarers): migrateDevConfigToPrep
+ *         owns the content migration, asPrepConfigPath owns the relocate. the `__CHANG3_ME__`
+ *         passwords stay as they are — `deploy.database.sh` creates prep users with that
+ *         password, so a flip to `$.at(aws::param)` would point the app at params that hold no
+ *         value (#683).
+ */
+export const fix: FileFixFunction = (contents, context) => ({
+  contents: contents
+    ? migrateDevConfigToPrep({ contents })
+    : (contents ?? null),
+  relativeFilePath: asPrepConfigPath({
+    relativeFilePath: context.relativeFilePath,
+  }),
+});

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.declapract.integration.test.ts

@@ -0,0 +1,221 @@
+import fs from 'fs/promises';
+import { readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import type { FileCheckContext } from 'declapract';
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+import { asTemplateFingerprint } from '../../../../utils/asTemplateFingerprint';
+import {
+  check as checkOldTest,
+  fix as fixOldTest,
+  OLD_TEST_TEMPLATE_FINGERPRINTS,
+} from './src/utils/database/getDatabaseConnection.integration.test.ts.declapract';
+import {
+  check as checkOldFactory,
+  fix as fixOldFactory,
+  OLD_TEMPLATE_FINGERPRINTS,
+} from './src/utils/database/getDatabaseConnection.ts.declapract';
+
+/**
+ * .what = proof of the old-get-database-connection retirement (#659): every body the practice
+ *         ever shipped at `src/utils/database/getDatabaseConnection.ts` is deleted, an edited copy
+ *         is kept and flagged, and every importer is repointed onto `getOneDatabaseConnection` —
+ *         first per declaration, then through the REAL declapract apply pipeline.
+ * .why = b8d4803 renamed the factory and left the old file behind, where it still reads the
+ *        `database.service` config key the practice removed — tsc goes red on every adopter that
+ *        carried it, and 50+ importers still name it. a delete of a file an adopter edited would
+ *        drop that edit silently, so the delete keys on a template match, never on existence.
+ * .teeth = drop a fingerprint and its fixture reddens; delete on existence alone and the edited
+ *          copy case reddens; rename every `getDatabaseConnection` token and the foreign-import
+ *          case in `daoSurfer.ts` reddens.
+ * .note = INTEGRATION by `rule.forbid.unit.remote-boundaries`: it reads fixture files and runs an
+ *         apply into a temp dir.
+ */
+// each apply evaluates the whole practice, and case4 runs four per pass
+jest.setTimeout(10 * 60 * 1000);
+
+const OLD_TEMPLATES_DIR =path.join(__dirname, '.test/assets/old-templates');
+const context = {} as FileCheckContext; // note: these declarations read no context
+
+const oldFactoryFixtures = readdirSync(OLD_TEMPLATES_DIR)
+  .filter((name) => /^getDatabaseConnection\.[0-9a-f]+\.ts$/.test(name))
+  .map((name) => ({
+    name,
+    source: readFileSync(path.join(OLD_TEMPLATES_DIR, name), 'utf8'),
+  }));
+const oldTestFixture = readFileSync(
+  path.join(OLD_TEMPLATES_DIR, 'getDatabaseConnection.integration.test.66284e3.ts'),
+  'utf8',
+);
+
+describe('old-get-database-connection (#659)', () => {
+  given('[case1] each body the practice shipped at getDatabaseConnection.ts', () => {
+    then('every template revision is held as a fixture', () => {
+      expect(oldFactoryFixtures.length).toEqual(10);
+    });
+
+    oldFactoryFixtures.forEach((fixture) =>
+      when(`[t0] ${fixture.name} is fixed`, () => {
+        then('its fingerprint is a known template', () => {
+          expect(OLD_TEMPLATE_FINGERPRINTS).toContain(
+            asTemplateFingerprint({ source: fixture.source }),
+          );
+        });
+        then('the file is deleted', () => {
+          expect(() => checkOldFactory(fixture.source, context)).not.toThrow();
+          expect(fixOldFactory(fixture.source, context)).toEqual({ contents: null });
+        });
+      }),
+    );
+
+    when('[t1] the newest template, reformatted (double quotes, no semicolons)', () => {
+      const newest = oldFactoryFixtures.find((fixture) =>
+        fixture.name.includes('e0c53d8'),
+      )!.source;
+      const reformatted = newest
+        .replace(/^(import .*)'([^']+)';$/gm, '$1"$2"')
+        .replace(/;$/gm, '');
+      then('format drift still reads as the template, so the file is deleted', () => {
+        expect(reformatted).not.toEqual(newest);
+        expect(fixOldFactory(reformatted, context)).toEqual({ contents: null });
+      });
+    });
+  });
+
+  given('[case2] a getDatabaseConnection.ts the adopter edited', () => {
+    const newest = oldFactoryFixtures.find((fixture) =>
+      fixture.name.includes('e0c53d8'),
+    )!.source;
+    const edited = newest.replace(
+      'await client.connect();',
+      "await client.connect();\n  await client.query('SET statement_timeout = 5000;');",
+    );
+
+    when('[t0] fix runs', () => {
+      const { contents: fixed } = fixOldFactory(edited, context) as {
+        contents: string;
+      };
+      then('the file is kept, with its edit and a review pointer', () => {
+        expect(fixed).toContain("SET statement_timeout = 5000;");
+        expect(fixed.split('\n')[0]).toContain(
+          '@declapract:review: getDatabaseConnection.ts is retired',
+        );
+      });
+      then('a second fix changes zero bytes', () => {
+        expect(fixOldFactory(fixed, context)).toEqual({ contents: fixed });
+      });
+    });
+  });
+
+  given('[case3] the old integration test', () => {
+    when('[t0] the shipped body is fixed', () => {
+      then('its fingerprint is known, and the duplicate is deleted', () => {
+        expect(OLD_TEST_TEMPLATE_FINGERPRINTS).toContain(
+          asTemplateFingerprint({ source: oldTestFixture }),
+        );
+        expect(fixOldTest(oldTestFixture, context)).toEqual({ contents: null });
+      });
+    });
+
+    when('[t1] an edited copy is fixed', () => {
+      const edited = oldTestFixture.replace(
+        "it('should be able",
+        "it('should still be able",
+      );
+      const { contents: fixed } = fixOldTest(edited, context) as {
+        contents: string;
+      };
+      then('it is kept and repointed, and check no longer detects it', () => {
+        expect(fixed).toContain("from './getOneDatabaseConnection'");
+        expect(fixed).toContain('await getOneDatabaseConnection()');
+        expect(() => checkOldTest(fixed, context)).toThrow(
+          'does not match bad practice',
+        );
+      });
+    });
+  });
+
+  given('[case4] a repo with the old factory, its test, and two importers', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-persist-with-rds-old-get-database-connection',
+      clone:
+        './src/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection',
+      symlink: [{ at: 'declarations', to: 'src' }],
+    });
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const exists = (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 apply = (file: string) =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'persist-with-rds',
+        file,
+      });
+    const importers = [
+      'src/domain.operations/getSurfLesson.ts',
+      'src/access/daos/daoSurfer.ts',
+    ];
+    const retired = [
+      'src/utils/database/getDatabaseConnection.ts',
+      'src/utils/database/getDatabaseConnection.integration.test.ts',
+    ];
+
+    when('[t0] the input, before any fix', () => {
+      then('each importer matches snapshot', async () => {
+        for (const importer of importers)
+          expect(await read(importer)).toMatchSnapshot(`${importer} — before`);
+      });
+    });
+
+    when('[t1] apply runs over each affected file', () => {
+      useThen('apply', async () => {
+        for (const file of [...retired, ...importers]) await apply(file);
+      });
+
+      then('the retired factory and its test are gone', async () => {
+        for (const file of retired) expect(await exists(file)).toEqual(false);
+      });
+
+      then('the operation reads getOneDatabaseConnection, and matches snapshot', async () => {
+        const after = await read('src/domain.operations/getSurfLesson.ts');
+        expect(after).toContain("from '../utils/database/getOneDatabaseConnection'");
+        expect(after).toContain('await getOneDatabaseConnection()');
+        expect(after).not.toMatch(/\bgetDatabaseConnection\b/);
+        expect(after).toMatchSnapshot('src/domain.operations/getSurfLesson.ts — after');
+      });
+
+      then('the dao is repointed, its foreign import untouched, and matches snapshot', async () => {
+        const after = await read('src/access/daos/daoSurfer.ts');
+        expect(after).toContain(
+          "from '@src/utils/database/getOneDatabaseConnection'",
+        );
+        expect(after).toContain(
+          "import { getDatabaseConnection as getLegacyWarehouse } from 'surf-warehouse-sdk'",
+        );
+        expect(after).toMatchSnapshot('src/access/daos/daoSurfer.ts — after');
+      });
+    });
+
+    when('[t2] apply runs again (idempotency)', () => {
+      const passes = useThen('a second apply', async () => {
+        const before = await Promise.all(importers.map((file) => read(file)));
+        for (const file of [...retired, ...importers]) await apply(file);
+        const after = await Promise.all(importers.map((file) => read(file)));
+        return { before, after };
+      });
+
+      then('the second apply changes zero bytes', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.declapract.readme.md

@@ -0,0 +1,11 @@
+persist-with-rds renamed its connection factory from `getDatabaseConnection` to
+`getOneDatabaseConnection`. the old file reads a config key the practice removed, so it fails tsc.
+
+this fix:
+- deletes `src/utils/database/getDatabaseConnection.ts` when it still matches a template the
+  practice shipped. the match ignores format, so a reformatted copy still counts
+- keeps a copy the repo edited, and stamps a review pointer at its top
+- deletes the old `getDatabaseConnection.integration.test.ts` on a template match. an edited copy
+  is kept and repointed
+- repoints every importer under `src/` onto `getOneDatabaseConnection`, both the module path and
+  the factory name. a `getDatabaseConnection` imported from another module is left alone

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/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/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/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/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/package.json

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

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/src/access/daos/daoSurfer.ts

@@ -0,0 +1,15 @@
+import type { DatabaseConnection } from '@src/utils/database/getDatabaseConnection';
+
+// a getDatabaseConnection from another module must never be renamed
+import { getDatabaseConnection as getLegacyWarehouse } from 'surf-warehouse-sdk';
+
+export const findSurferByUuid = async (
+  input: { uuid: string },
+  context: { dbConnection: DatabaseConnection },
+) => {
+  await getLegacyWarehouse();
+  return context.dbConnection.query({
+    sql: 'select * from surfer where uuid = $1',
+    values: [input.uuid],
+  });
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/src/domain.operations/getSurfLesson.ts

@@ -0,0 +1,14 @@
+import {
+  type DatabaseConnection,
+  getDatabaseConnection,
+} from '../utils/database/getDatabaseConnection';
+
+export const getSurfLesson = async (input: { uuid: string }) => {
+  const dbConnection: DatabaseConnection = await getDatabaseConnection();
+  const result = await dbConnection.query({
+    sql: 'select * from surf_lesson where uuid = $1',
+    values: [input.uuid],
+  });
+  await dbConnection.end();
+  return result.rows[0] ?? null;
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/src/utils/database/getDatabaseConnection.integration.test.ts

@@ -0,0 +1,10 @@
+import { getDatabaseConnection } from './getDatabaseConnection';
+
+describe('getDatabaseConnection', () => {
+  it('should be able to connect and execute a query', async () => {
+    const dbConnection = await getDatabaseConnection();
+    const result = await dbConnection.query({ sql: 'select 1' });
+    expect(result.rows.length).toEqual(1);
+    await dbConnection.end();
+  });
+});

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/demo-repo-with-old-get-database-connection/src/utils/database/getDatabaseConnection.ts

@@ -0,0 +1,68 @@
+import pg, { Client, QueryResult, QueryResultRow } from 'pg';
+
+import { getConfig } from '../config/getConfig';
+
+// https://github.com/brianc/node-postgres/pull/353#issuecomment-283709264
+pg.types.setTypeParser(20, (value) => parseInt(value, 10)); // cast bigints to numbers; by default, pg returns bigints as strings, since max val of bigint is bigger than max safe value in js
+pg.types.setTypeParser(1700, (value) => parseFloat(value)); // cast numerics to numbers; by default, pg returns numerics as strings
+
+export interface DatabaseConnection {
+  query: <Row extends QueryResultRow>(args: {
+    sql: string;
+    values?: any[];
+  }) => Promise<QueryResult<Row>>;
+  end: () => Promise<void>;
+}
+
+export class DatabaseQueryError extends Error {
+  constructor({
+    sql,
+    values,
+    caught,
+  }: {
+    sql: string;
+    values?: any[];
+    caught: Error;
+  }) {
+    const message = `
+caught error querying database: ${caught.message}
+
+sql:
+  ${sql.trim()}
+
+values:
+  ${JSON.stringify(values)}
+    `.trim();
+    super(message);
+  }
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const config = await getConfig();
+  const dbConfig = config.database.service;
+  const client = new Client({
+    host: dbConfig.host,
+    user: dbConfig.username,
+    password: dbConfig.password,
+    database: dbConfig.schema,
+    port: dbConfig.port,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${dbConfig.schema}, public;`); // https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-
+  const dbConnection = {
+    query: ({ sql, values }: { sql: string; values?: (string | number)[] }) =>
+      client.query(sql, values),
+    end: () => client.end(),
+  };
+  return {
+    query: (args: { sql: string; values?: any[] }) =>
+      dbConnection.query(args).catch((error) => {
+        throw new DatabaseQueryError({
+          sql: args.sql,
+          values: args.values,
+          caught: error,
+        });
+      }),
+    end: () => dbConnection.end(),
+  };
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/old-templates/getDatabaseConnection.3a193e5.ts

@@ -0,0 +1,65 @@
+import pg, { Client, QueryResult } from 'pg';
+
+import { getConfig } from '../config/getConfig';
+
+// https://github.com/brianc/node-postgres/pull/353#issuecomment-283709264
+pg.types.setTypeParser(20, (value) => parseInt(value, 10)); // cast bigints to numbers; by default, pg returns bigints as strings, since max val of bigint is bigger than max safe value in js
+pg.types.setTypeParser(1700, (value) => parseFloat(value)); // cast numerics to numbers; by default, pg returns numerics as strings
+
+export interface DatabaseConnection {
+  query: (args: { sql: string; values?: any[] }) => Promise<QueryResult<any>>;
+  end: () => Promise<void>;
+}
+
+export class DatabaseQueryError extends Error {
+  constructor({
+    sql,
+    values,
+    caught,
+  }: {
+    sql: string;
+    values?: any[];
+    caught: Error;
+  }) {
+    const message = `
+caught error querying database: ${caught.message}
+
+sql:
+  ${sql.trim()}
+
+values:
+  ${JSON.stringify(values)}
+    `.trim();
+    super(message);
+  }
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const config = await getConfig();
+  const dbConfig = config.database.service;
+  const client = new Client({
+    host: dbConfig.host,
+    user: dbConfig.username,
+    password: dbConfig.password,
+    database: dbConfig.schema,
+    port: dbConfig.port,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${dbConfig.schema}, public;`); // https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-
+  const dbConnection = {
+    query: ({ sql, values }: { sql: string; values?: (string | number)[] }) =>
+      client.query(sql, values),
+    end: () => client.end(),
+  };
+  return {
+    query: (args: { sql: string; values?: any[] }) =>
+      dbConnection.query(args).catch((error) => {
+        throw new DatabaseQueryError({
+          sql: args.sql,
+          values: args.values,
+          caught: error,
+        });
+      }),
+    end: () => dbConnection.end(),
+  };
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/old-templates/getDatabaseConnection.66284e3.ts

@@ -0,0 +1,30 @@
+import pg, { Client, QueryResult } from 'pg';
+import { getConfig } from '../config/getConfig';
+
+// https://github.com/brianc/node-postgres/pull/353#issuecomment-283709264
+pg.types.setTypeParser(20, (value) => parseInt(value, 10)); // cast bigints to numbers; by default, pg returns bigints as strings, since max val of bigint is bigger than max safe value in js
+pg.types.setTypeParser(1700, (value) => parseFloat(value)); // cast numerics to numbers; by default, pg returns numerics as strings
+
+export interface DatabaseConnection {
+  query: (args: { sql: string; values?: any[] }) => Promise<QueryResult<any>>;
+  end: () => Promise<void>;
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const config = await getConfig();
+  const dbConfig = config.database.service;
+  const client = new Client({
+    host: dbConfig.host,
+    user: dbConfig.username,
+    password: dbConfig.password,
+    database: dbConfig.schema,
+    port: dbConfig.port,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${dbConfig.schema}, public;`); // https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-
+  const dbConnection = {
+    query: ({ sql, values }: { sql: string; values?: (string | number)[] }) => client.query(sql, values),
+    end: () => client.end(),
+  };
+  return dbConnection;
+};