declapract-typescript-ehmpathy 0.17.0

package/dist/practices/lambda-clients/bad-practices/lambda-service-client-package/package.json.declapract.ts

@@ -0,0 +1,16 @@
+import { FileCheckType, FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {}; // should not reach here, file should exist; if doesnt though, do nothing
+  const parsedContents = JSON.parse(contents);
+  const fixedParsedContents = {
+    ...parsedContents,
+    dependencies: {
+      ...parsedContents.dependencies,
+      'lambda-service-client': undefined, // remove this module
+    },
+  };
+  return { contents: JSON.stringify(fixedParsedContents, null, 2) };
+};

package/dist/practices/lambda-clients/best-practice/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "simple-lambda-client": "@declapract{check.minVersion('2.1.3')}"
+  }
+}

package/dist/practices/lambda-clients/best-practice/package.json.declapract.ts

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

package/dist/practices/lambda-clients/best-practice/src/data/clients/<star>.ts

@@ -0,0 +1 @@
+import { invokeLambdaFunction } from 'simple-lambda-client';

package/dist/practices/lambda-clients/best-practice/src/data/clients/<star>.ts.declapract.ts

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

package/dist/practices/lambda-handlers/best-practice/package.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": {
+    "@middy/core": "@declapract{check.minVersion('1.0.0')}",
+    "simple-lambda-handlers": "@declapract{check.minVersion('0.6.0')}"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "@declapract{check.minVersion('8.10.40')}"
+  }
+}

package/dist/practices/lambda-handlers/best-practice/package.json.declapract.ts

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

package/dist/practices/lambda-handlers/best-practice/src/contract/handlers/<star><star>/<star>.declapract.ts

@@ -0,0 +1,3 @@
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.EXISTS; // we should have atleast one handler

package/dist/practices/linting/best-practice/.eslintrc.js

@@ -0,0 +1,44 @@
+module.exports = {
+  parser: '@typescript-eslint/parser', // Specifies the ESLint parser
+  extends: [
+    'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin
+    'airbnb-typescript/base', // uses the airbnb recommended rules
+    'prettier/@typescript-eslint', // disables ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
+    'plugin:prettier/recommended', // Enables eslint-plugin-prettier and displays prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
+  ],
+  parserOptions: {
+    project: './tsconfig.json',
+    ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
+    sourceType: 'module', // Allows for the use of imports
+  },
+  rules: {
+    '@typescript-eslint/explicit-function-return-type': 'off', // this can be figured out implicitly, and that is better
+    'sort-imports': 'off',
+    'import/prefer-default-export': 'off', // default export = bad
+    'import/no-default-export': 'error', // require named exports - they make it easier to refactor, enforce consistency, and increase constraints
+    '@typescript-eslint/no-non-null-assertion': 'off', // we use these to help typescript out when we know something it doesnt, and cant easily express that
+    'import/no-extraneous-dependencies': [
+      'error',
+      {
+        devDependencies: [
+          '**/*.test.ts',
+          '**/*.test.integration.ts',
+          '**/*.test.acceptance.ts',
+          'acceptance/**/*.ts',
+          '**/__test_utils__/**/*.ts',
+          'provision/**/*.ts',
+        ],
+      },
+    ],
+    '@typescript-eslint/no-explicit-any': 'off', // sometimes this is a valid definition
+    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    'import/no-cycle': 'off',
+    'max-classes-per-file': 'off',
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/no-floating-promises': 'error',
+    'prefer-destructuring': 'off',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    'lines-between-class-members': 'off',
+    'no-return-await': 'off', // this does not help anything and actually leads to bugs if we subsequently wrap the return in a try catch without remembering to _then_ add await
+  },
+};

package/dist/practices/linting/best-practice/package.json

@@ -0,0 +1,16 @@
+{
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "5.46.1",
+    "@typescript-eslint/parser": "5.46.1",
+    "eslint": "8.30.0",
+    "eslint-config-airbnb-base": "15.0.0",
+    "eslint-config-airbnb-typescript": "17.0.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-prettier": "4.2.1"
+  },
+  "scripts": {
+    "fix:lint": "eslint -c ./.eslintrc.js src/**/*.ts --fix",
+    "test:lint": "eslint -c ./.eslintrc.js src/**/*.ts"
+  }
+}

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

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;

