@rvoh/dream 0.29.1

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RecordNotFound extends Error {
+    dreamClassName;
+    constructor(dreamClassName) {
+        super();
+        this.dreamClassName = dreamClassName;
+    }
+    get message() {
+        return `\
+Failed to find a record for the following dream class: ${this.dreamClassName}
+`;
+    }
+}
+exports.default = RecordNotFound;

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ValidationError extends Error {
+    dreamClassName;
+    errors;
+    constructor(dreamClassName, errors) {
+        super();
+        this.dreamClassName = dreamClassName;
+        this.errors = errors;
+    }
+    get message() {
+        return `\
+Failed to save ${this.dreamClassName}. The following validation errors occurred while trying to save:
+
+${JSON.stringify(this.errors, null, 2)}
+`;
+    }
+}
+exports.default = ValidationError;

package/dist/cjs/src/errors/associations/CanOnlyPassBelongsToModelParam.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CanOnlyPassBelongsToModelParam extends Error {
+    dreamClass;
+    association;
+    constructor(dreamClass, association) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+Can only pass BelongsTo associated models as params
+Dream class: ${this.dreamClass.name}
+Association: ${this.association.as}
+Association type: ${this.association.type}
+    `;
+    }
+}
+exports.default = CanOnlyPassBelongsToModelParam;

package/dist/cjs/src/errors/associations/CannotAssociateThroughPolymorphic.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotAssociateThroughPolymorphic extends Error {
+    dreamClass;
+    association;
+    constructor({ dreamClass, association, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+Cannot join through a polymorphic association
+Dream class: ${this.dreamClass.name}
+Association: ${this.association.as}
+    `;
+    }
+}
+exports.default = CannotAssociateThroughPolymorphic;

