@rvoh/dream 0.29.1

package/dist/esm/src/helpers/cli/generateMigrationContent.js

@@ -0,0 +1,193 @@
+import pluralize from 'pluralize-esm';
+import InvalidDecimalFieldPassedToGenerator from '../../errors/InvalidDecimalFieldPassedToGenerator.js';
+import foreignKeyTypeFromPrimaryKey from '../db/foreignKeyTypeFromPrimaryKey.js';
+import snakeify from '../snakeify.js';
+export default function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', } = {}) {
+    const altering = createOrAlter === 'alter';
+    let requireCitextExtension = false;
+    const { columnDefs, columnDrops } = columnsWithTypes.reduce((acc, attribute) => {
+        const { columnDefs, columnDrops } = acc;
+        const [nonStandardAttributeName, attributeType, ...descriptors] = attribute.split(':');
+        let attributeName = snakeify(nonStandardAttributeName);
+        if (['has_one', 'has_many'].includes(attributeType))
+            return acc;
+        if (attributeType === 'citext')
+            requireCitextExtension = true;
+        const coercedAttributeType = getAttributeType(attribute);
+        switch (attributeType) {
+            case 'belongs_to':
+                columnDefs.push(generateBelongsToStr(attributeName, {
+                    primaryKeyType,
+                    optional: descriptors.includes('optional'),
+                }));
+                attributeName = associationNameToForeignKey(attributeName);
+                break;
+            case 'enum':
+                columnDefs.push(generateEnumStr(attribute));
+                break;
+            case 'decimal':
+                columnDefs.push(generateDecimalStr(attribute));
+                break;
+            case 'boolean':
+                columnDefs.push(generateBooleanStr(attributeName));
+                break;
+            case 'encrypted':
+                columnDefs.push(generateColumnStr(`encrypted_${attributeName}`, 'text', descriptors));
+                break;
+            default:
+                columnDefs.push(generateColumnStr(attributeName, coercedAttributeType, descriptors));
+                break;
+        }
+        columnDrops.push(`.dropColumn('${attributeName}')`);
+        return acc;
+    }, { columnDefs: [], columnDrops: [] });
+    if (!table) {
+        return `\
+import { Kysely, sql } from 'kysely'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function up(db: Kysely<any>): Promise<void> {
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function down(db: Kysely<any>): Promise<void> {
+}\
+`;
+    }
+    const citextExtension = requireCitextExtension
+        ? `  await DreamMigrationHelpers.createExtension(db, 'citext')\n\n`
+        : '';
+    const kyselyImports = ['Kysely', 'sql'];
+    const dreamImports = [];
+    if (requireCitextExtension)
+        dreamImports.push('DreamMigrationHelpers');
+    const newline = '\n    ';
+    const columnDefLines = columnDefs.length ? newline + columnDefs.join(newline) : '';
+    const columnDropLines = columnDrops.length ? newline + columnDrops.join(newline) + newline : '';
+    return `\
+${dreamImports.length ? `import { ${dreamImports.join(', ')} } from '@rvohealth/dream'\n` : ''}import { ${kyselyImports.join(', ')} } from 'kysely'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function up(db: Kysely<any>): Promise<void> {
+${citextExtension}${generateEnumStatements(columnsWithTypes)}  await db.schema
+    .${altering ? 'alterTable' : 'createTable'}('${table}')${altering ? '' : newline + generateIdStr({ primaryKeyType })}${columnDefLines}${altering
+        ? ''
+        : newline +
+            ".addColumn('created_at', 'timestamp', col => col.notNull())" +
+            newline +
+            ".addColumn('updated_at', 'timestamp', col => col.notNull())"}
+    .execute()
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function down(db: Kysely<any>): Promise<void> {
+  ${altering
+        ? `await db.schema${newline}.alterTable('${table}')${columnDropLines}.execute()`
+        : `await db.schema.dropTable('${table}').execute()`}${generateEnumDropStatements(columnsWithTypes)}
+}\
+`;
+}
+function getAttributeType(attribute) {
+    const [, attributeType, ...descriptors] = attribute.split(':');
+    if (attributeType === 'enum') {
+        return enumAttributeType(attribute)[0];
+    }
+    switch (attributeType) {
+        case 'datetime':
+            return 'timestamp';
+        case 'string':
+            return `varchar(${descriptors[0] || 255})`;
+        default:
+            return attributeType;
+    }
+}
+function enumAttributeType(attribute) {
+    const [, , ...descriptors] = attribute.split(':');
+    return `sql\`${descriptors[0]}_enum\``;
+}
+function generateEnumStatements(columnsWithTypes) {
+    const enumStatements = columnsWithTypes.filter(attribute => /:enum:.*:/.test(attribute));
+    const finalStatements = enumStatements.map(statement => {
+        const enumName = statement.split(':')[2];
+        const columnsWithTypes = statement.split(':')[3].split(/,\s{0,}/);
+        return `  await db.schema
+    .createType('${enumName}_enum')
+    .asEnum([
+      ${columnsWithTypes.map(attr => `'${attr}'`).join(',\n      ')}
+    ])
+    .execute()`;
+    });
+    return finalStatements.length ? finalStatements.join('\n\n') + '\n\n' : '';
+}
+function generateEnumDropStatements(columnsWithTypes) {
+    const enumStatements = columnsWithTypes.filter(attribute => /:enum:.*:/.test(attribute));
+    const finalStatements = enumStatements.map(statement => {
+        const enumName = statement.split(':')[2];
+        return `await db.schema.dropType('${enumName}_enum').execute()`;
+    });
+    return finalStatements.length ? '\n\n  ' + finalStatements.join('\n  ') : '';
+}
+function generateBooleanStr(attributeName) {
+    return `.addColumn('${attributeName}', 'boolean', col => col.notNull().defaultTo(false))`;
+}
+function generateEnumStr(attribute) {
+    const computedAttributeType = enumAttributeType(attribute);
+    return `.addColumn('${attribute.split(':')[0]}', ${computedAttributeType})`;
+}
+function generateDecimalStr(attribute) {
+    const [, , ...descriptors] = attribute.split(':');
+    const [scale, precision] = descriptors[0]?.split(',') || [null, null];
+    if (!scale || !precision)
+        throw new InvalidDecimalFieldPassedToGenerator(attribute);
+    return `.addColumn('${attribute.split(':')[0]}', 'decimal(${scale}, ${precision})')`;
+}
+function generateColumnStr(attributeName, attributeType, descriptors) {
+    let returnStr = `.addColumn('${attributeName}', ${attributeTypeString(attributeType)}`;
+    const providedDefaultArg = descriptors.find(d => /^default\(/.test(d));
+    const providedDefault = providedDefaultArg?.replace(/^default\(/, '')?.replace(/\)$/, '');
+    const hasExtraValues = descriptors.includes('primary') || providedDefault;
+    if (hasExtraValues)
+        returnStr += ', col => col';
+    if (descriptors.includes('primary'))
+        returnStr += `.defaultTo('${providedDefault}')`;
+    if (providedDefault)
+        returnStr += `.defaultTo('${providedDefault}')`;
+    // TODO: handle index
+    return `${returnStr}${hasExtraValues ? '))' : ')'}`;
+}
+function attributeTypeString(attributeType) {
+    const attributeTypesRequiringSql = ['citext'];
+    if (attributeTypesRequiringSql.includes(attributeType))
+        return `sql\`${attributeType}\``;
+    switch (attributeType) {
+        case 'varbit':
+        case 'bitvarying':
+            return "'bit varying'";
+        case 'txid_snapshot':
+            return "'txid_snapshot'";
+        default:
+            return `'${attributeType.replace(/_/g, ' ')}'`;
+    }
+}
+function generateBelongsToStr(associationName, { primaryKeyType, optional = false, }) {
+    const dataType = foreignKeyTypeFromPrimaryKey(primaryKeyType);
+    const references = pluralize(associationName.replace(/\//g, '_').replace(/_id$/, ''));
+    return `.addColumn('${associationNameToForeignKey(associationName)}', '${dataType}', col => col.references('${references}.id').onDelete('restrict')${optional ? '' : '.notNull()'})`;
+}
+function generateIdStr({ primaryKeyType }) {
+    switch (primaryKeyType) {
+        case 'uuid':
+            return `\
+.addColumn('id', 'uuid', col =>
+      col
+        .notNull()
+        .defaultTo(sql\`uuid_generate_v4()\`)
+        .unique(),
+    )`;
+        default:
+            return `.addColumn('id', '${primaryKeyType}', col => col.primaryKey())`;
+    }
+}
+function associationNameToForeignKey(associationName) {
+    return snakeify(associationName.replace(/\//g, '_').replace(/_id$/, '') + '_id');
+}

package/dist/esm/src/helpers/cli/generateSerializer.js

@@ -0,0 +1,23 @@
+import * as fs from 'fs/promises';
+import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
+import dreamPath from '../path/dreamPath.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import generateSerializerContent from './generateSerializerContent.js';
+export default async function generateSerializer({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('serializers'), `${fullyQualifiedModelName}Serializer.ts`);
+    try {
+        console.log(`generating serializer: ${relFilePath}`);
+        await fs.mkdir(absDirPath, { recursive: true });
+        await fs.writeFile(absFilePath, generateSerializerContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName }));
+    }
+    catch (error) {
+        throw new Error(`
+      Something happened while trying to create the serializer file:
+        ${relFilePath}
+
+      Does this file already exist? Here is the error that was raised:
+        ${error.message}
+    `);
+    }
+}

package/dist/esm/src/helpers/cli/generateSerializerContent.js

@@ -0,0 +1,127 @@
+import camelize from '../camelize.js';
+import globalClassNameFromFullyQualifiedModelName from '../globalClassNameFromFullyQualifiedModelName.js';
+import pascalize from '../pascalize.js';
+import relativeDreamPath from '../path/relativeDreamPath.js';
+import serializerNameFromFullyQualifiedModelName from '../serializerNameFromFullyQualifiedModelName.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import uniq from '../uniq.js';
+export default function generateSerializerContent({ fullyQualifiedModelName, columnsWithTypes = [], fullyQualifiedParentName, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const additionalImports = [];
+    let relatedModelImport = '';
+    let modelClassName = '';
+    let dataTypeCapture = '';
+    const dreamImports = [];
+    let dreamSerializerTypeArgs = '';
+    const isSTI = !!fullyQualifiedParentName;
+    if (isSTI) {
+        fullyQualifiedParentName = standardizeFullyQualifiedModelName(fullyQualifiedParentName);
+        additionalImports.push(importStatementForSerializer(fullyQualifiedModelName, fullyQualifiedParentName));
+    }
+    else {
+        dreamImports.push('Attribute');
+        dreamImports.push('DreamColumn');
+        dreamImports.push('DreamSerializer');
+    }
+    relatedModelImport = importStatementForModel(fullyQualifiedModelName);
+    modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
+    dataTypeCapture = `<
+  DataType extends ${modelClassName},
+  Passthrough extends object,
+>`;
+    dreamSerializerTypeArgs = `<DataType, Passthrough>`;
+    const defaultSerialzerClassName = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName));
+    const summarySerialzerClassName = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName, 'summary'));
+    const defaultSerialzerExtends = isSTI
+        ? globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedParentName))
+        : summarySerialzerClassName;
+    const summarySerialzerExtends = isSTI
+        ? globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedParentName, 'summary'))
+        : 'DreamSerializer';
+    const additionalModelImports = [];
+    columnsWithTypes.forEach(attr => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const [name, type] = attr.split(':');
+        switch (type) {
+            case 'belongs_to':
+            case 'has_one':
+            case 'has_many':
+                break;
+            default:
+                dreamImports.push('Attribute');
+                dreamImports.push('DreamColumn');
+        }
+    });
+    let dreamImport = '';
+    if (dreamImports.length) {
+        dreamImport = `import { ${uniq(dreamImports).join(', ')} } from '@rvohealth/dream'`;
+    }
+    const additionalImportsStr = additionalImports.length ? uniq(additionalImports).join('') : '';
+    return `\
+${dreamImport}${additionalImportsStr}${relatedModelImport}${additionalModelImports.join('')}
+
+export class ${summarySerialzerClassName}${dataTypeCapture} extends ${summarySerialzerExtends}${dreamSerializerTypeArgs} {
+${isSTI
+        ? ''
+        : `  @Attribute(${modelClassName})
+  public id: DreamColumn<${modelClassName}, 'id'>
+`}}
+
+export default class ${defaultSerialzerClassName}${dataTypeCapture} extends ${defaultSerialzerExtends}${dreamSerializerTypeArgs} {
+${columnsWithTypes
+        .map(attr => {
+        const [name, type] = attr.split(':');
+        const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(name);
+        const associatedModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
+        const propertyName = camelize(associatedModelName);
+        switch (type) {
+            case 'belongs_to':
+            case 'has_one':
+            case 'has_many':
+                return '';
+            default:
+                return `  @Attribute(${modelClassName}${attributeOptionsSpecifier(type, attr)})
+  public ${propertyName}: ${jsType(type, attr, propertyName, modelClassName)}`;
+        }
+    })
+        .join('\n\n  ')}
+}
+`;
+}
+function attributeOptionsSpecifier(type, attr) {
+    switch (type) {
+        case 'decimal':
+            return `, { precision: ${attr.split(',').pop()} }`;
+        default:
+            return '';
+    }
+}
+function jsType(type, originalAttribute, propertyName, modelClass = null) {
+    if (modelClass)
+        return `DreamColumn<${modelClass}, '${propertyName}'>`;
+    switch (type) {
+        case 'date':
+            return 'CalendarDate';
+        case 'datetime':
+            return 'DateTime';
+        case 'decimal':
+        case 'integer':
+        case 'number':
+            return 'number';
+        case 'string':
+        case 'text':
+        case 'bigint':
+        case 'uuid':
+            return 'string';
+        case 'enum':
+            return pascalize(originalAttribute.split(':')[2]) + 'Enum';
+        default:
+            return 'any';
+    }
+}
+function importStatementForSerializer(originModelName, destinationModelName) {
+    return `\nimport ${globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(destinationModelName))}, { ${globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(destinationModelName, 'summary'))} } from '${relativeDreamPath('serializers', 'serializers', originModelName, destinationModelName)}'`;
+}
+function importStatementForModel(originModelName, destinationModelName = originModelName) {
+    return `\nimport ${globalClassNameFromFullyQualifiedModelName(destinationModelName)} from '${relativeDreamPath('serializers', 'models', originModelName, destinationModelName)}'`;
+}