package/dist/practices/logging/best-practice/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "simple-leveled-log-methods": "@declapract{check.minVersion('0.2.2')}"
+  }
+}

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

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

package/dist/practices/logging/best-practice/src/utils/logger.ts

@@ -0,0 +1,3 @@
+import { generateLogMethods } from 'simple-leveled-log-methods';
+
+export const log = generateLogMethods();

package/dist/practices/node/bad-practices/license/package.json.declapract.ts

@@ -0,0 +1,22 @@
+import { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+export const check: FileCheckFunction = async (contents) => {
+  expect(JSON.parse(contents ?? 'null')).toEqual(
+    expect.objectContaining({
+      license: expect.any(String), // we shouldn't have a license declared for service code
+    }),
+  );
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents }; // do nothing if no contents
+  const packageJSON = JSON.parse(contents);
+  const updatedPackageJSON = {
+    ...packageJSON,
+    license: undefined,
+  };
+  return {
+    contents: JSON.stringify(updatedPackageJSON, null, 2),
+  };
+};

package/dist/practices/node/best-practice/.nvmrc

@@ -0,0 +1 @@
+lts/*

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

@@ -0,0 +1,11 @@
+{
+  "name": "@declapract{variable.projectName}",
+  "author": "@declapract{variable.organizationName}",
+  "version": "@declapract{check.minVersion('0.0.0')}",
+  "private": true,
+  "scripts": {
+    "prepush": "npm run test && npm run build",
+    "preversion": "npm run prepush",
+    "postversion": "git push origin HEAD --tags --no-verify"
+  }
+}

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

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

package/dist/practices/node/best-practice/readme.md

@@ -0,0 +1 @@
+# @declapract{variable.projectName}

package/dist/practices/node/best-practice/readme.md.declapract.ts

@@ -0,0 +1,3 @@
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.CONTAINS; // i.e., check that the contents of the file contains what's declared (default is equals)

package/dist/practices/nonpublished-modules/.declapract.readme.md

@@ -0,0 +1,5 @@
+nonpublished modules are used when we are testing out some new functionality and have not yet generalized it sufficiently to warrant creating a npm module of its own yet (e.g., follow W.E.T and have not written it twice already)
+
+however, when modules do graduate and get published, we want to make sure we start using them and stop using the "nonpublished" one
+
+this practice consists of bad-practice checks that make sure whenever we publish one (or deprecate one) we dont keep using the old one

package/dist/practices/nonpublished-modules/bad-practices/ahbode-standard-lambda-handler/.declapract.readme.md

@@ -0,0 +1 @@
+was published under `standard-lambda-handlers` package

package/dist/practices/nonpublished-modules/bad-practices/ahbode-standard-lambda-handler/src/__nonpublished_modules__/ahbode-standard-lambda-handler/<star><star>/<star>.ts.declapract.ts

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

package/dist/practices/nonpublished-modules/bad-practices/ahbode-standard-lambda-handler/src/contract/handlers/<star>.integration.test.ts

@@ -0,0 +1 @@
+import { promiseLambdaInvocation } from '../../__nonpublished_modules__/ahbode-standard-lambda-handler';

package/dist/practices/nonpublished-modules/bad-practices/ahbode-standard-lambda-handler/src/contract/handlers/<star>.integration.test.ts.declapract.ts

@@ -0,0 +1,15 @@
+import { FileCheckType, FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {};
+  return {
+    contents: contents
+      .replace(
+        `import { promiseLambdaInvocation } from '../../__nonpublished_modules__/ahbode-standard-lambda-handler';`,
+        `import { invokeHandlerForTesting } from 'simple-lambda-testing-methods';`,
+      )
+      .replace(/promiseLambdaInvocation/g, 'invokeHandlerForTesting'),
+  };
+};

package/dist/practices/nonpublished-modules/bad-practices/ahbode-standard-lambda-handler/src/contract/handlers/<star>.ts

@@ -0,0 +1 @@
+import { createStandardHandler } from '../../__nonpublished_modules__/ahbode-standard-lambda-handler';

package/dist/practices/nonpublished-modules/bad-practices/ahbode-standard-lambda-handler/src/contract/handlers/<star>.ts.declapract.ts

@@ -0,0 +1,13 @@
+import { FileCheckType, FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {};
+  return {
+    contents: contents.replace(
+      `import { createStandardHandler } from '../../__nonpublished_modules__/ahbode-standard-lambda-handler';`,
+      `import { createStandardHandler } from 'simple-lambda-handlers';`,
+    ),
+  };
+};

package/dist/practices/nonpublished-modules/bad-practices/deep-omit/.declapract.readme.md

@@ -0,0 +1 @@
+was replaced with `domain-objects#omitAutogeneratedValues`

package/dist/practices/nonpublished-modules/bad-practices/deep-omit/src/__nonpublished_modules__/deep-omit/<star><star>/<star>.ts.declapract.ts

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

package/dist/practices/nonpublished-modules/bad-practices/deep-omit/src/data/dao/<star><star>/<star>.integration.test.ts

@@ -0,0 +1 @@
+import { deepOmit } from '../../../__nonpublished_modules__/deep-omit';

package/dist/practices/nonpublished-modules/bad-practices/deep-omit/src/data/dao/<star><star>/<star>.integration.test.ts.declapract.ts

@@ -0,0 +1,18 @@
+import { FileCheckType, FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {};
+  return {
+    contents: contents
+      .replace(
+        `import { deepOmit } from '../../../__nonpublished_modules__/deep-omit';`,
+        `import { omitAutogeneratedValues } from 'domain-objects';`,
+      )
+      .replace(
+        /deepOmit\(([\w|!|?|\.]+), \[[\w'", ]+\]\)/g,
+        'omitAutogeneratedValues($1)',
+      ),
+  };
+};

package/dist/practices/nonpublished-modules/bad-practices/simple-dynamodb-client/.declapract.readme.md

@@ -0,0 +1 @@
+was published under `simple-dynamodb-client` package

package/dist/practices/nonpublished-modules/bad-practices/simple-dynamodb-client/src/__nonpublished_modules__/simple-dynamodb-client/<star><star>/<star>.ts.declapract.ts

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

package/dist/practices/package-json-order/best-practice/.declapract.readme.md

@@ -0,0 +1,3 @@
+technically json order doesn't matter
+
+but aesthetically it does - so lets define the order that we want to see

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

@@ -0,0 +1,171 @@
+import { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+/**
+ * define the relative key order of keys we care about
+ *
+ * relative meaning: things can be between them or more keys can be defined that we wont reorder - but these ones must have the correct relative order
+ */
+export const desiredRelativeKeyOrder = {
+  root: [
+    'name',
+    'author',
+    'description',
+    'private',
+    'version',
+    'main',
+    'module',
+    'scripts',
+    'dependencies',
+    'devDependencies',
+    'config',
+  ],
+  scripts: [
+    'commit:with-cli',
+    'fix:format:prettier',
+    'fix:format:terraform',
+    'fix:format',
+    'fix:lint',
+    'fix',
+    'generate:schema',
+    'generate:types-from-sql',
+    'generate:dao',
+    'build:clean',
+    'build:compile',
+    'build',
+    'provision:docker:prepare',
+    'provision:docker:up',
+    'provision:docker:await',
+    'provision:docker:down',
+    'provision:schema:plan',
+    'provision:schema:apply',
+    'provision:schema:sync',
+    'provision:integration-test-db',
+    'test:commits',
+    'test:types',
+    'test:format:prettier',
+    'test:format:terraform',
+    'test:format',
+    'test:lint',
+    'test:unit',
+    'test:integration',
+    'test:acceptance:locally',
+    'test',
+    'test:acceptance',
+    'prepush',
+    'preversion',
+    'postversion',
+    'deploy:release',
+    'deploy:send-notification',
+    'deploy:dev',
+    'deploy:prod',
+    'deploy',
+  ],
+};
+
+/**
+ * function which sorts keys in an object based on relative sort order given
+ *
+ * when a key is not in the array, its relative position in the array is not changed
+ *
+ * note: we're forced to write our own sorting function because `.sort()` assumes that `if a > b` and `b > c` then `a > c`, which does not hold in our case (because some relative ranks are not defined)
+ */
+const sortObjectByRelativeKeyOrder = ({
+  object,
+  order,
+}: {
+  object: Record<string, any>;
+  order: string[];
+}) => {
+  const objectKeys = Object.keys(object);
+  const objectKeysWithRelativePositionDefined = objectKeys.filter((key) =>
+    order.includes(key),
+  );
+  const objectKeysWithoutRelativePositionDefined = objectKeys.filter(
+    (key) => !order.includes(key),
+  );
+
+  // sort the keys that have relative order to eachother
+  const sortedRelativeOrderOnesOnly =
+    objectKeysWithRelativePositionDefined.sort((a, b) =>
+      order.indexOf(a) < order.indexOf(b) ? -1 : 1,
+    );
+
+  // then stick the ones that did not have relative order defined into the order (after the ones we relatively defined, when more than one option of position)
+  const sortedKeys = [
+    ...sortedRelativeOrderOnesOnly,
+    ...objectKeysWithoutRelativePositionDefined,
+  ].sort((a, b) => {
+    // lookup the relative orders
+    const relativeOrderIndexOfKeyA = order.indexOf(a);
+    const relativeOrderIndexOfKeyB = order.indexOf(b);
+
+    // if the relative order of both are defined, then  we can use that to sort
+    if (relativeOrderIndexOfKeyA > -1 && relativeOrderIndexOfKeyB > -1)
+      return relativeOrderIndexOfKeyA < relativeOrderIndexOfKeyB ? -1 : 1;
+
+    // lookup the index of each in original array
+    const originalOrderIndexOfKeyA = objectKeys.indexOf(a);
+    const originalOrderIndexOfKeyB = objectKeys.indexOf(b);
+
+    // otherwise keep the original order
+    return originalOrderIndexOfKeyA < originalOrderIndexOfKeyB ? -1 : 1;
+  });
+
+  // create a new object with the sorted keys
+  const newObject: Record<string, any> = {};
+  for (const key of sortedKeys) {
+    newObject[key] = object[key];
+  }
+
+  // return it
+  return newObject;
+};
+
+const sortPackageJSONObjectKeys = (packageJSONObject: Record<string, any>) => {
+  // sort the scripts
+  const sortedScripts = sortObjectByRelativeKeyOrder({
+    object: packageJSONObject.scripts ?? {},
+    order: desiredRelativeKeyOrder.scripts,
+  });
+
+  // sort the dependencies (alphabetical)
+  const sortedDeps = sortObjectByRelativeKeyOrder({
+    object: packageJSONObject.dependencies ?? {},
+    order: Object.keys(packageJSONObject.dependencies ?? {}).sort(), // alphabetical order
+  });
+  const sortedDevDeps = sortObjectByRelativeKeyOrder({
+    object: packageJSONObject.devDependencies ?? {},
+    order: Object.keys(packageJSONObject.devDependencies ?? {}).sort(), // alphabetical order
+  });
+
+  // sort the root
+  const sortedPackageJSONObject = sortObjectByRelativeKeyOrder({
+    object: {
+      ...packageJSONObject,
+      scripts: sortedScripts,
+      dependencies: sortedDeps,
+      devDependencies: sortedDevDeps,
+    },
+    order: desiredRelativeKeyOrder.root,
+  });
+
+  // return it
+  return sortedPackageJSONObject;
+};
+
+// define fix and check
+export const check: FileCheckFunction = (contents) => {
+  if (!contents) throw new Error('file not defined');
+  const packageJSONObject = JSON.parse(contents);
+  const sortedPackageJSONObject = sortPackageJSONObjectKeys(packageJSONObject);
+  expect(JSON.stringify(packageJSONObject, null, 2)).toEqual(
+    JSON.stringify(sortedPackageJSONObject, null, 2),
+  );
+};
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {}; // cant do anything if not defined
+  const packageJSONObject = JSON.parse(contents);
+  const sortedPackageJSONObject = sortPackageJSONObjectKeys(packageJSONObject);
+  return { contents: JSON.stringify(sortedPackageJSONObject, null, 2) };
+};

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

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "simple-dynamodb-client": "@declapract{check.minVersion('7.0.0')}"
+  }
+}

