@rvoh/dream 0.29.1

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

@@ -0,0 +1,18 @@
+export default function uniq(arr, toKey = undefined) {
+    if (toKey)
+        return uniqWith(arr, toKey);
+    else if (arr[0]?.isDreamInstance)
+        return uniqWith(arr, dreamKey);
+    else
+        return Array.from(new Set(arr));
+}
+function dreamKey(dream) {
+    return `${dream.constructor.globalName}:${dream.primaryKeyValue}`;
+}
+function uniqWith(arr, toKey) {
+    const map = arr.reduce((acc, val) => {
+        acc[toKey(val)] ||= val;
+        return acc;
+    }, {});
+    return Object.values(map);
+}

package/dist/esm/src/index.js

@@ -0,0 +1,73 @@
+export { default as DreamBin } from './bin/index.js';
+export { default as DreamCLI } from './cli/index.js';
+export { closeAllDbConnections, dreamDbConnections } from './db/DreamDbConnection.js';
+export { pgErrorType } from './db/errors.js';
+export { default as db } from './db/index.js';
+export { default as DreamMigrationHelpers } from './db/migration-helpers/DreamMigrationHelpers.js';
+export { default as validateColumn } from './db/validators/validateColumn.js';
+export { default as validateTable } from './db/validators/validateTable.js';
+export { default as Decorators } from './decorators/Decorators.js';
+export { default as AfterCreate } from './decorators/hooks/AfterCreate.js';
+export { default as AfterCreateCommit } from './decorators/hooks/AfterCreateCommit.js';
+export { default as AfterDestroy } from './decorators/hooks/AfterDestroy.js';
+export { default as AfterDestroyCommit } from './decorators/hooks/AfterDestroyCommit.js';
+export { default as AfterSave } from './decorators/hooks/AfterSave.js';
+export { default as AfterSaveCommit } from './decorators/hooks/AfterSaveCommit.js';
+export { default as AfterUpdate } from './decorators/hooks/AfterUpdate.js';
+export { default as AfterUpdateCommit } from './decorators/hooks/AfterUpdateCommit.js';
+export { default as BeforeCreate } from './decorators/hooks/BeforeCreate.js';
+export { default as BeforeDestroy } from './decorators/hooks/BeforeDestroy.js';
+export { default as BeforeSave } from './decorators/hooks/BeforeSave.js';
+export { default as BeforeUpdate } from './decorators/hooks/BeforeUpdate.js';
+export { default as ReplicaSafe } from './decorators/ReplicaSafe.js';
+export { default as Scope } from './decorators/Scope.js';
+export { default as SoftDelete } from './decorators/SoftDelete.js';
+export { default as Sortable } from './decorators/sortable/Sortable.js';
+export { default as STI } from './decorators/STI.js';
+export { default as Validate } from './decorators/validations/Validate.js';
+export { default as Validates } from './decorators/validations/Validates.js';
+export { default as Virtual } from './decorators/Virtual.js';
+export { default as DreamImporter } from './dream-application/helpers/DreamImporter.js';
+export { default as lookupClassByGlobalName } from './dream-application/helpers/lookupClassByGlobalName.js';
+export { default as DreamApplication, } from './dream-application/index.js';
+export { default as Dream } from './Dream.js';
+export { default as DreamTransaction } from './dream/DreamTransaction.js';
+export { default as Query } from './dream/Query.js';
+export { DreamConst, } from './dream/types.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 GlobalNameNotSet } from './errors/dream-application/GlobalNameNotSet.js';
+export { default as RecordNotFound } from './errors/RecordNotFound.js';
+export { default as ValidationError } from './errors/ValidationError.js';
+export { default as Benchmark } from './helpers/benchmark.js';
+export { default as CalendarDate } from './helpers/CalendarDate.js';
+export { default as camelize } from './helpers/camelize.js';
+export { default as capitalize } from './helpers/capitalize.js';
+export { default as generateDream } from './helpers/cli/generateDream.js';
+export { default as compact } from './helpers/compact.js';
+export { default as debug } from './helpers/debug.js';
+export { default as Env } from './helpers/Env.js';
+export { default as globalClassNameFromFullyQualifiedModelName } from './helpers/globalClassNameFromFullyQualifiedModelName.js';
+export { default as hyphenize } from './helpers/hyphenize.js';
+export { inferSerializerFromDreamClassOrViewModelClass, default as inferSerializerFromDreamOrViewModel, } from './helpers/inferSerializerFromDreamOrViewModel.js';
+export { default as isEmpty } from './helpers/isEmpty.js';
+export { default as loadRepl } from './helpers/loadRepl.js';
+export { default as pascalize } from './helpers/pascalize.js';
+export { default as dreamPath } from './helpers/path/dreamPath.js';
+export { default as relativeDreamPath } from './helpers/path/relativeDreamPath.js';
+export { default as sharedPathPrefix } from './helpers/path/sharedPathPrefix.js';
+export { Range, default as range } from './helpers/range.js';
+export { default as round } from './helpers/round.js';
+export { default as serializerNameFromFullyQualifiedModelName } from './helpers/serializerNameFromFullyQualifiedModelName.js';
+export { default as snakeify } from './helpers/snakeify.js';
+export { default as sortBy } from './helpers/sortBy.js';
+export { default as standardizeFullyQualifiedModelName } from './helpers/standardizeFullyQualifiedModelName.js';
+export { default as uncapitalize } from './helpers/uncapitalize.js';
+export { default as uniq } from './helpers/uniq.js';
+export { openapiPrimitiveTypes, openapiShorthandPrimitiveTypes, } from './openapi/types.js';
+export { default as ops } from './ops/index.js';
+export { default as RendersMany } from './serializer/decorators/associations/RendersMany.js';
+export { default as RendersOne } from './serializer/decorators/associations/RendersOne.js';
+export { default as Attribute, } from './serializer/decorators/attribute.js';
+export { default as DreamSerializer } from './serializer/index.js';

