adorn-api 1.1.11 → 1.1.13

package/README.md

@@ -639,6 +639,24 @@ export class UserController {
 
 The `listConfig` object contains: `filterMappings`, `sortableColumns`, `defaultSortBy`, `defaultSortDirection`, `defaultPageSize`, `maxPageSize`, `sortByKey`, and `sortDirectionKey`.
 
+### Type-Only Query Interfaces
+
+For consumer projects that need pure TypeScript interfaces (without creating extra DTO classes), Adorn exports:
+- `PaginationQueryParams`
+- `SortingQueryParams`
+- `PagedQueryParams`
+
+```typescript
+import type { PagedQueryParams } from "adorn-api";
+
+interface CaixaEntradaQueryDto extends PagedQueryParams {
+  usuarioId?: number;
+  lido?: boolean;
+}
+```
+
+`sortDirection` is the official typed sort field (`"asc" | "desc"`). `sortOrder` remains parser compatibility for legacy/external clients.
+
 ### `BaseService.list` Before/After (Boilerplate Reduction)
 
 Before:

package/dist/adapter/express/types.d.ts

@@ -1,53 +1,10 @@
-import type { Request, Response } from "express";
-import type { Constructor } from "../../core/types";
+import type { Constructor, RequestContext as CoreRequestContext, UploadedFileInfo } from "../../core/types";
 import type { OpenApiInfo, OpenApiServer } from "../../core/openapi";
-import type { SseEmitter, StreamWriter } from "../../core/streaming";
-/**
- * Uploaded file information from multipart form data.
- */
-export interface UploadedFileInfo {
-    /** Original filename as provided by the client */
-    originalName: string;
-    /** MIME type of the file */
-    mimeType: string;
-    /** Size of the file in bytes */
-    size: number;
-    /** File buffer (when using memory storage) */
-    buffer?: Buffer;
-    /** Path to the file on disk (when using disk storage) */
-    path?: string;
-    /** Field name from the form */
-    fieldName: string;
-}
+export { UploadedFileInfo };
 /**
  * Request context provided to route handlers.
  */
-export interface RequestContext<TBody = unknown, TQuery extends object | undefined = Record<string, unknown>, TParams extends object | undefined = Record<string, string | number | boolean | undefined>, THeaders extends object | undefined = Record<string, string | string[] | undefined>, TFiles extends Record<string, UploadedFileInfo | UploadedFileInfo[]> | undefined = undefined> {
-    /** Express request object */
-    req: Request;
-    /** Express response object */
-    res: Response;
-    /** Parsed request body */
-    body: TBody;
-    /** Parsed query parameters */
-    query: TQuery;
-    /** Parsed path parameters */
-    params: TParams;
-    /** Request headers */
-    headers: THeaders;
-    /** Uploaded files (when using multipart handling) */
-    files: TFiles;
-    /**
-     * Server-Sent Events emitter for streaming events to client.
-     * Only available on routes marked with @Sse decorator.
-     */
-    sse?: SseEmitter;
-    /**
-     * Stream writer for streaming responses.
-     * Available on routes marked with @Streaming or @Sse decorator.
-     */
-    stream?: StreamWriter;
-}
+export type RequestContext<TBody = any, TQuery extends object | undefined = Record<string, any>, TParams extends object | undefined = Record<string, any>, THeaders extends object | undefined = Record<string, any>, TFiles extends Record<string, UploadedFileInfo | UploadedFileInfo[]> | undefined = any> = CoreRequestContext<TBody, TQuery, TParams, THeaders, TFiles>;
 /**
  * Input coercion modes.
  */

package/dist/adapter/fastify/coercion.d.ts

@@ -0,0 +1,12 @@
+import { type InputMeta } from "../../core/metadata";
+import type { InputCoercionMode } from "./types";
+export type InputLocation = "params" | "query" | "body";
+interface CoerceInputOptions {
+    mode: InputCoercionMode;
+    location: InputLocation;
+}
+/**
+ * Creates an input coercer function for the given input metadata.
+ */
+export declare function createInputCoercer<T extends Record<string, unknown> = Record<string, unknown>>(input: InputMeta | undefined, options: CoerceInputOptions): ((value: T) => T) | undefined;
+export {};

package/dist/adapter/fastify/coercion.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInputCoercer = createInputCoercer;
+const metadata_1 = require("../../core/metadata");
+const coerce_1 = require("../../core/coerce");
+const errors_1 = require("../../core/errors");
+/**
+ * Creates an input coercer function for the given input metadata.
+ */
+function createInputCoercer(input, options) {
+    if (!input) {
+        return undefined;
+    }
+    const fields = extractFields(input.schema);
+    if (!fields.length) {
+        return undefined;
+    }
+    return (value) => {
+        const result = coerceRecord(value, fields, options.mode);
+        if (options.mode === "strict" && result.invalidFields.length) {
+            throw new errors_1.HttpError(400, buildInvalidMessage(options.location, result.invalidFields));
+        }
+        return result.value;
+    };
+}
+function coerceRecord(value, fields, mode) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { value, invalidFields: [] };
+    }
+    const input = value;
+    let changed = false;
+    const output = { ...input };
+    const invalidFields = [];
+    for (const field of fields) {
+        if (!(field.name in input)) {
+            continue;
+        }
+        const original = input[field.name];
+        const result = coerceValue(original, field.schema, mode);
+        if (!result.ok && mode === "strict") {
+            invalidFields.push(field.name);
+        }
+        if (result.changed) {
+            output[field.name] = result.value;
+            changed = true;
+        }
+    }
+    return { value: changed ? output : value, invalidFields };
+}
+function coerceValue(value, schema, mode) {
+    switch (schema.kind) {
+        case "integer":
+            return coerceNumber(value, schema, true);
+        case "number":
+            return coerceNumber(value, schema, false);
+        case "boolean": {
+            return coerceBoolean(value);
+        }
+        case "string": {
+            return coerceString(value, schema);
+        }
+        case "array":
+            return coerceArrayValue(value, schema, mode);
+        case "object":
+            return coerceObjectValue(value, schema, mode);
+        case "record":
+            return coerceRecordValue(value, schema, mode);
+        case "ref":
+            return coerceRefValue(value, schema, mode);
+        case "union":
+            return coerceUnionValue(value, schema, mode);
+        default:
+            return { value, ok: true, changed: false };
+    }
+}
+function coerceNumber(value, schema, integer) {
+    if (!isPresent(value)) {
+        return { value, ok: true, changed: false };
+    }
+    const parsed = integer
+        ? coerce_1.coerce.integer(value, { min: schema.minimum, max: schema.maximum })
+        : coerce_1.coerce.number(value, { min: schema.minimum, max: schema.maximum });
+    if (parsed === undefined) {
+        return { value, ok: false, changed: false };
+    }
+    if (schema.exclusiveMinimum !== undefined && parsed <= schema.exclusiveMinimum) {
+        return { value, ok: false, changed: false };
+    }
+    if (schema.exclusiveMaximum !== undefined && parsed >= schema.exclusiveMaximum) {
+        return { value, ok: false, changed: false };
+    }
+    return { value: parsed, ok: true, changed: parsed !== value };
+}
+function coerceBoolean(value) {
+    if (!isPresent(value)) {
+        return { value, ok: true, changed: false };
+    }
+    const parsed = coerce_1.coerce.boolean(value);
+    if (parsed === undefined) {
+        return { value, ok: false, changed: false };
+    }
+    return { value: parsed, ok: true, changed: parsed !== value };
+}
+function coerceString(value, schema) {
+    if (!isPresent(value)) {
+        return { value, ok: true, changed: false };
+    }
+    if (schema.format === "date" || schema.format === "date-time") {
+        const parsed = parseDateValue(value);
+        if (!parsed) {
+            return { value, ok: false, changed: false };
+        }
+        return { value: parsed, ok: true, changed: parsed !== value };
+    }
+    const parsed = coerce_1.coerce.string(value);
+    if (parsed === undefined) {
+        return { value, ok: true, changed: false };
+    }
+    return { value: parsed, ok: true, changed: parsed !== value };
+}
+function parseDateValue(value) {
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : value;
+    }
+    const text = coerce_1.coerce.string(value);
+    if (text === undefined) {
+        return undefined;
+    }
+    const parsed = new Date(text);
+    if (Number.isNaN(parsed.getTime())) {
+        return undefined;
+    }
+    return parsed;
+}
+function coerceArrayValue(value, schema, mode) {
+    if (value === undefined || value === null) {
+        return { value, ok: true, changed: false };
+    }
+    let input;
+    let changed;
+    if (Array.isArray(value)) {
+        input = value;
+        changed = false;
+    }
+    else if (typeof value === "string" && value.includes(",")) {
+        input = value.split(",").map((s) => s.trim());
+        changed = true;
+    }
+    else {
+        input = [value];
+        changed = true;
+    }
+    let ok = true;
+    const output = input.map((entry) => {
+        const result = coerceValue(entry, schema.items, mode);
+        if (!result.ok) {
+            ok = false;
+        }
+        if (result.changed) {
+            changed = true;
+        }
+        return result.value;
+    });
+    return { value: changed ? output : value, ok, changed };
+}
+function coerceObjectValue(value, schema, mode) {
+    if (value === undefined || value === null) {
+        return { value, ok: true, changed: false };
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return { value, ok: mode === "safe", changed: false };
+    }
+    const properties = schema.properties ?? {};
+    const fields = Object.entries(properties).map(([name, fieldSchema]) => ({
+        name,
+        schema: fieldSchema
+    }));
+    if (!fields.length) {
+        return { value, ok: true, changed: false };
+    }
+    const result = coerceRecord(value, fields, mode);
+    return {
+        value: result.value,
+        ok: result.invalidFields.length === 0,
+        changed: result.value !== value
+    };
+}
+function coerceRecordValue(value, schema, mode) {
+    if (value === undefined || value === null) {
+        return { value, ok: true, changed: false };
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return { value, ok: mode === "safe", changed: false };
+    }
+    const input = value;
+    let changed = false;
+    let ok = true;
+    const output = { ...input };
+    for (const [key, entry] of Object.entries(input)) {
+        const result = coerceValue(entry, schema.values, mode);
+        if (!result.ok) {
+            ok = false;
+        }
+        if (result.changed) {
+            output[key] = result.value;
+            changed = true;
+        }
+    }
+    return { value: changed ? output : value, ok, changed };
+}
+function coerceRefValue(value, schema, mode) {
+    if (value === undefined || value === null) {
+        return { value, ok: true, changed: false };
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return { value, ok: mode === "safe", changed: false };
+    }
+    const meta = getDtoMetaSafe(schema.dto);
+    const fields = Object.entries(meta.fields).map(([name, field]) => ({
+        name,
+        schema: field.schema
+    }));
+    if (!fields.length) {
+        return { value, ok: true, changed: false };
+    }
+    const result = coerceRecord(value, fields, mode);
+    return {
+        value: result.value,
+        ok: result.invalidFields.length === 0,
+        changed: result.value !== value
+    };
+}
+function coerceUnionValue(value, schema, mode) {
+    let fallback;
+    for (const option of schema.anyOf) {
+        const result = coerceValue(value, option, mode);
+        if (!result.ok) {
+            continue;
+        }
+        if (result.changed) {
+            return result;
+        }
+        fallback ??= result;
+    }
+    if (fallback) {
+        return fallback;
+    }
+    return { value, ok: mode === "safe", changed: false };
+}
+function extractFields(schema) {
+    if (isSchemaNode(schema)) {
+        if (schema.kind === "object" && schema.properties) {
+            return Object.entries(schema.properties).map(([name, fieldSchema]) => ({
+                name,
+                schema: fieldSchema
+            }));
+        }
+        return [];
+    }
+    const meta = getDtoMetaSafe(schema);
+    return Object.entries(meta.fields).map(([name, field]) => ({
+        name,
+        schema: field.schema
+    }));
+}
+function getDtoMetaSafe(dto) {
+    const meta = (0, metadata_1.getDtoMeta)(dto);
+    if (!meta) {
+        throw new Error(`DTO "${dto.name}" is missing @Dto decorator.`);
+    }
+    return meta;
+}
+function isSchemaNode(value) {
+    return !!value && typeof value === "object" && "kind" in value;
+}
+function isPresent(value) {
+    return coerce_1.coerce.string(value) !== undefined;
+}
+function buildInvalidMessage(location, fields) {
+    let label = "query parameter";
+    if (location === "params") {
+        label = "path parameter";
+    }
+    else if (location === "body") {
+        label = "request body field";
+    }
+    const suffix = fields.length > 1 ? "s" : "";
+    return `Invalid ${label}${suffix}: ${fields.join(", ")}.`;
+}

