@rvoh/dream 1.1.2 → 1.2.1

package/dist/cjs/src/Dream.js

@@ -7,6 +7,7 @@ const associationToGetterSetterProp_js_1 = require("./decorators/field/associati
 const shared_js_1 = require("./decorators/field/association/shared.js");
 const shared_js_2 = require("./decorators/field/lifecycle/shared.js");
 const resortAllRecords_js_1 = require("./decorators/field/sortable/helpers/resortAllRecords.js");
+const index_js_2 = require("./dream-app/index.js");
 const DreamClassTransactionBuilder_js_1 = require("./dream/DreamClassTransactionBuilder.js");
 const DreamInstanceTransactionBuilder_js_1 = require("./dream/DreamInstanceTransactionBuilder.js");
 const DreamTransaction_js_1 = require("./dream/DreamTransaction.js");
@@ -682,6 +683,19 @@ class Dream {
     static removeAllDefaultScopes() {
         return this.query().removeAllDefaultScopes();
     }
+    /**
+     * imports an object from the IOC. This is usually done in rare cases,
+     * in order to avoid circular dependencies, since you can always
+     * use regular imports to import models or serializers otherwise.
+     *
+     * @returns the found model or serializer, depending on what you are looking for
+     */
+    static lookup(lookupName) {
+        const dreamApp = index_js_2.default.getOrFail();
+        const models = dreamApp.models;
+        const serializers = dreamApp.serializers;
+        return models[lookupName] || serializers[lookupName];
+    }
     /**
      * Prevents a specific default scope from applying when
      * the Query is executed

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

@@ -11,8 +11,12 @@ exports.pgErrorType = pgErrorType;
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 const pg_1 = require("pg");
+const UNIQUE_CONSTRAINT_VIOLATION = 'UNIQUE_CONSTRAINT_VIOLATION';
+const INVALID_INPUT_SYNTAX = 'INVALID_INPUT_SYNTAX';
 exports.PG_ERRORS = {
-    23505: 'UNIQUE_CONSTRAINT_VIOLATION',
+    '23505': UNIQUE_CONSTRAINT_VIOLATION,
+    '22P02': INVALID_INPUT_SYNTAX,
+    '22007': INVALID_INPUT_SYNTAX,
 };
 function pgErrorFromCode(code) {
     return exports.PG_ERRORS[code] || null;

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -5,6 +5,7 @@ const pluralize_esm_1 = require("pluralize-esm");
 const sync_js_1 = require("../../bin/helpers/sync.js");
 const CliFileWriter_js_1 = require("../../cli/CliFileWriter.js");
 const index_js_1 = require("../../cli/index.js");
+const errors_js_1 = require("../../db/errors.js");
 const index_js_2 = require("../../db/index.js");
 const associationToGetterSetterProp_js_1 = require("../../decorators/field/association/associationToGetterSetterProp.js");
 const PackageManager_js_1 = require("../../dream-app/helpers/PackageManager.js");
@@ -19,6 +20,7 @@ const MissingThroughAssociationSource_js_1 = require("../../errors/associations/
 const ThroughAssociationConditionsIncompatibleWithThroughAssociationSource_js_1 = require("../../errors/associations/ThroughAssociationConditionsIncompatibleWithThroughAssociationSource.js");
 const CannotNegateSimilarityClause_js_1 = require("../../errors/CannotNegateSimilarityClause.js");
 const CannotPassUndefinedAsAValueToAWhereClause_js_1 = require("../../errors/CannotPassUndefinedAsAValueToAWhereClause.js");
+const DataTypeColumnTypeMismatch_js_1 = require("../../errors/db/DataTypeColumnTypeMismatch.js");
 const UnexpectedUndefined_js_1 = require("../../errors/UnexpectedUndefined.js");
 const CalendarDate_js_1 = require("../../helpers/CalendarDate.js");
 const camelize_js_1 = require("../../helpers/camelize.js");
@@ -415,19 +417,31 @@ class KyselyQueryDriver extends Base_js_1.default {
     static async saveDream(dream, txn = null) {
         const db = txn?.kyselyTransaction ?? (0, index_js_2.default)('primary');
         const sqlifiedAttributes = (0, sqlAttributes_js_1.default)(dream);
-        if (dream.isPersisted) {
-            const query = db
-                .updateTable(dream.table)
-                .set(sqlifiedAttributes)
-                .where((0, namespaceColumn_js_1.default)(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
-            return await (0, executeDatabaseQuery_js_1.default)(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+        try {
+            if (dream.isPersisted) {
+                const query = db
+                    .updateTable(dream.table)
+                    .set(sqlifiedAttributes)
+                    .where((0, namespaceColumn_js_1.default)(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
+                return await (0, executeDatabaseQuery_js_1.default)(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+            }
+            else {
+                const query = db
+                    .insertInto(dream.table)
+                    .values(sqlifiedAttributes)
+                    .returning([...dream.columns()]);
+                return await (0, executeDatabaseQuery_js_1.default)(query, 'executeTakeFirstOrThrow');
+            }
         }
-        else {
-            const query = db
-                .insertInto(dream.table)
-                .values(sqlifiedAttributes)
-                .returning([...dream.columns()]);
-            return await (0, executeDatabaseQuery_js_1.default)(query, 'executeTakeFirstOrThrow');
+        catch (error) {
+            switch ((0, errors_js_1.pgErrorType)(error)) {
+                case 'INVALID_INPUT_SYNTAX':
+                    throw new DataTypeColumnTypeMismatch_js_1.default({
+                        dream,
+                        error: error instanceof Error ? error : new Error('database column type error'),
+                    });
+            }
+            throw error;
         }
     }
     dbConnectionType(sqlCommandType) {

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DataTypeColumnTypeMismatch extends Error {
+    dream;
+    error;
+    constructor({ dream, error }) {
+        super();
+        this.dream = dream;
+        this.error = error;
+    }
+    get message() {
+        return `\
+Failed to save ${this.dream.sanitizedConstructorName}:
+
+${this.error.message}
+`;
+    }
+}
+exports.default = DataTypeColumnTypeMismatch;

package/dist/cjs/src/helpers/sqlAttributes.js

@@ -40,6 +40,12 @@ function sqlAttributes(dream) {
         return result;
     }, {});
 }
+/**
+ * Convert datetimes to UTC
+ */
 function valueToDatetime(val) {
-    return typeof val === 'string' ? DateTime_js_1.DateTime.fromISO(val, { zone: 'UTC' }) : val;
+    if (typeof val !== 'string')
+        return val;
+    const datetime = DateTime_js_1.DateTime.fromISO(val, { zone: 'UTC' });
+    return datetime.isValid ? datetime : val;
 }

package/dist/cjs/src/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.relativeDreamPath = exports.dreamPath = exports.pascalize = exports.normalizeUnicode = exports.loadRepl = exports.isEmpty = exports.intersection = exports.hyphenize = exports.groupBy = exports.globalClassNameFromFullyQualifiedModelName = exports.Env = exports.DreamLogos = exports.DateTime = exports.compact = exports.cloneDeepSafe = exports.generateDream = exports.capitalize = exports.camelize = exports.CalendarDate = exports.Benchmark = exports.ValidationError = exports.RecordNotFound = exports.GlobalNameNotSet = exports.CreateOrFindByFailedToCreateAndFind = exports.NonLoadedAssociation = exports.Encrypt = exports.Query = exports.DreamTransaction = exports.openapiShorthandPrimitiveTypes = exports.openapiPrimitiveTypes = exports.DreamConst = exports.Dream = exports.DreamAppAllowedPackageManagersEnumValues = exports.DreamApp = exports.lookupClassByGlobalName = exports.DreamImporter = exports.Decorators = exports.STI = exports.SoftDelete = exports.ReplicaSafe = exports.validateTable = exports.validateColumn = exports.DreamMigrationHelpers = exports.untypedDb = exports.pgErrorType = exports.dreamDbConnections = exports.closeAllDbConnections = exports.DreamCLI = exports.CliFileWriter = exports.DreamBin = void 0;
-exports.ObjectSerializerBuilder = exports.DreamSerializerBuilder = exports.ObjectSerializer = exports.DreamSerializer = exports.serializerNameFromFullyQualifiedModelName = exports.isDreamSerializer = exports.inferSerializersFromDreamClassOrViewModelClass = exports.inferSerializerFromDreamOrViewModel = exports.ops = exports.uniq = exports.uncapitalize = exports.expandStiClasses = exports.standardizeFullyQualifiedModelName = exports.sortObjectByValue = exports.sortObjectByKey = exports.sortBy = exports.sort = exports.snakeify = exports.round = exports.range = exports.Range = exports.sharedPathPrefix = void 0;
+exports.dreamPath = exports.pascalize = exports.normalizeUnicode = exports.loadRepl = exports.isEmpty = exports.intersection = exports.hyphenize = exports.groupBy = exports.globalClassNameFromFullyQualifiedModelName = exports.Env = exports.DreamLogos = exports.DateTime = exports.compact = exports.cloneDeepSafe = exports.generateDream = exports.capitalize = exports.camelize = exports.CalendarDate = exports.Benchmark = exports.ValidationError = exports.RecordNotFound = exports.GlobalNameNotSet = exports.DataTypeColumnTypeMismatch = exports.CreateOrFindByFailedToCreateAndFind = exports.NonLoadedAssociation = exports.Encrypt = exports.Query = exports.DreamTransaction = exports.openapiShorthandPrimitiveTypes = exports.openapiPrimitiveTypes = exports.DreamConst = exports.Dream = exports.DreamAppAllowedPackageManagersEnumValues = exports.DreamApp = exports.lookupClassByGlobalName = exports.DreamImporter = exports.Decorators = exports.STI = exports.SoftDelete = exports.ReplicaSafe = exports.validateTable = exports.validateColumn = exports.DreamMigrationHelpers = exports.untypedDb = exports.pgErrorType = exports.dreamDbConnections = exports.closeAllDbConnections = exports.DreamCLI = exports.CliFileWriter = exports.DreamBin = void 0;
+exports.ObjectSerializerBuilder = exports.DreamSerializerBuilder = exports.ObjectSerializer = exports.DreamSerializer = exports.serializerNameFromFullyQualifiedModelName = exports.isDreamSerializer = exports.inferSerializersFromDreamClassOrViewModelClass = exports.inferSerializerFromDreamOrViewModel = exports.ops = exports.uniq = exports.uncapitalize = exports.expandStiClasses = exports.standardizeFullyQualifiedModelName = exports.sortObjectByValue = exports.sortObjectByKey = exports.sortBy = exports.sort = exports.snakeify = exports.round = exports.range = exports.Range = exports.sharedPathPrefix = exports.relativeDreamPath = void 0;
 var index_js_1 = require("./bin/index.js");
 Object.defineProperty(exports, "DreamBin", { enumerable: true, get: function () { return index_js_1.default; } });
 var CliFileWriter_js_1 = require("./cli/CliFileWriter.js");
@@ -52,6 +52,8 @@ var NonLoadedAssociation_js_1 = require("./errors/associations/NonLoadedAssociat
 Object.defineProperty(exports, "NonLoadedAssociation", { enumerable: true, get: function () { return NonLoadedAssociation_js_1.default; } });
 var CreateOrFindByFailedToCreateAndFind_js_1 = require("./errors/CreateOrFindByFailedToCreateAndFind.js");
 Object.defineProperty(exports, "CreateOrFindByFailedToCreateAndFind", { enumerable: true, get: function () { return CreateOrFindByFailedToCreateAndFind_js_1.default; } });
+var DataTypeColumnTypeMismatch_js_1 = require("./errors/db/DataTypeColumnTypeMismatch.js");
+Object.defineProperty(exports, "DataTypeColumnTypeMismatch", { enumerable: true, get: function () { return DataTypeColumnTypeMismatch_js_1.default; } });
 var GlobalNameNotSet_js_1 = require("./errors/dream-app/GlobalNameNotSet.js");
 Object.defineProperty(exports, "GlobalNameNotSet", { enumerable: true, get: function () { return GlobalNameNotSet_js_1.default; } });
 var RecordNotFound_js_1 = require("./errors/RecordNotFound.js");

package/dist/esm/src/Dream.js

@@ -5,6 +5,7 @@ import associationToGetterSetterProp from './decorators/field/association/associ
 import { blankAssociationsFactory } from './decorators/field/association/shared.js';
 import { blankHooksFactory } from './decorators/field/lifecycle/shared.js';
 import resortAllRecords from './decorators/field/sortable/helpers/resortAllRecords.js';
+import DreamApp from './dream-app/index.js';
 import DreamClassTransactionBuilder from './dream/DreamClassTransactionBuilder.js';
 import DreamInstanceTransactionBuilder from './dream/DreamInstanceTransactionBuilder.js';
 import DreamTransaction from './dream/DreamTransaction.js';
@@ -680,6 +681,19 @@ export default class Dream {
     static removeAllDefaultScopes() {
         return this.query().removeAllDefaultScopes();
     }
+    /**
+     * imports an object from the IOC. This is usually done in rare cases,
+     * in order to avoid circular dependencies, since you can always
+     * use regular imports to import models or serializers otherwise.
+     *
+     * @returns the found model or serializer, depending on what you are looking for
+     */
+    static lookup(lookupName) {
+        const dreamApp = DreamApp.getOrFail();
+        const models = dreamApp.models;
+        const serializers = dreamApp.serializers;
+        return models[lookupName] || serializers[lookupName];
+    }
     /**
      * Prevents a specific default scope from applying when
      * the Query is executed

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

@@ -7,8 +7,12 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';
+const UNIQUE_CONSTRAINT_VIOLATION = 'UNIQUE_CONSTRAINT_VIOLATION';
+const INVALID_INPUT_SYNTAX = 'INVALID_INPUT_SYNTAX';
 export const PG_ERRORS = {
-    23505: 'UNIQUE_CONSTRAINT_VIOLATION',
+    '23505': UNIQUE_CONSTRAINT_VIOLATION,
+    '22P02': INVALID_INPUT_SYNTAX,
+    '22007': INVALID_INPUT_SYNTAX,
 };
 function pgErrorFromCode(code) {
     return PG_ERRORS[code] || null;

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -3,6 +3,7 @@ import pluralize from 'pluralize-esm';
 import writeSyncFile from '../../bin/helpers/sync.js';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
+import { pgErrorType } from '../../db/errors.js';
 import _db from '../../db/index.js';
 import associationToGetterSetterProp from '../../decorators/field/association/associationToGetterSetterProp.js';
 import PackageManager from '../../dream-app/helpers/PackageManager.js';
@@ -17,6 +18,7 @@ import MissingThroughAssociationSource from '../../errors/associations/MissingTh
 import ThroughAssociationConditionsIncompatibleWithThroughAssociationSource from '../../errors/associations/ThroughAssociationConditionsIncompatibleWithThroughAssociationSource.js';
 import CannotNegateSimilarityClause from '../../errors/CannotNegateSimilarityClause.js';
 import CannotPassUndefinedAsAValueToAWhereClause from '../../errors/CannotPassUndefinedAsAValueToAWhereClause.js';
+import DataTypeColumnTypeMismatch from '../../errors/db/DataTypeColumnTypeMismatch.js';
 import UnexpectedUndefined from '../../errors/UnexpectedUndefined.js';
 import CalendarDate from '../../helpers/CalendarDate.js';
 import camelize from '../../helpers/camelize.js';
@@ -413,19 +415,31 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     static async saveDream(dream, txn = null) {
         const db = txn?.kyselyTransaction ?? _db('primary');
         const sqlifiedAttributes = sqlAttributes(dream);
-        if (dream.isPersisted) {
-            const query = db
-                .updateTable(dream.table)
-                .set(sqlifiedAttributes)
-                .where(namespaceColumn(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
-            return await executeDatabaseQuery(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+        try {
+            if (dream.isPersisted) {
+                const query = db
+                    .updateTable(dream.table)
+                    .set(sqlifiedAttributes)
+                    .where(namespaceColumn(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
+                return await executeDatabaseQuery(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+            }
+            else {
+                const query = db
+                    .insertInto(dream.table)
+                    .values(sqlifiedAttributes)
+                    .returning([...dream.columns()]);
+                return await executeDatabaseQuery(query, 'executeTakeFirstOrThrow');
+            }
         }
-        else {
-            const query = db
-                .insertInto(dream.table)
-                .values(sqlifiedAttributes)
-                .returning([...dream.columns()]);
-            return await executeDatabaseQuery(query, 'executeTakeFirstOrThrow');
+        catch (error) {
+            switch (pgErrorType(error)) {
+                case 'INVALID_INPUT_SYNTAX':
+                    throw new DataTypeColumnTypeMismatch({
+                        dream,
+                        error: error instanceof Error ? error : new Error('database column type error'),
+                    });
+            }
+            throw error;
         }
     }
     dbConnectionType(sqlCommandType) {

package/dist/esm/src/errors/db/DataTypeColumnTypeMismatch.js

@@ -0,0 +1,16 @@
+export default class DataTypeColumnTypeMismatch extends Error {
+    dream;
+    error;
+    constructor({ dream, error }) {
+        super();
+        this.dream = dream;
+        this.error = error;
+    }
+    get message() {
+        return `\
+Failed to save ${this.dream.sanitizedConstructorName}:
+
+${this.error.message}
+`;
+    }
+}

package/dist/esm/src/helpers/sqlAttributes.js

@@ -37,6 +37,12 @@ export default function sqlAttributes(dream) {
         return result;
     }, {});
 }
+/**
+ * Convert datetimes to UTC
+ */
 function valueToDatetime(val) {
-    return typeof val === 'string' ? DateTime.fromISO(val, { zone: 'UTC' }) : val;
+    if (typeof val !== 'string')
+        return val;
+    const datetime = DateTime.fromISO(val, { zone: 'UTC' });
+    return datetime.isValid ? datetime : val;
 }

package/dist/esm/src/index.js

@@ -21,6 +21,7 @@ export { default as Query } from './dream/Query.js';
 export { default as Encrypt } from './encrypt/index.js';
 export { default as NonLoadedAssociation } from './errors/associations/NonLoadedAssociation.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from './errors/CreateOrFindByFailedToCreateAndFind.js';
+export { default as DataTypeColumnTypeMismatch } from './errors/db/DataTypeColumnTypeMismatch.js';
 export { default as GlobalNameNotSet } from './errors/dream-app/GlobalNameNotSet.js';
 export { default as RecordNotFound } from './errors/RecordNotFound.js';
 export { default as ValidationError } from './errors/ValidationError.js';

package/dist/types/src/Dream.d.ts

@@ -466,6 +466,14 @@ export default class Dream {
      * @returns A query for this model which disregards default scopes
      */
     static removeAllDefaultScopes<T extends typeof Dream>(this: T): Query<InstanceType<T>>;
+    /**
+     * imports an object from the IOC. This is usually done in rare cases,
+     * in order to avoid circular dependencies, since you can always
+     * use regular imports to import models or serializers otherwise.
+     *
+     * @returns the found model or serializer, depending on what you are looking for
+     */
+    static lookup<T extends typeof Dream, GlobalSchema = InstanceType<T>['globalSchema'], GlobalNames = GlobalSchema['globalNames' & keyof GlobalSchema], ModelGlobalNames = keyof GlobalNames['models' & keyof GlobalNames], SerializerGlobalNames = (GlobalNames['serializers' & keyof GlobalNames] & unknown[])[number], LookupName extends SerializerGlobalNames | ModelGlobalNames = SerializerGlobalNames | ModelGlobalNames>(this: T, lookupName: LookupName): typeof Dream | DreamModelSerializerType | SimpleObjectSerializerType | undefined;
     /**
      * Prevents a specific default scope from applying when
      * the Query is executed

package/dist/types/src/db/errors.d.ts

@@ -1,5 +1,7 @@
 export declare const PG_ERRORS: {
-    readonly 23505: "UNIQUE_CONSTRAINT_VIOLATION";
+    readonly '23505': "UNIQUE_CONSTRAINT_VIOLATION";
+    readonly '22P02': "INVALID_INPUT_SYNTAX";
+    readonly '22007': "INVALID_INPUT_SYNTAX";
 };
 type PgErrorType = (typeof PG_ERRORS)[keyof typeof PG_ERRORS];
 export declare function pgErrorType(error: any): PgErrorType | null;

package/dist/types/src/errors/db/DataTypeColumnTypeMismatch.d.ts

@@ -0,0 +1,10 @@
+import Dream from '../../Dream.js';
+export default class DataTypeColumnTypeMismatch extends Error {
+    dream: Dream;
+    error: Error;
+    constructor({ dream, error }: {
+        dream: Dream;
+        error: Error;
+    });
+    get message(): string;
+}

package/dist/types/src/index.d.ts

@@ -22,6 +22,7 @@ export { default as Query } from './dream/Query.js';
 export { default as Encrypt, type EncryptAlgorithm, type EncryptOptions } from './encrypt/index.js';
 export { default as NonLoadedAssociation } from './errors/associations/NonLoadedAssociation.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from './errors/CreateOrFindByFailedToCreateAndFind.js';
+export { default as DataTypeColumnTypeMismatch } from './errors/db/DataTypeColumnTypeMismatch.js';
 export { default as GlobalNameNotSet } from './errors/dream-app/GlobalNameNotSet.js';
 export { default as RecordNotFound } from './errors/RecordNotFound.js';
 export { default as ValidationError } from './errors/ValidationError.js';

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "data:application/octet-stream;base64,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"
+window.navigationData = "data:application/octet-stream;base64,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"

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "data:application/octet-stream;base64,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";
+window.searchData = "data:application/octet-stream;base64,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";