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

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = allSerializersFromHandWrittenOpenapi;
+const isObject_js_1 = __importDefault(require("../../helpers/isObject.js"));
+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 ((0, isObject_js_1.default)(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/cjs/src/openapi-renderer/helpers/allSerializersToRefsInOpenapi.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = allSerializersToRefsInOpenapi;
+const isObject_js_1 = __importDefault(require("../../helpers/isObject.js"));
+const SerializerOpenapiRenderer_js_1 = __importDefault(require("../SerializerOpenapiRenderer.js"));
+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_js_1.default($serializer).serializerRef;
+        return {
+            ...rest,
+            ...openapiRenderer,
+        };
+    }
+    else if ((0, isObject_js_1.default)(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/cjs/src/openapi-renderer/helpers/dreamAttributeOpenapiShape.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseCustomOpenapiForJson = exports.UseCustomOpenapiForVirtualAttributes = void 0;
+exports.dreamColumnOpenapiShape = dreamColumnOpenapiShape;
+const openapiShorthandToOpenapi_js_1 = __importDefault(require("./openapiShorthandToOpenapi.js"));
+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 (0, openapiShorthandToOpenapi_js_1.default)(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 (0, openapiShorthandToOpenapi_js_1.default)(openapi);
+            throw new UseCustomOpenapiForJson(dreamClass, column);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+    const openapiObject = (0, openapiShorthandToOpenapi_js_1.default)((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}`);
+    }
+}
+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}`;
+    }
+}
+exports.UseCustomOpenapiForVirtualAttributes = UseCustomOpenapiForVirtualAttributes;
+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' },
+      },
+    })`;
+    }
+}
+exports.UseCustomOpenapiForJson = UseCustomOpenapiForJson;

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

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isOpenapiShorthand;
+const dream_1 = require("@rvoh/dream");
+const maybeNullOpenapiShorthandToOpenapiShorthand_js_1 = __importDefault(require("./maybeNullOpenapiShorthandToOpenapiShorthand.js"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isOpenapiShorthand(openapi) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const openapiShorthand = (0, maybeNullOpenapiShorthandToOpenapiShorthand_js_1.default)(openapi);
+    if (typeof openapiShorthand !== 'string')
+        return false;
+    return dream_1.openapiShorthandPrimitiveTypes.includes(openapiShorthand);
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = maybeNullOpenapiShorthandToOpenapiShorthand;
+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];
+}

package/dist/cjs/src/openapi-renderer/helpers/openapiShorthandToOpenapi.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnrecognizedOpenapiShape = exports.UnrecognizedOpenapiShorthand = void 0;
+exports.default = openapiShorthandToOpenapi;
+const isObject_js_1 = __importDefault(require("../../helpers/isObject.js"));
+const isOpenapiShorthand_js_1 = __importDefault(require("./isOpenapiShorthand.js"));
+const maybeNullOpenapiShorthandToOpenapiShorthand_js_1 = __importDefault(require("./maybeNullOpenapiShorthandToOpenapiShorthand.js"));
+function openapiShorthandToOpenapi(openapi, options = {}) {
+    if ((0, isOpenapiShorthand_js_1.default)(openapi)) {
+        return _openapiShorthandToOpenapi(openapi, options);
+    }
+    else if ((0, isObject_js_1.default)(openapi)) {
+        return openapi;
+    }
+    else {
+        throw new UnrecognizedOpenapiShape(openapi);
+    }
+}
+function _openapiShorthandToOpenapi(shorthand, options) {
+    const shorthandString = (0, maybeNullOpenapiShorthandToOpenapiShorthand_js_1.default)(shorthand);
+    if (!shorthandString)
+        return { type: 'null' };
+    const openapi = simpleOpenapiShorthandToOpenapi(shorthandString);
+    if (options.maybeNull || openapiShorthandIncludesNull(shorthand))
+        return { ...openapi, type: [openapi.type, 'null'] };
+    return openapi;
+}
+function simpleOpenapiShorthandToOpenapi(shorthand) {
+    switch (shorthand) {
+        case 'string':
+            return { type: 'string' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'number':
+            return { type: 'number' };
+        case 'date':
+            return { type: 'string', format: 'date' };
+        case 'date-time':
+            return { type: 'string', format: 'date-time' };
+        case 'decimal':
+            return { type: 'number', format: 'decimal' };
+        case 'integer':
+            return { type: 'integer' };
+        case 'null':
+            return { type: 'null' };
+        case 'string[]':
+            return { type: 'array', items: { type: 'string' } };
+        case 'boolean[]':
+            return { type: 'array', items: { type: 'boolean' } };
+        case 'number[]':
+            return { type: 'array', items: { type: 'number' } };
+        case 'date[]':
+            return { type: 'array', items: { type: 'string', format: 'date' } };
+        case 'date-time[]':
+            return { type: 'array', items: { type: 'string', format: 'date-time' } };
+        case 'decimal[]':
+            return { type: 'array', items: { type: 'number', format: 'decimal' } };
+        case 'integer[]':
+            return { type: 'array', items: { type: 'integer' } };
+        case 'json':
+            return { type: 'json' };
+        default: {
+            // protection so that if a new OpenapiShorthandPrimitiveBaseTypes is ever added, this will throw a type error at build time
+            const _never = shorthand;
+            throw new UnrecognizedOpenapiShorthand(_never);
+        }
+    }
+}
+function openapiShorthandIncludesNull(openapi) {
+    if (openapi === undefined)
+        return false;
+    if (typeof openapi === 'string')
+        return false;
+    if (!Array.isArray(openapi))
+        return false;
+    if (openapi.length !== 2)
+        return false;
+    if (openapi[1] === 'null')
+        return true;
+    if (openapi[0] === 'null')
+        return true;
+    return false;
+}
+class UnrecognizedOpenapiShorthand extends Error {
+    shorthand;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(shorthand) {
+        super();
+        this.shorthand = shorthand;
+    }
+    get message() {
+        return `Unrecognized OpenAPI shorthand: ${JSON.stringify(this.shorthand)}`;
+    }
+}
+exports.UnrecognizedOpenapiShorthand = UnrecognizedOpenapiShorthand;
+class UnrecognizedOpenapiShape extends Error {
+    openapi;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(openapi) {
+        super();
+        this.openapi = openapi;
+    }
+    get message() {
+        return `Unrecognized OpenAPI shape:
+${JSON.stringify(this.openapi)}`;
+    }
+}
+exports.UnrecognizedOpenapiShape = UnrecognizedOpenapiShape;

package/dist/cjs/src/openapi-renderer/helpers/primitiveOpenapiStatementToOpenapi.js

@@ -1,12 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = primitiveOpenapiStatementToOpenapi;
-const dream_1 = require("@rvoh/dream");
+const openapiShorthandToOpenapi_js_1 = __importDefault(require("./openapiShorthandToOpenapi.js"));
 /**
  * @internal
  *
  * parses a primitive stored type
  */
 function primitiveOpenapiStatementToOpenapi(data, maybeNull = false) {
-    return (0, dream_1.openapiShorthandToOpenapi)(data, { maybeNull });
+    return (0, openapiShorthandToOpenapi_js_1.default)(data, { maybeNull });
 }

package/dist/cjs/src/server/params.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const dream_1 = require("@rvoh/dream");
 const ParamValidationError_js_1 = __importDefault(require("../error/controller/ParamValidationError.js"));
 const ParamValidationErrors_js_1 = __importDefault(require("../error/controller/ParamValidationErrors.js"));
-const isUuid_js_1 = __importDefault(require("../helpers/isUuid.js"));
-const typechecks_js_1 = require("../helpers/typechecks.js");
-const isArrayParamName_js_1 = __importDefault(require("../helpers/isArrayParamName.js"));
 const alternateParamName_js_1 = __importDefault(require("../helpers/alternateParamName.js"));
+const isArrayParamName_js_1 = __importDefault(require("../helpers/isArrayParamName.js"));
+const isObject_js_1 = __importDefault(require("../helpers/isObject.js"));
+const isUuid_js_1 = __importDefault(require("../helpers/isUuid.js"));
 class Params {
     $params;
     /**
@@ -303,7 +303,7 @@ class Params {
         const permitted = {};
         if (params === null || params === undefined)
             return permitted;
-        if (!(0, typechecks_js_1.isObject)(params))
+        if (!(0, isObject_js_1.default)(params))
             throw new Error(`Params.restrict expects object or null, received: ${JSON.stringify(params)}`);
         const objectParam = params;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 import TypesBuilder from '../cli/helpers/TypesBuilder.js';
 import generateController from '../generate/controller.js';
 import generateResource from '../generate/resource.js';
-import { isObject } from '../helpers/typechecks.js';
+import isObject from '../helpers/isObject.js';
 import OpenapiAppRenderer from '../openapi-renderer/app.js';
 import PsychicApp from '../psychic-app/index.js';
 import PsychicServer from '../server/index.js';

package/dist/esm/src/controller/helpers/isPaginatedResult.js

@@ -1,4 +1,4 @@
-import { isObject } from '../../helpers/typechecks.js';
+import isObject from '../../helpers/isObject.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export default function isPaginatedResult(result) {
     if (!isObject(result))

package/dist/esm/src/error/openapi/AttemptedToDeriveDescendentSerializersFromNonSerializer.js

@@ -0,0 +1,13 @@
+import { inspect } from 'node:util';
+export default class AttemptedToDeriveDescendentSerializersFromNonSerializer extends Error {
+    serializer;
+    constructor(serializer) {
+        super();
+        this.serializer = serializer;
+    }
+    get message() {
+        return `
+Attempted to derive descendant serializers from non serializer:
+${inspect(this.serializer)}`;
+    }
+}

package/dist/esm/src/error/openapi/ExpectedSerializerForRendersOneOrManyOption.js

@@ -0,0 +1,33 @@
+export default class ExpectedSerializerForRendersOneOrManyOption extends Error {
+    rendersOneOrMany;
+    referencingSerializerName;
+    attribute;
+    constructor(rendersOneOrMany, referencingSerializerName, attribute) {
+        super();
+        this.rendersOneOrMany = rendersOneOrMany;
+        this.referencingSerializerName = referencingSerializerName;
+        this.attribute = attribute;
+    }
+    get message() {
+        const baseString = `
+The \`serializer\` option on the \`${this.attribute.name}\` \`${this.rendersOneOrMany}\`
+on serializer \`${this.referencingSerializerName}\``;
+        if (this.attribute.options?.serializer) {
+            return `${baseString}
+specifies something other than a serializer.
+It should look something like the following:
+
+\`\`\`
+.${this.rendersOneOrMany}('${this.attribute.name}', {
+  serializer: MySerializer
+})
+\`\`\`
+`;
+        }
+        else {
+            return `${baseString}
+is throwing an error.
+`;
+        }
+    }
+}