package/dist/esm/src/openapi/types.js

@@ -0,0 +1,23 @@
+export const openapiPrimitiveTypes = [
+    'string',
+    'boolean',
+    'number',
+    'date',
+    'date-time',
+    'double',
+    'integer',
+    'null',
+];
+export const openapiShorthandPrimitiveTypes = [
+    ...openapiPrimitiveTypes,
+    'decimal',
+    'string[]',
+    'boolean[]',
+    'number[]',
+    'date[]',
+    'date-time[]',
+    'decimal[]',
+    'double[]',
+    'integer[]',
+    'json',
+];

package/dist/esm/src/ops/curried-ops-statement.js

@@ -0,0 +1,9 @@
+export default class CurriedOpsStatement {
+    factoryFn;
+    constructor(factoryFn) {
+        this.factoryFn = factoryFn;
+    }
+    toOpsStatement(dreamClass, fieldName) {
+        return this.factoryFn(dreamClass, fieldName);
+    }
+}

package/dist/esm/src/ops/index.js

@@ -0,0 +1,40 @@
+import { sql } from 'kysely';
+import AnyRequiresArrayColumn from '../errors/ops/AnyRequiresArrayColumn.js';
+import isDatabaseArrayColumn from '../helpers/db/types/isDatabaseArrayColumn.js';
+import CurriedOpsStatement from './curried-ops-statement.js';
+import OpsStatement from './ops-statement.js';
+const ops = {
+    expression: (operator, value) => new OpsStatement(operator, value),
+    in: (arr) => new OpsStatement('in', arr),
+    any: (value) => new CurriedOpsStatement(function (dreamClass, fieldName) {
+        const column = fieldName.replace(/^.*\./, '');
+        if (!isDatabaseArrayColumn(dreamClass, column))
+            throw new AnyRequiresArrayColumn(dreamClass, column);
+        const castType = dreamClass['cachedTypeFor'](column);
+        return new OpsStatement('@>', sql `ARRAY[${sql.join([value])}]::${sql.raw(castType)}`);
+    }),
+    like: (like) => new OpsStatement('like', like),
+    ilike: (ilike) => new OpsStatement('ilike', ilike),
+    match: (match, { caseInsensitive = false } = {}) => new OpsStatement(caseInsensitive ? '~*' : '~', match),
+    // current
+    equal: (equal) => new OpsStatement('=', equal),
+    lessThan: (lessThan) => new OpsStatement('<', lessThan),
+    lessThanOrEqualTo: (lessThanOrEqualTo) => new OpsStatement('<=', lessThanOrEqualTo),
+    greaterThan: (greaterThan) => new OpsStatement('>', greaterThan),
+    greaterThanOrEqualTo: (greaterThanOrEqualTo) => new OpsStatement('>=', greaterThanOrEqualTo),
+    similarity: (similarity, { score = 0.3 } = {}) => new OpsStatement('%', similarity, { score }),
+    wordSimilarity: (similarity, { score = 0.5 } = {}) => new OpsStatement('<%', similarity, { score }),
+    strictWordSimilarity: (similarity, { score = 0.6 } = {}) => new OpsStatement('<<%', similarity, { score }),
+    not: {
+        in: (arr) => new OpsStatement('not in', arr),
+        like: (like) => new OpsStatement('not like', like),
+        ilike: (ilike) => new OpsStatement('not ilike', ilike),
+        match: (match, { caseInsensitive = false } = {}) => new OpsStatement(caseInsensitive ? '!~*' : '!~', match),
+        equal: (equal) => new OpsStatement('!=', equal),
+        lessThan: (lessThan) => new OpsStatement('>=', lessThan),
+        lessThanOrEqualTo: (lessThanOrEqualTo) => new OpsStatement('>', lessThanOrEqualTo),
+        greaterThan: (greaterThan) => new OpsStatement('<=', greaterThan),
+        greaterThanOrEqualTo: (greaterThanOrEqualTo) => new OpsStatement('<', greaterThanOrEqualTo),
+    },
+};
+export default ops;

