@rvoh/dream 0.29.1

package/dist/cjs/src/dream-application/helpers/DreamImporter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs/promises");
+const path = require("path");
+class DreamImporter {
+    static async ls(dir) {
+        try {
+            const dirents = await fs.readdir(dir, { withFileTypes: true });
+            const files = await Promise.all(dirents
+                .map(dirent => {
+                const res = path.resolve(dir, dirent.name);
+                const sanitizedPath = res.replace(/\.ts$/, '.js');
+                return dirent.isDirectory() ? this.ls(res) : /\.js$/.test(sanitizedPath) ? sanitizedPath : null;
+            })
+                .filter(ent => ent !== null));
+            return Array.prototype.concat(...files);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return [];
+            throw err;
+        }
+    }
+    static async importDreams(pathToModels, importCb) {
+        const modelPaths = await DreamImporter.ls(pathToModels);
+        const modelClasses = [];
+        for (const modelPath of modelPaths) {
+            modelClasses.push([modelPath, (await importCb(modelPath))]);
+        }
+        return modelClasses;
+    }
+    static async importSerializers(pathToSerializers, importCb) {
+        const serializerPaths = await DreamImporter.ls(pathToSerializers);
+        const serializerClasses = [];
+        for (const serializerPath of serializerPaths) {
+            serializerClasses.push([
+                serializerPath,
+                (await importCb(serializerPath)),
+            ]);
+        }
+        return serializerClasses;
+    }
+    static async importServices(pathToServices, importCb) {
+        const servicePaths = await DreamImporter.ls(pathToServices);
+        const serviceClasses = [];
+        for (const servicePath of servicePaths) {
+            serviceClasses.push([servicePath, await importCb(servicePath)]);
+        }
+        return serviceClasses;
+    }
+}
+exports.default = DreamImporter;

