@rvoh/dream 0.29.1

package/dist/cjs/src/bin/helpers/sync.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = writeSyncFile;
+require("../../helpers/loadEnv.js");
+const fs = require("fs/promises");
+const path = require("path");
+const ConnectionConfRetriever_js_1 = require("../../db/ConnectionConfRetriever.js");
+const index_js_1 = require("../../dream-application/index.js");
+const autogeneratedFileMessage_js_1 = require("../../global-cli/helpers/autogeneratedFileMessage.js");
+const compact_js_1 = require("../../helpers/compact.js");
+const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
+const dreamPath_js_1 = require("../../helpers/path/dreamPath.js");
+const snakeify_js_1 = require("../../helpers/snakeify.js");
+const sspawn_js_1 = require("../../helpers/sspawn.js");
+async function writeSyncFile() {
+    const dbConf = new ConnectionConfRetriever_js_1.default().getConnectionConf('primary');
+    const dreamApp = index_js_1.default.getOrFail();
+    const dbSyncFilePath = path.join((0, dreamPath_js_1.default)('types'), 'db.ts');
+    const absoluteDbSyncPath = path.join(dreamApp.projectRoot, dbSyncFilePath);
+    await (0, sspawn_js_1.default)(`kysely-codegen --url=postgres://${dbConf.user}:${dbConf.password}@${dbConf.host}:${dbConf.port}/${dbConf.name} --out-file=${absoluteDbSyncPath}`);
+    // intentionally bypassing helpers here, since they often end up referencing
+    // from the dist folder, whereas dirname here is pointing to true src folder.
+    const file = (await fs.readFile(absoluteDbSyncPath)).toString();
+    const enhancedSchema = enhanceSchema(file);
+    await fs.writeFile(absoluteDbSyncPath, enhancedSchema);
+    index_js_1.default.log('done writing dream sync file!');
+}
+// begin: schema helpers
+function enhanceSchema(file) {
+    file = removeUnwantedExports(file);
+    file = replaceInt8Type(file);
+    file = replaceJsonType(file);
+    const interfaces = file.split(/export interface /g);
+    const results = interfaces.slice(1, interfaces.length);
+    const dbInterface = results.find(str => /^DB \{/.test(str));
+    const camelDbInterface = camelcasify(dbInterface);
+    file = camelcasify(file);
+    file = file.replace(camelDbInterface, dbInterface);
+    file = addCustomImports(file);
+    const transformedNames = (0, compact_js_1.default)(results.map(result => transformName(result)));
+    const fileWithCoercedTypes = exportedEnumTypesToExportedTypeValues(file);
+    // BEGIN FILE CONTENTS BUILDING
+    const newFileContents = `${fileWithCoercedTypes}
+
+export class DBClass {
+  ${transformedNames
+        .map(name => `${(0, snakeify_js_1.default)(name)}: ${name}`)
+        .sort()
+        .join('\n  ')}
+}
+`;
+    const sortedFileContents = alphaSortInterfaceProperties(newFileContents);
+    return sortedFileContents;
+}
+function removeUnwantedExports(file) {
+    return file.replace(/\nexport type Timestamp = ColumnType<.*/, `export type IdType = string | number | bigint
+export type Timestamp = ColumnType<DateTime | CalendarDate>`);
+}
+function addCustomImports(file) {
+    const calendarDateImportStatement = EnvInternal_js_1.default.boolean('DREAM_CORE_DEVELOPMENT')
+        ? "import CalendarDate from '../../src/helpers/CalendarDate'"
+        : "import { CalendarDate } from '@rvohealth/dream'";
+    const customImports = `${calendarDateImportStatement}
+import { DateTime } from 'luxon'`;
+    return `${(0, autogeneratedFileMessage_js_1.default)()}${customImports}
+${file}`;
+}
+function replaceInt8Type(str) {
+    return str.replace('export type Int8 = ColumnType<string, bigint | number | string>', 'export type Int8 = ColumnType<string, bigint | number | string, bigint | number | string>');
+}
+function replaceJsonType(str) {
+    return str.replace('export type Json = ColumnType<JsonValue, string, string>', 'export type Json = ColumnType<JsonValue, string | JsonValue, string | JsonValue>');
+}
+function camelcasify(str) {
+    return _camelcasify(str);
+}
+function _camelcasify(str) {
+    const camelString = str.replace(/([( .])([a-z][a-zA-Z0-9]*)_([a-z0-9])([a-z0-9]*)/g, (match, p1, p2, p3, p4) => `${p1}${p2}${p3.toUpperCase()}${p4}`);
+    return camelString === str ? camelString : _camelcasify(camelString);
+}
+function alphaSortInterfaceProperties(str) {
+    return str.replace(/(export interface [^\n{]+){\n([^}]+)\n}/g, (_match, interfaceDeclaration, lines) => {
+        const props = lines.split(/\n/);
+        return `${interfaceDeclaration}{
+${props.sort().join('\n')}
+}`;
+    });
+}
+function exportedEnumTypesToExportedTypeValues(str) {
+    const ommitedTypes = ['Generated<T>', 'Json', 'JsonArray', 'JsonObject', 'JsonPrimitive', 'JsonValue'];
+    return str.replace(/export type ([^=]*) = ((?!ColumnType)[^;\n]*);/g, (_match, typeDeclaration, types) => {
+        const originalType = `export type ${typeDeclaration} = ${types};`;
+        if (ommitedTypes.some(type => type === typeDeclaration)) {
+            return originalType;
+        }
+        return `\
+${originalType}
+export const ${typeDeclaration}Values = [
+  ${types.split(' | ').join(',\n  ')}
+] as const
+`;
+    });
+}
+function transformName(str) {
+    const name = str.split(' {')[0].replace(/\s/g, '');
+    if (name === 'DB')
+        return null;
+    return name;
+}

package/dist/cjs/src/bin/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConnectionConfRetriever_js_1 = require("../db/ConnectionConfRetriever.js");
+const index_js_1 = require("../dream-application/index.js");
+const SchemaBuilder_js_1 = require("../helpers/cli/SchemaBuilder.js");
+const generateDream_js_1 = require("../helpers/cli/generateDream.js");
+const generateMigration_js_1 = require("../helpers/cli/generateMigration.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");
+require("../helpers/loadEnv.js");
+const sspawn_js_1 = require("../helpers/sspawn.js");
+const sync_js_1 = require("./helpers/sync.js");
+class DreamBin {
+    static async sync(onSync) {
+        await (0, sync_js_1.default)();
+        await this.buildDreamSchema();
+        await onSync();
+    }
+    static async buildDreamSchema() {
+        console.log('writing dream schema...');
+        await new SchemaBuilder_js_1.default().build();
+        console.log('Done!');
+    }
+    static async dbCreate() {
+        const connectionRetriever = new ConnectionConfRetriever_js_1.default();
+        const primaryDbConf = connectionRetriever.getConnectionConf('primary');
+        console.log(`creating ${primaryDbConf.name}`);
+        await (0, createDb_js_1.default)('primary');
+        // 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')
+        // }
+        console.log('complete!');
+    }
+    static async dbDrop() {
+        const connectionRetriever = new ConnectionConfRetriever_js_1.default();
+        const primaryDbConf = connectionRetriever.getConnectionConf('primary');
+        console.log(`dropping ${primaryDbConf.name}`);
+        await (0, dropDb_js_1.default)('primary');
+        // 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')
+        // }
+        console.log('complete!');
+    }
+    static async dbMigrate() {
+        await (0, runMigration_js_1.default)({ mode: 'migrate' });
+        await this.duplicateDatabase();
+    }
+    static async dbRollback(opts) {
+        let step = opts.steps;
+        while (step > 0) {
+            await (0, runMigration_js_1.default)({ mode: 'rollback' });
+            step -= 1;
+        }
+        await this.duplicateDatabase();
+    }
+    static async generateDream(fullyQualifiedModelName, columnsWithTypes, options) {
+        await (0, generateDream_js_1.default)({ fullyQualifiedModelName, columnsWithTypes, options });
+    }
+    static async generateStiChild(fullyQualifiedModelName, fullyQualifiedParentName, columnsWithTypes, options) {
+        await (0, generateDream_js_1.default)({ fullyQualifiedModelName, columnsWithTypes, options, fullyQualifiedParentName });
+    }
+    static async generateMigration(migrationName, columnsWithTypes) {
+        await (0, generateMigration_js_1.default)({ migrationName, columnsWithTypes });
+    }
+    // though this is a private method, it is still used internally.
+    // It is only made private so that people don't mistakenly try
+    // to use it to generate docs for their apps.
+    static async buildDocs() {
+        console.log('generating docs...');
+        await (0, sspawn_js_1.default)('yarn typedoc src/index.ts --tsconfig ./tsconfig.esm.build.json --out docs');
+        console.log('done!');
+    }
+    static async duplicateDatabase() {
+        const parallelTests = index_js_1.default.getOrFail().parallelTests;
+        if (!parallelTests)
+            return;
+        const connectionRetriever = new ConnectionConfRetriever_js_1.default();
+        const dbConf = connectionRetriever.getConnectionConf('primary');
+        const client = await (0, loadPgClient_js_1.default)({ useSystemDb: true });
+        if (process.env.DREAM_CORE_DEVELOPMENT === '1') {
+            const replicaTestWorkerDatabaseName = `replica_test_${dbConf.name}`;
+            console.log(`creating fake replica test database ${replicaTestWorkerDatabaseName}`);
+            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}`;
+            console.log(`creating duplicate test database ${workerDatabaseName} for concurrent tests`);
+            await client.query(`DROP DATABASE IF EXISTS ${workerDatabaseName};`);
+            await client.query(`CREATE DATABASE ${workerDatabaseName} TEMPLATE ${dbConf.name};`);
+        }
+        await client.end();
+    }
+}
+exports.default = DreamBin;

package/dist/cjs/src/cli/index.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const index_js_1 = require("../bin/index.js");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+class DreamCLI {
+    /**
+     * use this method for initializing a standalone dream application. If using Psychic and Dream together,
+     * a different pattern is used, which leverages the `generateDreamCli` method instead.
+     */
+    static provide(program, { initializeDreamApplication, seedDb, }) {
+        program
+            .command('sync')
+            .description('sync introspects your database, updating your schema to reflect, and then syncs the new schema with the installed dream node module, allowing it provide your schema to the underlying kysely integration')
+            .action(async () => {
+            await initializeDreamApplication();
+            await index_js_1.default.sync(() => { });
+            process.exit();
+        });
+        this.generateDreamCli(program, { initializeDreamApplication, seedDb, onSync: () => { } });
+    }
+    /**
+     * called under the hood when provisioning both psychic and dream applications.
+     */
+    static generateDreamCli(program, { initializeDreamApplication, seedDb, onSync, }) {
+        program
+            .command('generate:migration')
+            .alias('g:migration')
+            .description('create a new migration')
+            .argument('<migrationName>', 'end with -to-table-name to prepopulate with an alterTable command')
+            .argument('[columnsWithTypes...]', 'properties of the model column1:text/string/enum/etc. column2:text/string/enum/etc. ... columnN:text/string/enum/etc.')
+            .action(async (migrationName, columnsWithTypes) => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            await initializeDreamApplication();
+            await index_js_1.default.generateMigration(migrationName, columnsWithTypes);
+            process.exit();
+        });
+        program
+            .command('generate:model')
+            .alias('g:model')
+            .alias('generate:dream')
+            .alias('g:dream')
+            .option('--no-serializer')
+            .description('create a new Dream model')
+            .argument('<modelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
+            .argument('[columnsWithTypes...]', 'properties of the model property1:text/string/enum/etc. property2:text/string/enum/etc. ... propertyN:text/string/enum/etc.')
+            .action(async (modelName, columnsWithTypes, options) => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            await initializeDreamApplication();
+            await index_js_1.default.generateDream(modelName, columnsWithTypes, options);
+            process.exit();
+        });
+        program
+            .command('generate:sti-child')
+            .alias('g:sti-child')
+            .description('create a new Dream model that extends another Dream model, leveraging STI (single table inheritance)')
+            .option('--no-serializer')
+            .argument('<childModelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
+            .argument('<extends>', 'just the word extends')
+            .argument('<parentModelName>', 'name of the parent model')
+            .argument('[columnsWithTypes...]', 'properties of the model property1:text/string/enum/etc. property2:text/string/enum/etc. ... propertyN:text/string/enum/etc.')
+            .action(async (childModelName, extendsWord, parentModelName, columnsWithTypes, options) => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            await initializeDreamApplication();
+            if (extendsWord !== 'extends')
+                throw new Error('Expecting: `<child-name> extends <parent-name> <columns-and-types>');
+            await index_js_1.default.generateStiChild(childModelName, parentModelName, columnsWithTypes, options);
+            process.exit();
+        });
+        program
+            .command('db:create')
+            .description('creates a new database, seeding from local .env or .env.test if NODE_ENV=test is set for env vars')
+            .action(async () => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            EnvInternal_js_1.default.setBoolean('BYPASS_DB_CONNECTIONS_DURING_INIT');
+            await initializeDreamApplication({ bypassModelIntegrityCheck: true });
+            await index_js_1.default.dbCreate();
+            process.exit();
+        });
+        program
+            .command('db:migrate')
+            .description('db:migrate runs any outstanding database migrations')
+            .option('--skip-sync', 'skips syncing local schema after running migrations')
+            .action(async ({ skipSync }) => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            await initializeDreamApplication({ bypassModelIntegrityCheck: true });
+            await index_js_1.default.dbMigrate();
+            if (EnvInternal_js_1.default.isDevelopmentOrTest && !skipSync) {
+                await index_js_1.default.sync(onSync);
+            }
+            process.exit();
+        });
+        program
+            .command('db:rollback')
+            .description('db:rollback rolls back the migration')
+            .option('--steps <number>', 'number of steps back to travel', myParseInt, 1)
+            .option('--skip-sync', 'skips syncing local schema after running migrations')
+            .action(async ({ steps, skipSync }) => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            await initializeDreamApplication({ bypassModelIntegrityCheck: true });
+            await index_js_1.default.dbRollback({ steps });
+            if (EnvInternal_js_1.default.isDevelopmentOrTest && !skipSync) {
+                await index_js_1.default.sync(onSync);
+            }
+            process.exit();
+        });
+        program
+            .command('db:drop')
+            .description('drops the database, seeding from local .env or .env.test if NODE_ENV=test is set for env vars')
+            .action(async () => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            EnvInternal_js_1.default.setBoolean('BYPASS_DB_CONNECTIONS_DURING_INIT');
+            await initializeDreamApplication({ bypassModelIntegrityCheck: true });
+            await index_js_1.default.dbDrop();
+            process.exit();
+        });
+        program
+            .command('db:reset')
+            .description('runs db:drop (safely), then db:create, db:migrate, and db:seed')
+            .action(async () => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            EnvInternal_js_1.default.setBoolean('BYPASS_DB_CONNECTIONS_DURING_INIT');
+            await initializeDreamApplication({ bypassModelIntegrityCheck: true });
+            await index_js_1.default.dbDrop();
+            await index_js_1.default.dbCreate();
+            EnvInternal_js_1.default.unsetBoolean('BYPASS_DB_CONNECTIONS_DURING_INIT');
+            await initializeDreamApplication({ bypassModelIntegrityCheck: true });
+            await index_js_1.default.dbMigrate();
+            await index_js_1.default.sync(onSync);
+            await seedDb();
+            process.exit();
+        });
+        program
+            .command('db:seed')
+            .description('seeds the database using the file located in db/seed.ts')
+            .action(async () => {
+            EnvInternal_js_1.default.provideDefaultNodeEnv('test');
+            if (process.env.NODE_ENV === 'test' && process.env.DREAM_SEED_DB_IN_TEST !== '1') {
+                console.log('skipping db seed for test env. To really seed for test, add DREAM_SEED_DB_IN_TEST=1');
+                return;
+            }
+            await initializeDreamApplication();
+            await seedDb();
+            process.exit();
+        });
+    }
+}
+exports.default = DreamCLI;
+function myParseInt(value) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new commander_1.InvalidArgumentError(`${value} is not a number`);
+    }
+    return parsedValue;
+}

