@rvoh/psychic 3.0.0-alpha.8 → 3.0.1

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

@@ -197,7 +197,10 @@ export default class PsychicController {
         };
     }
     /**
-     * Gets the HTTP request headers from the Express request object.
+     * Gets the HTTP request headers from the Koa ctx object.
+     * We recommend using the #header method instead when looking
+     * to retreive the value for a specific header, since that method
+     * will be safe with regards to case sensitivity.
      *
      * @returns The request headers as a key-value object where header names are lowercase strings
      * and values can be strings, string arrays, or undefined.
@@ -216,6 +219,16 @@ export default class PsychicController {
     get headers() {
         return this.ctx.request.headers;
     }
+    /**
+     * returns the value for the requested header. This method is case insensitive.
+     * If the header requested is not found, a blank string is returned.
+     *
+     * @param headerName - the name of the header
+     * @returns string
+     */
+    header(headerName) {
+        return this.ctx.request.get(headerName);
+    }
     /**
      * Gets the combined parameters from the HTTP request. This includes URL parameters,
      * request body, and query string parameters merged together. The merge order is:
@@ -796,7 +809,7 @@ export default class PsychicController {
      * ```
      */
     redirect(path) {
-        this.ctx.redirect(path);
+        this.koaRedirect(302, path);
     }
     // begin: http status codes
     /**

package/dist/esm/src/generate/controller.js

@@ -20,9 +20,9 @@ export default async function generateController({ fullyQualifiedControllerName,
     const allControllerNameParts = fullyQualifiedControllerName.split('/');
     const forAdmin = allControllerNameParts[0] === 'Admin';
     const forInternal = allControllerNameParts[0] === 'Internal';
-    const controllerNameParts = (forAdmin || forInternal) ? [allControllerNameParts.shift()] : [];
+    const controllerNameParts = forAdmin || forInternal ? [allControllerNameParts.shift()] : [];
     for (let index = 0; index < allControllerNameParts.length; index++) {
-        if (controllerNameParts.length > ((forAdmin || forInternal) ? 1 : 0)) {
+        if (controllerNameParts.length > (forAdmin || forInternal ? 1 : 0)) {
             // Write the ancestor controller
             const [baseAncestorName, baseAncestorImportStatement] = baseAncestorNameAndImport(controllerNameParts, forAdmin, forInternal, { forBaseController: true });
             if (baseAncestorName === undefined)
@@ -97,7 +97,7 @@ export default async function generateController({ fullyQualifiedControllerName,
 function baseAncestorNameAndImport(controllerNameParts, forAdmin, forInternal, { forBaseController }) {
     const maybeAncestorNameForBase = `${controllerNameParts.slice(0, controllerNameParts.length - 1).join('')}BaseController`;
     const dotFiles = forBaseController ? '..' : '.';
-    return controllerNameParts.length === ((forAdmin || forInternal) ? 2 : 1)
+    return controllerNameParts.length === (forAdmin || forInternal ? 2 : 1)
         ? forAdmin
             ? [
                 `AdminAuthedController`,

package/dist/esm/src/generate/helpers/generateResourceControllerSpecContent.js

@@ -124,6 +124,7 @@ function processAttributeByType({ attributeType, attributeName, isArray, enumVal
         case 'string':
         case 'text':
         case 'citext':
+        case 'encrypted':
             processStringAttribute({
                 attributeName,
                 isArray,
@@ -267,7 +268,7 @@ function generateIndexActionSpec(options) {
     if (options.actionConfig.omitIndex)
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, singular } = options;
-    const subjectFunctionName = `index${pluralize(modelConfig.modelClassName)}`;
+    const subjectFunctionName = 'index';
     return `
 
   describe('GET index', () => {
@@ -304,7 +305,7 @@ function generateShowActionSpec(options) {
     if (options.actionConfig.omitShow)
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, attributeData } = options;
-    const subjectFunctionName = `show${modelConfig.modelClassName}`;
+    const subjectFunctionName = 'show';
     const subjectFunction = singular
         ? `
     const ${subjectFunctionName} = async <StatusCode extends 200 | 400 | 404>(expectedStatus: StatusCode) => {
@@ -345,7 +346,7 @@ function generateCreateActionSpec(options) {
     if (options.actionConfig.omitCreate)
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, attributeData } = options;
-    const subjectFunctionName = `create${modelConfig.modelClassName}`;
+    const subjectFunctionName = 'create';
     const uuidSetup = attributeData.uuidAttributes
         .map(attrName => {
         const isArray = attributeData.uuidArrayAttributes.includes(attrName);
@@ -396,7 +397,7 @@ function generateUpdateActionSpec(options) {
     if (options.actionConfig.omitUpdate)
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, singular, attributeData } = options;
-    const subjectFunctionName = `update${modelConfig.modelClassName}`;
+    const subjectFunctionName = 'update';
     const uuidSetup = attributeData.uuidAttributes
         .map(attrName => {
         const isArray = attributeData.uuidArrayAttributes.includes(attrName);
@@ -491,7 +492,7 @@ function generateDestroyActionSpec(options) {
     if (options.actionConfig.omitDestroy)
         return '';
     const { path, pathParams, modelConfig, fullyQualifiedModelName, singular } = options;
-    const subjectFunctionName = `destroy${modelConfig.modelClassName}`;
+    const subjectFunctionName = 'destroy';
     const subjectFunction = singular
         ? `
     const ${subjectFunctionName} = async <StatusCode extends 204 | 400 | 404>(expectedStatus: StatusCode) => {

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

@@ -310,7 +310,6 @@ export default class OpenapiSegmentExpander {
         }
         let referencedSerializers = [];
         if (objectBodySegment.additionalProperties === false) {
-            ;
             data.additionalProperties = false;
         }
         else if (objectBodySegment.additionalProperties) {

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

@@ -9,11 +9,9 @@ import PsychicApp from '../psychic-app/index.js';
 import openapiParamNamesForDreamClass from '../server/helpers/openapiParamNamesForDreamClass.js';
 import OpenapiSegmentExpander from './body-segment.js';
 import { DEFAULT_OPENAPI_RESPONSES } from './defaults.js';
-import cursorPaginationParamOpenapiProperty from './helpers/cursorPaginationParamOpenapiProperty.js';
 import { dreamColumnOpenapiShape } from './helpers/dreamColumnOpenapiShape.js';
 import openapiOpts from './helpers/openapiOpts.js';
 import openapiRoute from './helpers/openapiRoute.js';
-import paginationPageParamOpenapiProperty from './helpers/paginationPageParamOpenapiProperty.js';
 import safelyAttachCursorPaginationParamToRequestBodySegment from './helpers/safelyAttachCursorPaginationParamToRequestBodySegment.js';
 import safelyAttachPaginationParamToRequestBodySegment from './helpers/safelyAttachPaginationParamsToBodySegment.js';
 import SerializerOpenapiRenderer from './SerializerOpenapiRenderer.js';
@@ -464,37 +462,23 @@ export default class OpenapiEndpointRenderer {
     defaultRequestBody() {
         const bodyPaginationPageParam = this.paginate?.body;
         const bodyCursorPaginationParam = this.cursorPaginate?.body ?? this.scrollPaginate?.body;
+        const paramName = bodyPaginationPageParam || bodyCursorPaginationParam;
+        if (!paramName)
+            return undefined;
+        let schema = undefined;
         if (bodyPaginationPageParam) {
-            return {
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            properties: {
-                                [bodyPaginationPageParam]: paginationPageParamOpenapiProperty(),
-                            },
-                        },
-                    },
-                },
-            };
+            schema = safelyAttachPaginationParamToRequestBodySegment(bodyPaginationPageParam, schema);
         }
         else if (bodyCursorPaginationParam) {
-            return {
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            properties: {
-                                [bodyCursorPaginationParam]: cursorPaginationParamOpenapiProperty(),
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            },
-                        },
-                    },
-                },
-            };
+            schema = safelyAttachCursorPaginationParamToRequestBodySegment(bodyCursorPaginationParam, schema);
         }
-        return undefined;
+        return {
+            content: {
+                'application/json': {
+                    schema: schema,
+                },
+            },
+        };
     }
     /**
      * @internal

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

@@ -1,8 +1,9 @@
 import cursorPaginationParamOpenapiProperty from './cursorPaginationParamOpenapiProperty.js';
+import { safelyAttachParamToRequestBodySegment } from './safelyAttachPaginationParamsToBodySegment.js';
 /**
  * @internal
  *
- * Used to carefully bind implicit pagination params
+ * Used to carefully bind implicit cursor pagination params
  * to the requestBody properties. It will not apply
  * the pagination param unless the provided bodySegment
  * is:
@@ -14,18 +15,5 @@ import cursorPaginationParamOpenapiProperty from './cursorPaginationParamOpenapi
  * what was given to it, without any modifications
  */
 export default function safelyAttachCursorPaginationParamToRequestBodySegment(paramName, bodySegment) {
-    bodySegment ||= {
-        type: 'object',
-        properties: {},
-    };
-    if (bodySegment.type === 'object') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        ;
-        bodySegment.properties = {
-            ...bodySegment.properties,
-            [paramName]: cursorPaginationParamOpenapiProperty(),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        };
-    }
-    return bodySegment;
+    return safelyAttachParamToRequestBodySegment(paramName, cursorPaginationParamOpenapiProperty(), bodySegment);
 }

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

