@rvoh/dream 0.29.1

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

@@ -0,0 +1,14 @@
+export default function (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/esm/src/dream-application/helpers/globalServiceKeyFromPath.js

@@ -0,0 +1,8 @@
+export default function (filepath, dirPath) {
+    const prefixPath = dirPath;
+    return ('services/' +
+        filepath
+            .replace(prefixPath, '')
+            .replace(/\.[jt]s$/, '')
+            .replace(/^\//, ''));
+}

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

@@ -0,0 +1,75 @@
+import Dream from '../../../Dream.js';
+import MissingTable from '../../../errors/MissingTable.js';
+import DreamImporter from '../DreamImporter.js';
+import globalModelKeyFromPath from '../globalModelKeyFromPath.js';
+let _models;
+export default async function importModels(modelsPath, modelImportCb) {
+    if (_models)
+        return _models;
+    const modelClasses = await DreamImporter.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['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 = globalModelKeyFromPath(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))
+                    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))
+                    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['globallyInitializingDecorators'] = false;
+    return _models;
+}
+export function setCachedModels(models) {
+    _models = models;
+}
+export function getModelsOrFail() {
+    if (!_models)
+        throw new Error('Must call loadModels before calling getModelsOrFail');
+    return _models;
+}
+export function getModelsOrBlank() {
+    return _models || {};
+}

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

@@ -0,0 +1,57 @@
+import SerializerNameConflict from '../../../errors/dream-application/SerializerNameConflict.js';
+import DreamSerializer from '../../../serializer/index.js';
+import DreamImporter from '../DreamImporter.js';
+import globalSerializerKeyFromPath from '../globalSerializerKeyFromPath.js';
+let _serializers;
+export default async function importSerializers(serializersPath, serializerImportCb) {
+    if (_serializers)
+        return _serializers;
+    const serializerClasses = await DreamImporter.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.
+     */
+    DreamSerializer['globallyInitializingDecorators'] = true;
+    _serializers = {};
+    for (const [serializerPath, allSerializers] of serializerClasses) {
+        Object.keys(allSerializers).forEach(key => {
+            const potentialSerializer = allSerializers[key];
+            if (potentialSerializer?.isDreamSerializer) {
+                const serializerKey = globalSerializerKeyFromPath(serializerPath, serializersPath, key);
+                if (_serializers[serializerKey])
+                    throw new SerializerNameConflict(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.
+     */
+    DreamSerializer['globallyInitializingDecorators'] = false;
+    return _serializers;
+}
+export function setCachedSerializers(serializers) {
+    _serializers = serializers;
+}
+export function getSerializersOrFail() {
+    if (!_serializers)
+        throw new Error('Must call loadSerializers before calling getSerializersOrFail');
+    return _serializers;
+}
+export function getSerializersOrBlank() {
+    return _serializers || {};
+}

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

@@ -0,0 +1,37 @@
+import DreamImporter from '../DreamImporter.js';
+import globalServiceKeyFromPath from '../globalServiceKeyFromPath.js';
+let _services;
+export default async function importServices(servicesPath, serviceImportCb) {
+    if (_services)
+        return _services;
+    _services = {};
+    const serviceClasses = await DreamImporter.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 = globalServiceKeyFromPath(servicePath, servicesPath);
+            if (typeof serviceClass['setGlobalName'] === 'function') {
+                serviceClass['setGlobalName'](serviceKey);
+            }
+            else {
+                serviceClass.globalName = serviceKey;
+            }
+            _services[serviceKey] = serviceClass;
+        }
+    }
+    return _services;
+}
+export function setCachedServices(services) {
+    _services = services;
+}
+export function getServicesOrFail() {
+    if (!_services)
+        throw new Error('Must call loadServices before calling getServicesOrFail');
+    return _services;
+}
+export function getServicesOrBlank() {
+    return _services || {};
+}

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

@@ -0,0 +1,14 @@
+import { getModelsOrFail } from './importers/importModels.js';
+import { getSerializersOrFail } from './importers/importSerializers.js';
+import { getServicesOrFail } from './importers/importServices.js';
+let _globalNameMap;
+export default function lookupClassByGlobalName(globalName) {
+    if (_globalNameMap)
+        return _globalNameMap[globalName] || null;
+    _globalNameMap = {
+        ...getServicesOrFail(),
+        ...getSerializersOrFail(),
+        ...getModelsOrFail(),
+    };
+    return lookupClassByGlobalName(globalName);
+}

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

@@ -0,0 +1,10 @@
+import { getModelsOrFail } from './importers/importModels.js';
+let _globalNameMap;
+export default function lookupModelByGlobalName(globalName) {
+    if (_globalNameMap)
+        return _globalNameMap[globalName] || null;
+    _globalNameMap = {
+        ...getModelsOrFail(),
+    };
+    return lookupModelByGlobalName(globalName);
+}

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

@@ -0,0 +1,7 @@
+import compact from '../../helpers/compact.js';
+import lookupModelByGlobalName from './lookupModelByGlobalName.js';
+export default function lookupModelByGlobalNameOrNames(globalName) {
+    if (Array.isArray(globalName))
+        return compact(globalName.map(name => lookupModelByGlobalName(name)));
+    return lookupModelByGlobalName(globalName);
+}

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

@@ -0,0 +1,281 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import pg from 'pg';
+import { Settings } from 'luxon';
+import db from '../db/index.js';
+import validateTable from '../db/validators/validateTable.js';
+import Encrypt from '../encrypt/index.js';
+import DreamApplicationInitMissingCallToLoadModels from '../errors/dream-application/DreamApplicationInitMissingCallToLoadModels.js';
+import DreamApplicationInitMissingMissingProjectRoot from '../errors/dream-application/DreamApplicationInitMissingMissingProjectRoot.js';
+import { findCitextArrayOid, findCorrespondingArrayOid, findEnumArrayOids, parsePostgresDate, parsePostgresDatetime, parsePostgresDecimal, } from '../helpers/customPgParsers.js';
+import EnvInternal from '../helpers/EnvInternal.js';
+import { cacheDreamApplication, getCachedDreamApplicationOrFail } from './cache.js';
+import importModels, { getModelsOrFail } from './helpers/importers/importModels.js';
+import importSerializers, { getSerializersOrFail, setCachedSerializers, } from './helpers/importers/importSerializers.js';
+import importServices, { getServicesOrFail, setCachedServices } from './helpers/importers/importServices.js';
+const pgTypes = pg.types;
+// this needs to be done top-level to ensure proper configuration
+Settings.defaultZone = 'UTC';
+export default 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)
+            setCachedSerializers({});
+        if (!dreamApp.services)
+            setCachedServices({});
+        cacheDreamApplication(dreamApp);
+        if (!EnvInternal.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();
+        if (!this.loadedModels)
+            throw new DreamApplicationInitMissingCallToLoadModels();
+        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 => {
+            validateTable(modelClass.prototype.schema, modelClass.prototype.table);
+        });
+    }
+    /**
+     * @internal
+     *
+     *
+     */
+    static async setDatabaseTypeParsers() {
+        const kyselyDb = db('primary');
+        pgTypes.setTypeParser(pgTypes.builtins.DATE, parsePostgresDate);
+        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMP, parsePostgresDatetime);
+        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMPTZ, parsePostgresDatetime);
+        pgTypes.setTypeParser(pgTypes.builtins.NUMERIC, parsePostgresDecimal);
+        const textArrayOid = await 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 findEnumArrayOids(kyselyDb);
+            enumArrayOids.forEach((enumArrayOid) => pgTypes.setTypeParser(enumArrayOid, textArrayParser));
+            oid = await findCitextArrayOid(kyselyDb);
+            if (oid)
+                pgTypes.setTypeParser(oid, textArrayParser);
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.UUID);
+            if (oid)
+                pgTypes.setTypeParser(oid, textArrayParser);
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.DATE);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDate));
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIMESTAMP);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDatetime));
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIMESTAMPTZ);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDatetime));
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.NUMERIC);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDecimal));
+        }
+    }
+    static checkKey(encryptionIdentifier, key, algorithm) {
+        if (!Encrypt.validateKey(key, algorithm))
+            console.warn(`
+Your current key value for ${encryptionIdentifier} encryption is invalid.
+Try setting it to something valid, like:
+  ${Encrypt.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 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 getModelsOrFail();
+    }
+    get serializers() {
+        return getSerializersOrFail();
+    }
+    get services() {
+        return getServicesOrFail();
+    }
+    async load(resourceType, resourcePath, importCb) {
+        switch (resourceType) {
+            case 'models':
+                await importModels(resourcePath, importCb);
+                this.loadedModels = true;
+                break;
+            case 'serializers':
+                await importSerializers(resourcePath, importCb);
+                break;
+            case 'services':
+                await importServices(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;
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+import Encrypt from './index.js';
+import DreamApplication from '../dream-application/index.js';
+import MissingColumnEncryptionOpts from '../errors/encrypt/MissingColumnEncryptionOpts.js';
+export default class InternalEncrypt {
+    static encryptColumn(data) {
+        const dreamApp = DreamApplication.getOrFail();
+        const encryptOpts = dreamApp.encryption?.columns;
+        if (!encryptOpts)
+            throw new MissingColumnEncryptionOpts();
+        if (data === null || data === undefined)
+            return null;
+        return this.doEncryption(data, encryptOpts.current);
+    }
+    static decryptColumn(data) {
+        const dreamApp = DreamApplication.getOrFail();
+        const encryptOpts = dreamApp.encryption?.columns;
+        if (!encryptOpts)
+            throw new MissingColumnEncryptionOpts();
+        if (data === null || data === undefined)
+            return null;
+        return this.doDecryption(data, encryptOpts.current, encryptOpts.legacy);
+    }
+    static doEncryption(data, encryptionOpts) {
+        return Encrypt.encrypt(data, encryptionOpts);
+    }
+    static doDecryption(data, encryptionOpts, legacyEncryptionOpts) {
+        return Encrypt.decrypt(data, encryptionOpts, legacyEncryptionOpts);
+    }
+}

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

@@ -0,0 +1,23 @@
+import * as crypto from 'crypto';
+export default 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 };
+}

package/dist/esm/src/encrypt/algorithms/aes-gcm/encryptAESGCM.js

@@ -0,0 +1,9 @@
+import * as crypto from 'crypto';
+export default function encryptAESGCM(algorithm, data, key) {
+    const iv = crypto.randomBytes(12).toString('base64');
+    const cipher = crypto.createCipheriv(algorithm, Buffer.from(key, 'base64'), Buffer.from(iv, 'base64'));
+    let ciphertext = cipher.update(JSON.stringify(data), 'utf8', 'base64');
+    ciphertext += cipher.final('base64');
+    const tag = cipher.getAuthTag().toString('base64');
+    return Buffer.from(JSON.stringify({ ciphertext, iv, tag })).toString('base64');
+}

package/dist/esm/src/encrypt/algorithms/aes-gcm/generateKeyAESGCM.js

@@ -0,0 +1,4 @@
+import * as crypto from 'crypto';
+export default function generateKeyAESGCM(bitSize) {
+    return crypto.randomBytes(bitSize / 8).toString('base64');
+}

package/dist/esm/src/encrypt/algorithms/aes-gcm/validateKeyAESGCM.js

@@ -0,0 +1,8 @@
+export default function validateKeyAESGCM(base64EncodedKey, bitSize) {
+    try {
+        return Buffer.from(base64EncodedKey, 'base64')?.length === bitSize / 8;
+    }
+    catch {
+        return false;
+    }
+}