package/dist/esm/src/ops/ops-statement.js

@@ -0,0 +1,35 @@
+import { TRIGRAM_OPERATORS } from '../dream/types.js';
+import ScoreMustBeANormalNumber from '../errors/ops/ScoreMustBeANormalNumber.js';
+export default class OpsStatement {
+    operator;
+    value;
+    extraArgs;
+    constructor(operator, value, extraArgs) {
+        this.operator = operator;
+        this.value = value;
+        this.extraArgs = extraArgs;
+        if (typeof extraArgs?.score === 'number' &&
+            (extraArgs.score < 0 || extraArgs.score > 1)) {
+            throw new ScoreMustBeANormalNumber(extraArgs.score);
+        }
+        this.operator = operator;
+        this.value = value;
+        if (extraArgs) {
+            this.extraArgs = Object.freeze({ ...extraArgs });
+        }
+    }
+    get isOpsStatement() {
+        return true;
+    }
+    get shouldBypassWhereStatement() {
+        return TRIGRAM_OPERATORS.includes(this.operator);
+    }
+    get minTrigramScore() {
+        if (TRIGRAM_OPERATORS.includes(this.operator)) {
+            return this.extraArgs?.score;
+        }
+        else {
+            return null;
+        }
+    }
+}

package/dist/esm/src/serializer/decorators/associations/RendersMany.js

@@ -0,0 +1,81 @@
+import { isSerializable } from './shared.js';
+/**
+ * Establishes a One to Many relationship between
+ * the base serializer and the child serializer
+ *
+ * This relationship is similar to a RendersOne relationship,
+ * except that it will an array of serialized records. It is generally
+ * used to correspond with a HasMany association
+ * on the models being driven through the serializer.
+ *
+ * If no argument is provided to RendersMany, it will infer the serializer
+ * by looking to the default serializer of the model
+ *
+ * ```ts
+ * class User extends ApplicationModel {
+ *   @Deco.HasOne('Settings')
+ *   public settings: Settings
+ * }
+ *
+ * class Post extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ * }
+ *
+ * class UserSerializer {
+ *   @RendersMany()
+ *   public posts: Post[]
+ * }
+ * ```
+ *
+ * An explicit serializer can also be provided:
+ *
+ * ```ts
+ * class UserSerializer {
+ *   @RendersMany(() => PostSummarySerializer)
+ *   public posts: Post[]
+ * }
+ * ```
+ */
+export default function RendersMany(serializableClassOrClasses = null, opts) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const target = this;
+            const serializerClass = target.constructor;
+            if (!serializerClass['globallyInitializingDecorators']) {
+                /**
+                 * Modern Javascript applies implicit accessors to instance properties
+                 * that don't have an accessor explicitly defined in the class definition.
+                 * The instance accessors shadow prototype accessors.
+                 * `addInitializer` is called by Decorators after an instance has been fully
+                 * constructed. We leverage this opportunity to delete the instance accessors
+                 * so that the prototype accessors applied by this decorator can be reached.
+                 */
+                delete this[key];
+                return;
+            }
+            if (isSerializable(serializableClassOrClasses)) {
+                opts ||= {};
+            }
+            else {
+                opts = (serializableClassOrClasses || {});
+                serializableClassOrClasses = null;
+            }
+            serializerClass.associationStatements = [
+                ...(serializerClass.associationStatements || []),
+                {
+                    type: 'RendersMany',
+                    field: key,
+                    optional: opts.optional || false,
+                    dreamOrSerializerClass: serializableClassOrClasses,
+                    serializerKey: opts.serializerKey,
+                    source: opts.source || key,
+                    through: opts.through || null,
+                    path: opts.path || null,
+                    exportedAs: opts.exportedAs || null,
+                },
+            ];
+        });
+    };
+}