package/dist/esm/src/helpers/cli/generateStiMigrationContent.js

@@ -0,0 +1,4 @@
+import generateMigrationContent from './generateMigrationContent.js';
+export default function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', } = {}) {
+    return generateMigrationContent({ table, columnsWithTypes, primaryKeyType, createOrAlter: 'alter' });
+}

package/dist/esm/src/helpers/cli/generateUnitSpec.js

@@ -0,0 +1,23 @@
+import * as fs from 'fs/promises';
+import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
+import dreamPath from '../path/dreamPath.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import generateUnitSpecContent from './generateUnitSpecContent.js';
+export default async function generateUnitSpec({ fullyQualifiedModelName, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('modelSpecs'), `${fullyQualifiedModelName}.spec.ts`);
+    try {
+        console.log(`generating spec: ${relFilePath}`);
+        await fs.mkdir(absDirPath, { recursive: true });
+        await fs.writeFile(absFilePath, generateUnitSpecContent({ fullyQualifiedModelName }));
+    }
+    catch (error) {
+        throw new Error(`
+      Something happened while trying to create the spec file:
+        ${relFilePath}
+
+      Does this file already exist? Here is the error that was raised:
+        ${error.message}
+    `);
+    }
+}

package/dist/esm/src/helpers/cli/generateUnitSpecContent.js