package/dist/cjs/src/dream-application/helpers/globalModelKeyFromPath.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(filepath, dirPath) {
+    const prefixPath = dirPath;
+    return filepath
+        .replace(prefixPath, '')
+        .replace(/\.[jt]s$/, '')
+        .replace(/^\//, '');
+}

package/dist/cjs/src/dream-application/helpers/globalSerializerKeyFromPath.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(filepath, dirPath, exportKey = 'default') {
+    const prefixPath = dirPath;
+    const defaultExport = filepath
+        .replace(prefixPath, '')
+        .replace(/\.[jt]s$/, '')
+        .replace(/^\//, '');
+    if (exportKey === 'default') {
+        return defaultExport;
+    }
+    else {
+        const namePrefixFromPath = defaultExport.replace(/[^/]+\/?$/, '');
+        return namePrefixFromPath + exportKey.replace(new RegExp(`^${namePrefixFromPath.replace(/\/$/, '')}`), '');
+    }
+}

package/dist/cjs/src/dream-application/helpers/globalServiceKeyFromPath.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(filepath, dirPath) {
+    const prefixPath = dirPath;
+    return ('services/' +
+        filepath
+            .replace(prefixPath, '')
+            .replace(/\.[jt]s$/, '')
+            .replace(/^\//, ''));
+}

package/dist/cjs/src/dream-application/helpers/importers/importModels.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = importModels;
+exports.setCachedModels = setCachedModels;
+exports.getModelsOrFail = getModelsOrFail;
+exports.getModelsOrBlank = getModelsOrBlank;
+const Dream_js_1 = require("../../../Dream.js");
+const MissingTable_js_1 = require("../../../errors/MissingTable.js");
+const DreamImporter_js_1 = require("../DreamImporter.js");
+const globalModelKeyFromPath_js_1 = require("../globalModelKeyFromPath.js");
+let _models;
+async function importModels(modelsPath, modelImportCb) {
+    if (_models)
+        return _models;
+    const modelClasses = await DreamImporter_js_1.default.importDreams(modelsPath, modelImportCb);
+    /**
+     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+     */
+    Dream_js_1.default['globallyInitializingDecorators'] = true;
+    _models = {};
+    for (const [modelPath, modelClass] of modelClasses) {
+        if (modelClass.isDream) {
+            try {
+                // Don't create a global lookup for ApplicationModel
+                // ApplicationModel does not have a table
+                if (modelClass.table) {
+                    const modelKey = (0, globalModelKeyFromPath_js_1.default)(modelPath, modelsPath);
+                    modelClass['setGlobalName'](modelKey);
+                    _models[modelKey] = modelClass;
+                }
+            }
+            catch (error) {
+                // ApplicationModel will automatically raise an exception here,
+                // since it does not have a table.
+                if (!(error instanceof MissingTable_js_1.default))
+                    throw error;
+            }
+        }
+    }
+    for (const [, modelClass] of modelClasses) {
+        if (modelClass.isDream) {
+            try {
+                /**
+                 * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+                 * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+                 * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+                 * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+                 */
+                new modelClass({}, { _internalUseOnly: true });
+            }
+            catch (error) {
+                // ApplicationModel will automatically raise an exception here,
+                // since it does not have a table.
+                if (!(error instanceof MissingTable_js_1.default))
+                    throw error;
+            }
+        }
+    }
+    /**
+     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+     */
+    Dream_js_1.default['globallyInitializingDecorators'] = false;
+    return _models;
+}
+function setCachedModels(models) {
+    _models = models;
+}
+function getModelsOrFail() {
+    if (!_models)
+        throw new Error('Must call loadModels before calling getModelsOrFail');
+    return _models;
+}
+function getModelsOrBlank() {
+    return _models || {};
+}

package/dist/cjs/src/dream-application/helpers/importers/importSerializers.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = importSerializers;
+exports.setCachedSerializers = setCachedSerializers;
+exports.getSerializersOrFail = getSerializersOrFail;
+exports.getSerializersOrBlank = getSerializersOrBlank;
+const SerializerNameConflict_js_1 = require("../../../errors/dream-application/SerializerNameConflict.js");
+const index_js_1 = require("../../../serializer/index.js");
+const DreamImporter_js_1 = require("../DreamImporter.js");
+const globalSerializerKeyFromPath_js_1 = require("../globalSerializerKeyFromPath.js");
+let _serializers;
+async function importSerializers(serializersPath, serializerImportCb) {
+    if (_serializers)
+        return _serializers;
+    const serializerClasses = await DreamImporter_js_1.default.importSerializers(serializersPath, serializerImportCb);
+    /**
+     * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
+     * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on DreamSerializer, and all serializers are instantiated.
+     */
+    index_js_1.default['globallyInitializingDecorators'] = true;
+    _serializers = {};
+    for (const [serializerPath, allSerializers] of serializerClasses) {
+        Object.keys(allSerializers).forEach(key => {
+            const potentialSerializer = allSerializers[key];
+            if (potentialSerializer?.isDreamSerializer) {
+                const serializerKey = (0, globalSerializerKeyFromPath_js_1.default)(serializerPath, serializersPath, key);
+                if (_serializers[serializerKey])
+                    throw new SerializerNameConflict_js_1.default(serializerKey);
+                const serializerClass = potentialSerializer;
+                serializerClass['setGlobalName'](serializerKey);
+                /**
+                 * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
+                 * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
+                 * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+                 * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on DreamSerializer, and all serializers are instantiated.
+                 */
+                new serializerClass({});
+                _serializers[serializerKey] = potentialSerializer;
+            }
+        });
+    }
+    /**
+     * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
+     * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on DreamSerializer, and all serializers are instantiated.
+     */
+    index_js_1.default['globallyInitializingDecorators'] = false;
+    return _serializers;
+}
+function setCachedSerializers(serializers) {
+    _serializers = serializers;
+}
+function getSerializersOrFail() {
+    if (!_serializers)
+        throw new Error('Must call loadSerializers before calling getSerializersOrFail');
+    return _serializers;
+}
+function getSerializersOrBlank() {
+    return _serializers || {};
+}

package/dist/cjs/src/dream-application/helpers/importers/importServices.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = importServices;
+exports.setCachedServices = setCachedServices;
+exports.getServicesOrFail = getServicesOrFail;
+exports.getServicesOrBlank = getServicesOrBlank;
+const DreamImporter_js_1 = require("../DreamImporter.js");
+const globalServiceKeyFromPath_js_1 = require("../globalServiceKeyFromPath.js");
+let _services;
+async function importServices(servicesPath, serviceImportCb) {
+    if (_services)
+        return _services;
+    _services = {};
+    const serviceClasses = await DreamImporter_js_1.default.importServices(servicesPath, serviceImportCb);
+    for (const [servicePath, serviceClass] of serviceClasses) {
+        // we only want to register services within our app
+        // that are backgroundable, since the only purpose
+        // for keeping these indices is to be able to summon
+        // a service for backgrounding.
+        if (typeof serviceClass?.background === 'function' || typeof serviceClass?.schedule === 'function') {
+            const serviceKey = (0, globalServiceKeyFromPath_js_1.default)(servicePath, servicesPath);
+            if (typeof serviceClass['setGlobalName'] === 'function') {
+                serviceClass['setGlobalName'](serviceKey);
+            }
+            else {
+                serviceClass.globalName = serviceKey;
+            }
+            _services[serviceKey] = serviceClass;
+        }
+    }
+    return _services;
+}
+function setCachedServices(services) {
+    _services = services;
+}
+function getServicesOrFail() {
+    if (!_services)
+        throw new Error('Must call loadServices before calling getServicesOrFail');
+    return _services;
+}
+function getServicesOrBlank() {
+    return _services || {};
+}

package/dist/cjs/src/dream-application/helpers/lookupClassByGlobalName.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = lookupClassByGlobalName;
+const importModels_js_1 = require("./importers/importModels.js");
+const importSerializers_js_1 = require("./importers/importSerializers.js");
+const importServices_js_1 = require("./importers/importServices.js");
+let _globalNameMap;
+function lookupClassByGlobalName(globalName) {
+    if (_globalNameMap)
+        return _globalNameMap[globalName] || null;
+    _globalNameMap = {
+        ...(0, importServices_js_1.getServicesOrFail)(),
+        ...(0, importSerializers_js_1.getSerializersOrFail)(),
+        ...(0, importModels_js_1.getModelsOrFail)(),
+    };
+    return lookupClassByGlobalName(globalName);
+}

package/dist/cjs/src/dream-application/helpers/lookupModelByGlobalName.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = lookupModelByGlobalName;
+const importModels_js_1 = require("./importers/importModels.js");
+let _globalNameMap;
+function lookupModelByGlobalName(globalName) {
+    if (_globalNameMap)
+        return _globalNameMap[globalName] || null;
+    _globalNameMap = {
+        ...(0, importModels_js_1.getModelsOrFail)(),
+    };
+    return lookupModelByGlobalName(globalName);
+}

package/dist/cjs/src/dream-application/helpers/lookupModelByGlobalNameOrNames.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = lookupModelByGlobalNameOrNames;
+const compact_js_1 = require("../../helpers/compact.js");
+const lookupModelByGlobalName_js_1 = require("./lookupModelByGlobalName.js");
+function lookupModelByGlobalNameOrNames(globalName) {
+    if (Array.isArray(globalName))
+        return (0, compact_js_1.default)(globalName.map(name => (0, lookupModelByGlobalName_js_1.default)(name)));
+    return (0, lookupModelByGlobalName_js_1.default)(globalName);
+}

package/dist/cjs/src/dream-application/index.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const pg_1 = require("pg");
+const luxon_1 = require("luxon");
+const index_js_1 = require("../db/index.js");
+const validateTable_js_1 = require("../db/validators/validateTable.js");
+const index_js_2 = require("../encrypt/index.js");
+const DreamApplicationInitMissingCallToLoadModels_js_1 = require("../errors/dream-application/DreamApplicationInitMissingCallToLoadModels.js");
+const DreamApplicationInitMissingMissingProjectRoot_js_1 = require("../errors/dream-application/DreamApplicationInitMissingMissingProjectRoot.js");
+const customPgParsers_js_1 = require("../helpers/customPgParsers.js");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+const cache_js_1 = require("./cache.js");
+const importModels_js_1 = require("./helpers/importers/importModels.js");
+const importSerializers_js_1 = require("./helpers/importers/importSerializers.js");
+const importServices_js_1 = require("./helpers/importers/importServices.js");
+const pgTypes = pg_1.default.types;
+// this needs to be done top-level to ensure proper configuration
+luxon_1.Settings.defaultZone = 'UTC';
+class DreamApplication {
+    /**
+     * initializes a new dream application and caches it for use
+     * within this processes lifecycle.
+     *
+     * Within dream, we rely on cached information about your app
+     * to be able to serve routes, perform serializer lookups,
+     * generate files, connect to the database, etc...
+     *
+     * In order for this to work properly, the DreamApplication#init
+     * function must be called before anything else is called within
+     * Dream.
+     */
+    static async init(cb, opts = {}, deferCb) {
+        const dreamApp = new DreamApplication(opts);
+        await cb(dreamApp);
+        await dreamApp.inflections?.();
+        await deferCb?.(dreamApp);
+        dreamApp.validateApplicationBuildIntegrity({
+            bypassModelIntegrityCheck: opts.bypassModelIntegrityCheck || false,
+        });
+        if (!dreamApp.serializers)
+            (0, importSerializers_js_1.setCachedSerializers)({});
+        if (!dreamApp.services)
+            (0, importServices_js_1.setCachedServices)({});
+        (0, cache_js_1.cacheDreamApplication)(dreamApp);
+        if (!EnvInternal_js_1.default.boolean('BYPASS_DB_CONNECTIONS_DURING_INIT'))
+            await this.setDatabaseTypeParsers();
+        return dreamApp;
+    }
+    /**
+     * @internal
+     *
+     * Ensures that the application build is not missing any critical components
+     * that would render it in an invalid state
+     *
+     */
+    validateApplicationBuildIntegrity({ bypassModelIntegrityCheck }) {
+        if (!this.projectRoot)
+            throw new DreamApplicationInitMissingMissingProjectRoot_js_1.default();
+        if (!this.loadedModels)
+            throw new DreamApplicationInitMissingCallToLoadModels_js_1.default();
+        if (this.encryption?.columns?.current)
+            DreamApplication.checkKey('columns', this.encryption.columns.current.key, this.encryption.columns.current.algorithm);
+        if (!bypassModelIntegrityCheck)
+            this.validateApplicationModels();
+    }
+    /**
+     * @internal
+     *
+     * Ensures that all models are in a valid state
+     *
+     */
+    validateApplicationModels() {
+        Object.values(this.models).forEach(modelClass => {
+            (0, validateTable_js_1.default)(modelClass.prototype.schema, modelClass.prototype.table);
+        });
+    }
+    /**
+     * @internal
+     *
+     *
+     */
+    static async setDatabaseTypeParsers() {
+        const kyselyDb = (0, index_js_1.default)('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);
+        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));
+        }
+    }
+    static checkKey(encryptionIdentifier, key, algorithm) {
+        if (!index_js_2.default.validateKey(key, algorithm))
+            console.warn(`
+Your current key value for ${encryptionIdentifier} encryption is invalid.
+Try setting it to something valid, like:
+  ${index_js_2.default.generateKey(algorithm)}
+
+(This was done by calling:
+  Encrypt.generateKey('${algorithm}')
+`);
+    }
+    /**
+     * Returns the cached dream application if it has been set.
+     * If it has not been set, an exception is raised.
+     *
+     * The dream application can be set by calling DreamApplication#init,
+     * or alternatively, if you are using Psychic along with Dream,
+     * it can be set during PsychicApplication#init, which will set caches
+     * for both the dream and psychic applications at once.
+     */
+    static getOrFail() {
+        return (0, cache_js_1.getCachedDreamApplicationOrFail)();
+    }
+    static log(...args) {
+        this.getOrFail().logger.info(...args);
+    }
+    static logWithLevel(level, ...args) {
+        this.getOrFail().logger[level](...args);
+    }
+    _specialHooks = {
+        dbLog: [],
+    };
+    get specialHooks() {
+        return this._specialHooks;
+    }
+    _dbCredentials;
+    get dbCredentials() {
+        return this._dbCredentials;
+    }
+    _encryption;
+    get encryption() {
+        return this._encryption;
+    }
+    _parallelTests;
+    get parallelTests() {
+        return process.env.NODE_ENV === 'test' ? this._parallelTests : undefined;
+    }
+    _primaryKeyType = 'bigserial';
+    get primaryKeyType() {
+        return this._primaryKeyType;
+    }
+    _projectRoot;
+    get projectRoot() {
+        return this._projectRoot;
+    }
+    _paths;
+    get paths() {
+        return this._paths;
+    }
+    _serializerCasing;
+    get serializerCasing() {
+        return this._serializerCasing;
+    }
+    _logger = console;
+    get logger() {
+        return this._logger;
+    }
+    _inflections;
+    get inflections() {
+        return this._inflections;
+    }
+    loadedModels = false;
+    constructor(opts) {
+        if (opts?.db)
+            this._dbCredentials = opts.db;
+        if (opts?.primaryKeyType)
+            this._primaryKeyType = opts.primaryKeyType;
+        if (opts?.projectRoot)
+            this._projectRoot = opts.projectRoot;
+        if (opts?.inflections)
+            this._inflections = opts.inflections;
+        if (opts?.serializerCasing)
+            this._serializerCasing = opts.serializerCasing;
+        if (opts?.parallelTests)
+            this._parallelTests = opts.parallelTests;
+        this._paths = {
+            conf: opts?.paths?.conf || 'src/app/conf',
+            db: opts?.paths?.db || 'src/db',
+            factories: opts?.paths?.factories || 'spec/factories',
+            models: opts?.paths?.models || 'src/app/models',
+            modelSpecs: opts?.paths?.modelSpecs || 'spec/unit/models',
+            serializers: opts?.paths?.serializers || 'src/app/serializers',
+            services: opts?.paths?.services || 'src/app/services',
+            types: opts?.paths?.types || 'src/types',
+        };
+    }
+    get models() {
+        return (0, importModels_js_1.getModelsOrFail)();
+    }
+    get serializers() {
+        return (0, importSerializers_js_1.getSerializersOrFail)();
+    }
+    get services() {
+        return (0, importServices_js_1.getServicesOrFail)();
+    }
+    async load(resourceType, resourcePath, importCb) {
+        switch (resourceType) {
+            case 'models':
+                await (0, importModels_js_1.default)(resourcePath, importCb);
+                this.loadedModels = true;
+                break;
+            case 'serializers':
+                await (0, importSerializers_js_1.default)(resourcePath, importCb);
+                break;
+            case 'services':
+                await (0, importServices_js_1.default)(resourcePath, importCb);
+                break;
+        }
+    }
+    set(applyOption, options) {
+        switch (applyOption) {
+            case 'db':
+                this._dbCredentials = options;
+                break;
+            case 'encryption':
+                this._encryption = options;
+                break;
+            case 'primaryKeyType':
+                this._primaryKeyType = options;
+                break;
+            case 'logger':
+                this._logger = options;
+                break;
+            case 'projectRoot':
+                this._projectRoot = options;
+                break;
+            case 'inflections':
+                this._inflections = options;
+                break;
+            case 'serializerCasing':
+                this._serializerCasing = options;
+                break;
+            case 'paths':
+                this._paths = {
+                    ...this.paths,
+                    ...options,
+                };
+                break;
+            case 'parallelTests':
+                if (process.env.NODE_ENV === 'test' && !Number.isNaN(Number(options)) && Number(options) > 1) {
+                    this._parallelTests = options;
+                }
+                break;
+            default:
+                throw new Error(`Unhandled applyOption encountered in Dreamconf: ${applyOption}`);
+        }
+    }
+    on(hookEventType, cb) {
+        switch (hookEventType) {
+            case 'db:log':
+                this._specialHooks.dbLog.push(cb);
+                break;
+        }
+    }
+}
+exports.default = DreamApplication;

package/dist/cjs/src/encrypt/InternalEncrypt.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+const index_js_2 = require("../dream-application/index.js");
+const MissingColumnEncryptionOpts_js_1 = require("../errors/encrypt/MissingColumnEncryptionOpts.js");
+class InternalEncrypt {
+    static encryptColumn(data) {
+        const dreamApp = index_js_2.default.getOrFail();
+        const encryptOpts = dreamApp.encryption?.columns;
+        if (!encryptOpts)
+            throw new MissingColumnEncryptionOpts_js_1.default();
+        if (data === null || data === undefined)
+            return null;
+        return this.doEncryption(data, encryptOpts.current);
+    }
+    static decryptColumn(data) {
+        const dreamApp = index_js_2.default.getOrFail();
+        const encryptOpts = dreamApp.encryption?.columns;
+        if (!encryptOpts)
+            throw new MissingColumnEncryptionOpts_js_1.default();
+        if (data === null || data === undefined)
+            return null;
+        return this.doDecryption(data, encryptOpts.current, encryptOpts.legacy);
+    }
+    static doEncryption(data, encryptionOpts) {
+        return index_js_1.default.encrypt(data, encryptionOpts);
+    }
+    static doDecryption(data, encryptionOpts, legacyEncryptionOpts) {
+        return index_js_1.default.decrypt(data, encryptionOpts, legacyEncryptionOpts);
+    }
+}
+exports.default = InternalEncrypt;

package/dist/cjs/src/encrypt/algorithms/aes-gcm/decryptAESGCM.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = decryptAESGCM;
+const crypto = require("crypto");
+function decryptAESGCM(algorithm, encrypted, key) {
+    const { ciphertext, tag, iv } = unpackPayloadOrFail(encrypted);
+    const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key, 'base64'), Buffer.from(iv, 'base64'));
+    decipher.setAuthTag(Buffer.from(tag, 'base64'));
+    let plaintext = decipher.update(ciphertext, 'base64', 'utf8');
+    plaintext += decipher.final('utf8');
+    return JSON.parse(plaintext);
+}
+function unpackPayloadOrFail(payload) {
+    const unpackedPayload = (typeof payload === 'string' ? JSON.parse(Buffer.from(payload, 'base64').toString()) : payload);
+    if (typeof unpackedPayload !== 'object') {
+        throw new Error('Failed to unpack encrypted object. Must be an object with a ciphertext and tag property');
+    }
+    const { ciphertext, tag, iv } = unpackedPayload;
+    if (!ciphertext)
+        throw new Error('invalid ciphertext found');
+    if (!tag)
+        throw new Error('invalid tag found');
+    if (!iv)
+        throw new Error('missing iv');
+    return { ciphertext, tag, iv };
+}