package/dist/esm/src/serializer/decorators/associations/RendersOne.js

@@ -0,0 +1,84 @@
+import { isSerializable } from './shared.js';
+/**
+ * Establishes a One to One relationship between
+ * the base serializer and the child serializer
+ *
+ * This relationship is similar to a RendersMany relationship,
+ * except that it will only render one item. It is generally
+ * used to correspond with HasOne and BelongsTo associations
+ * on the models being driven through the serializer.
+ *
+ * If no argument is provided to RendersOne, it will infer the serializer
+ * by looking to the default serializer of the model
+ *
+ * ```ts
+ * class User extends ApplicationModel {
+ *   @Deco.HasOne('Settings')
+ *   public settings: Settings
+ * }
+ *
+ * class Settings extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ * }
+ *
+ * class UserSerializer {
+ *   @RendersOne()
+ *   public settings: Settings
+ * }
+ * ```
+ *
+ * An explicit serializer can also be provided:
+ *
+ * ```ts
+ * class UserSerializer {
+ *   @RendersOne(() => SettingsSummarySerializer)
+ *   public settings: Settings
+ * }
+ * ```
+ *
+ * @param opts.flatten - whether or not to flatten the association's attributes into this serializer when rendering. Defaults to false.
+ */
+export default function RendersOne(serializableClassOrClasses = null, opts) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const target = this;
+            const serializerClass = target.constructor;
+            if (!serializerClass['globallyInitializingDecorators']) {
+                /**
+                 * Modern Javascript applies implicit accessors to instance properties
+                 * that don't have an accessor explicitly defined in the class definition.
+                 * The instance accessors shadow prototype accessors.
+                 * `addInitializer` is called by Decorators after an instance has been fully
+                 * constructed. We leverage this opportunity to delete the instance accessors
+                 * so that the prototype accessors applied by this decorator can be reached.
+                 */
+                delete this[key];
+                return;
+            }
+            if (isSerializable(serializableClassOrClasses)) {
+                opts ||= {};
+            }
+            else {
+                opts = (serializableClassOrClasses || {});
+                serializableClassOrClasses = null;
+            }
+            serializerClass.associationStatements = [
+                ...(serializerClass.associationStatements || []),
+                {
+                    type: 'RendersOne',
+                    field: key,
+                    flatten: opts.flatten || false,
+                    optional: opts.optional || false,
+                    dreamOrSerializerClass: serializableClassOrClasses,
+                    serializerKey: opts.serializerKey,
+                    source: opts.source || key,
+                    through: opts.through || null,
+                    path: opts.path || null,
+                    exportedAs: opts.exportedAs || null,
+                },
+            ];
+        });
+    };
+}

package/dist/esm/src/serializer/decorators/associations/shared.js

@@ -0,0 +1,7 @@
+import hasSerializersGetter from '../helpers/hasSerializersGetter.js';
+import maybeSerializableToDreamSerializerCallbackFunction from '../helpers/maybeSerializableToDreamSerializerCallbackFunction.js';
+export function isSerializable(dreamOrSerializerClass) {
+    return (Array.isArray(dreamOrSerializerClass) ||
+        hasSerializersGetter(dreamOrSerializerClass) ||
+        !!maybeSerializableToDreamSerializerCallbackFunction(dreamOrSerializerClass));
+}

package/dist/esm/src/serializer/decorators/attribute.js

