@rvoh/dream 1.4.2 → 1.5.1

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -1,11 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const pg_1 = require("pg");
 const kysely_1 = require("kysely");
 const pluralize_esm_1 = require("pluralize-esm");
-const sync_js_1 = require("../../bin/helpers/sync.js");
 const CliFileWriter_js_1 = require("../../cli/CliFileWriter.js");
 const index_js_1 = require("../../cli/index.js");
 const errors_js_1 = require("../../db/errors.js");
+const syncDbTypesFiles_js_1 = require("../../db/helpers/syncDbTypesFiles.js");
 const index_js_2 = require("../../db/index.js");
 const associationToGetterSetterProp_js_1 = require("../../decorators/field/association/associationToGetterSetterProp.js");
 const PackageManager_js_1 = require("../../dream-app/helpers/PackageManager.js");
@@ -30,16 +39,13 @@ const generateMigration_js_1 = require("../../helpers/cli/generateMigration.js")
 const SchemaBuilder_js_1 = require("../../helpers/cli/SchemaBuilder.js");
 const compact_js_1 = require("../../helpers/compact.js");
 const DateTime_js_1 = require("../../helpers/DateTime.js");
-const createDb_js_1 = require("../../helpers/db/createDb.js");
-const dropDb_js_1 = require("../../helpers/db/dropDb.js");
-const loadPgClient_js_1 = require("../../helpers/db/loadPgClient.js");
-const runMigration_js_1 = require("../../helpers/db/runMigration.js");
 const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
 const groupBy_js_1 = require("../../helpers/groupBy.js");
 const isEmpty_js_1 = require("../../helpers/isEmpty.js");
 const namespaceColumn_js_1 = require("../../helpers/namespaceColumn.js");
 const normalizeUnicode_js_1 = require("../../helpers/normalizeUnicode.js");
 const objectPathsToArrays_js_1 = require("../../helpers/objectPathsToArrays.js");
+const pascalize_js_1 = require("../../helpers/pascalize.js");
 const protectAgainstPollutingAssignment_js_1 = require("../../helpers/protectAgainstPollutingAssignment.js");
 const range_js_1 = require("../../helpers/range.js");
 const snakeify_js_1 = require("../../helpers/snakeify.js");
@@ -48,6 +54,7 @@ const uniq_js_1 = require("../../helpers/uniq.js");
 const curried_ops_statement_js_1 = require("../../ops/curried-ops-statement.js");
 const ops_statement_js_1 = require("../../ops/ops-statement.js");
 const constants_js_1 = require("../constants.js");
+const DreamTransaction_js_1 = require("../DreamTransaction.js");
 const throughAssociationHasOptionsBesidesThroughAndSource_js_1 = require("../internal/associations/throughAssociationHasOptionsBesidesThroughAndSource.js");
 const associationStringToNameAndAlias_js_1 = require("../internal/associationStringToNameAndAlias.js");
 const executeDatabaseQuery_js_1 = require("../internal/executeDatabaseQuery.js");