package/dist/cjs/src/errors/associations/CannotCreateAssociationWithThroughContext.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotCreateAssociationWithThroughContext extends Error {
+    dreamClass;
+    association;
+    constructor({ dreamClass, association, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+'createAssociation' is not supported for through associations.
+Dream class: ${this.dreamClass.name}
+Association: ${this.association.as}
+    `;
+    }
+}
+exports.default = CannotCreateAssociationWithThroughContext;

package/dist/cjs/src/errors/associations/CannotJoinPolymorphicBelongsToError.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotJoinPolymorphicBelongsToError extends Error {
+    dreamClass;
+    association;
+    innerJoinStatements;
+    leftJoinStatements;
+    constructor({ dreamClass, association, innerJoinStatements, leftJoinStatements, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+        this.innerJoinStatements = innerJoinStatements;
+        this.leftJoinStatements = leftJoinStatements;
+    }
+    get message() {
+        return `
+Cannot join on a polymorphic BelongsTo
+Dream class: ${this.dreamClass.name}
+Association: ${this.association.as}
+Inner Join statements:
+${JSON.stringify(this.innerJoinStatements, null, 2)}
+Left Join statements:
+${JSON.stringify(this.leftJoinStatements, null, 2)}
+    `;
+    }
+}
+exports.default = CannotJoinPolymorphicBelongsToError;

package/dist/cjs/src/errors/associations/CannotPassNullOrUndefinedToRequiredBelongsTo.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotPassNullOrUndefinedToRequiredBelongsTo extends Error {
+    dreamClass;
+    association;
+    constructor(dreamClass, association) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+Cannot pass null or undefined as a value to a required association.
+Dream class: ${this.dreamClass.name}
+Association: ${this.association.as}
+    `;
+    }
+}
+exports.default = CannotPassNullOrUndefinedToRequiredBelongsTo;

package/dist/cjs/src/errors/associations/InvalidComputedForeignKey.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplicitForeignKeyRequired = exports.InvalidComputedForeignKey = void 0;
+exports.checkForeignKey = checkForeignKey;
+const shared_js_1 = require("../../decorators/associations/shared.js");
+class InvalidComputedForeignKey extends Error {
+    dreamClass;
+    partialAssociation;
+    computedForeignKey;
+    table;
+    constructor(dreamClass, partialAssociation, computedForeignKey, table) {
+        super();
+        this.dreamClass = dreamClass;
+        this.partialAssociation = partialAssociation;
+        this.computedForeignKey = computedForeignKey;
+        this.table = table;
+    }
+    get message() {
+        return `
+Add an explicit foreignKey declaration to this association declaration:
+  Dream class: ${this.dreamClass.name}
+  Association: ${this.partialAssociation.as}
+Dream tried ${this.computedForeignKey} automatically, but it isn't a column in table ${this.table}.
+    `;
+    }
+}
+exports.InvalidComputedForeignKey = InvalidComputedForeignKey;
+class ExplicitForeignKeyRequired extends Error {
+    dreamClass;
+    partialAssociation;
+    explicitForeignKey;
+    table;
+    constructor(dreamClass, partialAssociation, explicitForeignKey, table) {
+        super();
+        this.dreamClass = dreamClass;
+        this.partialAssociation = partialAssociation;
+        this.explicitForeignKey = explicitForeignKey;
+        this.table = table;
+    }
+    get message() {
+        return `
+${this.explicitForeignKey} is not a valid column on table ${this.table}.
+Fix the foreignKey declaration on:
+  Dream class: ${this.dreamClass.name}
+  Association: ${this.partialAssociation.as}
+    `;
+    }
+}
+exports.ExplicitForeignKeyRequired = ExplicitForeignKeyRequired;
+function checkForeignKey(explicitForeignKey, computedForeignKey, dreamClass, partialAssociation) {
+    let table;
+    if (partialAssociation.type === 'BelongsTo')
+        table = dreamClass.table;
+    else
+        table = (0, shared_js_1.modelCBtoSingleDreamClass)(dreamClass, partialAssociation).table;
+    const tableColumns = Object.keys(dreamClass.prototype.schema[table]?.columns);
+    const validForeignKey = tableColumns.includes(computedForeignKey);
+    if (validForeignKey)
+        return;
+    if (explicitForeignKey)
+        throw new ExplicitForeignKeyRequired(dreamClass, partialAssociation, explicitForeignKey, table);
+    else
+        throw new InvalidComputedForeignKey(dreamClass, partialAssociation, computedForeignKey, table);
+}

package/dist/cjs/src/errors/associations/JoinAttemptedOnMissingAssociation.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class JoinAttemptedOnMissingAssociation extends Error {
+    dreamClass;
+    associationName;
+    constructor({ dreamClass, associationName }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+A joins call has been attempted on \`${this.dreamClass.name}\` association \`${this.associationName}\`,
+but \`${this.dreamClass.name}\` does not define association \`${this.associationName}\`.
+
+
+Either \`${this.associationName}\` is a typo in the joins statement, or association \`${this.associationName}\` needs to be defined on \`${this.dreamClass.name}\`, for example:
+
+class ${this.dreamClass.name} {
+  ...
+  @${this.dreamClass.name}.HasMany('SomeModelClass')
+  public ${this.associationName}: SomeModelClass[]
+}
+    `;
+    }
+}
+exports.default = JoinAttemptedOnMissingAssociation;

package/dist/cjs/src/errors/associations/MissingRequiredAssociationOnClause.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingRequiredAssociationOnClause extends Error {
+    association;
+    column;
+    constructor(association, column) {
+        super();
+        this.association = association;
+        this.column = column;
+    }
+    get message() {
+        return `
+Missing required association on clause:
+Association: ${this.association.as}
+Missing on clause for column: ${this.column}
+`;
+    }
+}
+exports.default = MissingRequiredAssociationOnClause;

package/dist/cjs/src/errors/associations/MissingRequiredPassthroughForAssociationOnClause.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingRequiredPassthroughForAssociationOnClause extends Error {
+    column;
+    constructor(column) {
+        super();
+        this.column = column;
+    }
+    get message() {
+        return `
+Missing passthrough for association on clause:
+Missing passthrough on clause for column: ${this.column}
+`;
+    }
+}
+exports.default = MissingRequiredPassthroughForAssociationOnClause;

package/dist/cjs/src/errors/associations/MissingThroughAssociation.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingThroughAssociation extends Error {
+    dreamClass;
+    association;
+    constructor({ dreamClass, association, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+\`${this.dreamClass.name}\` defines through association \`${this.association.through}\`, but \`${this.dreamClass.name}\` does not define association \`${this.association.through}\`.
+
+
+To fix, define association \`${this.association.through}\` on \`${this.dreamClass.name}\`.
+For example:
+
+class ${this.dreamClass.name} {
+  ...
+  @${this.dreamClass.name}.HasMany('TheJoinModelClass')
+  public ${this.association.through}: TheJoinModelClass[]
+}
+    `;
+    }
+}
+exports.default = MissingThroughAssociation;

package/dist/cjs/src/errors/associations/MissingThroughAssociationSource.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingThroughAssociationSource extends Error {
+    dreamClass;
+    throughClass;
+    association;
+    constructor({ dreamClass, throughClass, association, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.throughClass = throughClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+\`${this.dreamClass.name}\` defines association \`${this.association.as}\` through \`${this.dreamClass.name}\` association \`${this.association.through}\`.
+
+\`${this.dreamClass.name}\` association \`${this.association.through}\` points to \`${this.throughClass.name}\`.
+
+Dream expects association \`${this.association.source}\` to be defiend on \`${this.throughClass.name}\`, but \`${this.throughClass.name}\` does not define association \`${this.association.source}\`.
+
+There are two possible fixes:
+
+1. Provide an explicit \`source\` in addition to \`through\`.
+
+class ${this.dreamClass.name} {
+  ...
+  @${this.dreamClass.name}.HasMany(() => ${this.throughClass.name}, { through: '${this.association.through}', source: '<a valid association on ${this.throughClass.name}>'})
+  public ${this.association.as}: ${this.throughClass.name}[]
+}
+
+2. Define association \`${this.association.source}\` on \`${this.throughClass.name}\`.
+For example:
+
+class ${this.throughClass.name} {
+  ...
+  @${this.throughClass.name}.HasMany(() => ${this.association.modelCB().name})
+  public ${this.association.source}: ${this.association.modelCB().name}[]
+}
+    `;
+    }
+}
+exports.default = MissingThroughAssociationSource;

package/dist/cjs/src/errors/associations/NonLoadedAssociation.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NonLoadedAssociation extends Error {
+    dreamClass;
+    associationName;
+    constructor({ dreamClass, associationName }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+Attempting to access \`${this.associationName}\` on an instance of \`${this.dreamClass.name}\`,
+but \`${this.associationName}\` has not been preloaded or loaded.
+`;
+    }
+}
+exports.default = NonLoadedAssociation;

package/dist/cjs/src/errors/dream-application/DreamApplicationInitMissingCallToLoadModels.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DreamApplicationInitMissingCallToLoadModels extends Error {
+    get message() {
+        return `
+must load models when initializing a new DreamApplication.
+
+within conf/dream.ts, you must have a call to "#load('models', pathToModels)", i.e.
+
+
+  // conf/dream.ts
+  export default async (app: DreamApplication) => {
+    await app.load('models', path.join(__dirname, '..', 'app', 'models')
+  }
+    `;
+    }
+}
+exports.default = DreamApplicationInitMissingCallToLoadModels;

package/dist/cjs/src/errors/dream-application/DreamApplicationInitMissingMissingProjectRoot.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DreamApplicationInitMissingMissingProjectRoot extends Error {
+    get message() {
+        return `
+must set app root when initializing a new DreamApplication.
+
+within conf/dream.ts, you must have a call to "#set('projectRoot', pathToAppRoot), i.e.
+
+
+  // conf/dream.ts
+  export default async (app: DreamApplication) => {
+    // this should be the absolute path to the "src" folder.
+    app.set('projectRoot', path.join(__dirname, '..')
+  }
+    `;
+    }
+}
+exports.default = DreamApplicationInitMissingMissingProjectRoot;

package/dist/cjs/src/errors/dream-application/GlobalNameNotSet.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class GlobalNameNotSet extends Error {
+    klass;
+    constructor(klass) {
+        super();
+        this.klass = klass;
+    }
+    get message() {
+        return `
+Attempted to reference global name for ${this.klass.name}, but the global name has not been set.`;
+    }
+}
+exports.default = GlobalNameNotSet;

package/dist/cjs/src/errors/dream-application/SerializerNameConflict.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SerializerNameConflict extends Error {
+    serializerGlobalName;
+    constructor(serializerGlobalName) {
+        super();
+        this.serializerGlobalName = serializerGlobalName;
+    }
+    get message() {
+        return `
+Attempted to register ${this.serializerGlobalName}, but another serializer
+has the sane name.`;
+    }
+}
+exports.default = SerializerNameConflict;

package/dist/cjs/src/errors/encrypt/MissingColumnEncryptionOpts.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingColumnEncryptionOpts extends Error {
+    get message() {
+        return `
+      In order to use the Encrypt library to encrypt columns,
+      encryption keys must be provided to dream:
+
+        // conf/dream.ts
+        export default (dream: DreamApplication) => {
+          dream.set('encryption', {
+            column: {
+              current: {
+                algorithm: 'aes-256-gcm',
+                key: Env.string('COLUMN_ENCRYPTION_KEY') 
+              },
+            }
+          })
+        }
+
+      A valid encryption key can be generated using:
+
+        Encrypt.generateKey()
+    `;
+    }
+}
+exports.default = MissingColumnEncryptionOpts;

package/dist/cjs/src/errors/encrypt/MissingEncryptionKey.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingEncryptionKey extends Error {
+    get message() {
+        return `
+      In order to use the Encrypt library, encryption key and algorithm must be provided:
+
+        Encrypt.encrypt(data, { algorithm: '<YOUR_ALGORITHM>', key: '<YOUR_ENCRYPTION_KEY>' })
+    `;
+    }
+}
+exports.default = MissingEncryptionKey;

package/dist/cjs/src/errors/environment/MissingRequiredEnvironmentVariable.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MissingRequiredEnvironmentVariable extends Error {
+    environmentVariableName;
+    constructor(environmentVariableName) {
+        super();
+        this.environmentVariableName = environmentVariableName;
+    }
+    get message() {
+        return `Missing required environment variable ${this.environmentVariableName}`;
+    }
+}
+exports.default = MissingRequiredEnvironmentVariable;

package/dist/cjs/src/errors/ops/AnyRequiresArrayColumn.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AnyRequiresArrayColumn extends Error {
+    dreamClass;
+    column;
+    constructor(dreamClass, column) {
+        super();
+        this.dreamClass = dreamClass;
+        this.column = column;
+    }
+    get message() {
+        return `
+Attempting to call where({ ${this.column}: ops.any(<some value>)} ),
+but ${this.dreamClass.name}#${this.column} is not an array in the database.
+`;
+    }
+}
+exports.default = AnyRequiresArrayColumn;

package/dist/cjs/src/errors/ops/ScoreMustBeANormalNumber.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ScoreMustBeANormalNumber extends Error {
+    score;
+    constructor(score) {
+        super();
+        this.score = score;
+    }
+    get message() {
+        return `
+Attempting to pass a non-normal number to a similarity score in your query.
+When passing a score, make sure it is a number between 0 and 1, i.e. 0.5
+    provided score: ${this.score}
+`;
+    }
+}
+exports.default = ScoreMustBeANormalNumber;

package/dist/cjs/src/errors/schema-builder/FailedToIdentifyAssociation.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../dream-application/index.js");
+class FailedToIdentifyAssociation extends Error {
+    modelClass;
+    associationType;
+    associationName;
+    globalAssociationNameOrNames;
+    constructor(modelClass, associationType, associationName, globalAssociationNameOrNames) {
+        super();
+        this.modelClass = modelClass;
+        this.associationType = associationType;
+        this.associationName = associationName;
+        this.globalAssociationNameOrNames = globalAssociationNameOrNames;
+    }
+    get message() {
+        const dreamApp = index_js_1.default.getOrFail();
+        const attemptedName = Array.isArray(this.globalAssociationNameOrNames)
+            ? this.globalAssociationNameOrNames[0]
+            : this.globalAssociationNameOrNames;
+        if (typeof attemptedName !== 'string') {
+            return `
+An unexpected error occurred while looking up an association that you have defined.
+
+While building the schema for your app, we failed to find a match for
+the ${this.associationType} association "${this.associationName}" on the
+${this.modelClass.name} model.
+
+This method requires either a string or string array as the first argument,
+to the ${this.associationType} decorator. However, we received the following:
+
+  expected:
+    "string"
+
+  received:
+    "${typeof attemptedName}"
+
+Details:
+    dream: ${this.modelClass.name} (${this.modelClass.globalName})
+    association type: ${this.associationType}
+    association name: ${this.associationName}
+".
+`;
+        }
+        const possibleMatches = Object.keys(dreamApp.models).filter(globalName => new RegExp(attemptedName.slice(0, Math.min(attemptedName.length, 8)), 'i').test(globalName.replace(/\//g, '')));
+        const possibleMatchesMessage = possibleMatches.length
+            ? `\
+Did you by chance mean one of these associations?:
+    ${possibleMatches.join('\n    ')}`
+            : '';
+        return `
+An unexpected error occurred while looking up an association that you have defined.
+
+While building the schema for your app, we failed to find a match for
+the ${this.associationType} association "${this.associationName}"
+on ${this.modelClass.name}, using the global model name "${attemptedName}".
+
+Usually, this is because the global name for
+the model is not what you anticipated, which often happens when you are
+using models that are in nested directories, since their names can be
+counter-intuitive.
+
+We recommend that you lean into the autocomplete when providing the
+first argument to an association, since it can help to catch these
+familiar gotchas.
+
+Details:
+    dream: ${this.modelClass.name} (${this.modelClass.globalName})
+    association type: ${this.associationType}
+    association name: ${this.associationName}
+    attempted model name: ${attemptedName}
+
+${possibleMatchesMessage}
+
+Here is a complete list of possible associations:
+    ${Object.keys(dreamApp.models).join(',\n    ')}
+`;
+    }
+}
+exports.default = FailedToIdentifyAssociation;

package/dist/cjs/src/errors/serializers/FailedToRenderThroughAssociationForSerializer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FailedToRenderThroughAssociationForSerializer extends Error {
+    className;
+    missingThroughField;
+    constructor(className, missingThroughField) {
+        super();
+        this.className = className;
+        this.missingThroughField = missingThroughField;
+    }
+    get message() {
+        return `
+Failed to render association data for ${this.className}
+missing through field: "${this.missingThroughField}"`;
+    }
+}
+exports.default = FailedToRenderThroughAssociationForSerializer;