package/dist/cjs/src/db/ConnectedToDB.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../db/index.js");
+class ConnectedToDB {
+    dreamInstance;
+    dreamClass;
+    dreamTransaction = null;
+    connectionOverride;
+    /**
+     * @internal
+     *
+     * stores the Dream models joined in this Query instance
+     */
+    innerJoinDreamClasses = Object.freeze([]);
+    constructor(dreamInstance, opts = {}) {
+        this.dreamInstance = dreamInstance;
+        this.dreamClass = dreamInstance.constructor;
+        this.dreamTransaction = opts.transaction || null;
+        this.connectionOverride = opts.connection;
+        this.innerJoinDreamClasses = Object.freeze(opts.innerJoinDreamClasses || []);
+    }
+    dbConnectionType(sqlCommandType) {
+        if (this.dreamTransaction)
+            return 'primary';
+        switch (sqlCommandType) {
+            case 'select':
+                return this.connectionOverride || (this.isReplicaSafe() ? 'replica' : 'primary');
+            default:
+                return 'primary';
+        }
+    }
+    // ATTENTION FRED
+    // stop trying to make this async. You never learn...
+    dbFor(sqlCommandType) {
+        if (this.dreamTransaction?.kyselyTransaction)
+            return this.dreamTransaction?.kyselyTransaction;
+        return (0, index_js_1.default)(this.dbConnectionType(sqlCommandType));
+    }
+    isReplicaSafe() {
+        return this.innerJoinDreamClasses.reduce((accumulator, dreamClass) => accumulator && dreamClass['replicaSafe'], this.dreamClass['replicaSafe']);
+    }
+}
+exports.default = ConnectedToDB;