@@ -0,0 +1,7 @@
+export default function generateUnitSpecContent({ fullyQualifiedModelName, }) {
+    return `\
+describe('${fullyQualifiedModelName}', () => {
+  it.todo('add a test here to get started building ${fullyQualifiedModelName}')
+})
+`;
+}

package/dist/esm/src/helpers/cloneDeepSafe.js

@@ -0,0 +1,64 @@
+import { DateTime } from 'luxon';
+import OpsStatement from '../ops/ops-statement.js';
+import CalendarDate from './CalendarDate.js';
+import { Range } from './range.js';
+import { isObject } from './typechecks.js';
+/**
+ * @internal
+ *
+ * accepts any value, and will return a valid clone of
+ * that object. Any dream or query instances passed
+ * will automatically be cloned using special cloning
+ * methods.
+ *
+ * @param original - the value to clone
+ * @param includePrimaryKey - Whether or not to copy the primary key when cloning a dream instance
+ * @returns Either a clone, or else the original value
+ */
+export default function cloneDeepSafe(original) {
+    if (original === undefined)
+        return original;
+    if (original === null)
+        return original;
+    if (typeof original === 'string')
+        return original;
+    if (['number', 'boolean', 'bigint', 'symbol'].includes(typeof original))
+        return original;
+    if (original instanceof DateTime)
+        return original;
+    if (original instanceof CalendarDate)
+        return original;
+    if (original instanceof Range)
+        return original;
+    if (original instanceof OpsStatement)
+        return original;
+    if (original?.isDreamInstance)
+        return original['clone']();
+    if (original?.isDreamQuery)
+        return original.clone();
+    if (original?.isSelectQueryBuilder)
+        return original;
+    if (Array.isArray(original))
+        return original.map(value => cloneDeepSafe(value));
+    if (isObject(original) && original.constructor.name === 'Object') {
+        const clone = { ...original };
+        Object.keys(clone).forEach(key => (clone[key] = cloneDeepSafe(clone[key])));
+        return clone;
+    }
+    throw new TypeUnsupportedByClone(original);
+}
+export class TypeUnsupportedByClone extends Error {
+    original;
+    constructor(original) {
+        super();
+        this.original = original;
+    }
+    get message() {
+        return `Type unsupported by cloneDeepSafe:
+${this.original}
+${this.original.toString()}
+${this.original.constructor?.name}
+${typeof this.original}
+`;
+    }
+}