@@ -0,0 +1,158 @@
+import { isString } from '../../helpers/typechecks.js';
+import { dreamAttributeOpenapiShape } from './helpers/dreamAttributeOpenapiShape.js';
+/*
+ * Used to indicate which properties or methods on a
+ * serializer should be returned when rendering this
+ * serializer.
+ *
+ * When calling the @Attribute decorator, the first
+ * argument passed is used to inform psychic of the
+ * intended return shape. The api for the UserSerializer
+ * class is a shorthand hybrid of the openapi spec.
+ *
+ * You are able to pass types directly like so:
+ *
+ * ```ts
+ * class UserSerializer extends DreamSerializer {
+ *   @Attribute('string')
+ *   public email: string
+ * }
+ * ```
+ *
+ * And can also easily communicate array types:
+ *
+ * ```ts
+ * class UserSerializer extends DreamSerializer {
+ *   @Attribute('decimal[]')
+ *   public scores: number[]
+ * }
+ * ```
+ *
+ * For more complex types, utilize the openapi
+ * shorthand api provided by dream to communicate
+ * the custom payload shape:
+ *
+ * ```ts
+ * class UserSerializer extends DreamSerializer {
+ *   @Attribute({
+ *     first: 'string',
+ *     last: {
+ *       type: 'string',
+ *       nullable: true,
+ *     },
+ *   })
+ *   public name: { first: string; last: number | null }
+ * }
+ * ```
+ *
+ * You are able to use advanced openapi types
+ * to communicate complex possibilities:
+ *
+ * ```ts
+ * class UserSerializer extends DreamSerializer {
+ *   @Attribute({
+ *     anyOf: [
+ *       {
+ *         type: 'object',
+ *         properties: {
+ *           first: 'string',
+ *           last: {
+ *             type: 'string',
+ *             nullable: true,
+ *           },
+ *         }
+ *       },
+ *       {
+ *         type: 'string',
+ *         nullable: true,
+ *       },
+ *       {
+ *         $schema: 'UserName'
+ *       }
+ *     ]
+ *   })
+ *   public name: any
+ * }
+ * ```
+ */
+export default function Attribute(dreamClass_or_shorthandAttribute_or_manualOpenapiOptions, openApiAndRenderOptions_or_renderOptions = {}) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const target = this;
+            const serializerClass = target.constructor;
+            if (!serializerClass['globallyInitializingDecorators']) {
+                /**
+                 * Modern Javascript applies implicit accessors to instance properties
+                 * that don't have an accessor explicitly defined in the class definition.
+                 * The instance accessors shadow prototype accessors.
+                 * `addInitializer` is called by Decorators after an instance has been fully
+                 * constructed. We leverage this opportunity to delete the instance accessors
+                 * so that the prototype accessors applied by this decorator can be reached.
+                 */
+                delete this[key];
+                return;
+            }
+            let renderAs;
+            let openApiShape;
+            const { openApiOptions, renderOptions } = openApiAndRenderOptionsToSeparateOptions(openApiAndRenderOptions_or_renderOptions);
+            if (dreamClass_or_shorthandAttribute_or_manualOpenapiOptions?.isDream) {
+                openApiShape = {
+                    ...dreamAttributeOpenapiShape(dreamClass_or_shorthandAttribute_or_manualOpenapiOptions, key),
+                    ...openApiOptions,
+                };
+                //
+            }
+            else if (isString(dreamClass_or_shorthandAttribute_or_manualOpenapiOptions)) {
+                renderAs = dreamClass_or_shorthandAttribute_or_manualOpenapiOptions;
+                openApiShape = { type: renderAs, ...openApiOptions };
+                //
+            }
+            else if (typeof dreamClass_or_shorthandAttribute_or_manualOpenapiOptions === 'object') {
+                openApiShape = dreamClass_or_shorthandAttribute_or_manualOpenapiOptions;
+                renderAs = openApiShape;
+            }
+            else if (dreamClass_or_shorthandAttribute_or_manualOpenapiOptions === undefined) {
+                // no-op
+            }
+            else {
+                throw new Error(`
+Unrecognized first argument to @Attriute decorator: ${JSON.stringify(dreamClass_or_shorthandAttribute_or_manualOpenapiOptions)}
+Serializer: ${serializerClass.name}
+Attribute: ${key}
+`);
+            }
+            serializerClass.attributeStatements = [
+                ...(serializerClass.attributeStatements || []),
+                {
+                    field: key,
+                    functional: context.kind === 'method',
+                    openApiShape,
+                    renderAs,
+                    renderOptions,
+                },
+            ];
+        });
+    };
+}
+function openApiAndRenderOptionsToSeparateOptions(openApiAndRenderOptions) {
+    let openApiOptions;
+    let renderOptions;
+    if (openApiAndRenderOptions.description !== undefined) {
+        openApiOptions ||= {};
+        openApiOptions.description = openApiAndRenderOptions.description;
+    }
+    if (openApiAndRenderOptions.nullable !== undefined) {
+        openApiOptions ||= {};
+        openApiOptions.nullable = openApiAndRenderOptions.nullable;
+    }
+    if (openApiAndRenderOptions.delegate !== undefined) {
+        renderOptions ||= {};
+        renderOptions.delegate = openApiAndRenderOptions.delegate;
+    }
+    if (openApiAndRenderOptions.precision !== undefined) {
+        renderOptions ||= {};
+        renderOptions.precision = openApiAndRenderOptions.precision;
+    }
+    return { openApiOptions, renderOptions };
+}

