@rvoh/psychic 0.37.0-beta.3 → 0.37.0-beta.5

package/dist/esm/src/openapi-renderer/SerializerOpenapiRenderer.js

@@ -0,0 +1,356 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { compact, expandStiClasses, inferSerializersFromDreamClassOrViewModelClass, isDreamSerializer, snakeify, sort, sortBy, sortObjectByKey, uniq, } from '@rvoh/dream';
+import { inspect } from 'node:util';
+import AttemptedToDeriveDescendentSerializersFromNonSerializer from '../error/openapi/AttemptedToDeriveDescendentSerializersFromNonSerializer.js';
+import ExpectedSerializerForRendersOneOrManyOption from '../error/openapi/ExpectedSerializerForRendersOneOrManyOption.js';
+import NonSerializerPassedToSerializerOpenapiRenderer from '../error/openapi/NonSerializerPassedToSerializerOpenapiRenderer.js';
+import NonSerializerSerializerOverrideProvided from '../error/openapi/NonSerializerSerializerOverrideProvided.js';
+import NoSerializerFoundForRendersOneAndMany from '../error/openapi/NoSerializerFoundForRendersOneAndMany.js';
+import ObjectSerializerRendersOneAndManyRequireClassType from '../error/openapi/ObjectSerializerRendersOneAndManyRequireClassType.js';
+import allSerializersFromHandWrittenOpenapi from './helpers/allSerializersFromHandWrittenOpenapi.js';
+import allSerializersToRefsInOpenapi from './helpers/allSerializersToRefsInOpenapi.js';
+import { dreamColumnOpenapiShape } from './helpers/dreamAttributeOpenapiShape.js';
+import openapiShorthandToOpenapi from './helpers/openapiShorthandToOpenapi.js';
+const NULL_OBJECT_OPENAPI = { type: 'null' };
+export default class SerializerOpenapiRenderer {
+    serializer;
+    casing;
+    suppressResponseEnums;
+    allOfSiblings = [];
+    constructor(serializer, { casing = 'camel', suppressResponseEnums = false, } = {}) {
+        this.serializer = serializer;
+        if (!isDreamSerializer(this.serializer))
+            throw new NonSerializerPassedToSerializerOpenapiRenderer(this.serializer);
+        this.casing = casing;
+        this.suppressResponseEnums = suppressResponseEnums;
+    }
+    get globalName() {
+        return this.serializer.globalName ?? '--unnamed--';
+    }
+    get openapiName() {
+        return this.serializer.openapiName ?? '--unnamed--';
+    }
+    get serializerRef() {
+        return {
+            $ref: `#/components/schemas/${this.openapiName}`,
+        };
+    }
+    _serializerBuilder;
+    get serializerBuilder() {
+        if (this._serializerBuilder)
+            return this._serializerBuilder;
+        this._serializerBuilder = this.serializer(undefined, undefined);
+        return this._serializerBuilder;
+    }
+    renderedOpenapi(alreadyExtractedDescendantSerializers = {}) {
+        alreadyExtractedDescendantSerializers[this.serializer.globalName] = true;
+        const referencedSerializersAndOpenapiSchemaBodyShorthand = this._renderedOpenapi(alreadyExtractedDescendantSerializers);
+        if (this.allOfSiblings.length) {
+            const openapi = referencedSerializersAndOpenapiSchemaBodyShorthand.openapi;
+            return {
+                ...referencedSerializersAndOpenapiSchemaBodyShorthand,
+                openapi: {
+                    allOf: [openapi, ...this.allOfSiblings],
+                },
+            };
+        }
+        else {
+            return referencedSerializersAndOpenapiSchemaBodyShorthand;
+        }
+    }
+    _renderedOpenapi(alreadyExtractedDescendantSerializers) {
+        const referencedSerializersAndAttributes = this.renderedOpenapiAttributes(alreadyExtractedDescendantSerializers);
+        const requiredProperties = compact(this.serializerBuilder['attributes'].map(attribute => {
+            const attributeType = attribute.type;
+            switch (attributeType) {
+                case 'attribute': {
+                    return attribute.options?.as ?? attribute.name;
+                }
+                case 'delegatedAttribute': {
+                    return attribute.options?.as ?? attribute.name;
+                }
+                case 'customAttribute': {
+                    return attribute.options.flatten ? null : attribute.name;
+                }
+                case 'rendersOne': {
+                    return attribute.options.flatten ? null : (attribute.options?.as ?? attribute.name);
+                }
+                case 'rendersMany': {
+                    return attribute.options?.as ?? attribute.name;
+                }
+                default: {
+                    // protection so that if a new ValidationType is ever added, this will throw a type error at build time
+                    const _never = attributeType;
+                    throw new Error(`Unhandled serializer attribute type: ${_never}`);
+                }
+            }
+        }));
+        return {
+            referencedSerializers: referencedSerializersAndAttributes.referencedSerializers,
+            openapi: {
+                type: 'object',
+                required: sort(uniq(requiredProperties.map(property => this.setCase(property)))),
+                properties: sortObjectByKey(referencedSerializersAndAttributes.attributes),
+            },
+        };
+    }
+    renderedOpenapiAttributes(alreadyExtractedDescendantSerializers = {}) {
+        const $typeForOpenapi = this.serializerBuilder['$typeForOpenapi'];
+        const DataTypeForOpenapi = $typeForOpenapi;
+        let referencedSerializers = [];
+        let renderedOpenapi = {};
+        const openapiRenderingOpts = {
+            casing: this.casing,
+            suppressResponseEnums: this.suppressResponseEnums,
+        };
+        renderedOpenapi = this.serializerBuilder['attributes'].reduce((accumulator, attribute) => {
+            const attributeType = attribute.type;
+            let newlyReferencedSerializers = [];
+            accumulator = (() => {
+                switch (attributeType) {
+                    ////////////////
+                    // attributes //
+                    ////////////////
+                    case 'attribute': {
+                        const outputAttributeName = this.setCase(attribute.options?.as ?? attribute.name);
+                        const openapi = attribute.options.openapi;
+                        newlyReferencedSerializers = allSerializersFromHandWrittenOpenapi(openapi);
+                        accumulator[outputAttributeName] = DataTypeForOpenapi?.isDream
+                            ? dreamColumnOpenapiShape(DataTypeForOpenapi, attribute.name, openapi, {
+                                suppressResponseEnums: this.suppressResponseEnums,
+                            })
+                            : allSerializersToRefsInOpenapi(openapiShorthandToOpenapi(openapi));
+                        return accumulator;
+                    }
+                    /////////////////////
+                    // end: attributes //
+                    /////////////////////
+                    ///////////////////////
+                    // custom attributes //
+                    ///////////////////////
+                    case 'customAttribute': {
+                        const outputAttributeName = this.setCase(attribute.name);
+                        const openapi = attribute.options.openapi;
+                        newlyReferencedSerializers = allSerializersFromHandWrittenOpenapi(openapi);
+                        if (attribute.options.flatten) {
+                            this.allOfSiblings.push(allSerializersToRefsInOpenapi(openapiShorthandToOpenapi(openapi)));
+                        }
+                        else {
+                            accumulator[outputAttributeName] = allSerializersToRefsInOpenapi(openapiShorthandToOpenapi(openapi));
+                        }
+                        return accumulator;
+                    }
+                    ////////////////////////////
+                    // end: custom attributes //
+                    ////////////////////////////
+                    //////////////////////////
+                    // delegated attributes //
+                    //////////////////////////
+                    case 'delegatedAttribute': {
+                        const outputAttributeName = this.setCase(attribute.options?.as ?? attribute.name);
+                        const openapi = attribute.options.openapi;
+                        newlyReferencedSerializers = allSerializersFromHandWrittenOpenapi(openapi);
+                        accumulator[outputAttributeName] = allSerializersToRefsInOpenapi(openapiShorthandToOpenapi(openapi));
+                        return accumulator;
+                    }
+                    ///////////////////////////////
+                    // end: delegated attributes //
+                    ///////////////////////////////
+                    //////////////////
+                    // rendersOnes  //
+                    //////////////////
+                    case 'rendersOne': {
+                        try {
+                            const outputAttributeName = this.setCase(attribute.options.as ?? attribute.name);
+                            const referencedSerializersAndOpenapiSchemaBodyShorthand = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, openapiRenderingOpts);
+                            newlyReferencedSerializers =
+                                referencedSerializersAndOpenapiSchemaBodyShorthand.referencedSerializers;
+                            if (attribute.options.flatten && attribute.options.optional) {
+                                this.allOfSiblings.push({
+                                    anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
+                                });
+                                //
+                            }
+                            else if (attribute.options.flatten) {
+                                this.allOfSiblings.push(referencedSerializersAndOpenapiSchemaBodyShorthand.openapi);
+                                //
+                            }
+                            else if (attribute.options.optional) {
+                                accumulator[outputAttributeName] = {
+                                    anyOf: [referencedSerializersAndOpenapiSchemaBodyShorthand.openapi, NULL_OBJECT_OPENAPI],
+                                };
+                            }
+                            else {
+                                accumulator[outputAttributeName] = referencedSerializersAndOpenapiSchemaBodyShorthand.openapi;
+                            }
+                            return accumulator;
+                        }
+                        catch (error) {
+                            if (error instanceof CallingSerializersThrewError)
+                                return accumulator;
+                            if (error instanceof AttemptedToDeriveDescendentSerializersFromNonSerializer)
+                                throw new ExpectedSerializerForRendersOneOrManyOption('rendersOne', this.globalName, attribute);
+                            throw error;
+                        }
+                    }
+                    ///////////////////////
+                    // end: rendersOnes  //
+                    ///////////////////////
+                    ///////////////////
+                    // rendersManys  //
+                    ///////////////////
+                    case 'rendersMany': {
+                        try {
+                            const outputAttributeName = this.setCase(attribute.options.as ?? attribute.name);
+                            const referencedSerializersAndOpenapiSchemaBodyShorthand = associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, openapiRenderingOpts);
+                            newlyReferencedSerializers =
+                                referencedSerializersAndOpenapiSchemaBodyShorthand.referencedSerializers;
+                            accumulator[outputAttributeName] = {
+                                type: 'array',
+                                items: referencedSerializersAndOpenapiSchemaBodyShorthand.openapi,
+                            };
+                            return accumulator;
+                        }
+                        catch (error) {
+                            if (error instanceof CallingSerializersThrewError)
+                                return accumulator;
+                            if (error instanceof AttemptedToDeriveDescendentSerializersFromNonSerializer)
+                                throw new ExpectedSerializerForRendersOneOrManyOption('rendersMany', this.globalName, attribute);
+                            throw error;
+                        }
+                    }
+                    ////////////////////////
+                    // end: rendersManys  //
+                    ////////////////////////
+                    default: {
+                        // protection so that if a new ValidationType is ever added, this will throw a type error at build time
+                        const _never = attributeType;
+                        throw new Error(`Unhandled serializer attribute type: ${_never}`);
+                    }
+                }
+            })();
+            const recursiveNewlyReferencedSerializers = newlyReferencedSerializers.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers, openapiRenderingOpts));
+            referencedSerializers = [
+                ...referencedSerializers,
+                ...newlyReferencedSerializers,
+                ...recursiveNewlyReferencedSerializers,
+            ];
+            return accumulator;
+        }, renderedOpenapi);
+        return {
+            referencedSerializers: uniq(referencedSerializers, serializer => serializer.globalName),
+            attributes: renderedOpenapi,
+        };
+    }
+    setCase(attr) {
+        switch (this.casing) {
+            case 'camel':
+                return attr;
+            case 'snake':
+                return snakeify(attr);
+            default: {
+                // protection so that if a new Casing is ever added, this will throw a type error at build time
+                const _never = this.casing;
+                throw new Error(`Unhandled Casing: ${_never}`);
+            }
+        }
+    }
+}
+function associationOpenapi(attribute, DataTypeForOpenapi, alreadyExtractedDescendantSerializers, opts) {
+    const serializerOverride = attribute.options.serializer;
+    if (serializerOverride) {
+        try {
+            return {
+                referencedSerializers: [
+                    serializerOverride,
+                    ...descendantSerializers(serializerOverride, alreadyExtractedDescendantSerializers, opts),
+                ],
+                openapi: new SerializerOpenapiRenderer(serializerOverride, opts).serializerRef,
+            };
+        }
+        catch (error) {
+            if (error instanceof NonSerializerPassedToSerializerOpenapiRenderer)
+                throw new NonSerializerSerializerOverrideProvided(attribute, serializerOverride);
+            throw error;
+        }
+    }
+    let associatedClasses;
+    const association = DataTypeForOpenapi?.isDream &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        DataTypeForOpenapi['getAssociationMetadata'](attribute.name);
+    if (association) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        associatedClasses = expandStiClasses(association.modelCB());
+        //
+    }
+    else {
+        const associatedClass = attribute.options.dreamClass ?? attribute.options.viewModelClass;
+        if (associatedClass === undefined) {
+            let serializerCheck;
+            try {
+                ;
+                DataTypeForOpenapi?.prototype?.serializers;
+            }
+            catch {
+                throw new CallingSerializersThrewError();
+            }
+            if (serializerCheck)
+                throw new ObjectSerializerRendersOneAndManyRequireClassType(attribute.name);
+            throw new ObjectSerializerRendersOneAndManyRequireClassType(attribute.name);
+        }
+        if (associatedClass?.isDream) {
+            associatedClasses = expandStiClasses(associatedClass);
+        }
+        else {
+            associatedClasses = [associatedClass];
+        }
+    }
+    const serializersOpenapi = associatedClasses.flatMap(associatedClass => inferSerializersFromDreamClassOrViewModelClass(associatedClass, attribute.options.serializerKey));
+    if (serializersOpenapi.length === 0)
+        throw new NoSerializerFoundForRendersOneAndMany(attribute.name);
+    if (serializersOpenapi.length === 1) {
+        const serializer = serializersOpenapi[0];
+        return {
+            referencedSerializers: [
+                serializer,
+                ...descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts),
+            ],
+            openapi: new SerializerOpenapiRenderer(serializer, opts).serializerRef,
+        };
+    }
+    return {
+        referencedSerializers: [
+            ...serializersOpenapi,
+            ...serializersOpenapi.flatMap(serializer => descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts)),
+        ],
+        openapi: {
+            anyOf: sortBy(uniq(serializersOpenapi.map(serializer => new SerializerOpenapiRenderer(serializer, opts).serializerRef), ref => ref['$ref']), ref => (ref['$ref'] ? ref['$ref'] : inspect(ref, { depth: 2 }))),
+        },
+    };
+}
+function descendantSerializers(serializer, alreadyExtractedDescendantSerializers, opts) {
+    // alreadyExtractedDescendantSerializers is used not only to avoid duplicate
+    // work (and thereby speed up OpenAPI spec generation), but also to avoid
+    // infinite loops (a recursive OpenAPI structure is valid)
+    if (alreadyExtractedDescendantSerializers[serializer.globalName])
+        return [];
+    if (!isDreamSerializer(serializer))
+        throw new AttemptedToDeriveDescendentSerializersFromNonSerializer(serializer);
+    const immediateDescendantSerializers = new SerializerOpenapiRenderer(serializer, opts).renderedOpenapi(alreadyExtractedDescendantSerializers).referencedSerializers;
+    return [
+        ...immediateDescendantSerializers,
+        ...immediateDescendantSerializers.flatMap(descendantSerializer => descendantSerializers(descendantSerializer, alreadyExtractedDescendantSerializers, opts)),
+    ];
+}
+// When attempting to expand STI children, we might call `.serializers` on
+// an instance that throws an error just by calling `.serializers` (so that
+// they can be sure to define serializers on the STI children, but in this
+// case, there might be STI children that are intermediaries to the intended
+// STI children, so they don't have serializers and calling `.serializers`
+// throws an error)
+class CallingSerializersThrewError extends Error {
+}

