declapract-typescript-ehmpathy 0.49.14 → 0.50.0

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

@@ -0,0 +1,90 @@
+import { HelpfulError, UnexpectedCodePathError } from 'helpful-errors';
+import pg, { Client, type QueryResult, type QueryResultRow } from 'pg';
+
+import { getConfig } from '../config/getConfig';
+import { getEnvironment } from '../environment';
+
+// 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?: unknown[];
+  }) => Promise<QueryResult<Row>>;
+  end: () => Promise<void>;
+}
+
+export class DatabaseQueryError extends HelpfulError {
+  constructor({
+    sql,
+    values,
+    caught,
+  }: {
+    sql: string;
+    values?: unknown[];
+    caught: Error;
+  }) {
+    const message = `
+caught error querying database: ${caught.message}
+
+sql:
+  ${sql.trim()}
+
+values:
+  ${JSON.stringify(values)}
+    `.trim();
+    super(message, { sql, values, cause: caught });
+  }
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const environment = await getEnvironment();
+  const config = await getConfig();
+  const target = config.database.target;
+  const role = config.database.role.crud;
+
+  // determine which tunnel to use based on environment.server
+  const tunnel =
+    environment.server === 'AWS:LAMBDA'
+      ? config.database.tunnel.lambda
+      : config.database.tunnel.local;
+
+  // ensure tunnel is defined for the requested server
+  if (!tunnel) {
+    throw new UnexpectedCodePathError(
+      `Database tunnel not configured for environment.server + env.access`,
+      { environment },
+    );
+  }
+
+  // instantiate the client
+  const client = new Client({
+    host: tunnel.host,
+    port: tunnel.port,
+    user: role.username,
+    password: role.password,
+    database: target.database,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${target.schema}, public;`); // https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-
+  const dbConnection = {
+    query: ({ sql, values }: { sql: string; values?: unknown[] }) =>
+      client.query(sql, values),
+    end: () => client.end(),
+  };
+
+  // declare our interface
+  return {
+    query: (args: { sql: string; values?: unknown[] }) =>
+      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.9e1bdc4.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.c6cef7e.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.c8eb35b.ts

@@ -0,0 +1,90 @@
+import { HelpfulError, UnexpectedCodePathError } from 'helpful-errors';
+import pg, { Client, QueryResult, QueryResultRow } from 'pg';
+
+import { getConfig } from '../config/getConfig';
+import { getEnvironment } from '../environment';
+
+// 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 HelpfulError {
+  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, { sql, values, cause: caught });
+  }
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const environment = await getEnvironment();
+  const config = await getConfig();
+  const target = config.database.target;
+  const role = config.database.role.crud;
+
+  // determine which tunnel to use based on environment.server
+  const tunnel =
+    environment.server === 'AWS:LAMBDA'
+      ? config.database.tunnel.lambda
+      : config.database.tunnel.local;
+
+  // ensure tunnel is defined for the requested server
+  if (!tunnel) {
+    throw new UnexpectedCodePathError(
+      `Database tunnel not configured for environment.server + env.access`,
+      { environment },
+    );
+  }
+
+  // instantiate the client
+  const client = new Client({
+    host: tunnel.host,
+    port: tunnel.port,
+    user: role.username,
+    password: role.password,
+    database: target.database,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${target.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(),
+  };
+
+  // declare our interface
+  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.d1e8cd7.ts

@@ -0,0 +1,31 @@
+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;
+};

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

@@ -0,0 +1,90 @@
+import { HelpfulError, UnexpectedCodePathError } from 'helpful-errors';
+import pg, { Client, type QueryResult, type QueryResultRow } from 'pg';
+
+import { getConfig } from '../config/getConfig';
+import { getEnvironment } from '../environment';
+
+// 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?: unknown[];
+  }) => Promise<QueryResult<Row>>;
+  end: () => Promise<void>;
+}
+
+export class DatabaseQueryError extends HelpfulError {
+  constructor({
+    sql,
+    values,
+    caught,
+  }: {
+    sql: string;
+    values?: unknown[];
+    caught: Error;
+  }) {
+    const message = `
+caught error querying database: ${caught.message}
+
+sql:
+  ${sql.trim()}
+
+values:
+  ${JSON.stringify(values)}
+    `.trim();
+    super(message, { sql, values, cause: caught });
+  }
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const environment = await getEnvironment();
+  const config = await getConfig();
+  const target = config.database.target;
+  const role = config.database.role.crud;
+
+  // determine which tunnel to use based on environment.server
+  const tunnel =
+    environment.server === 'cloud@aws.lambda'
+      ? config.database.tunnel.lambda
+      : config.database.tunnel.local;
+
+  // ensure tunnel is defined for the requested server
+  if (!tunnel) {
+    throw new UnexpectedCodePathError(
+      `Database tunnel not configured for environment.server + env.access`,
+      { environment },
+    );
+  }
+
+  // instantiate the client
+  const client = new Client({
+    host: tunnel.host,
+    port: tunnel.port,
+    user: role.username,
+    password: role.password,
+    database: target.database,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${target.schema}, public;`); // https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-
+  const dbConnection = {
+    query: ({ sql, values }: { sql: string; values?: unknown[] }) =>
+      client.query(sql, values),
+    end: () => client.end(),
+  };
+
+  // declare our interface
+  return {
+    query: (args: { sql: string; values?: unknown[] }) =>
+      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.eab15c0.ts

@@ -0,0 +1,89 @@
+import { HelpfulError, UnexpectedCodePathError } from 'helpful-errors';
+import pg, { Client, QueryResult, QueryResultRow } from 'pg';
+
+import { getConfig } from '../config/getConfig';
+import { environment } from '../environment';
+
+// 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 HelpfulError {
+  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, { sql, values, cause: caught });
+  }
+}
+
+export const getDatabaseConnection = async (): Promise<DatabaseConnection> => {
+  const config = await getConfig();
+  const target = config.database.target;
+  const role = config.database.role.crud;
+
+  // determine which tunnel to use based on environment.server
+  const tunnel =
+    environment.server === 'AWS:LAMBDA'
+      ? config.database.tunnel.lambda
+      : config.database.tunnel.local;
+
+  // ensure tunnel is defined for the requested server
+  if (!tunnel) {
+    throw new UnexpectedCodePathError(
+      `Database tunnel not configured for environment.server + env.access`,
+      { environment },
+    );
+  }
+
+  // instantiate the client
+  const client = new Client({
+    host: tunnel.host,
+    port: tunnel.port,
+    user: role.username,
+    password: role.password,
+    database: target.database,
+  });
+  await client.connect();
+  await client.query(`SET search_path TO ${target.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(),
+  };
+
+  // declare our interface
+  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.ef25ae0.ts

@@ -0,0 +1,32 @@
+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;
+};

package/dist/.test/assets/git/declarations/practices/persist-with-rds/bad-practices/old-get-database-connection/.test/assets/old-templates/getDatabaseConnection.integration.test.66284e3.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/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,75 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`old-get-database-connection (#659) given: [case4] a repo with the old factory, its test, and two importers when: [t0] the input, before any fix then: each importer matches snapshot: src/access/daos/daoSurfer.ts — before 1`] = `
+"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],
+  });
+};
+"
+`;
+
+exports[`old-get-database-connection (#659) given: [case4] a repo with the old factory, its test, and two importers when: [t0] the input, before any fix then: each importer matches snapshot: src/domain.operations/getSurfLesson.ts — before 1`] = `
+"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;
+};
+"
+`;
+
+exports[`old-get-database-connection (#659) given: [case4] a repo with the old factory, its test, and two importers when: [t1] apply runs over each affected file then: the dao is repointed, its foreign import untouched, and matches snapshot: src/access/daos/daoSurfer.ts — after 1`] = `
+"import type { DatabaseConnection } from '@src/utils/database/getOneDatabaseConnection';
+
+// 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],
+  });
+};
+"
+`;
+
+exports[`old-get-database-connection (#659) given: [case4] a repo with the old factory, its test, and two importers when: [t1] apply runs over each affected file then: the operation reads getOneDatabaseConnection, and matches snapshot: src/domain.operations/getSurfLesson.ts — after 1`] = `
+"import {
+  type DatabaseConnection,
+  getOneDatabaseConnection,
+} from '../utils/database/getOneDatabaseConnection';
+
+export const getSurfLesson = async (input: { uuid: string }) => {
+  const dbConnection: DatabaseConnection = await getOneDatabaseConnection();
+  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/src/<star><star>/<star>.ts.declapract.ts

@@ -0,0 +1,33 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import {
+  isGetDatabaseConnectionImporter,
+  withGetDatabaseConnectionRepointed,
+} from '../../../../../../utils/withGetDatabaseConnectionRepointed';
+
+/**
+ * .what = the two retired files this bad-practice declares by their own path
+ * .why = each has its own declaration (delete on a template match, else keep); this wildcard
+ *        repoints every OTHER importer, so the two never race on one file
+ */
+const RETIRED_FILE_PATHS = [
+  'src/utils/database/getDatabaseConnection.ts',
+  'src/utils/database/getDatabaseConnection.integration.test.ts',
+];
+
+export const check: FileCheckFunction = (contents, context) => {
+  if (
+    contents &&
+    !RETIRED_FILE_PATHS.includes(context.relativeFilePath) &&
+    isGetDatabaseConnectionImporter({ source: contents })
+  )
+    return; // bad practice detected: this file imports the retired factory module
+  throw new Error(
+    'does not match bad practice: no import of src/utils/database/getDatabaseConnection',
+  );
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+  return { contents: withGetDatabaseConnectionRepointed({ source: contents }) };
+};