@@ -57,6 +64,8 @@ const SimilarityBuilder_js_1 = require("../internal/similarity/SimilarityBuilder
 const sqlResultToDreamInstance_js_1 = require("../internal/sqlResultToDreamInstance.js");
 const Query_js_1 = require("../Query.js");
 const Base_js_1 = require("./Base.js");
+const runMigration_js_1 = require("./helpers/kysely/runMigration.js");
+const softDeleteDream_js_1 = require("../internal/softDeleteDream.js");
 class KyselyQueryDriver extends Base_js_1.default {
     // ATTENTION FRED
     // stop trying to make this async. You never learn...
@@ -67,48 +76,101 @@ class KyselyQueryDriver extends Base_js_1.default {
     // you are attempting to support. By default, dream is postgres-only, so our internal _db
     // function will return a kysely instance, tightly coupled to a postgres-specific connection.
     dbFor(sqlCommandType) {
-        if (this.dreamTransaction?.kyselyTransaction)
-            return this.dreamTransaction?.kyselyTransaction;
-        return (0, index_js_2.default)(this.dbConnectionType(sqlCommandType));
+        const constructor = this.constructor;
+        return constructor.dbFor(this.dreamInstance.connectionName, this.dbConnectionType(sqlCommandType), this.dreamTransaction);
+    }
+    // if you are attempting to leverage a kysely-based connection using a different driver,
+    // you would want to extend this KyselyQueryDriver class, and then change this method
+    // to return a custom kysely instance, tailored to the specific database connection
+    // you are attempting to support. By default, dream is postgres-only, so our internal _db
+    // function will return a kysely instance, tightly coupled to a postgres-specific connection.
+    static dbFor(connectionName, dbConnectionType, dreamTransaction) {
+        if (dreamTransaction?.kyselyTransaction)
+            return dreamTransaction?.kyselyTransaction;
+        return (0, index_js_2.default)(connectionName || 'default', dbConnectionType, this.dialectProvider(connectionName, dbConnectionType));
+    }
+    static dialectProvider(connectionName, dbConnectionType) {
+        return (connectionConf) => new kysely_1.PostgresDialect({
+            pool: new pg_1.default.Pool({
+                user: connectionConf.user || '',
+                password: connectionConf.password || '',
+                database: index_js_3.default.getOrFail().dbName(connectionName, dbConnectionType),
+                host: connectionConf.host || 'localhost',
+                port: connectionConf.port || 5432,
+                ssl: connectionConf.useSsl ? defaultPostgresSslConfig(connectionConf) : false,
+            }),
+        });
     }
     /**
      * migrate the database. Must respond to the NODE_ENV value.
      */
-    static async migrate() {
+    static async migrate(connectionName) {
         const dreamApp = index_js_3.default.getOrFail();
-        const primaryDbConf = dreamApp.dbConnectionConfig('primary');
+        const primaryDbConf = dreamApp.dbConnectionConfig(connectionName, 'primary');
         index_js_1.default.logger.logStartProgress(`migrating ${primaryDbConf.name}...`);
-        await (0, runMigration_js_1.default)({ mode: 'migrate' });
+        await (0, runMigration_js_1.default)({
+            connectionName,
+            mode: 'migrate',
+            dialectProvider: this.dialectProvider(connectionName, 'primary'),
+        });
         index_js_1.default.logger.logEndProgress();
-        await this.duplicateDatabase();
+        await this.duplicateDatabase(connectionName);
     }
     /**
      * rollback the database. Must respond to the NODE_ENV value.
      */
     static async rollback(opts) {
         const dreamApp = index_js_3.default.getOrFail();
-        const primaryDbConf = dreamApp.dbConnectionConfig('primary');
+        const primaryDbConf = dreamApp.dbConnectionConfig(opts.connectionName || 'default', 'primary');
         index_js_1.default.logger.logStartProgress(`rolling back ${primaryDbConf.name}...`);
         let step = opts.steps;
         while (step > 0) {
-            await (0, runMigration_js_1.default)({ mode: 'rollback' });
+            await (0, runMigration_js_1.default)({
+                connectionName: opts.connectionName,
+                mode: 'rollback',
+                dialectProvider: this.dialectProvider(opts.connectionName, 'primary'),
+            });
             step -= 1;
         }
         index_js_1.default.logger.logEndProgress();
-        await this.duplicateDatabase();
+        await this.duplicateDatabase(opts.connectionName);
     }
-    static async generateMigration(migrationName, columnsWithTypes) {
-        await (0, generateMigration_js_1.default)({ migrationName, columnsWithTypes });
+    /**
+     * This should build a new migration file in the migrations folder
+     * of your application. This will then need to be read and run
+     * whenever the `migrate` method is called. The filename should
+     * contain a timestamp at the front of the filename, so that it
+     * is sorted by date in the file tree, and, more importantly, so
+     * they can be run in order by your migration runner.
+     */
+    static async generateMigration(connectionName, migrationName, columnsWithTypes) {
+        await (0, generateMigration_js_1.default)({ migrationName, columnsWithTypes, connectionName });
     }
-    static async sync(onSync, options = {}) {
+    /**
+     * defines the syncing behavior for dream and psychic,
+     * which is run whenever the `sync` command is called.
+     * This is an important step, and will be incredibly
+     * comlpex to override. You will need to do the following
+     * when overriding this method:
+     *
+     * 1. introspect the db and use it to generate a db.ts file in the
+     *    same shape as the existing one. Currently, the process for generating
+     *    this file is extremely complex and messy, and will be difficult
+     *    to achieve.
+     * 2. generate a types/dream.ts file in the same shape as the existing
+     *    one. This is normally done using `await new SchemaBuilder().build()`,
+     *    but this will likely need to be overridden to tailor to your custom
+     *    database engine.
+     */
+    static async sync(connectionName, onSync, options = {}) {
         try {
             if (!options?.schemaOnly) {
-                await index_js_1.default.logger.logProgress('writing db schema...', async () => {
-                    await (0, sync_js_1.default)();
+                await index_js_1.default.logger.logProgress(`introspecting db for connection: ${connectionName}...`, async () => {
+                    await (0, syncDbTypesFiles_js_1.default)(connectionName);
                 });
             }
-            const schemaBuilder = new SchemaBuilder_js_1.default();
-            await index_js_1.default.logger.logProgress('building dream schema...', async () => {
+            const schemaBuilder = new SchemaBuilder_js_1.default(connectionName);
+            await index_js_1.default.logger.logProgress(`building dream schema for connection ${connectionName}...`, async () => {
                 await schemaBuilder.build();
             });
             if (schemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
@@ -125,6 +187,7 @@ class KyselyQueryDriver extends Base_js_1.default {
                     });
                 });
             }
+            await SchemaBuilder_js_1.default.buildGlobalTypes();
             if (!options?.schemaOnly) {
                 // intentionally leaving logs off here, since it allows other
                 // onSync handlers to determine their own independent logging approach
@@ -138,41 +201,68 @@ class KyselyQueryDriver extends Base_js_1.default {
             });
         }
     }
+    static get syncDialect() {
+        return 'postgres';
+    }
     /**
-     * create the database. Must respond to the NODE_ENV value.
+     * @internal
+     *
+     * returns the foreign key type based on the primary key received.
+     * gives the driver the opportunity to switch i.e. bigserial to bigint.
      */
-    static async dbCreate() {
-        const dreamApp = index_js_3.default.getOrFail();
-        const primaryDbConf = dreamApp.dbConnectionConfig('primary');
-        index_js_1.default.logger.logStartProgress(`creating ${primaryDbConf.name}...`);
-        await (0, createDb_js_1.default)('primary');
-        index_js_1.default.logger.logEndProgress();
-        // TODO: add support for creating replicas. Began doing it below, but it is very tricky,
-        // and we don't need it at the moment, so kicking off for future development when we have more time
-        // to flesh this out.
-        // if (connectionRetriever.hasReplicaConfig()) {
-        //   const replicaDbConf = connectionRetriever.getConnectionConf('replica')
-        //   console.log(`creating ${process.env[replicaDbConf.name]}`)
-        //   await createDb('replica')
-        // }
+    static foreignKeyTypeFromPrimaryKey(primaryKey) {
+        switch (primaryKey) {
+            case 'bigserial':
+                return 'bigint';
+            default:
+                return primaryKey;
+        }
     }
     /**
-     * delete the database. Must respond to the NODE_ENV value.
+     * @internal
+     *
+     * used to return the computed primary key type based
+     * on the primaryKeyType set in the DreamApp class.
      */
-    static async dbDrop() {
-        const dreamApp = index_js_3.default.getOrFail();
-        const primaryDbConf = dreamApp.dbConnectionConfig('primary');
-        index_js_1.default.logger.logStartProgress(`dropping ${primaryDbConf.name}...`);
-        await (0, dropDb_js_1.default)('primary');
-        index_js_1.default.logger.logEndProgress();
-        // TODO: add support for dropping replicas. Began doing it below, but it is very tricky,
-        // and we don't need it at the moment, so kicking off for future development when we have more time
-        // to flesh this out.
-        // if (connectionRetriever.hasReplicaConfig()) {
-        //   const replicaDbConf = connectionRetriever.getConnectionConf('replica')
-        //   console.log(`dropping ${process.env[replicaDbConf.name]}`)
-        //   await _dropDb('replica')
-        // }
+    static primaryKeyType() {
+        const dreamconf = index_js_3.default.getOrFail();
+        switch (dreamconf.primaryKeyType) {
+            case 'bigint':
+            case 'bigserial':
+            case 'uuid':
+            case 'integer':
+                return dreamconf.primaryKeyType;
+            default: {
+                // protection so that if a new EncryptAlgorithm is ever added, this will throw a type error at build time
+                const _never = dreamconf.primaryKeyType;
+                throw new Error(`
+  ATTENTION!
+
+    unrecognized primary key type "${_never}" found in .dream.yml.
+    please use one of the allowed primary key types:
+      ${constants_js_1.primaryKeyTypes.join(', ')}
+        `);
+            }
+        }
+    }
+    /**
+     * destroys a dream, possibly implementing soft delete if reallyDestroy is false
+     * and the record being deleted implements soft delete.
+     *
+     * @param dream - the dream instance you wish to destroy
+     * @param txn - a transaction to encapsulate, consistently provided by underlying dream mechanisms
+     * @param reallyDestroy - whether or not to reallyDestroy. If false, soft delete will be attempted when relevant
+     */
+    static async destroyDream(dream, txn, reallyDestroy) {
+        if (shouldSoftDelete(dream, reallyDestroy)) {
+            await (0, softDeleteDream_js_1.default)(dream, txn);
+        }
+        else if (!dream['_preventDeletion']) {
+            await txn.kyselyTransaction
+                .deleteFrom(dream.table)
+                .where(dream['_primaryKey'], '=', dream.primaryKeyValue())
+                .execute();
+        }
     }
     /**
      * Converts the given dream class into a Kysely query, enabling
@@ -202,6 +292,41 @@ class KyselyQueryDriver extends Base_js_1.default {
             }
         }
     }
+    /**
+     * Builds a new DreamTransaction instance, provides
+     * the instance to the provided callback.
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   const user = await User.txn(txn).create({ email: 'how@yadoin' })
+     *   await Pet.txn(txn).create({ user })
+     * })
+     * ```
+     *
+     * @param callback - A callback function to call. The transaction provided to the callback can be passed to subsequent database calls within the transaction callback
+     * @returns void
+     */
+    static async transaction(dreamInstance, callback) {
+        const dreamTransaction = new DreamTransaction_js_1.default();
+        let callbackResponse = undefined;
+        await this.dbFor(dreamInstance.connectionName || 'default', 'primary')
+            .transaction()
+            .execute(async (kyselyTransaction) => {
+            dreamTransaction.kyselyTransaction = kyselyTransaction;
+            callbackResponse = (await callback(dreamTransaction));
+        });
+        await dreamTransaction.runAfterCommitHooks(dreamTransaction);
+        return callbackResponse;
+    }
+    /**
+     * @internal
+     *
+     * this is used by getColumnData to serialize enums
+     */
+    static enumType(row) {
+        const enumName = (0, pascalize_js_1.default)(row.udtName.replace(/\[\]$/, ''));
+        return enumName;
+    }
     /**
      * @internal
      *
@@ -246,7 +371,7 @@ class KyselyQueryDriver extends Base_js_1.default {
             const driverClass = this.constructor;
             return (await new driverClass(query)['executeJoinLoad']())[0] || null;
         }
-        const kyselyQuery = new KyselyQueryDriver(this.query.limit(1)).buildSelect();
+        const kyselyQuery = new this.constructor(this.query.limit(1)).buildSelect();
         const results = await (0, executeDatabaseQuery_js_1.default)(kyselyQuery, 'executeTakeFirst');
         if (results) {
             const theFirst = this.dbResultToDreamInstance(results, this.dreamClass);
@@ -295,7 +420,7 @@ class KyselyQueryDriver extends Base_js_1.default {
     async max(columnName) {
         // eslint-disable-next-line @typescript-eslint/unbound-method
         const { max } = this.dbFor('select').fn;
-        let kyselyQuery = new KyselyQueryDriver(this.query).buildSelect({
+        let kyselyQuery = new this.constructor(this.query).buildSelect({
             bypassSelectAll: true,
             bypassOrder: true,
         });
@@ -318,7 +443,7 @@ class KyselyQueryDriver extends Base_js_1.default {
     async min(columnName) {
         // eslint-disable-next-line @typescript-eslint/unbound-method
         const { min } = this.dbFor('select').fn;
-        let kyselyQuery = new KyselyQueryDriver(this.query).buildSelect({
+        let kyselyQuery = new this.constructor(this.query).buildSelect({
             bypassSelectAll: true,
             bypassOrder: true,
         });
@@ -340,7 +465,10 @@ class KyselyQueryDriver extends Base_js_1.default {
         const { count } = this.dbFor('select').fn;
         const distinctColumn = this.query['distinctColumn'];
         const query = this.query.clone({ distinctColumn: null });
-        let kyselyQuery = new KyselyQueryDriver(query).buildSelect({ bypassSelectAll: true, bypassOrder: true });
+        let kyselyQuery = new this.constructor(query).buildSelect({
+            bypassSelectAll: true,
+            bypassOrder: true,
+        });
         const countClause = distinctColumn
             ? count((0, kysely_1.sql) `DISTINCT ${distinctColumn}`)
             : count(query['namespaceColumn'](query.dreamInstance['_primaryKey']));
@@ -356,7 +484,7 @@ class KyselyQueryDriver extends Base_js_1.default {
      * @returns An array of plucked values
      */
     async pluck(...fields) {
-        let kyselyQuery = new KyselyQueryDriver(this.query['removeAllDefaultScopesExceptOnAssociations']()).buildSelect({
+        let kyselyQuery = new this.constructor(this.query['removeAllDefaultScopesExceptOnAssociations']()).buildSelect({
             bypassSelectAll: true,
         });
         const aliases = [];
@@ -418,7 +546,8 @@ class KyselyQueryDriver extends Base_js_1.default {
      * subsequent model hooks that are fired.
      */
     static async saveDream(dream, txn = null) {
-        const db = txn?.kyselyTransaction ?? (0, index_js_2.default)('primary');
+        const connectionName = dream.connectionName || 'default';
+        const db = txn?.kyselyTransaction ?? this.dbFor(connectionName, 'primary');
         const sqlifiedAttributes = (0, sqlAttributes_js_1.default)(dream);
         try {
             if (dream.isPersisted) {
@@ -509,7 +638,7 @@ class KyselyQueryDriver extends Base_js_1.default {
     buildDelete() {
         const kyselyQuery = this.dbFor('delete').deleteFrom(this.query['baseSqlAlias']);
         const results = this.attachLimitAndOrderStatementsToNonSelectQuery(kyselyQuery);
-        return new KyselyQueryDriver(results.clone).buildCommon(results.kyselyQuery);
+        return new this.constructor(results.clone).buildCommon(results.kyselyQuery);
     }
     buildSelect({ bypassSelectAll = false, bypassOrder = false, columns, } = {}) {
         let kyselyQuery;
@@ -518,7 +647,9 @@ class KyselyQueryDriver extends Base_js_1.default {
             const query = connectionOverride
                 ? this.query['baseSelectQuery'].connection(connectionOverride)
                 : this.query['baseSelectQuery'];
-            kyselyQuery = new KyselyQueryDriver(query).buildSelect({ bypassSelectAll: true });
+            kyselyQuery = new this.constructor(query).buildSelect({
+                bypassSelectAll: true,
+            });
         }
         else {
             const from = this.query['baseSqlAlias'] === this.query['tableName']
@@ -535,7 +666,7 @@ class KyselyQueryDriver extends Base_js_1.default {
         });
         if (this.query['orderStatements'].length && !bypassOrder) {
             this.query['orderStatements'].forEach(orderStatement => {
-                kyselyQuery = kyselyQuery.orderBy(this.namespaceColumn(orderStatement.column), (0, orderByDirection_js_1.default)(orderStatement.direction));
+                kyselyQuery = kyselyQuery.orderBy(this.namespaceColumn(orderStatement.column), this.orderByDirection(orderStatement.direction));
             });
         }
         if (this.query['limitStatement'])
@@ -555,13 +686,16 @@ class KyselyQueryDriver extends Base_js_1.default {
             kyselyQuery = kyselyQuery.clearOrderBy();
         return kyselyQuery;
     }
+    orderByDirection(direction) {
+        return (0, orderByDirection_js_1.default)(direction);
+    }
     buildUpdate(attributes) {
         let kyselyQuery = this.dbFor('update')
             .updateTable(this.query['tableName'])
             .set(attributes);
         kyselyQuery = this.conditionallyAttachSimilarityColumnsToUpdate(kyselyQuery);
         const results = this.attachLimitAndOrderStatementsToNonSelectQuery(kyselyQuery);
-        return new KyselyQueryDriver(results.clone).buildCommon(results.kyselyQuery);
+        return new this.constructor(results.clone).buildCommon(results.kyselyQuery);
     }
     /**
      * @internal
@@ -612,29 +746,6 @@ class KyselyQueryDriver extends Base_js_1.default {
     async hydratePreload(dream) {
         await this.applyPreload(this.query['preloadStatements'], this.query['preloadOnStatements'], dream);
     }
-    static async duplicateDatabase() {
-        const dreamApp = index_js_3.default.getOrFail();
-        const parallelTests = dreamApp.parallelTests;
-        if (!parallelTests)
-            return;
-        index_js_1.default.logger.logStartProgress(`duplicating db for parallel tests...`);
-        const dbConf = dreamApp.dbConnectionConfig('primary');
-        const client = await (0, loadPgClient_js_1.default)({ useSystemDb: true });
-        if (EnvInternal_js_1.default.boolean('DREAM_CORE_DEVELOPMENT')) {
-            const replicaTestWorkerDatabaseName = `replica_test_${dbConf.name}`;
-            index_js_1.default.logger.logContinueProgress(`creating fake replica test database ${replicaTestWorkerDatabaseName}...`, { logPrefix: '  ├ [db]', logPrefixColor: 'cyan' });
-            await client.query(`DROP DATABASE IF EXISTS ${replicaTestWorkerDatabaseName};`);
-            await client.query(`CREATE DATABASE ${replicaTestWorkerDatabaseName} TEMPLATE ${dbConf.name};`);
-        }
-        for (let i = 2; i <= parallelTests; i++) {
-            const workerDatabaseName = `${dbConf.name}_${i}`;
-            index_js_1.default.logger.logContinueProgress(`creating duplicate test database ${workerDatabaseName} for concurrent tests...`, { logPrefix: '  ├ [db]', logPrefixColor: 'cyan' });
-            await client.query(`DROP DATABASE IF EXISTS ${workerDatabaseName};`);
-            await client.query(`CREATE DATABASE ${workerDatabaseName} TEMPLATE ${dbConf.name};`);
-        }
-        await client.end();
-        index_js_1.default.logger.logEndProgress();
-    }
     aliasWhereStatements(whereStatements, alias) {
         return whereStatements.map(whereStatement => this.aliasWhereStatement(whereStatement, alias));
     }
@@ -682,7 +793,9 @@ class KyselyQueryDriver extends Base_js_1.default {
      */
     async executeJoinLoad(options = {}) {
         const query = this.query['limit'](null).offset(null);
-        let kyselyQuery = new KyselyQueryDriver(query).buildSelect({ bypassSelectAll: true });
+        let kyselyQuery = new this.constructor(query).buildSelect({
+            bypassSelectAll: true,
+        });
         const aliasToDreamClassesMap = {
             [this.query['baseSqlAlias']]: this.dreamClass,
             ...this.joinStatementsToDreamClassesMap(this.query['leftJoinStatements']),
@@ -1867,3 +1980,17 @@ const associationStringToAssociationAndMaybeAlias = function ({ dreamClass, asso
         alias,
     };
 };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function defaultPostgresSslConfig(connectionConf) {
+    // TODO: properly configure (https://rvohealth.atlassian.net/browse/PDTC-2914)
+    return {
+        rejectUnauthorized: false,
+        // ca: fs.readFileSync('/path/to/server-certificates/root.crt').toString(),
+        // key: fs.readFileSync('/path/to/client-key/postgresql.key').toString(),
+        // cert: fs.readFileSync('/path/to/client-certificates/postgresql.crt').toString(),
+    };
+}
+function shouldSoftDelete(dream, reallyDestroy) {
+    const dreamClass = dream.constructor;
+    return dreamClass['softDelete'] && !reallyDestroy;
+}

package/dist/cjs/src/dream/QueryDriver/Postgres.js

@@ -1,6 +1,168 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const pg_1 = require("pg");
+const kysely_1 = require("kysely");
+const index_js_1 = require("../../cli/index.js");
+const dataTypes_js_1 = require("../../db/dataTypes.js");
+const index_js_2 = require("../../dream-app/index.js");
+const camelize_js_1 = require("../../helpers/camelize.js");
+const customPgParsers_js_1 = require("../../helpers/customPgParsers.js");
+const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
+const createDb_js_1 = require("./helpers/pg/createDb.js");
+const dropDb_js_1 = require("./helpers/pg/dropDb.js");
+const loadPgClient_js_1 = require("./helpers/pg/loadPgClient.js");
 const Kysely_js_1 = require("./Kysely.js");
+const pgTypes = pg_1.default.types;
 class PostgresQueryDriver extends Kysely_js_1.default {
+    /**
+     * create the database. Must respond to the NODE_ENV value.
+     */
+    static async dbCreate(connectionName) {
+        const dreamApp = index_js_2.default.getOrFail();
+        const primaryDbConf = dreamApp.dbConnectionConfig(connectionName, 'primary');
+        index_js_1.default.logger.logStartProgress(`creating ${primaryDbConf.name}...`);
+        await (0, createDb_js_1.default)(connectionName, 'primary');
+        index_js_1.default.logger.logEndProgress();
+        // TODO: add support for creating replicas. Began doing it below, but it is very tricky,
+        // and we don't need it at the moment, so kicking off for future development when we have more time
+        // to flesh this out.
+        // if (connectionRetriever.hasReplicaConfig(connectionName)) {
+        //   const replicaDbConf = connectionRetriever.getConnectionConf('replica')
+        //   console.log(`creating ${process.env[replicaDbConf.name]}`)
+        //   await createDb('replica')
+        // }
+    }
+    /**
+     * delete the database. Must respond to the NODE_ENV value.
+     */
+    static async dbDrop(connectionName) {
+        const dreamApp = index_js_2.default.getOrFail();
+        const primaryDbConf = dreamApp.dbConnectionConfig(connectionName, 'primary');
+        index_js_1.default.logger.logStartProgress(`dropping ${primaryDbConf.name}...`);
+        await (0, dropDb_js_1.default)(connectionName, 'primary');
+        index_js_1.default.logger.logEndProgress();
+        // TODO: add support for dropping replicas. Began doing it below, but it is very tricky,
+        // and we don't need it at the moment, so kicking off for future development when we have more time
+        // to flesh this out.
+        // if (connectionRetriever.hasReplicaConfig(connectionName)) {
+        //   const replicaDbConf = connectionRetriever.getConnectionConf('replica')
+        //   console.log(`dropping ${process.env[replicaDbConf.name]}`)
+        //   await _dropDb('replica')
+        // }
+    }
+    /**
+     * @internal
+     *
+     * this method is called when dream is initializing, and is used
+     * to configure the database to utilize custom type parsers for
+     * a variety of data types.
+     *
+     * @param connectionName - the name of the connection you are doing this for
+     * @returns void
+     */
+    static async setDatabaseTypeParsers(connectionName) {
+        const kyselyDb = this.dbFor(connectionName, 'primary');
+        pgTypes.setTypeParser(pgTypes.builtins.DATE, customPgParsers_js_1.parsePostgresDate);
+        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMP, customPgParsers_js_1.parsePostgresDatetime);
+        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMPTZ, customPgParsers_js_1.parsePostgresDatetime);
+        pgTypes.setTypeParser(pgTypes.builtins.NUMERIC, customPgParsers_js_1.parsePostgresDecimal);
+        pgTypes.setTypeParser(pgTypes.builtins.INT8, customPgParsers_js_1.parsePostgresBigint);
+        const textArrayOid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.TEXT);
+        if (textArrayOid) {
+            let oid;
+            const textArrayParser = pgTypes.getTypeParser(textArrayOid);
+            function transformPostgresArray(transformer) {
+                return (value) => textArrayParser(value).map(str => transformer(str));
+            }
+            const enumArrayOids = await (0, customPgParsers_js_1.findEnumArrayOids)(kyselyDb);
+            enumArrayOids.forEach((enumArrayOid) => pgTypes.setTypeParser(enumArrayOid, textArrayParser));
+            oid = await (0, customPgParsers_js_1.findCitextArrayOid)(kyselyDb);
+            if (oid)
+                pgTypes.setTypeParser(oid, textArrayParser);
+            oid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.UUID);
+            if (oid)
+                pgTypes.setTypeParser(oid, textArrayParser);
+            oid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.DATE);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(customPgParsers_js_1.parsePostgresDate));
+            oid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.TIMESTAMP);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(customPgParsers_js_1.parsePostgresDatetime));
+            oid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.TIMESTAMPTZ);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(customPgParsers_js_1.parsePostgresDatetime));
+            oid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.NUMERIC);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(customPgParsers_js_1.parsePostgresDecimal));
+            oid = await (0, customPgParsers_js_1.findCorrespondingArrayOid)(kyselyDb, pgTypes.builtins.INT8);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(customPgParsers_js_1.parsePostgresBigint));
+        }
+    }
+    /**
+     * @internal
+     *
+     * this is used by the SchemaBuilder to store column data permanently
+     * within the types/dream.ts file.
+     */
+    static async getColumnData(connectionName, tableName, associationData) {
+        const db = this.dbFor(connectionName, 'primary');
+        const sqlQuery = (0, kysely_1.sql) `SELECT column_name, udt_name::regtype, is_nullable, data_type FROM information_schema.columns WHERE table_name = ${tableName}`;
+        const columnToDBTypeMap = await sqlQuery.execute(db);
+        const rows = columnToDBTypeMap.rows;
+        const columnData = {};
+        rows.forEach(row => {
+            const isEnum = ['USER-DEFINED', 'ARRAY'].includes(row.dataType) && !(0, dataTypes_js_1.isPrimitiveDataType)(row.udtName);
+            const isArray = ['ARRAY'].includes(row.dataType);
+            const associationMetadata = associationData[row.columnName];
+            columnData[(0, camelize_js_1.default)(row.columnName)] = {
+                dbType: row.udtName,
+                allowNull: row.isNullable === 'YES',
+                enumType: isEnum ? this.enumType(row) : null,
+                enumValues: isEnum ? `${this.enumType(row)}Values` : null,
+                isArray,
+                foreignKey: associationMetadata?.foreignKey || null,
+            };
+        });
+        return Object.keys(columnData)
+            .sort()
+            .reduce((acc, key) => {
+            if (columnData[key] === undefined)
+                return acc;
+            acc[key] = columnData[key];
+            return acc;
+        }, {});
+    }
+    static async duplicateDatabase(connectionName) {
+        const dreamApp = index_js_2.default.getOrFail();
+        const parallelTests = dreamApp.parallelTests;
+        if (!parallelTests)
+            return;
+        index_js_1.default.logger.logStartProgress(`duplicating db for parallel tests...`);
+        const dbConf = dreamApp.dbConnectionConfig(connectionName, 'primary');
+        const client = await (0, loadPgClient_js_1.default)({ useSystemDb: true, connectionName });
+        if (EnvInternal_js_1.default.boolean('DREAM_CORE_DEVELOPMENT')) {
+            const replicaTestWorkerDatabaseName = `replica_test_${dbConf.name}`;
+            index_js_1.default.logger.logContinueProgress(`creating fake replica test database ${replicaTestWorkerDatabaseName}...`, { logPrefix: '  ├ [db]', logPrefixColor: 'cyan' });
+            await client.query(`DROP DATABASE IF EXISTS ${replicaTestWorkerDatabaseName};`);
+            await client.query(`CREATE DATABASE ${replicaTestWorkerDatabaseName} TEMPLATE ${dbConf.name};`);
+        }
+        for (let i = 2; i <= parallelTests; i++) {
+            const workerDatabaseName = `${dbConf.name}_${i}`;
+            index_js_1.default.logger.logContinueProgress(`creating duplicate test database ${workerDatabaseName} for concurrent tests...`, { logPrefix: '  ├ [db]', logPrefixColor: 'cyan' });
+            await client.query(`DROP DATABASE IF EXISTS ${workerDatabaseName};`);
+            await client.query(`CREATE DATABASE ${workerDatabaseName} TEMPLATE ${dbConf.name};`);
+        }
+        await client.end();
+        index_js_1.default.logger.logEndProgress();
+    }
 }
 exports.default = PostgresQueryDriver;