package/dist/cjs/src/db/ConnectionConfRetriever.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../dream-application/index.js");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+class ConnectionConfRetriever {
+    getConnectionConf(connection) {
+        const dreamApplication = index_js_1.default.getOrFail();
+        const conf = dreamApplication.dbCredentials?.[connection] || dreamApplication.dbCredentials?.primary;
+        if (!conf)
+            throw new Error(`
+      Cannot find a connection config given the following connection and node environment:
+        connection: ${connection}
+        NODE_ENV: ${EnvInternal_js_1.default.nodeEnv}
+    `);
+        return conf;
+    }
+    hasReplicaConfig() {
+        const dreamApplication = index_js_1.default.getOrFail();
+        return !!dreamApplication.dbCredentials.replica;
+    }
+}
+exports.default = ConnectionConfRetriever;

package/dist/cjs/src/db/DreamDbConnection.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dreamDbConnections = dreamDbConnections;
+exports.closeAllDbConnections = closeAllDbConnections;
+const kysely_1 = require("kysely");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const pg_1 = require("pg");
+const index_js_1 = require("../dream-application/index.js");
+const ConnectionConfRetriever_js_1 = require("./ConnectionConfRetriever.js");
+let connections = {};
+class DreamDbConnection {
+    static getConnection(connectionType) {
+        const connectionName = getConnectionTypeName(connectionType);
+        const connection = connections[connectionName];
+        if (connection) {
+            return connection;
+        }
+        const connectionConf = new ConnectionConfRetriever_js_1.default().getConnectionConf(connectionType);
+        const dbConn = new kysely_1.Kysely({
+            log(event) {
+                const dreamApp = index_js_1.default.getOrFail();
+                dreamApp.specialHooks.dbLog.forEach(fn => {
+                    fn(event);
+                });
+            },
+            dialect: new kysely_1.PostgresDialect({
+                pool: new pg_1.default.Pool({
+                    user: connectionConf.user || '',
+                    password: connectionConf.password || '',
+                    database: getDatabaseName(connectionConf.name),
+                    host: connectionConf.host || 'localhost',
+                    port: connectionConf.port || 5432,
+                    ssl: connectionConf.useSsl ? sslConfig(connectionConf) : false,
+                }),
+            }),
+            plugins: [new kysely_1.CamelCasePlugin({ underscoreBetweenUppercaseLetters: true })],
+        });
+        connections[getConnectionTypeName(connectionType)] = dbConn;
+        return dbConn;
+    }
+    static async dropAllConnections() {
+        for (const key of Object.keys(connections)) {
+            await connections[key].destroy();
+            delete connections[key];
+        }
+    }
+}
+exports.default = DreamDbConnection;
+function getConnectionTypeName(connectionType) {
+    return parallelDatabasesEnabled() ? `${connectionType}_${process.env.JEST_WORKER_ID}` : connectionType;
+}
+function getDatabaseName(dbName) {
+    return parallelDatabasesEnabled() ? `${dbName}_${process.env.JEST_WORKER_ID}` : dbName;
+}
+function parallelDatabasesEnabled() {
+    return (!!index_js_1.default.getOrFail().parallelTests &&
+        !Number.isNaN(Number(process.env.JEST_WORKER_ID)) &&
+        Number(process.env.JEST_WORKER_ID) > 1);
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function sslConfig(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 dreamDbConnections() {
+    return connections;
+}
+async function closeAllDbConnections() {
+    await Promise.all(Object.values(connections).map(conn => conn.destroy()));
+    connections = {};
+}

package/dist/cjs/src/db/dataTypes.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postgresDatatypes = void 0;
+exports.default = dataTypes;
+exports.isPrimitiveDataType = isPrimitiveDataType;
+function dataTypes() {
+    // In the future, when we support multiple db drivers,
+    // this will need to be updated
+    return exports.postgresDatatypes;
+}
+function isPrimitiveDataType(type) {
+    return dataTypes().includes(type.replace(/\[\]$/, ''));
+}
+exports.postgresDatatypes = [
+    'bigint',
+    'bigserial',
+    'bit',
+    'bit varying',
+    'boolean',
+    'box',
+    'bytea',
+    'character',
+    'character varying',
+    'char',
+    'cidr',
+    'circle',
+    'citext',
+    'date',
+    'double precision',
+    'inet',
+    'integer',
+    'interval',
+    'json',
+    'jsonb',
+    'line',
+    'lseg',
+    'macaddr',
+    'money',
+    'numeric',
+    'path',
+    'point',
+    'polygon',
+    'real',
+    'smallint',
+    'smallserial',
+    'serial',
+    'text',
+    'time',
+    'time with time zone',
+    'timestamp',
+    'timestamp with time zone',
+    'timestamp without time zone',
+    'tsquery',
+    'tsvector',
+    'txid_snapshot',
+    'uuid',
+    'xml',
+];

package/dist/cjs/src/db/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG_ERRORS = void 0;
+exports.pgErrorType = pgErrorType;
+const pg = require("pg");
+const { DatabaseError } = pg;
+exports.PG_ERRORS = {
+    23505: 'UNIQUE_CONSTRAINT_VIOLATION',
+};
+function pgErrorFromCode(code) {
+    return exports.PG_ERRORS[code] || null;
+}
+function pgErrorType(error) {
+    if (error instanceof DatabaseError)
+        return pgErrorFromCode(error.code);
+    return null;
+}

package/dist/cjs/src/db/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = db;
+const luxon_1 = require("luxon");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+require("../helpers/loadEnv.js");
+const DreamDbConnection_js_1 = require("./DreamDbConnection.js");
+if (EnvInternal_js_1.default.string('TZ', { optional: true }))
+    luxon_1.Settings.defaultZone = EnvInternal_js_1.default.string('TZ');
+function db(connectionType = 'primary') {
+    return DreamDbConnection_js_1.default.getConnection(connectionType);
+}