package/dist/esm/src/openapi-renderer/body-segment.js

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { SerializerOpenapiRenderer, inferSerializerFromDreamOrViewModel, isDreamSerializer, maybeNullOpenapiShorthandToOpenapiShorthand, openapiShorthandPrimitiveTypes, } from '@rvoh/dream';
+import { inferSerializerFromDreamOrViewModel, isDreamSerializer, openapiShorthandPrimitiveTypes, } from '@rvoh/dream';
 import NonSerializerSuppliedToSerializerBodySegment from '../error/openapi/NonSerializerSuppliedToSerializerBodySegment.js';
 import isArrayParamName from '../helpers/isArrayParamName.js';
 import isBlankDescription from './helpers/isBlankDescription.js';
+import maybeNullOpenapiShorthandToOpenapiShorthand from './helpers/maybeNullOpenapiShorthandToOpenapiShorthand.js';
 import primitiveOpenapiStatementToOpenapi from './helpers/primitiveOpenapiStatementToOpenapi.js';
 import schemaToRef from './helpers/schemaToRef.js';
+import SerializerOpenapiRenderer from './SerializerOpenapiRenderer.js';
 export default class OpenapiBodySegmentRenderer {
     bodySegment;
     casing;

package/dist/esm/src/openapi-renderer/endpoint.js

@@ -1,4 +1,4 @@
-import { SerializerOpenapiRenderer, cloneDeepSafe, compact, inferSerializersFromDreamClassOrViewModelClass, isDreamSerializer, sortBy, } from '@rvoh/dream';
+import { cloneDeepSafe, compact, inferSerializersFromDreamClassOrViewModelClass, isDreamSerializer, sortBy, } from '@rvoh/dream';
 import OpenApiFailedToLookupSerializerForEndpoint from '../error/openapi/FailedToLookupSerializerForEndpoint.js';
 import NonSerializerDerivedInOpenapiEndpointRenderer from '../error/openapi/NonSerializerDerivedInOpenapiEndpointRenderer.js';
 import NonSerializerDerivedInToSchemaObjects from '../error/openapi/NonSerializerDerivedInToSchemaObjects.js';
@@ -10,6 +10,7 @@ import openapiRoute from './helpers/openapiRoute.js';
 import openapiPageParamProperty from './helpers/pageParamOpenapiProperty.js';
 import primitiveOpenapiStatementToOpenapi from './helpers/primitiveOpenapiStatementToOpenapi.js';
 import safelyAttachPaginationParamToRequestBodySegment from './helpers/safelyAttachPaginationParamsToBodySegment.js';
+import SerializerOpenapiRenderer from './SerializerOpenapiRenderer.js';
 export default class OpenapiEndpointRenderer {
     dreamsOrSerializers;
     controllerClass;

package/dist/esm/src/openapi-renderer/helpers/allSerializersFromHandWrittenOpenapi.js

@@ -0,0 +1,28 @@
+import isObject from '../../helpers/isObject.js';
+export default function allSerializersFromHandWrittenOpenapi(openapi) {
+    const serializers = new Set();
+    extractSerializers(openapi, serializers);
+    return [...serializers];
+}
+function extractSerializers(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value, serializers) {
+    if (!value)
+        return;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (value.$serializer) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+        serializers.add(value.$serializer);
+        //
+    }
+    else if (isObject(value)) {
+        // Recurse into objects
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        Object.values(value).forEach(val => extractSerializers(val, serializers));
+        //
+    }
+    else if (Array.isArray(value)) {
+        // Recurse into arrays
+        value.forEach(val => extractSerializers(val, serializers));
+    }
+}

package/dist/esm/src/openapi-renderer/helpers/allSerializersToRefsInOpenapi.js

@@ -0,0 +1,46 @@
+import isObject from '../../helpers/isObject.js';
+import SerializerOpenapiRenderer from '../SerializerOpenapiRenderer.js';
+export default function allSerializersToRefsInOpenapi(openapi) {
+    if (!openapi)
+        return {};
+    return transformValue(openapi);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function transformValue(value) {
+    if (!value)
+        return value;
+    // If this is an object with a $serializer property, replace it with $ref
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (value.$serializer) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const { $serializer, ...rest } = value;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const openapiRenderer = new SerializerOpenapiRenderer($serializer).serializerRef;
+        return {
+            ...rest,
+            ...openapiRenderer,
+        };
+    }
+    else if (isObject(value)) {
+        // Recurse into objects
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const transformed = {};
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        for (const [key, val] of Object.entries(value)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+            transformed[key] = transformValue(val);
+        }
+        return transformed;
+        //
+    }
+    else if (Array.isArray(value)) {
+        // Recurse into arrays
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return value.map(val => transformValue(val));
+        //
+    }
+    else {
+        // Return primitive values as-is
+        return value;
+    }
+}

package/dist/esm/src/openapi-renderer/helpers/dreamAttributeOpenapiShape.js

@@ -0,0 +1,136 @@
+import openapiShorthandToOpenapi from './openapiShorthandToOpenapi.js';
+export function dreamColumnOpenapiShape(dreamClass, column, openapi = undefined, { suppressResponseEnums = false } = {}) {
+    const dream = dreamClass.prototype;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
+    const dreamColumnInfo = dream.schema[dream.table]?.columns[column];
+    if (!dreamColumnInfo) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+        if (openapi)
+            return openapiShorthandToOpenapi(openapi);
+        throw new UseCustomOpenapiForVirtualAttributes(dreamClass, column);
+    }
+    switch (baseDbType(dreamColumnInfo)) {
+        case 'json':
+        case 'jsonb':
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+            if (openapi)
+                return openapiShorthandToOpenapi(openapi);
+            throw new UseCustomOpenapiForJson(dreamClass, column);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+    const openapiObject = openapiShorthandToOpenapi((openapi ?? {}));
+    const singleType = singularAttributeOpenapiShape(dreamColumnInfo, suppressResponseEnums);
+    if (dreamColumnInfo.isArray) {
+        return {
+            type: dreamColumnInfo.allowNull ? ['array', 'null'] : 'array',
+            items: singleType,
+            ...openapiObject,
+        };
+    }
+    else {
+        const existingType = singleType.type;
+        return {
+            ...singleType,
+            type: dreamColumnInfo.allowNull && !Array.isArray(existingType) ? [existingType, 'null'] : existingType,
+            ...openapiObject,
+        };
+    }
+}
+function baseDbType(dreamColumnInfo) {
+    return dreamColumnInfo.dbType.replace('[]', '');
+}
+function singularAttributeOpenapiShape(dreamColumnInfo, suppressResponseEnums) {
+    if (dreamColumnInfo.enumValues) {
+        if (suppressResponseEnums) {
+            return {
+                type: 'string',
+                description: `The following values will be allowed:\n  ${dreamColumnInfo.enumValues.join(',\n  ')}`,
+            };
+        }
+        else {
+            return { type: 'string', enum: dreamColumnInfo.enumValues };
+        }
+    }
+    switch (baseDbType(dreamColumnInfo)) {
+        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 'numeric':
+        case 'decimal':
+            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' };
+        default:
+            throw new Error(`Unrecognized dbType used in serializer OpenAPI type declaration: ${dreamColumnInfo.dbType}`);
+    }
+}
+export class UseCustomOpenapiForVirtualAttributes extends Error {
+    dreamClass;
+    field;
+    constructor(dreamClass, field) {
+        super();
+        this.dreamClass = dreamClass;
+        this.field = field;
+    }
+    get message() {
+        return `Use custom OpenAPI declaration (OpenapiSchemaBodyShorthand) to define shape of virtual fields:
+Dream model: ${this.dreamClass.sanitizedName}
+Attribute: ${this.field}`;
+    }
+}
+export class UseCustomOpenapiForJson extends Error {
+    dreamClass;
+    field;
+    constructor(dreamClass, field) {
+        super();
+        this.dreamClass = dreamClass;
+        this.field = field;
+    }
+    get message() {
+        return `Use custom OpenAPI declaration (OpenapiSchemaBodyShorthand) to define shape of json and jsonb fields:
+Dream model: ${this.dreamClass.sanitizedName}
+Attribute: ${this.field}
+
+For example:
+
+export const MySerializer = (data: MyModel) =>
+  DreamSerializer(MyModel, data)
+    .jsonAttribute('myJson', {
+      openapi: {
+        type: 'object', properties: { hello: 'string' },
+      },
+    })`;
+    }
+}

package/dist/esm/src/openapi-renderer/helpers/isOpenapiShorthand.js

@@ -0,0 +1,10 @@
+import { openapiShorthandPrimitiveTypes } from '@rvoh/dream';
+import maybeNullOpenapiShorthandToOpenapiShorthand from './maybeNullOpenapiShorthandToOpenapiShorthand.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function isOpenapiShorthand(openapi) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const openapiShorthand = maybeNullOpenapiShorthandToOpenapiShorthand(openapi);
+    if (typeof openapiShorthand !== 'string')
+        return false;
+    return openapiShorthandPrimitiveTypes.includes(openapiShorthand);
+}

package/dist/esm/src/openapi-renderer/helpers/maybeNullOpenapiShorthandToOpenapiShorthand.js

@@ -0,0 +1,14 @@
+export default function maybeNullOpenapiShorthandToOpenapiShorthand(openapi) {
+    if (openapi === undefined)
+        return undefined;
+    if (typeof openapi === 'string')
+        return openapi;
+    if (!Array.isArray(openapi))
+        return undefined;
+    if (openapi.length !== 2)
+        return undefined;
+    if (openapi[1] === 'null')
+        return openapi[0];
+    if (openapi[0] === 'null')
+        return openapi[1];
+}