@rvoh/dream 0.29.1

package/dist/cjs/src/helpers/cli/generateMigration.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateMigration;
+const fs = require("fs/promises");
+const path = require("path");
+const pluralize_esm_1 = require("pluralize-esm");
+const generateMigrationContent_js_1 = require("../cli/generateMigrationContent.js");
+const primaryKeyType_js_1 = require("../db/primaryKeyType.js");
+const hyphenize_js_1 = require("../hyphenize.js");
+const migrationVersion_js_1 = require("../migrationVersion.js");
+const pascalizePath_js_1 = require("../pascalizePath.js");
+const dreamFileAndDirPaths_js_1 = require("../path/dreamFileAndDirPaths.js");
+const dreamPath_js_1 = require("../path/dreamPath.js");
+const snakeify_js_1 = require("../snakeify.js");
+const generateStiMigrationContent_js_1 = require("./generateStiMigrationContent.js");
+async function generateMigration({ migrationName, columnsWithTypes, fullyQualifiedModelName, fullyQualifiedParentName, }) {
+    const { relFilePath, absFilePath } = (0, dreamFileAndDirPaths_js_1.default)(path.join((0, dreamPath_js_1.default)('db'), 'migrations'), `${(0, migrationVersion_js_1.default)()}-${(0, hyphenize_js_1.default)(migrationName).replace(/\//g, '-')}.ts`);
+    const isSTI = !!fullyQualifiedParentName;
+    let finalContent = '';
+    if (isSTI) {
+        finalContent = (0, generateStiMigrationContent_js_1.default)({
+            table: (0, snakeify_js_1.default)((0, pluralize_esm_1.default)((0, pascalizePath_js_1.default)(fullyQualifiedParentName))),
+            columnsWithTypes,
+            primaryKeyType: (0, primaryKeyType_js_1.default)(),
+        });
+    }
+    else if (fullyQualifiedModelName) {
+        finalContent = (0, generateMigrationContent_js_1.default)({
+            table: (0, snakeify_js_1.default)((0, pluralize_esm_1.default)((0, pascalizePath_js_1.default)(fullyQualifiedModelName))),
+            columnsWithTypes,
+            primaryKeyType: (0, primaryKeyType_js_1.default)(),
+        });
+    }
+    else {
+        const tableName = migrationName.match(/-to-(.+)$/)?.[1];
+        finalContent = (0, generateMigrationContent_js_1.default)({
+            table: tableName ? (0, pluralize_esm_1.default)((0, snakeify_js_1.default)(tableName)) : '<table-name>',
+            columnsWithTypes,
+            primaryKeyType: (0, primaryKeyType_js_1.default)(),
+            createOrAlter: 'alter',
+        });
+    }
+    try {
+        console.log(`generating migration: ${relFilePath}`);
+        await fs.writeFile(absFilePath, finalContent);
+    }
+    catch (error) {
+        throw new Error(`
+      Something happened while trying to create the migration file:
+        ${relFilePath}
+
+      Does this file already exist? Here is the error that was raised:
+        ${error.message}
+    `);
+    }
+}

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

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateMigrationContent;
+const pluralize_esm_1 = require("pluralize-esm");
+const InvalidDecimalFieldPassedToGenerator_js_1 = require("../../errors/InvalidDecimalFieldPassedToGenerator.js");
+const foreignKeyTypeFromPrimaryKey_js_1 = require("../db/foreignKeyTypeFromPrimaryKey.js");
+const snakeify_js_1 = require("../snakeify.js");
+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 = (0, snakeify_js_1.default)(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_js_1.default(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 = (0, foreignKeyTypeFromPrimaryKey_js_1.default)(primaryKeyType);
+    const references = (0, pluralize_esm_1.default)(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 (0, snakeify_js_1.default)(associationName.replace(/\//g, '_').replace(/_id$/, '') + '_id');
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateSerializer;
+const fs = require("fs/promises");
+const dreamFileAndDirPaths_js_1 = require("../path/dreamFileAndDirPaths.js");
+const dreamPath_js_1 = require("../path/dreamPath.js");
+const standardizeFullyQualifiedModelName_js_1 = require("../standardizeFullyQualifiedModelName.js");
+const generateSerializerContent_js_1 = require("./generateSerializerContent.js");
+async function generateSerializer({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, }) {
+    fullyQualifiedModelName = (0, standardizeFullyQualifiedModelName_js_1.default)(fullyQualifiedModelName);
+    const { relFilePath, absDirPath, absFilePath } = (0, dreamFileAndDirPaths_js_1.default)((0, dreamPath_js_1.default)('serializers'), `${fullyQualifiedModelName}Serializer.ts`);
+    try {
+        console.log(`generating serializer: ${relFilePath}`);
+        await fs.mkdir(absDirPath, { recursive: true });
+        await fs.writeFile(absFilePath, (0, generateSerializerContent_js_1.default)({ 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/cjs/src/helpers/cli/generateSerializerContent.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateSerializerContent;
+const camelize_js_1 = require("../camelize.js");
+const globalClassNameFromFullyQualifiedModelName_js_1 = require("../globalClassNameFromFullyQualifiedModelName.js");
+const pascalize_js_1 = require("../pascalize.js");
+const relativeDreamPath_js_1 = require("../path/relativeDreamPath.js");
+const serializerNameFromFullyQualifiedModelName_js_1 = require("../serializerNameFromFullyQualifiedModelName.js");
+const standardizeFullyQualifiedModelName_js_1 = require("../standardizeFullyQualifiedModelName.js");
+const uniq_js_1 = require("../uniq.js");
+function generateSerializerContent({ fullyQualifiedModelName, columnsWithTypes = [], fullyQualifiedParentName, }) {
+    fullyQualifiedModelName = (0, standardizeFullyQualifiedModelName_js_1.default)(fullyQualifiedModelName);
+    const additionalImports = [];
+    let relatedModelImport = '';
+    let modelClassName = '';
+    let dataTypeCapture = '';
+    const dreamImports = [];
+    let dreamSerializerTypeArgs = '';
+    const isSTI = !!fullyQualifiedParentName;
+    if (isSTI) {
+        fullyQualifiedParentName = (0, standardizeFullyQualifiedModelName_js_1.default)(fullyQualifiedParentName);
+        additionalImports.push(importStatementForSerializer(fullyQualifiedModelName, fullyQualifiedParentName));
+    }
+    else {
+        dreamImports.push('Attribute');
+        dreamImports.push('DreamColumn');
+        dreamImports.push('DreamSerializer');
+    }
+    relatedModelImport = importStatementForModel(fullyQualifiedModelName);
+    modelClassName = (0, globalClassNameFromFullyQualifiedModelName_js_1.default)(fullyQualifiedModelName);
+    dataTypeCapture = `<
+  DataType extends ${modelClassName},
+  Passthrough extends object,
+>`;
+    dreamSerializerTypeArgs = `<DataType, Passthrough>`;
+    const defaultSerialzerClassName = (0, globalClassNameFromFullyQualifiedModelName_js_1.default)((0, serializerNameFromFullyQualifiedModelName_js_1.default)(fullyQualifiedModelName));
+    const summarySerialzerClassName = (0, globalClassNameFromFullyQualifiedModelName_js_1.default)((0, serializerNameFromFullyQualifiedModelName_js_1.default)(fullyQualifiedModelName, 'summary'));
+    const defaultSerialzerExtends = isSTI
+        ? (0, globalClassNameFromFullyQualifiedModelName_js_1.default)((0, serializerNameFromFullyQualifiedModelName_js_1.default)(fullyQualifiedParentName))
+        : summarySerialzerClassName;
+    const summarySerialzerExtends = isSTI
+        ? (0, globalClassNameFromFullyQualifiedModelName_js_1.default)((0, serializerNameFromFullyQualifiedModelName_js_1.default)(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 { ${(0, uniq_js_1.default)(dreamImports).join(', ')} } from '@rvohealth/dream'`;
+    }
+    const additionalImportsStr = additionalImports.length ? (0, uniq_js_1.default)(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 = (0, standardizeFullyQualifiedModelName_js_1.default)(name);
+        const associatedModelName = (0, globalClassNameFromFullyQualifiedModelName_js_1.default)(fullyQualifiedAssociatedModelName);
+        const propertyName = (0, camelize_js_1.default)(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 (0, pascalize_js_1.default)(originalAttribute.split(':')[2]) + 'Enum';
+        default:
+            return 'any';
+    }
+}
+function importStatementForSerializer(originModelName, destinationModelName) {
+    return `\nimport ${(0, globalClassNameFromFullyQualifiedModelName_js_1.default)((0, serializerNameFromFullyQualifiedModelName_js_1.default)(destinationModelName))}, { ${(0, globalClassNameFromFullyQualifiedModelName_js_1.default)((0, serializerNameFromFullyQualifiedModelName_js_1.default)(destinationModelName, 'summary'))} } from '${(0, relativeDreamPath_js_1.default)('serializers', 'serializers', originModelName, destinationModelName)}'`;
+}
+function importStatementForModel(originModelName, destinationModelName = originModelName) {
+    return `\nimport ${(0, globalClassNameFromFullyQualifiedModelName_js_1.default)(destinationModelName)} from '${(0, relativeDreamPath_js_1.default)('serializers', 'models', originModelName, destinationModelName)}'`;
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateStiMigrationContent;
+const generateMigrationContent_js_1 = require("./generateMigrationContent.js");
+function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', } = {}) {
+    return (0, generateMigrationContent_js_1.default)({ table, columnsWithTypes, primaryKeyType, createOrAlter: 'alter' });
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateUnitSpec;
+const fs = require("fs/promises");
+const dreamFileAndDirPaths_js_1 = require("../path/dreamFileAndDirPaths.js");
+const dreamPath_js_1 = require("../path/dreamPath.js");
+const standardizeFullyQualifiedModelName_js_1 = require("../standardizeFullyQualifiedModelName.js");
+const generateUnitSpecContent_js_1 = require("./generateUnitSpecContent.js");
+async function generateUnitSpec({ fullyQualifiedModelName, }) {
+    fullyQualifiedModelName = (0, standardizeFullyQualifiedModelName_js_1.default)(fullyQualifiedModelName);
+    const { relFilePath, absDirPath, absFilePath } = (0, dreamFileAndDirPaths_js_1.default)((0, dreamPath_js_1.default)('modelSpecs'), `${fullyQualifiedModelName}.spec.ts`);
+    try {
+        console.log(`generating spec: ${relFilePath}`);
+        await fs.mkdir(absDirPath, { recursive: true });
+        await fs.writeFile(absFilePath, (0, generateUnitSpecContent_js_1.default)({ 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/cjs/src/helpers/cli/generateUnitSpecContent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateUnitSpecContent;
+function generateUnitSpecContent({ fullyQualifiedModelName, }) {
+    return `\
+describe('${fullyQualifiedModelName}', () => {
+  it.todo('add a test here to get started building ${fullyQualifiedModelName}')
+})
+`;
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeUnsupportedByClone = void 0;
+exports.default = cloneDeepSafe;
+const luxon_1 = require("luxon");
+const ops_statement_js_1 = require("../ops/ops-statement.js");
+const CalendarDate_js_1 = require("./CalendarDate.js");
+const range_js_1 = require("./range.js");
+const typechecks_js_1 = require("./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
+ */
+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 luxon_1.DateTime)
+        return original;
+    if (original instanceof CalendarDate_js_1.default)
+        return original;
+    if (original instanceof range_js_1.Range)
+        return original;
+    if (original instanceof ops_statement_js_1.default)
+        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 ((0, typechecks_js_1.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);
+}
+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}
+`;
+    }
+}
+exports.TypeUnsupportedByClone = TypeUnsupportedByClone;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = compact;
+//
+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/cjs/src/helpers/customPgParsers.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEnumArrayOids = findEnumArrayOids;
+exports.findCitextArrayOid = findCitextArrayOid;
+exports.findCorrespondingArrayOid = findCorrespondingArrayOid;
+exports.parsePostgresDate = parsePostgresDate;
+exports.parsePostgresDatetime = parsePostgresDatetime;
+exports.parsePostgresDecimal = parsePostgresDecimal;
+const luxon_1 = require("luxon");
+const CalendarDate_js_1 = require("./CalendarDate.js");
+async function findEnumArrayOids(kyselyDb) {
+    const result = await kyselyDb.selectFrom('pg_type').select('typarray').where('typtype', '=', 'e').execute();
+    return result.map(values => values.typarray);
+}
+async function findCitextArrayOid(kyselyDb) {
+    const result = await kyselyDb
+        .selectFrom('pg_type')
+        .select('typarray')
+        .where('typname', '=', 'citext')
+        .executeTakeFirst();
+    return result?.typarray;
+}
+async function findCorrespondingArrayOid(kyselyDb, oid) {
+    const result = await kyselyDb
+        .selectFrom('pg_type')
+        .select('typarray')
+        .where('oid', '=', oid)
+        .executeTakeFirst();
+    return result?.typarray;
+}
+function parsePostgresDate(dateString) {
+    return dateString ? CalendarDate_js_1.default.fromSQL(dateString) : dateString;
+}
+function parsePostgresDatetime(datetimeString) {
+    return datetimeString ? luxon_1.DateTime.fromSQL(datetimeString, { zone: 'UTC' }) : datetimeString;
+}
+function parsePostgresDecimal(numberString) {
+    return numberString ? parseFloat(numberString) : numberString;
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cachedTypeForAttribute;
+function cachedTypeForAttribute(dreamClass, attribute) {
+    return dreamClass.prototype.schema[dreamClass.table]?.['columns']?.[attribute]?.['dbType'];
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createDb;
+const ConnectionConfRetriever_js_1 = require("../../db/ConnectionConfRetriever.js");
+const EnvInternal_js_1 = require("../EnvInternal.js");
+const loadPgClient_js_1 = require("./loadPgClient.js");
+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_js_1.default.isProduction)
+        return false;
+    const connectionRetriever = new ConnectionConfRetriever_js_1.default();
+    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 (0, loadPgClient_js_1.default)({ useSystemDb: true });
+    await client.query(`CREATE DATABASE ${dbName};`);
+    await client.end();
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dropDb;
+const ConnectionConfRetriever_js_1 = require("../../db/ConnectionConfRetriever.js");
+const index_js_1 = require("../../dream-application/index.js");
+const EnvInternal_js_1 = require("../EnvInternal.js");
+const loadPgClient_js_1 = require("./loadPgClient.js");
+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_js_1.default.isProduction)
+        return false;
+    const connectionRetriever = new ConnectionConfRetriever_js_1.default();
+    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 (0, loadPgClient_js_1.default)({ useSystemDb: true });
+    await maybeDropDuplicateDatabases(client, dbName);
+    await client.query(`DROP DATABASE IF EXISTS ${dbName};`);
+}
+async function maybeDropDuplicateDatabases(client, dbName) {
+    const parallelTests = index_js_1.default.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/cjs/src/helpers/db/foreignKeyTypeFromPrimaryKey.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = foreignKeyTypeFromPrimaryKey;
+function foreignKeyTypeFromPrimaryKey(primaryKey) {
+    switch (primaryKey) {
+        case 'bigserial':
+            return 'bigint';
+        default:
+            return primaryKey;
+    }
+}