package/dist/esm/src/helpers/compact.js

@@ -0,0 +1,11 @@
+//
+export default function compact(obj) {
+    if (Array.isArray(obj)) {
+        return obj.filter(val => ![undefined, null].includes(val));
+    }
+    else {
+        return Object.fromEntries(Object.entries(obj).filter(([, v]) => v != null));
+    }
+}
+// const x = compact(['a', 2, null, undefined])
+// const y = compact({ a: 1, b: 'b', c: null, d: undefined })

package/dist/esm/src/helpers/customPgParsers.js

@@ -0,0 +1,31 @@
+import { DateTime } from 'luxon';
+import CalendarDate from './CalendarDate.js';
+export async function findEnumArrayOids(kyselyDb) {
+    const result = await kyselyDb.selectFrom('pg_type').select('typarray').where('typtype', '=', 'e').execute();
+    return result.map(values => values.typarray);
+}
+export async function findCitextArrayOid(kyselyDb) {
+    const result = await kyselyDb
+        .selectFrom('pg_type')
+        .select('typarray')
+        .where('typname', '=', 'citext')
+        .executeTakeFirst();
+    return result?.typarray;
+}
+export async function findCorrespondingArrayOid(kyselyDb, oid) {
+    const result = await kyselyDb
+        .selectFrom('pg_type')
+        .select('typarray')
+        .where('oid', '=', oid)
+        .executeTakeFirst();
+    return result?.typarray;
+}
+export function parsePostgresDate(dateString) {
+    return dateString ? CalendarDate.fromSQL(dateString) : dateString;
+}
+export function parsePostgresDatetime(datetimeString) {
+    return datetimeString ? DateTime.fromSQL(datetimeString, { zone: 'UTC' }) : datetimeString;
+}
+export function parsePostgresDecimal(numberString) {
+    return numberString ? parseFloat(numberString) : numberString;
+}