@@ -14,15 +14,28 @@ import paginationPageParamOpenapiProperty from './paginationPageParamOpenapiProp
  * what was given to it, without any modifications
  */
 export default function safelyAttachPaginationParamToRequestBodySegment(paramName, bodySegment) {
+    return safelyAttachParamToRequestBodySegment(paramName, paginationPageParamOpenapiProperty(), bodySegment);
+}
+/**
+ * @internal
+ *
+ * Generic version: attaches any OpenAPI property definition to a body segment.
+ */
+export function safelyAttachParamToRequestBodySegment(paramName, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+property, bodySegment) {
     bodySegment ||= {
         type: 'object',
         properties: {},
     };
     if (bodySegment.type === 'object') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         ;
         bodySegment.properties = {
             ...bodySegment.properties,
-            [paramName]: paginationPageParamOpenapiProperty(),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            [paramName]: property,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         };
     }
     return bodySegment;

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

@@ -58,13 +58,14 @@ function inferControllerOrFail(filteredNamespaces, opts) {
         });
     return controller;
 }
-export function applyResourcesAction(path, action, routingMechanism, options) {
+export function applyResourcefulAction(path, action, routingMechanism, options, plural) {
     const controller = options?.controller ||
         lookupControllerOrFail(routingMechanism, {
             path: action,
             httpMethod: httpMethodFromResourcefulAction(action),
             resourceName: path,
         });
+    const memberPath = plural ? `${path}/:id` : path;
     switch (action) {
         case 'index':
             routingMechanism.get(path, controller, 'index');
@@ -73,41 +74,24 @@ export function applyResourcesAction(path, action, routingMechanism, options) {
             routingMechanism.post(path, controller, 'create');
             break;
         case 'update':
-            routingMechanism.put(`${path}/:id`, controller, 'update');
-            routingMechanism.patch(`${path}/:id`, controller, 'update');
+            routingMechanism.put(memberPath, controller, 'update');
+            routingMechanism.patch(memberPath, controller, 'update');
             break;
         case 'show':
-            routingMechanism.get(`${path}/:id`, controller, 'show');
+            routingMechanism.get(memberPath, controller, 'show');
             break;
         case 'destroy':
-            routingMechanism.delete(`${path}/:id`, controller, 'destroy');
+            routingMechanism.delete(memberPath, controller, 'destroy');
             break;
     }
 }
+/** @deprecated Use applyResourcefulAction with plural parameter instead */
+export function applyResourcesAction(path, action, routingMechanism, options) {
+    return applyResourcefulAction(path, action, routingMechanism, options, true);
+}
+/** @deprecated Use applyResourcefulAction with plural parameter instead */
 export function applyResourceAction(path, action, routingMechanism, options) {
-    const controller = options?.controller ||
-        lookupControllerOrFail(routingMechanism, {
-            path: action,
-            httpMethod: httpMethodFromResourcefulAction(action),
-            resourceName: path,
-        });
-    switch (action) {
-        case 'create':
-            routingMechanism.post(path, controller, 'create');
-            break;
-        case 'update':
-            routingMechanism.put(path, controller, 'update');
-            routingMechanism.patch(path, controller, 'update');
-            break;
-        case 'show':
-            routingMechanism.get(path, controller, 'show');
-            break;
-        case 'destroy':
-            routingMechanism.delete(path, controller, 'destroy');
-            break;
-        default:
-            throw new Error(`unsupported resource method type: ${action}`);
-    }
+    return applyResourcefulAction(path, action, routingMechanism, options, false);
 }
 /**
  * Converts OpenAPI-style route parameters to Express.js-style parameters

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

@@ -10,7 +10,7 @@ import CannotCommitRoutesWithoutKoaApp from '../error/router/cannot-commit-route
 import EnvInternal from '../helpers/EnvInternal.js';
 import errorIsRescuableHttpError from '../helpers/error/errorIsRescuableHttpError.js';
 import PsychicApp from '../psychic-app/index.js';
-import { applyResourceAction, applyResourcesAction, convertRouteParams, lookupControllerOrFail, routePath, } from '../router/helpers.js';
+import { applyResourcefulAction, convertRouteParams, lookupControllerOrFail, routePath, } from '../router/helpers.js';
 import RouteManager from './route-manager.js';
 import { ResourceMethods, ResourcesMethods, } from './types.js';
 const ERROR_LOGGING_DEPTH = 6;
@@ -170,12 +170,7 @@ suggested fix:  "${convertRouteParams(path)}"
         this.runNestedCallbacks(path, nestedRouter, cb, { asMember: plural, resourceful: true });
         this.currentNamespaces = originalCurrentNamespaces;
         resourceMethods.forEach(action => {
-            if (plural) {
-                applyResourcesAction(path, action, nestedRouter, options);
-            }
-            else {
-                applyResourceAction(path, action, nestedRouter, options);
-            }
+            applyResourcefulAction(path, action, nestedRouter, options, plural);
         });
     }
     runNestedCallbacks(namespace, nestedRouter, cb, { asMember = false, resourceful = false, treatNamespaceAsScope = false, } = {}) {

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

@@ -48,97 +48,31 @@ export default class Params {
                 continue;
             const columnMetadata = columns[columnName];
             try {
-                switch (columnMetadata?.dbType) {
-                    case 'bigint':
-                    case 'bigint[]':
-                    case 'boolean':
-                    case 'boolean[]':
-                    case 'date':
-                    case 'date[]':
-                    case 'integer':
-                    case 'integer[]':
-                    case 'uuid':
-                    case 'uuid[]':
-                    case 'json':
-                    case 'json[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), columnMetadata.dbType, { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'character varying':
-                    case 'citext':
-                    case 'text':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'string', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'character varying[]':
-                    case 'citext[]':
-                    case 'text[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'string[]', {
+                const castType = DB_TYPE_TO_CAST_TYPE[columnMetadata?.dbType];
+                if (castType) {
+                    returnObj[columnName] = this.cast(params, columnName.toString(), castType, { allowNull: columnMetadata.allowNull });
+                }
+                else if (dreamClass.isVirtualColumn(columnName)) {
+                    returnObj[columnName] = params[columnName];
+                }
+                else if (columnMetadata?.enumValues) {
+                    const paramValue = params[columnName];
+                    if (columnMetadata.isArray) {
+                        if (!Array.isArray(paramValue))
+                            returnObj[columnName] = ['expected an array of enum values'];
+                        returnObj[columnName] = paramValue.map(p => {
+                            return new this(params).cast(columnName.toString(), p, 'string', {
+                                allowNull: columnMetadata.allowNull,
+                                enum: columnMetadata.enumValues,
+                            });
+                        });
+                    }
+                    else {
+                        returnObj[columnName] = this.cast(params, columnName.toString(), 'string', {
                             allowNull: columnMetadata.allowNull,
+                            enum: columnMetadata.enumValues,
                         });
-                        break;
-                    case 'timestamp':
-                    case 'timestamp with time zone':
-                    case 'timestamp without time zone':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'datetime', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'timestamp[]':
-                    case 'timestamp with time zone[]':
-                    case 'timestamp without time zone[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'datetime[]', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'time':
-                    case 'time without time zone':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'time', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'time[]':
-                    case 'time without time zone[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'time[]', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'timetz':
-                    case 'time with time zone':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'timetz', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'timetz[]':
-                    case 'time with time zone[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'timetz[]', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'jsonb':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'json', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'jsonb[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'json[]', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'numeric':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'number', { allowNull: columnMetadata.allowNull });
-                        break;
-                    case 'numeric[]':
-                        returnObj[columnName] = this.cast(params, columnName.toString(), 'number[]', { allowNull: columnMetadata.allowNull });
-                        break;
-                    default:
-                        if (dreamClass.isVirtualColumn(columnName))
-                            returnObj[columnName] = params[columnName];
-                        if (columnMetadata?.enumValues) {
-                            const paramValue = params[columnName];
-                            if (columnMetadata.isArray) {
-                                if (!Array.isArray(paramValue))
-                                    returnObj[columnName] = ['expected an array of enum values'];
-                                returnObj[columnName] = paramValue.map(p => {
-                                    return new this(params).cast(columnName.toString(), p, 
-                                    // casting to allow enum handling at lower level
-                                    'string', {
-                                        allowNull: columnMetadata.allowNull,
-                                        enum: columnMetadata.enumValues,
-                                    });
-                                });
-                            }
-                            else {
-                                returnObj[columnName] = this.cast(params, columnName.toString(), 
-                                // casting to allow enum handling at lower level
-                                'string', {
-                                    allowNull: columnMetadata.allowNull,
-                                    enum: columnMetadata.enumValues,
-                                });
-                            }
-                        }
+                    }
                 }
             }
             catch (err) {
@@ -402,6 +336,54 @@ export default class Params {
         throw new ParamValidationError(paramName, [message]);
     }
 }
+/**
+ * Maps PostgreSQL database column types to Psychic cast types.
+ * Used by Params.for() to determine how to validate and cast each column value.
+ */
+const DB_TYPE_TO_CAST_TYPE = {
+    // identity mappings (db type matches cast type)
+    bigint: 'bigint',
+    'bigint[]': 'bigint[]',
+    boolean: 'boolean',
+    'boolean[]': 'boolean[]',
+    date: 'date',
+    'date[]': 'date[]',
+    integer: 'integer',
+    'integer[]': 'integer[]',
+    uuid: 'uuid',
+    'uuid[]': 'uuid[]',
+    json: 'json',
+    'json[]': 'json[]',
+    // text variants → string
+    'character varying': 'string',
+    citext: 'string',
+    text: 'string',
+    'character varying[]': 'string[]',
+    'citext[]': 'string[]',
+    'text[]': 'string[]',
+    // timestamp variants → datetime
+    timestamp: 'datetime',
+    'timestamp with time zone': 'datetime',
+    'timestamp without time zone': 'datetime',
+    'timestamp[]': 'datetime[]',
+    'timestamp with time zone[]': 'datetime[]',
+    'timestamp without time zone[]': 'datetime[]',
+    // time variants
+    time: 'time',
+    'time without time zone': 'time',
+    'time[]': 'time[]',
+    'time without time zone[]': 'time[]',
+    timetz: 'timetz',
+    'time with time zone': 'timetz',
+    'timetz[]': 'timetz[]',
+    'time with time zone[]': 'timetz[]',
+    // jsonb → json
+    jsonb: 'json',
+    'jsonb[]': 'json[]',
+    // numeric → number
+    numeric: 'number',
+    'numeric[]': 'number[]',
+};
 const typeToErrorMap = {
     bigint: 'expected bigint',
     boolean: 'expected boolean',

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

@@ -111,7 +111,10 @@ export default class PsychicController {
         action: string;
     });
     /**
-     * Gets the HTTP request headers from the Express request object.
+     * Gets the HTTP request headers from the Koa ctx object.
+     * We recommend using the #header method instead when looking
+     * to retreive the value for a specific header, since that method
+     * will be safe with regards to case sensitivity.
      *
      * @returns The request headers as a key-value object where header names are lowercase strings
      * and values can be strings, string arrays, or undefined.
@@ -128,6 +131,14 @@ export default class PsychicController {
      * ```
      */
     get headers(): import("http").IncomingHttpHeaders;
+    /**
+     * returns the value for the requested header. This method is case insensitive.
+     * If the header requested is not found, a blank string is returned.
+     *
+     * @param headerName - the name of the header
+     * @returns string
+     */
+    header(headerName: string): string;
     /**
      * Gets the combined parameters from the HTTP request. This includes URL parameters,
      * request body, and query string parameters merged together. The merge order is:

package/dist/types/src/openapi-renderer/helpers/safelyAttachCursorPaginationParamToRequestBodySegment.d.ts

@@ -1,7 +1,7 @@
 /**
  * @internal
  *
- * Used to carefully bind implicit pagination params
+ * Used to carefully bind implicit cursor pagination params
  * to the requestBody properties. It will not apply
  * the pagination param unless the provided bodySegment
  * is:

package/dist/types/src/openapi-renderer/helpers/safelyAttachPaginationParamsToBodySegment.d.ts

@@ -13,3 +13,9 @@
  * what was given to it, without any modifications
  */
 export default function safelyAttachPaginationParamToRequestBodySegment<T>(paramName: string, bodySegment: T): T;
+/**
+ * @internal
+ *
+ * Generic version: attaches any OpenAPI property definition to a body segment.
+ */
+export declare function safelyAttachParamToRequestBodySegment<T>(paramName: string, property: any, bodySegment: T): T;

package/dist/types/src/router/helpers.d.ts

@@ -21,7 +21,10 @@ export interface NamespaceConfig {
     resourceful: boolean;
     isScope: boolean;
 }
+export declare function applyResourcefulAction(path: string, action: ResourcesMethodType, routingMechanism: RoutingMechanism, options?: ResourcesOptions, plural?: boolean): void;
+/** @deprecated Use applyResourcefulAction with plural parameter instead */
 export declare function applyResourcesAction(path: string, action: ResourcesMethodType, routingMechanism: RoutingMechanism, options?: ResourcesOptions): void;
+/** @deprecated Use applyResourcefulAction with plural parameter instead */
 export declare function applyResourceAction(path: string, action: ResourcesMethodType, routingMechanism: RoutingMechanism, options?: ResourcesOptions): void;
 /**
  * Converts OpenAPI-style route parameters to Express.js-style parameters