package/dist/esm/src/error/openapi/NoSerializerFoundForRendersOneAndMany.js

@@ -0,0 +1,13 @@
+export default class NoSerializerFoundForRendersOneAndMany extends Error {
+    associationName;
+    constructor(associationName) {
+        super();
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+Attempted to render \`rendersOne\` / \`rendersMany\`
+\`${this.associationName}\`, but could not locate a
+serializer.`;
+    }
+}

package/dist/esm/src/error/openapi/NonSerializerPassedToSerializerOpenapiRenderer.js

@@ -0,0 +1,13 @@
+import { inspect } from 'node:util';
+export default class NonSerializerPassedToSerializerOpenapiRenderer extends Error {
+    serializer;
+    constructor(serializer) {
+        super();
+        this.serializer = serializer;
+    }
+    get message() {
+        return `
+Non-serializer passed to SerializerOpenapiRenderer:
+${inspect(this.serializer)}`;
+    }
+}

package/dist/esm/src/error/openapi/NonSerializerSerializerOverrideProvided.js

@@ -0,0 +1,20 @@
+import { inspect } from 'node:util';
+export default class NonSerializerSerializerOverrideProvided extends Error {
+    rendersAssociation;
+    serializer;
+    constructor(rendersAssociation, serializer) {
+        super();
+        this.rendersAssociation = rendersAssociation;
+        this.serializer = serializer;
+    }
+    get message() {
+        return `
+Non-serializer passed to \`serializerOverride\` of a rendersOne/Many declaration:
+
+rendersOne/Many declaration:
+${inspect(this.rendersAssociation)}
+
+non-serializer passed to serializerOverride:
+${inspect(this.serializer)}`;
+    }
+}

package/dist/esm/src/error/openapi/ObjectSerializerRendersOneAndManyRequireClassType.js

@@ -0,0 +1,16 @@
+export default class ObjectSerializerRendersOneAndManyRequireClassType extends Error {
+    associationName;
+    constructor(associationName) {
+        super();
+        this.associationName = associationName;
+    }
+    get message() {
+        return `
+ObjectSerializer \`rendersOne\` and \`rendersMany\`
+options must include \`dreamClass\`, \`viewModelClass\`, or
+\`serializer\`.
+
+rendersOne/Many name: ${this.associationName}
+`;
+    }
+}

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

@@ -0,0 +1,9 @@
+// also in Dream
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function isObject(x) {
+    if (x === null)
+        return false;
+    if (Array.isArray(x))
+        return false;
+    return typeof x === 'object';
+}

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

@@ -1,4 +1,4 @@
-import { isObject } from './typechecks.js';
+import isObject from './isObject.js';
 export default function pathifyNestedObject(obj, prefix = '') {
     return Object.keys(obj).reduce((acc, k) => {
         const pre = prefix.length ? prefix + '/' : '';