package/dist/adapter/fastify/controllers.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from "fastify";
+import type { Constructor } from "../../core/types";
+import type { InputCoercionSetting, MultipartOptions, ValidationOptions } from "./types";
+/**
+ * Attaches controllers to a Fastify application.
+ */
+export declare function attachControllers(app: FastifyInstance, controllers: Constructor[], inputCoercion?: InputCoercionSetting, multipart?: boolean | MultipartOptions, validation?: boolean | ValidationOptions): Promise<void>;

package/dist/adapter/fastify/controllers.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachControllers = attachControllers;
+const metadata_1 = require("../../core/metadata");
+const auth_1 = require("../../core/auth");
+const errors_1 = require("../../core/errors");
+const response_1 = require("../../core/response");
+const coercion_1 = require("./coercion");
+const response_serializer_1 = require("./response-serializer");
+const multipart_1 = require("./multipart");
+const lifecycle_1 = require("../../core/lifecycle");
+const streaming_1 = require("../../core/streaming");
+const validation_1 = require("../../core/validation");
+const validation_errors_1 = require("../../core/validation-errors");
+/**
+ * Attaches controllers to a Fastify application.
+ */
+async function attachControllers(app, controllers, inputCoercion = "safe", multipart, validation) {
+    const multipartOptions = (0, multipart_1.normalizeMultipartOptions)(multipart);
+    for (const controller of controllers) {
+        const meta = (0, metadata_1.getControllerMeta)(controller);
+        if (!meta) {
+            throw new Error(`Controller "${controller.name}" is missing @Controller decorator.`);
+        }
+        const instance = new controller();
+        lifecycle_1.lifecycleRegistry.register(instance);
+        await lifecycle_1.lifecycleRegistry.callOnModuleInit(instance);
+        for (const route of meta.routes) {
+            const path = joinPaths(meta.basePath, route.path);
+            const handler = instance[route.handlerName];
+            if (typeof handler !== "function") {
+                throw new Error(`Handler "${String(route.handlerName)}" is not a function on ${controller.name}.`);
+            }
+            const coerceParams = inputCoercion === false
+                ? undefined
+                : (0, coercion_1.createInputCoercer)(route.params, { mode: inputCoercion, location: "params" });
+            const coerceQuery = inputCoercion === false
+                ? undefined
+                : (0, coercion_1.createInputCoercer)(route.query, { mode: inputCoercion, location: "query" });
+            const coerceBody = inputCoercion === false
+                ? undefined
+                : (0, coercion_1.createInputCoercer)(route.body, { mode: inputCoercion, location: "body" });
+            const isValidationEnabled = validation !== false && validation?.enabled !== false;
+            const authMeta = (0, auth_1.getRouteAuthMeta)(controller, route.handlerName);
+            app.route({
+                method: route.httpMethod.toUpperCase(),
+                url: path,
+                handler: async (req, reply) => {
+                    try {
+                        // Apply auth guard if metadata exists
+                        if (authMeta && authMeta.requiresAuth && !authMeta.isPublic) {
+                            const user = req.user || req.raw.user;
+                            if (!user) {
+                                throw new errors_1.HttpError(401, "Unauthorized");
+                            }
+                            if (authMeta.roles?.length) {
+                                const hasRole = authMeta.roles.some((role) => user.roles?.includes(role));
+                                if (!hasRole) {
+                                    throw new errors_1.HttpError(403, "Insufficient permissions");
+                                }
+                            }
+                            if (authMeta.allRoles?.length) {
+                                const hasAllRoles = authMeta.allRoles.every((role) => user.roles?.includes(role));
+                                if (!hasAllRoles) {
+                                    throw new errors_1.HttpError(403, "Insufficient permissions");
+                                }
+                            }
+                            if (authMeta.guard) {
+                                const allowed = await authMeta.guard(user, req);
+                                if (!allowed) {
+                                    throw new errors_1.HttpError(403, "Access denied by guard");
+                                }
+                            }
+                        }
+                        let files = undefined;
+                        if (multipartOptions && (0, multipart_1.hasFileUploads)(route.files)) {
+                            files = await (0, multipart_1.extractFiles)(req);
+                        }
+                        const body = req.body;
+                        const query = (coerceQuery && req.query && Object.keys(req.query).length > 0) ? coerceQuery(req.query) : req.query;
+                        const params = (coerceParams && req.params && Object.keys(req.params).length > 0) ? coerceParams(req.params) : req.params;
+                        if (isValidationEnabled) {
+                            const validationErrors = [];
+                            if (route.body) {
+                                const bodyErrors = (0, validation_1.validate)(body, route.body.schema);
+                                validationErrors.push(...bodyErrors);
+                            }
+                            if (route.query) {
+                                const queryErrors = (0, validation_1.validate)(query, route.query.schema);
+                                validationErrors.push(...queryErrors);
+                            }
+                            if (route.params) {
+                                const paramsErrors = (0, validation_1.validate)(params, route.params.schema);
+                                validationErrors.push(...paramsErrors);
+                            }
+                            if (route.headers) {
+                                const headersErrors = (0, validation_1.validate)(req.headers, route.headers.schema);
+                                validationErrors.push(...headersErrors);
+                            }
+                            if (validationErrors.length > 0) {
+                                throw new validation_errors_1.ValidationErrors(validationErrors);
+                            }
+                        }
+                        const ctx = {
+                            req,
+                            res: reply.raw,
+                            body,
+                            query,
+                            params,
+                            headers: req.headers,
+                            files,
+                            sse: route.sse ? (0, streaming_1.createSseEmitter)(reply.raw) : undefined,
+                            stream: route.streaming || route.sse ? (0, streaming_1.createStreamWriter)(reply.raw) : undefined
+                        };
+                        const result = await handler.call(instance, ctx);
+                        if (reply.sent || route.sse || route.streaming) {
+                            return;
+                        }
+                        if ((0, response_1.isHttpResponse)(result)) {
+                            if (result.headers) {
+                                reply.headers(result.headers);
+                            }
+                            if (result.body === undefined) {
+                                reply.status(result.status).send();
+                            }
+                            else if (route.raw) {
+                                if (!reply.getHeader("Content-Type")) {
+                                    const ct = getResponseContentType(route) ?? "application/octet-stream";
+                                    reply.type(ct);
+                                }
+                                reply.status(result.status).send(result.body);
+                            }
+                            else {
+                                const responseSchema = getResponseSchemaForStatus(route, result.status);
+                                const output = responseSchema ? (0, response_serializer_1.serializeResponse)(result.body, responseSchema) : result.body;
+                                reply.status(result.status).send(output);
+                            }
+                            return;
+                        }
+                        if (result === undefined) {
+                            reply.status(defaultStatus(route)).send();
+                            return;
+                        }
+                        if (route.raw) {
+                            if (!reply.getHeader("Content-Type")) {
+                                const ct = getResponseContentType(route) ?? "application/octet-stream";
+                                reply.type(ct);
+                            }
+                            reply.status(defaultStatus(route)).send(result);
+                        }
+                        else {
+                            const responseSchema = getResponseSchema(route);
+                            const output = responseSchema ? (0, response_serializer_1.serializeResponse)(result, responseSchema) : result;
+                            reply.status(defaultStatus(route)).send(output);
+                        }
+                    }
+                    catch (error) {
+                        if ((0, validation_errors_1.isValidationErrors)(error)) {
+                            reply.status(error.status).send(error.body);
+                            return;
+                        }
+                        if ((0, errors_1.isHttpError)(error)) {
+                            if (error.headers) {
+                                reply.headers(error.headers);
+                            }
+                            const body = error.body ?? { message: error.message };
+                            reply.status(error.status).send(body);
+                            return;
+                        }
+                        throw error;
+                    }
+                }
+            });
+        }
+    }
+}
+function defaultStatus(route) {
+    const responses = route.responses ?? [];
+    const success = responses.find((response) => !response.error && response.status < 400);
+    return success?.status ?? 200;
+}
+function getResponseSchema(route) {
+    const responses = route.responses ?? [];
+    const success = responses.find((response) => !response.error && response.status < 400);
+    return success?.schema;
+}
+function getResponseContentType(route) {
+    const responses = route.responses ?? [];
+    const success = responses.find((r) => !r.error && r.status < 400);
+    return success?.contentType;
+}
+function getResponseSchemaForStatus(route, status) {
+    const responses = route.responses ?? [];
+    const response = responses.find((r) => r.status === status);
+    return response?.schema;
+}
+function joinPaths(base, path) {
+    const normalizedBase = base.replace(/\/+$/, "");
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${normalizedBase}${normalizedPath}`;
+}

package/dist/adapter/fastify/index.d.ts

@@ -0,0 +1,14 @@
+import type { FastifyAdapterOptions } from "./types";
+export * from "./types";
+export { attachControllers } from "./controllers";
+export { attachOpenApi } from "./openapi";
+/**
+ * Creates a Fastify application with Adorn controllers.
+ * @param options - Fastify adapter options
+ * @returns Configured Fastify application
+ */
+export declare function createFastifyApp(options: FastifyAdapterOptions): Promise<any>;
+/**
+ * Trigger shutdown hooks for graceful application shutdown.
+ */
+export declare function shutdownApp(signal?: string): Promise<void>;

package/dist/adapter/fastify/index.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachOpenApi = exports.attachControllers = void 0;
+exports.createFastifyApp = createFastifyApp;
+exports.shutdownApp = shutdownApp;
+const fastify_1 = __importDefault(require("fastify"));
+const controllers_1 = require("./controllers");
+const openapi_1 = require("./openapi");
+const lifecycle_1 = require("../../core/lifecycle");
+const cors_1 = __importDefault(require("@fastify/cors"));
+const multipart_1 = __importDefault(require("@fastify/multipart"));
+__exportStar(require("./types"), exports);
+var controllers_2 = require("./controllers");
+Object.defineProperty(exports, "attachControllers", { enumerable: true, get: function () { return controllers_2.attachControllers; } });
+var openapi_2 = require("./openapi");
+Object.defineProperty(exports, "attachOpenApi", { enumerable: true, get: function () { return openapi_2.attachOpenApi; } });
+/**
+ * Creates a Fastify application with Adorn controllers.
+ * @param options - Fastify adapter options
+ * @returns Configured Fastify application
+ */
+async function createFastifyApp(options) {
+    const app = (0, fastify_1.default)({
+        bodyLimit: options.bodyLimit
+    });
+    if (options.cors) {
+        app.register(cors_1.default, options.cors === true ? {} : options.cors);
+    }
+    if (options.multipart) {
+        app.register(multipart_1.default, {
+            limits: {
+                fileSize: typeof options.multipart === "object" ? options.multipart.maxFileSize : undefined
+            }
+        });
+    }
+    const inputCoercion = options.inputCoercion ?? "safe";
+    await (0, controllers_1.attachControllers)(app, options.controllers, inputCoercion, options.multipart, options.validation);
+    if (options.openApi) {
+        (0, openapi_1.attachOpenApi)(app, options.controllers, options.openApi);
+    }
+    await lifecycle_1.lifecycleRegistry.callOnApplicationBootstrap();
+    return app;
+}
+/**
+ * Trigger shutdown hooks for graceful application shutdown.
+ */
+async function shutdownApp(signal) {
+    await lifecycle_1.lifecycleRegistry.callShutdownHooks(signal);
+    lifecycle_1.lifecycleRegistry.clear();
+}