package/dist/esm/src/helpers/db/cachedTypeForAttribute.js

@@ -0,0 +1,3 @@
+export default function cachedTypeForAttribute(dreamClass, attribute) {
+    return dreamClass.prototype.schema[dreamClass.table]?.['columns']?.[attribute]?.['dbType'];
+}

package/dist/esm/src/helpers/db/createDb.js

@@ -0,0 +1,17 @@
+import ConnectionConfRetriever from '../../db/ConnectionConfRetriever.js';
+import EnvInternal from '../EnvInternal.js';
+import loadPgClient from './loadPgClient.js';
+export default async function createDb(connection, dbName) {
+    // this was only ever written to clear the db between tests or in development,
+    // so there is no way to drop in production
+    if (EnvInternal.isProduction)
+        return false;
+    const connectionRetriever = new ConnectionConfRetriever();
+    const dbConf = connectionRetriever.getConnectionConf(connection);
+    dbName ||= dbConf.name || null;
+    if (!dbName)
+        throw new Error('Must either pass a dbName to the create function, or else ensure that DB_NAME is set in the env');
+    const client = await loadPgClient({ useSystemDb: true });
+    await client.query(`CREATE DATABASE ${dbName};`);
+    await client.end();
+}

package/dist/esm/src/helpers/db/dropDb.js