package/dist/esm/src/serializer/decorators/helpers/dreamAttributeOpenapiShape.js

@@ -0,0 +1,73 @@
+export function dreamAttributeOpenapiShape(dreamClass, column) {
+    const dream = dreamClass.prototype;
+    const dreamColumnInfo = dream.schema[dream.table]?.columns[column];
+    if (!dreamColumnInfo)
+        return { type: 'string' };
+    const singleType = singularAttributeOpenapiShape(dreamColumnInfo);
+    const nullable = dreamColumnInfo.allowNull ? { nullable: true } : {};
+    if (dreamColumnInfo.isArray)
+        return { type: 'array', items: singleType, ...nullable };
+    return {
+        ...singleType,
+        ...nullable,
+    };
+}
+function singularAttributeOpenapiShape(dreamColumnInfo) {
+    if (dreamColumnInfo.enumValues)
+        return {
+            type: 'string',
+            enum: [...dreamColumnInfo.enumValues, ...(dreamColumnInfo.allowNull ? ['null'] : [])],
+        };
+    switch (dreamColumnInfo.dbType.replace('[]', '')) {
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'bigint':
+        case 'bigserial':
+        case 'bytea':
+        case 'char':
+        case 'character varying':
+        case 'character':
+        case 'cidr':
+        case 'citext':
+        case 'inet':
+        case 'macaddr':
+        case 'money':
+        case 'path':
+        case 'text':
+        case 'uuid':
+        case 'varbit':
+        case 'varchar':
+        case 'xml':
+            return { type: 'string' };
+        case 'integer':
+        case 'serial':
+        case 'smallint':
+        case 'smallserial':
+            return { type: 'integer' };
+        case 'decimal':
+        case 'numeric':
+            return { type: 'number', format: 'decimal' };
+        case 'double':
+        case 'real':
+            return { type: 'number' };
+        case 'datetime':
+        case 'time':
+        case 'time with time zone':
+        case 'timestamp':
+        case 'timestamp with time zone':
+        case 'timestamp without time zone':
+            return { type: 'string', format: 'date-time' };
+        case 'date':
+            return { type: 'string', format: 'date' };
+        case 'json':
+        case 'jsonb':
+            throw new UseCustomOpenapiForJson();
+        default:
+            throw new Error(`Unrecognized dbType used in serializer OpenAPI type declaration: ${dreamColumnInfo.dbType}`);
+    }
+}
+export class UseCustomOpenapiForJson extends Error {
+    get message() {
+        return `Use custom OpenAPI declaration (OpenapiSchemaBodyShorthand) to define shape of json and jsonb fields`;
+    }
+}

package/dist/esm/src/serializer/decorators/helpers/hasSerializersGetter.js

@@ -0,0 +1,8 @@
+export default function (dreamOrSerializerClass) {
+    try {
+        return !!dreamOrSerializerClass?.prototype?.serializers;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/esm/src/serializer/decorators/helpers/maybeSerializableToDreamSerializerCallbackFunction.js

@@ -0,0 +1,17 @@
+import hasSerializersGetter from './hasSerializersGetter.js';
+export default function (dreamOrSerializerClass) {
+    if (dreamOrSerializerClass === null)
+        return null;
+    if (Array.isArray(dreamOrSerializerClass))
+        return null;
+    if (dreamOrSerializerClass.isDream)
+        return null;
+    if (hasSerializersGetter(dreamOrSerializerClass))
+        return null;
+    // this must not call the function because this function is called as part of decorator
+    // execution, which happens at file load time and creates circular dependencies if the
+    // class is referenced directly during file load
+    if (dreamOrSerializerClass instanceof Function)
+        return dreamOrSerializerClass;
+    return null;
+}