package/dist/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/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/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, 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/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/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/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/practices/persist-with-rds/bad-practices/non-prefixed-manual-init-sqls/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/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/practices/persist-with-rds/bad-practices/schema-entities-dir/.declapract.readme.md

@@ -0,0 +1 @@
+provision/schema/entities -> provision/schema/domain

package/dist/practices/persist-with-rds/bad-practices/schema-entities-dir/provision/schema/entities/<star>.ts.declapract.ts

@@ -0,0 +1,12 @@
+import { FileCheckType, FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS;
+
+export const fix: FileFixFunction = (_, context) => {
+  return {
+    relativeFilePath: context.relativeFilePath.replace(
+      /provision\/schema\/entities\//g,
+      'provision/schema/domain/',
+    ),
+  };
+};

package/dist/practices/persist-with-rds/bad-practices/schema-entities-dir/provision/schema/sql/entities.yml.declapract.ts

@@ -0,0 +1,13 @@
+import { FileCheckType, FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS;
+
+export const fix: FileFixFunction = (_, context) => {
+  return {
+    // rename file to "domain.yml"
+    relativeFilePath: context.relativeFilePath.replace(
+      /entities\.yml$/,
+      'domain.yml',
+    ),
+  };
+};

package/dist/practices/persist-with-rds/best-practice/.declapract.readme.md

@@ -0,0 +1,6 @@
+we use:
+- postgres database
+  - provisioned by aws rds aurora when in dev and prod env
+  - provisioned by docker when in test env
+- sql-schema-control to manage sql schema
+- sql-dao-generator to generate the sql-schemas + daos

package/dist/practices/persist-with-rds/best-practice/codegen.sql.dao.yml

@@ -0,0 +1,18 @@
+language: postgres
+dialect: 10.7
+generates:
+  daos:
+    to: src/data/dao
+    using:
+      log: src/utils/logger#log
+      DatabaseConnection: src/utils/database/getDatabaseConnection#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'

package/dist/practices/persist-with-rds/best-practice/codegen.sql.dao.yml.declapract.ts

@@ -0,0 +1,3 @@
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.CONTAINS; // contains since the user may have exclusions in that "for" object

package/dist/practices/persist-with-rds/best-practice/codegen.sql.schema.yml

@@ -0,0 +1,6 @@
+language: postgres
+dialect: 10.7
+declarations: provision/schema/domain/index.ts
+generates:
+  sql:
+    to: provision/schema/sql

package/dist/practices/persist-with-rds/best-practice/codegen.sql.types.yml

@@ -0,0 +1,15 @@
+language: postgres
+dialect: 10.7
+resources: # where to find your tables, functions, views, procedures
+  - 'provision/schema/sql/tables/**/*.sql'
+  - 'provision/schema/sql/views/**/*.sql'
+  - 'provision/schema/sql/functions/**/*.sql'
+queries: # where to find your queries (each file must `export const query = `...`);
+  - 'src/data/dao/**/*.ts'
+  - '!src/data/dao/**/index.ts'
+  - '!src/data/dao/**/castFromDatabaseObject.ts'
+  - '!src/**/*.test.ts'
+  - '!src/**/*.test.integration.ts'
+generates: # where to output the generated code
+  types: src/data/dao/.generated/types.ts
+  queryFunctions: src/data/dao/.generated/queryFunctions.ts

package/dist/practices/persist-with-rds/best-practice/config/dev.json

@@ -0,0 +1,20 @@
+{
+  "database": {
+    "admin": {
+      "host": "@declapract{variable.databaseClusterHost.dev}",
+      "port": 5432,
+      "database": "@declapract{variable.databaseName}",
+      "schema": "@declapract{variable.databaseName}",
+      "username": "@declapract{variable.databaseUserName.cicdUser}",
+      "password": "__CHANG3_ME__"
+    },
+    "service": {
+      "host": "@declapract{variable.databaseClusterHost.dev}",
+      "port": 5432,
+      "database": "@declapract{variable.databaseName}",
+      "schema": "@declapract{variable.databaseName}",
+      "username": "@declapract{variable.databaseUserName.serviceUser}",
+      "password": "__CHANG3_ME__"
+    }
+  }
+}