@@ -0,0 +1,33 @@
+import ConnectionConfRetriever from '../../db/ConnectionConfRetriever.js';
+import DreamApplication from '../../dream-application/index.js';
+import EnvInternal from '../EnvInternal.js';
+import loadPgClient from './loadPgClient.js';
+export default async function dropDb(connection, dbName) {
+    // this was only ever written to clear the db between tests or in development,
+    // so there is no way to drop in production
+    if (EnvInternal.isProduction)
+        return false;
+    const connectionRetriever = new ConnectionConfRetriever();
+    const dbConf = connectionRetriever.getConnectionConf(connection);
+    dbName ||= dbConf.name || null;
+    if (!dbName)
+        throw new Error('Must either pass a dbName to the drop function, or else ensure that DB_NAME is set in the env');
+    const client = await loadPgClient({ useSystemDb: true });
+    await maybeDropDuplicateDatabases(client, dbName);
+    await client.query(`DROP DATABASE IF EXISTS ${dbName};`);
+}
+async function maybeDropDuplicateDatabases(client, dbName) {
+    const parallelTests = DreamApplication.getOrFail().parallelTests;
+    if (!parallelTests)
+        return;
+    if (process.env.DREAM_CORE_DEVELOPMENT === '1') {
+        const replicaTestWorkerDatabaseName = `replica_test_${dbName}`;
+        console.log(`dropping fake replica test database ${replicaTestWorkerDatabaseName}`);
+        await client.query(`DROP DATABASE IF EXISTS ${replicaTestWorkerDatabaseName};`);
+    }
+    for (let i = 2; i <= parallelTests; i++) {
+        const workerDatabaseName = `${dbName}_${i}`;
+        console.log(`dropping duplicate test database ${workerDatabaseName}`);
+        await client.query(`DROP DATABASE IF EXISTS ${workerDatabaseName};`);
+    }
+}

package/dist/esm/src/helpers/db/foreignKeyTypeFromPrimaryKey.js

@@ -0,0 +1,8 @@
+export default function foreignKeyTypeFromPrimaryKey(primaryKey) {
+    switch (primaryKey) {
+        case 'bigserial':
+            return 'bigint';
+        default:
+            return primaryKey;
+    }
+}

package/dist/esm/src/helpers/db/loadPgClient.js

@@ -0,0 +1,17 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import pg from 'pg';
+import DreamApplication from '../../dream-application/index.js';
+export default async function loadPgClient({ useSystemDb } = {}) {
+    const dreamconf = DreamApplication.getOrFail();
+    const creds = dreamconf.dbCredentials.primary;
+    const client = new pg.Client({
+        host: creds.host || 'localhost',
+        port: creds.port,
+        database: useSystemDb ? 'postgres' : creds.name,
+        user: creds.user,
+        password: creds.password,
+    });
+    await client.connect();
+    return client;
+}

package/dist/esm/src/helpers/db/primaryKeyType.js

@@ -0,0 +1,20 @@
+import DreamApplication from '../../dream-application/index.js';
+import { primaryKeyTypes } from '../../dream/types.js';
+export default function primaryKeyType() {
+    const dreamconf = DreamApplication.getOrFail();
+    switch (dreamconf.primaryKeyType) {
+        case 'bigint':
+        case 'bigserial':
+        case 'uuid':
+        case 'integer':
+            return dreamconf.primaryKeyType;
+        default:
+            throw new Error(`
+ATTENTION!
+
+  unrecognized primary key type "${dreamconf.primaryKeyType}" found in .dream.yml.
+  please use one of the allowed primary key types:
+    ${primaryKeyTypes.join(', ')}
+      `);
+    }
+}