@rvoh/dream 0.29.1

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = encryptAESGCM;
+const crypto = require("crypto");
+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/cjs/src/encrypt/algorithms/aes-gcm/generateKeyAESGCM.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateKeyAESGCM;
+const crypto = require("crypto");
+function generateKeyAESGCM(bitSize) {
+    return crypto.randomBytes(bitSize / 8).toString('base64');
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = validateKeyAESGCM;
+function validateKeyAESGCM(base64EncodedKey, bitSize) {
+    try {
+        return Buffer.from(base64EncodedKey, 'base64')?.length === bitSize / 8;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("crypto");
+const MissingEncryptionKey_js_1 = require("../errors/encrypt/MissingEncryptionKey.js");
+const decryptAESGCM_js_1 = require("./algorithms/aes-gcm/decryptAESGCM.js");
+const encryptAESGCM_js_1 = require("./algorithms/aes-gcm/encryptAESGCM.js");
+const generateKeyAESGCM_js_1 = require("./algorithms/aes-gcm/generateKeyAESGCM.js");
+const validateKeyAESGCM_js_1 = require("./algorithms/aes-gcm/validateKeyAESGCM.js");
+//
+class Encrypt {
+    static encrypt(data, { algorithm, key }) {
+        if (!key)
+            throw new MissingEncryptionKey_js_1.default();
+        switch (algorithm) {
+            case 'aes-256-gcm':
+            case 'aes-192-gcm':
+            case 'aes-128-gcm':
+                return (0, encryptAESGCM_js_1.default)(algorithm, data, key);
+            default:
+                throw new Error(`unrecognized algorith provided to encrypt: ${algorithm}`);
+        }
+    }
+    static decrypt(encrypted, { algorithm, key }, legacyOpts) {
+        if (legacyOpts)
+            return this.attemptDecryptionWithLegacyKeys(encrypted, { algorithm, key }, legacyOpts);
+        if (!key)
+            throw new MissingEncryptionKey_js_1.default();
+        if ([null, undefined].includes(encrypted))
+            return null;
+        switch (algorithm) {
+            case 'aes-256-gcm':
+            case 'aes-192-gcm':
+            case 'aes-128-gcm':
+                try {
+                    return (0, decryptAESGCM_js_1.default)(algorithm, encrypted, key);
+                }
+                catch {
+                    return null;
+                }
+            default:
+                throw new Error(`unrecognized algorith provided to decrypt: ${algorithm}`);
+        }
+    }
+    static attemptDecryptionWithLegacyKeys(encrypted, { algorithm, key }, legacyOpts) {
+        const decrypted = this.decrypt(encrypted, { algorithm, key });
+        if (decrypted !== null)
+            return decrypted;
+        return this.decrypt(encrypted, legacyOpts);
+    }
+    static generateKey(algorithm) {
+        switch (algorithm) {
+            case 'aes-256-gcm':
+                return (0, generateKeyAESGCM_js_1.default)(256);
+            case 'aes-192-gcm':
+                return (0, generateKeyAESGCM_js_1.default)(192);
+            case 'aes-128-gcm':
+                return (0, generateKeyAESGCM_js_1.default)(128);
+            default:
+                throw new Error(`unrecognized algorithm provided to generateKey: ${algorithm}`);
+        }
+    }
+    static validateKey(base64EncodedKey, algorithm) {
+        switch (algorithm) {
+            case 'aes-256-gcm':
+                return (0, validateKeyAESGCM_js_1.default)(base64EncodedKey, 256);
+            case 'aes-192-gcm':
+                return (0, validateKeyAESGCM_js_1.default)(base64EncodedKey, 192);
+            case 'aes-128-gcm':
+                return (0, validateKeyAESGCM_js_1.default)(base64EncodedKey, 128);
+            default:
+                throw new Error(`unrecognized algorith provided to validateKey: ${algorithm}`);
+        }
+    }
+    static async hash(plaintext) {
+        return new Promise((resolve, reject) => {
+            const salt = crypto.randomBytes(16).toString('hex');
+            crypto.scrypt(plaintext, salt, 64, (err, derivedKey) => {
+                if (err)
+                    reject(err);
+                resolve(salt + ':' + derivedKey.toString('hex'));
+            });
+        });
+    }
+    static async verifyHash(plaintext, hash) {
+        return new Promise((resolve, reject) => {
+            const [salt, key] = hash.split(':');
+            crypto.scrypt(plaintext, salt, 64, (err, derivedKey) => {
+                if (err)
+                    reject(err);
+                resolve(crypto.timingSafeEqual(Buffer.from(key), Buffer.from(derivedKey.toString('hex'))));
+            });
+        });
+    }
+}
+exports.default = Encrypt;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AttemptingToMarshalInvalidArrayType extends Error {
+    given;
+    constructor(given) {
+        super();
+        this.given = given;
+    }
+    get message() {
+        return `
+cannot properly interpret array value. Expecting value to match either
+an array or a postgres-serialized array.
+
+received:
+  ${this.given?.constructor?.name}
+  ${JSON.stringify(this.given)}
+    `;
+    }
+}
+exports.default = AttemptingToMarshalInvalidArrayType;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotCallUndestroyOnANonSoftDeleteModel extends Error {
+    dreamClass;
+    constructor(dreamClass) {
+        super();
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        return `
+Cannot call "undestroy" on a non-SoftDelete model. Ensure that your
+model has @SoftDelete applied before calling "undestroy":
+
+@SoftDelete()
+class ${this.dreamClass.name} extends ApplicationModel {
+  ...
+}
+    `;
+    }
+}
+exports.default = CannotCallUndestroyOnANonSoftDeleteModel;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotDefineAssociationWithBothDependentAndPassthrough extends Error {
+    dreamClass;
+    associationName;
+    constructor(dreamClass, associationName) {
+        super();
+        this.dreamClass = dreamClass;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+Cannot define association with both "dependent" and "DreamConst.passthrough".
+Error found when trying to parse "${this.associationName}" on the 
+${this.dreamClass.name} dream class.
+    `;
+    }
+}
+exports.default = CannotDefineAssociationWithBothDependentAndPassthrough;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotDefineAssociationWithBothDependentAndRequiredOnClause extends Error {
+    dreamClass;
+    associationName;
+    constructor(dreamClass, associationName) {
+        super();
+        this.dreamClass = dreamClass;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+Cannot define association with both "dependent" and "DreamConst.required".
+Error found when trying to parse "${this.associationName}" on the 
+${this.dreamClass.name} dream class.
+    `;
+    }
+}
+exports.default = CannotDefineAssociationWithBothDependentAndRequiredOnClause;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotNegateSimilarityClause extends Error {
+    tableName;
+    columnName;
+    value;
+    constructor(tableName, columnName, value) {
+        super();
+        this.tableName = tableName;
+        this.columnName = columnName;
+        this.value = value;
+    }
+    get message() {
+        return `
+Negating similarity expressions is not supported.
+  table: ${this.tableName}
+  column: ${this.columnName}
+  value passed to similarity clause: ${this.value}
+    `;
+    }
+}
+exports.default = CannotNegateSimilarityClause;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotPassAdditionalFieldsToPluckEachAfterCallback extends Error {
+    methodName;
+    args;
+    constructor(methodName, providedArgs) {
+        super();
+        this.methodName = methodName;
+        this.args = providedArgs;
+    }
+    get message() {
+        return `
+Cannot pass additional fields after the callback function when calling ${this.methodName}
+args provided were:
+  ${this.args.join(',\n  ')}
+
+A callback function must be provided as either the last or the second to last argument,
+followed by options (which are not required).
+    `;
+    }
+}
+exports.default = CannotPassAdditionalFieldsToPluckEachAfterCallback;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotPassUndefinedAsAValueToAWhereClause extends Error {
+    dreamClass;
+    key;
+    constructor(dreamClass, key) {
+        super();
+        this.dreamClass = dreamClass;
+        this.key = key;
+    }
+    get message() {
+        return `
+Cannot pass undefined as a value to a where clause.
+
+dream class: ${this.dreamClass.name}
+key receiving an undefined value: ${this.key}
+`;
+    }
+}
+exports.default = CannotPassUndefinedAsAValueToAWhereClause;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotReloadUnsavedDream extends Error {
+    dream;
+    constructor(dream) {
+        super();
+        this.dream = dream;
+    }
+    get message() {
+        return `
+Cannot reload a Dream that has not yet been persisted
+  dream: ${this.dream.constructor.name}
+    `;
+    }
+}
+exports.default = CannotReloadUnsavedDream;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ConstructorOnlyForInternalUse extends Error {
+    get message() {
+        return `Do not call \`new MyDreamModel({...})\` directly. Instead,
+call \`MyDreamModel.new({...})\` or \`MyDreamModel.create({...})\``;
+    }
+}
+exports.default = ConstructorOnlyForInternalUse;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CreateOrFindByFailedToCreateAndFind extends Error {
+    dreamClass;
+    constructor(dreamClass) {
+        super();
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        return `
+Failed to create instance of ${this.dreamClass.name} and no matching model exists.
+
+The likely cause is that one of the \`createWith\` fields violates
+a uniqueness constraint.
+    `;
+    }
+}
+exports.default = CreateOrFindByFailedToCreateAndFind;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DoNotSetEncryptedFieldsDirectly extends Error {
+    dreamClass;
+    encryptedColumnName;
+    encryptedProperty;
+    constructor(dreamClass, encryptedColumnName, encryptedProperty) {
+        super();
+        this.dreamClass = dreamClass;
+        this.encryptedColumnName = encryptedColumnName;
+        this.encryptedProperty = encryptedProperty;
+    }
+    get message() {
+        return `
+Do not set @Encrypted columns directly. Instead, set their accessors, so that
+those fields can be encrypted by Dream internally.
+
+Dream class: ${this.dreamClass.name}
+Problematic setter: ${this.encryptedColumnName}
+Setter to be used instead: ${this.encryptedProperty}`;
+    }
+}
+exports.default = DoNotSetEncryptedFieldsDirectly;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InvalidColumnName extends Error {
+    tableName;
+    columnName;
+    constructor(tableName, columnName) {
+        super();
+        this.tableName = tableName;
+        this.columnName = columnName;
+    }
+    get message() {
+        return `
+Invalid column name passed to an underlying sql function.
+The invalid column name received was:
+  ${this.tableName}.${this.columnName}
+    `;
+    }
+}
+exports.default = InvalidColumnName;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InvalidDecimalFieldPassedToGenerator extends Error {
+    attribute;
+    constructor(attribute) {
+        super();
+        this.attribute = attribute;
+    }
+    get message() {
+        return `
+must pass scale and precision after decimal, like so:
+  ${this.attribute.split(':')[0]}:decimal:4,2
+
+received:
+  ${this.attribute}
+    `;
+    }
+}
+exports.default = InvalidDecimalFieldPassedToGenerator;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InvalidTableAlias extends Error {
+    tableAlias;
+    constructor(tableAlias) {
+        super();
+        this.tableAlias = tableAlias;
+    }
+    get message() {
+        return `
+Invalid table alias passed to an underlying sql function.
+table alias given:
+  "${this.tableAlias}"
+
+Table aliases must conform to a very basic shape, using only snake-cased alpha-numeric
+aliases will be permitted, and they must not be an sql keyword
+
+examples of GOOD table aliases:
+  "users"
+  "user_settings"
+
+example of BAD table aliases:
+  "users.settings"
+  "user settings"
+  "select"
+  "truncate"
+    `;
+    }
+}
+exports.default = InvalidTableAlias;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InvalidTableName extends Error {
+    schema;
+    tableName;
+    constructor(schema, tableName) {
+        super();
+        this.schema = schema;
+        this.tableName = tableName;
+    }
+    get message() {
+        const keys = Object.keys(this.schema);
+        return `
+Invalid table name passed to an underlying sql function.
+The invalid table name received was:
+  ${this.tableName}
+
+Please make sure to only pass a valid table name. Valid table names are:
+  ${keys.join(',\n        ')}
+    `;
+    }
+}
+exports.default = InvalidTableName;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LeftJoinPreloadIncompatibleWithFindEach extends Error {
+    get message() {
+        // An unknown and irregular number of records will be returned for each base
+        // model, so we cannot establish the correct pagination points to flesh out
+        // all the associations (if we broke at a certain number of records, there
+        // could be other records for that association in the next pagination of results)
+        return `LeftJoinPreload is incompabile with findEach`;
+    }
+}
+exports.default = LeftJoinPreloadIncompatibleWithFindEach;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingDB extends Error {
+    get message() {
+        return `
+Missing DB definition on the ApplicationModel of your app
+    `;
+    }
+}
+exports.default = MissingDB;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingDeletedAtFieldForSoftDelete extends Error {
+    dreamClass;
+    constructor(dreamClass) {
+        super();
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        const deletedAtField = this.dreamClass.prototype.deletedAtField;
+        return `
+Expected "${deletedAtField}" to be a valid column for the ${this.dreamClass.name} model.
+Whenever the using SoftDelete decorator, you must have either a deletedAt column,
+or else another column defined, along with an ovrriding getter on your model, like so:
+
+  @SoftDelete()
+  class ${this.dreamClass.name} extends ApplicationModel {
+    public get deletedAtField() {
+      return 'customDeletedAtField' as const
+    }
+  }`;
+    }
+}
+exports.default = MissingDeletedAtFieldForSoftDelete;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingRequiredCallbackFunctionToPluckEach extends Error {
+    methodName;
+    args;
+    constructor(methodName, providedArgs) {
+        super();
+        this.methodName = methodName;
+        this.args = providedArgs;
+    }
+    get message() {
+        return `
+Missing required callback function when calling ${this.methodName}
+args provided were:
+  ${this.args.join(',\n  ')}
+
+A callback function must be provided as either the last or the second to last argument,
+followed by options (which are not required).
+    `;
+    }
+}
+exports.default = MissingRequiredCallbackFunctionToPluckEach;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingSerializersDefinition extends Error {
+    dreamClass;
+    constructor(dreamClass) {
+        super();
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        return `
+Missing serializers definition on the following class
+Dream class: ${this.dreamClass.name}
+
+Try something like this in your ${this.dreamClass.name}'s serializer getter:
+
+class ${this.dreamClass.name} {
+  public get serializers(): DreamSerializers<${this.dreamClass.name}> {
+    return {
+      default: '${this.dreamClass.name}Serializer'
+    }
+  }
+  ...
+}`;
+    }
+}
+exports.default = MissingSerializersDefinition;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluralize_esm_1 = require("pluralize-esm");
+const snakeify_js_1 = require("../helpers/snakeify.js");
+class MissingTable extends Error {
+    dreamClass;
+    constructor(dreamClass) {
+        super();
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        return `
+Missing table definition on the following dream class:
+Dream class: ${this.dreamClass.name}
+
+Try something like this in your ${this.dreamClass.name}'s table getter:
+
+class ${this.dreamClass.name} {
+  ...
+  public get table() {
+    return '${(0, pluralize_esm_1.default)((0, snakeify_js_1.default)(this.dreamClass.name))}'
+  }
+}
+    `;
+    }
+}
+exports.default = MissingTable;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NoUpdateAllOnJoins extends Error {
+    get message() {
+        return `
+udpateAll may not yet be called on joins. As a workaround,
+use where + nestedSelect instead, e.g.:
+
+  ModelA.where({ id: ModelB.nestedSelect('modelAId') })
+`;
+    }
+}
+exports.default = NoUpdateAllOnJoins;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NoUpdateOnAssociationQuery extends Error {
+    get message() {
+        return `
+udpate may not be called on an associationQuery. Use updateAssociation instead.
+    `;
+    }
+}
+exports.default = NoUpdateOnAssociationQuery;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NonBelongsToAssociationProvidedAsSortableDecoratorScope extends Error {
+    scope;
+    dreamClass;
+    constructor(scope, dreamClass) {
+        super();
+        this.scope = scope;
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        return `
+Only BelongsTo associations are supported as scopes for the @Sortable decorator.
+received:
+  dream model class: ${this.dreamClass.name}
+  scope: ${this.scope}
+
+BelongsTo scopes on ${this.dreamClass.name} are:
+  ${this.dreamClass['associationMetadataByType'].belongsTo.map(assoc => assoc.as).join('\n        ')}
+    `;
+    }
+}
+exports.default = NonBelongsToAssociationProvidedAsSortableDecoratorScope;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NonExistentScopeProvidedToResort extends Error {
+    scopes;
+    dreamClass;
+    constructor(scopes, dreamClass) {
+        super();
+        this.scopes = scopes;
+        this.dreamClass = dreamClass;
+    }
+    get message() {
+        return `
+Only BelongsTo scopes are supported by the #resort method
+received:
+  dream model class: ${this.dreamClass.name}
+  scope: ${this.scopes.join(', ')}
+
+BelongsTo scopes on ${this.dreamClass.name} are:
+  ${this.dreamClass['sortableFields'].map(conf => conf.positionField).join('\n        ')}
+    `;
+    }
+}
+exports.default = NonExistentScopeProvidedToResort;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PrototypePollutingAssignment extends Error {
+    key;
+    constructor(key) {
+        super();
+        this.key = key;
+    }
+    get message() {
+        return `Passed "${this.key}" as the key to modify an object`;
+    }
+}
+exports.default = PrototypePollutingAssignment;