@rvoh/psychic 1.10.3 → 1.10.5

package/CHANGELOG.md

@@ -0,0 +1,320 @@
+## 1.10.5
+
+- add "combining" option to requestBody for OpenAPI decorator, enabling you to combine additional openapi fields to the request body, while still leveraging the powerful automatically-generated request body.
+- syncing client enums now sync types along with values
+- better dev logging
+
+## 1.10.4
+
+Fix issue with rendering incorrect enum descriptions when suppressResponseEnums is set to true and enums are explicitly overridden in the openapi option.
+
+## 1.10.3
+
+- respect `required: false` when generating OpenAPI spec
+
+## 1.10.2
+
+- return 400 instead of throwing error and 500 when there is a column overflow at the database level (let database validation suffice for enforcing data length validation rather than requiring model level validation)
+
+## 1.10.1
+
+- OpenAPI and castParam validation errors are logged only when `NODE_DEBUG=psychic`
+
+## 1.10.0
+
+- remove OpenAPI and Dream validation error response configuration and do not respond with errors (don't introduce such a difference between development and production environments)
+- log validation errors in test and dev (not prod to avoid DOS)
+- remove distinction between 400 and 422 to block ability of attacker to get feedback on how far into the system their request made it
+
+## 1.9.0
+
+1. Validate params against OpenAPI at the latest possible of:
+   a. when the params are accessed
+   b. when about to render the action
+   This ensures that we return the proper 401/403 response instead of 400 for authenticated endpoints that fail authentication and prevents unauthenticated requests from gaining information about the API
+
+2. Ability to configure whether or not OpenAPI validation errors include detailed information
+
+## 1.8.6
+
+remove dead env variable, now that we are open sourced
+
+## 1.8.5
+
+Do not hard crash when initializing a psychic application when one of the openapi routes is not found for an openapi-decorated controller endpoint. We will continue to raise this exception when building openapi specs, but not when booting up the psychic application, since one can define routes that are i.e. not available in certain environments, and we don't want this to cause hard crashes when our app boots in those environments.
+
+## 1.8.4
+
+- OpenAPI decorator with default 204 status does not throw an exception when passed a Dream model without a `serializers` getter
+- OpenAPI decorator that defines an explicit OpenAPI shape for the default status code does not throw an exception when passed a Dream model without a `serializers` getter
+
+## 1.8.3
+
+- don't build openapi when `bypassModelIntegrityCheck: true`
+
+## 1.8.2
+
+- openapi validation properly coerces non-array query params to arrays when validating, since both express and ajv fail to do this under the hood properly. This solves issues where sending up array params with only a single item in them are not treated as arrays.
+
+## 1.8.1
+
+- do not coerce types in ajv when processing request or response bodies during validation. Type coercion will still happen for headers and query params, since they will need to respect the schema type specified in the openapi docuement.
+
+## 1.8.0
+
+- remove unused `clientRoot` config
+
+## 1.7.2
+
+- generate admin routes in routes.admin.ts (requires `routes.admin.ts` next to `routes.ts`)
+
+## 1.7.1
+
+- compute openapi doc during intiialization, rather than problematically reading from a file cache
+
+## 1.7.0
+
+- `sanitizeResponseJson` config to automatically escape `<`, `>`, `&`, `/`, `\`, `'`, and `"` unicode representations when rendering json to satisfy security reviews (e.g., a pentest report recently called this out on one of our applications). For all practical purposes, this doesn't protect against anything (now that we have the `nosniff` header) since `JSON.parse` on the other end restores the original, dangerous string. Modern front end web frameworks already handle safely displaying arbitrary content, so further sanitization generally isn't needed. This version does provide the `sanitizeString` function that could be used to sanitize individual strings, replacing the above characters with string representations of the unicode characters that will survive Psychic converting to json and then parsing that json (i.e.: `<` will end up as the string "\u003c")
+
+- Fix openapi serializer fallback issue introduced in 1.6.3, where we mistakenly double render data that has already been serialized.
+
+## 1.6.4
+
+Raise an exception if attempting to import an openapi file during PsychicApp.init when in production. We will still swallow the exception in non-prod environments so that one can create a new openapi configuration and run sync without getting an error.
+
+## 1.6.3
+
+- castParam accepts raw openapi shapes as type arguments, correctly casting the result to an interface representing the provided openapi shape.
+
+```ts
+class MyController extends ApplicationController {
+  public index() {
+    const myParam = this.castParam('myParam', {
+      type: 'array',
+      items: {
+        anyOf: [{ type: 'string' }, { type: 'number' }],
+      },
+    })
+    myParam[0] // string | number
+  }
+}
+```
+
+- simplify the needlessly-robust new psychic router patterns by making expressApp optional, essentially reverting us back to the same psychic router we had prior to the recent openapi validation changes.
+
+- fallback to serializer specified in openapi decorator before falling back to dream serializer when rendering dreams
+
+## 1.6.2
+
+fix OpenAPI spec generation by DRYing up generation of request and response body
+
+## 1.6.1
+
+fix issue preventing validation fallbacks from properly overriding on OpenAPI decorator calls when explicitly opting out of validation
+
+## 1.6.0
+
+enables validation to be added to both openapi configurations, as well as to `OpenAPI` decorator calls, enabling the developer to granularly control validation logic for their endpoints.
+
+To leverage global config:
+
+```ts
+// conf/app.ts
+export default async (psy: PsychicApp) => {
+  ...
+
+  psy.set('openapi', {
+    // ...
+    validate: {
+      headers: true,
+      requestBody: true,
+      query: true,
+      responseBody: AppEnv.isTest,
+    },
+  })
+}
+```
+
+To leverage endpoint config:
+
+```ts
+// controllers/PetsController
+export default class PetsController {
+  @OpenAPI(Pet, {
+    ...
+    validate: {
+      headers: true,
+      requestBody: true,
+      query: true,
+      responseBody: AppEnv.isTest,
+    }
+  })
+  public async index() {
+    ...
+  }
+}
+```
+
+This PR additionally formally introduces a new possible error type for 400 status codes, and to help distinguish, it also introduces a `type` field, which can be either `openapi` or `dream` to aid the developer in easily handling the various cases.
+
+We have made a conscious decision to render openapi errors in the exact format that ajv returns, since it empowers the developer to utilize tools which can already respond to ajv errors.
+
+For added flexibility, this PR includes the ability to provide configuration overrides for the ajv instance, as well as the ability to provide an initialization function to override ajv behavior, since much of the configuration for ajv is driven by method calls, rather than simple config.
+
+```ts
+// controllers/PetsController
+export default class PetsController {
+  @OpenAPI(Pet, {
+    ...
+    validate: {
+      ajvOptions: {
+        // this is off by default, but you will
+        // always want to keep this off in prod
+        // to avoid DoS vulnerabilities
+        allErrors: AppEnv.isTest,
+
+        // provide a custom init function to further
+        // configure your ajv instance before validating
+        init: ajv => {
+          ajv.addFormat('myFormat', {
+            type: 'string',
+            validate: data => MY_FORMAT_REGEX.test(data),
+          })
+        }
+      }
+    }
+  })
+  public async index() {
+    ...
+  }
+}
+```
+
+## 1.5.5
+
+- ensure that openapi-typescript and typescript are not required dependencies when running migrations with --skip-sync flag
+
+## 1.5.4
+
+- fix issue when providing the `including` argument exclusively to an OpenAPI decorator's `requestBody`
+
+## 1.5.3
+
+- add missing peer dependency for openapi-typescript, allow BIGINT type when generating openapi-typescript bigints
+
+## 1.5.2
+
+- ensure that bigints are converted to number | string when generating openapi-typescript type files
+
+## 1.5.1
+
+- fix issue with enum syncing related to multi-db engine support regression
+
+## 1.5.0
+
+- add support for multiple database engines in dream
+
+## 1.2.3
+
+- add support for the connectionName argument when generating a resource
+
+## 1.2.2
+
+- bump supertest and express-session to close dependabot issues [53](https://github.com/rvohealth/psychic/security/dependabot/53), [56](https://github.com/rvohealth/psychic/security/dependabot/56), and [57](https://github.com/rvohealth/psychic/security/dependabot/57)
+
+## 1.2.1
+
+- add ability to set custom import extension, which will be used when generating new files for your application
+
+## 1.2.0
+
+- update for Dream 1.4.0
+
+## 1.1.11
+
+- 400 is more appropriate than 422 for `DataTypeColumnTypeMismatch`
+
+## 1.1.10
+
+- Don't include deletedAt in generated create/update actions in resource specs since deletedAt is for deleting
+
+- return 422 if Dream throws `NotNullViolation` or `CheckConstraintViolation`
+
+## 1.1.9
+
+- return 422 if dream throws `DataTypeColumnTypeMismatch`, which happens when a dream is saved to the database with data that cannot be inserted into the respective columns, usually because of a type mismatch.
+
+- castParam will now encase params in an array when being explicitly casted as an array type, bypassing a known bug in express from causing arrays with single items in them to be treated as non-arrays.
+
+## 1.1.8
+
+- Tap into CliFileWriter provided by dream to tap into file reversion for sync files, since the auto-sync function in psychic can fail and leave your file tree in a bad state.
+
+## 1.1.7
+
+- Add support for middleware arrays, enabling express plugins like passport
+
+## 1.1.6
+
+- fix regression caused by missing --schema-only option in psychic cli
+
+## 1.1.5
+
+- pass packageManager through to dream, now that it accepts a packageManager setting.
+- update dream shadowing within psychic application initialization to take place after initializers and plugins are processed, so that those initializers and plugins have an opportunity to adjust the settings.
+
+## 1.1.4
+
+- fix regressions to redux bindings caused by default openapi path location changes
+- resource generator can handle prefixing slashes
+
+## 1.1.3
+
+- fix more minor issues with redux openapi bindings
+
+## 1.1.2
+
+- Fix various issues with openapi redux bindings
+- raise hard exception if accidentally using openapi route params in an expressjs route path
+
+## 1.1.1
+
+Fix route printing regression causing route printouts to show the path instead of the action
+
+## v1.1.0
+
+Provides easier access to express middleware by exposing `PsychicApp#use`, which enables a developer to provide express middleware directly through the psychcic application, without tapping into any hooks.
+
+```ts
+psy.use((_, res) => {
+  res.send(
+    'this will be run after psychic middleware (i.e. cors and bodyParser) are processed, but before routes are processed',
+  )
+})
+```
+
+Some middleware needs to be run before other middleware, so we expose an optional first argument which can be provided so explicitly send your middleware into express at various stages of the psychic configuration process. For example, to inject your middleware before cors and bodyParser are configured, provide `before-middleware` as the first argument. To initialize your middleware after the psychic default middleware, but before your routes have been processed, provide `after-middleware` as the first argument (or simply provide a callback function directly, since this is the default). To run after routes have been processed, provide `after-routes` as the first argument.
+
+```ts
+psy.use('before-middleware', (_, res) => {
+  res.send('this will be run before psychic has configured any default middleware')
+})
+
+psy.use('after-middleware', (_, res) => {
+  res.send('this will be run after psychic has configured default middleware')
+})
+
+psy.use('after-routes', (_, res) => {
+  res.send('this will be run after psychic has processed all the routes in your conf/routes.ts file')
+})
+```
+
+Additionally, a new overload has been added to all CRUD methods on the PsychicRouter class, enabling you to provide RequestHandler middleware directly to psychic, like so:
+
+```ts
+// conf/routes.ts
+
+r.get('helloworld', (req, res, next) => {
+  res.json({ hello: 'world' })
+})
+```

package/dist/cjs/src/bin/helpers/enumsFileStr.js

@@ -20,6 +20,7 @@ export const ${exportedTypeName} = [
             .map(val => `'${val}'`)
             .join(',\n  ')}
 ] as const
+export type ${exportedTypeName.replace(/Values^/, '')} = (typeof ${exportedTypeName})[number]
 
 `;
     });

package/dist/cjs/src/cli/helpers/PsychicLogos.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const colorize_js_1 = __importDefault(require("./colorize.js"));
+class PsychicLogos {
+    static babyAster() {
+        const g = (str) => (0, colorize_js_1.default)(str, { color: 'green' });
+        return `
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+░░░░░░█▀█░█▀▀░█░█░█▀▀░█░█░▀█▀░█▀▀░░░░░░░░░
+░░░░░░█▀▀░▀▀█░░█░░█░░░█▀█░░█░░█░░░░░░░░░░░
+░░░░░░▀░░░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░░░░░░░░
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠿⣿⣿⣿⣿⣿⣿⣿⣿⠟⢉⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⣀⡀⠈⠻⠿⡿⠿⠛⠉⠁⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠀⠀⠹⠀⠀⠀⠀⠀⠀⠀⢰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⠟⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⠿⠛⠋⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢴⣲⠀⠀⠀⠋⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⡀⠀⢀⣠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿
+⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⢸▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓
+⠀⠀⠀⠀⢠▓⣿⠀⠀⠀⣿ ⠀ ⣸⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿
+⠀⠀⠀⢠▓⣿▓⣦⠀⠀⣿▓⠀⠀⠋▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓
+⠀⠀⠀⢸⣿▓⣿▓⡄⠀⠈⠙⣄⣀⣠⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿
+⠀⠀⠀⠺▓⣿▓⣿▓⣄⣀⣤⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓⣿▓\
+`.replace(/▓/g, g('▓'));
+    }
+}
+exports.default = PsychicLogos;

package/dist/cjs/src/controller/helpers/httpMethodColor.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = httpMethodColor;
+exports.httpMethodBgColor = httpMethodBgColor;
+function httpMethodColor(httpMethod) {
+    switch (httpMethod) {
+        case 'delete':
+            return 'red';
+        case 'options':
+            return 'gray';
+        case 'patch':
+        case 'put':
+            return 'magentaBright';
+        case 'post':
+            return 'greenBright';
+        default:
+            return 'blue';
+    }
+}
+function httpMethodBgColor(httpMethod) {
+    switch (httpMethod) {
+        case 'delete':
+            return 'bgRed';
+        case 'options':
+            return 'bgWhite';
+        case 'patch':
+        case 'put':
+            return 'bgMagentaBright';
+        case 'post':
+            return 'bgGreen';
+        default:
+            return 'bgBlue';
+    }
+}

package/dist/cjs/src/controller/helpers/logIfDevelopment.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logIfDevelopment;
+const dream_1 = require("@rvoh/dream");
+const colorize_js_1 = __importDefault(require("../../cli/helpers/colorize.js"));
+const EnvInternal_js_1 = __importDefault(require("../../helpers/EnvInternal.js"));
+const httpMethodColor_js_1 = require("./httpMethodColor.js");
+const statusCodeColor_js_1 = require("./statusCodeColor.js");
+function logIfDevelopment({ req, res, startTime, fallbackStatusCode = 200, }) {
+    if (!EnvInternal_js_1.default.isDevelopment)
+        return;
+    const method = (0, colorize_js_1.default)(` ${req.method.toUpperCase()} `, {
+        color: 'black',
+        bgColor: (0, httpMethodColor_js_1.httpMethodBgColor)(req.method.toLowerCase()),
+    });
+    const computedStatus = res.statusCode || fallbackStatusCode;
+    const statusBgColor = (0, statusCodeColor_js_1.statusCodeBgColor)(computedStatus);
+    const status = (0, colorize_js_1.default)(` ${computedStatus} `, {
+        color: 'black',
+        bgColor: statusBgColor,
+    });
+    const url = (0, colorize_js_1.default)(req.url, { color: 'green' });
+    const benchmark = (0, colorize_js_1.default)(`${Date.now() - startTime}ms`, { color: 'gray' });
+    dream_1.DreamCLI.logger.log(`${method} ${url} ${status} ${benchmark}`, { logPrefix: '' });
+}

package/dist/cjs/src/controller/helpers/statusCodeColor.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = statusCodeColor;
+exports.statusCodeBgColor = statusCodeBgColor;
+function statusCodeColor(statusCode) {
+    if (statusCode >= 200 && statusCode < 300)
+        return 'green';
+    if (statusCode >= 300 && statusCode < 400)
+        return 'yellow';
+    if (statusCode >= 400 && statusCode < 500)
+        return 'red';
+    return 'redBright';
+}
+function statusCodeBgColor(statusCode) {
+    if (statusCode >= 200 && statusCode < 300)
+        return 'bgGreen';
+    if (statusCode >= 300 && statusCode < 400)
+        return 'bgYellow';
+    if (statusCode >= 400 && statusCode < 500)
+        return 'bgRed';
+    return 'bgRedBright';
+}

package/dist/cjs/src/controller/index.js

@@ -43,7 +43,9 @@ const index_js_1 = __importDefault(require("../psychic-app/index.js"));
 const params_js_1 = __importDefault(require("../server/params.js"));
 const index_js_2 = __importDefault(require("../session/index.js"));
 const isPaginatedResult_js_1 = __importDefault(require("./helpers/isPaginatedResult.js"));
+const logIfDevelopment_js_1 = __importDefault(require("./helpers/logIfDevelopment.js"));
 const renderDreamOrViewModel_js_1 = __importDefault(require("./helpers/renderDreamOrViewModel.js"));
+const EnvInternal_js_1 = __importDefault(require("../helpers/EnvInternal.js"));
 exports.PsychicParamsPrimitiveLiterals = [
     'bigint',
     'bigint[]',
@@ -177,7 +179,9 @@ class PsychicController {
     session;
     action;
     renderOpts;
+    startTime;
     constructor(req, res, { action, }) {
+        this.startTime = Date.now();
         this.req = req;
         this.res = res;
         this.session = new index_js_2.default(req, res);
@@ -428,7 +432,26 @@ class PsychicController {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     data) {
         this.validateOpenapiResponseBody(data);
-        this.res.type('json').send((0, toJson_js_1.default)(data, index_js_1.default.getOrFail().sanitizeResponseJson));
+        this.expressSendJson(data);
+    }
+    expressSendJson(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data, statusCode = this.res.statusCode) {
+        this.res.type('json').status(statusCode).send((0, toJson_js_1.default)(data, index_js_1.default.getOrFail().sanitizeResponseJson));
+        this.logIfDevelopment();
+    }
+    expressSendStatus(statusCode) {
+        this.res.sendStatus(statusCode);
+        this.logIfDevelopment();
+    }
+    expressRedirect(statusCode, newLocation) {
+        this.res.redirect(statusCode, newLocation);
+        this.logIfDevelopment();
+    }
+    logIfDevelopment() {
+        if (!EnvInternal_js_1.default.isDevelopment)
+            return;
+        (0, logIfDevelopment_js_1.default)({ req: this.req, res: this.res, startTime: this.startTime });
     }
     defaultSerializerPassthrough = {};
     serializerPassthrough(passthrough) {
@@ -475,15 +498,15 @@ class PsychicController {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     nonAuthoritativeInformation(message = undefined) {
         if (message) {
-            this.res.status(203).json(message);
+            this.expressSendJson(message, 203);
         }
         else {
-            this.res.sendStatus(203);
+            this.expressSendStatus(203);
         }
     }
     // 204
     noContent() {
-        this.res.sendStatus(204);
+        this.expressSendStatus(204);
     }
     // 205
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -499,27 +522,23 @@ class PsychicController {
     }
     // 301
     movedPermanently(newLocation) {
-        this.res.redirect(301, newLocation);
+        this.expressRedirect(301, newLocation);
     }
     // 302
     found(newLocation) {
-        this.res.redirect(302, newLocation);
+        this.expressRedirect(302, newLocation);
     }
     // 303
     seeOther(newLocation) {
-        this.res.redirect(303, newLocation);
-    }
-    // 304
-    notModified(newLocation) {
-        this.res.redirect(304, newLocation);
+        this.expressRedirect(303, newLocation);
     }
     // 307
     temporaryRedirect(newLocation) {
-        this.res.redirect(307, newLocation);
+        this.expressRedirect(307, newLocation);
     }
     // 308
     permanentRedirect(newLocation) {
-        this.res.redirect(308, newLocation);
+        this.expressRedirect(308, newLocation);
     }
     // 400
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -474,6 +474,8 @@ class OpenapiEndpointRenderer {
             return true;
         if (body.including)
             return true;
+        if (body.combining)
+            return true;
         if (body.for)
             return true;
         if (body.required && body.type !== 'object')
@@ -494,12 +496,16 @@ class OpenapiEndpointRenderer {
         const dreamClass = forDreamClass || this.getSingleDreamModelClass();
         if (!dreamClass)
             return this.defaultRequestBody();
-        const { only, including } = (this.requestBody || {});
+        const { only, including, combining } = (this.requestBody || {});
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const paramSafeColumns = (0, paramNamesForDreamClass_js_1.default)(dreamClass, { only, including });
         const paramsShape = {
             type: 'object',
-            properties: {},
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            properties: {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ...(combining || {}),
+            },
         };
         const required = this.requestBody?.required;
         if (required) {

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

@@ -54,7 +54,7 @@ function dreamColumnOpenapiShape(dreamClass, column, openapi = undefined, { supp
     }
     // 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);
+    const singleType = singularAttributeOpenapiShape(dreamColumnInfo, suppressResponseEnums, openapiObject);
     if (dreamColumnInfo.isArray) {
         return {
             type: dreamColumnInfo.allowNull ? ['array', 'null'] : 'array',
@@ -66,31 +66,32 @@ function dreamColumnOpenapiShape(dreamClass, column, openapi = undefined, { supp
         const existingType = dreamColumnInfo.allowNull
             ? [singleType.type, 'null']
             : singleType.type;
-        return {
+        const returnObj = {
             ...singleType,
             type: existingType,
             ...openapiObject,
         };
+        if (suppressResponseEnums)
+            delete returnObj['enum'];
+        return returnObj;
     }
 }
 function baseDbType(dreamColumnInfo) {
     return dreamColumnInfo.dbType.replace('[]', '');
 }
-function singularAttributeOpenapiShape(dreamColumnInfo, suppressResponseEnums) {
+function singularAttributeOpenapiShape(dreamColumnInfo, suppressResponseEnums, openapiSchema) {
     if (dreamColumnInfo.enumValues) {
+        const enumOverrides = openapiSchema.enum || dreamColumnInfo.enumValues;
         if (suppressResponseEnums) {
             return {
                 type: 'string',
-                description: `The following values will be allowed:\n  ${dreamColumnInfo.enumValues.join(',\n  ')}`,
+                description: `The following values will be allowed:\n  ${enumOverrides.join(',\n  ')}`,
             };
         }
         else {
             return {
                 type: 'string',
-                enum: [
-                    ...dreamColumnInfo.enumValues,
-                    ...(dreamColumnInfo.allowNull && !dreamColumnInfo.isArray ? [null] : []),
-                ],
+                enum: [...enumOverrides, ...(dreamColumnInfo.allowNull && !dreamColumnInfo.isArray ? [null] : [])],
             };
         }
     }