arkos 1.2.3-test → 1.2.4-beta

package/dist/cjs/modules/swagger/utils/helpers/get-system-json-schema-paths.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSystemJsonSchemaPaths = getSystemJsonSchemaPaths;
+function getSystemJsonSchemaPaths() {
+    const paths = {};
+    paths["/api/available-resources"] = {
+        get: {
+            tags: ["System"],
+            summary: "Get available resources",
+            description: "Returns a comprehensive list of all available API resource endpoints",
+            operationId: "getAvailableResources",
+            responses: {
+                "200": {
+                    description: "List of available resources retrieved successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    data: {
+                                        type: "array",
+                                        items: {
+                                            type: "string",
+                                        },
+                                        description: "Array of available resource endpoints",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    paths["/api/available-routes"] = {
+        get: {
+            tags: ["System"],
+            summary: "Get available routes",
+            description: "Returns a comprehensive list of all registered API routes and their methods",
+            operationId: "getAvailableRoutes",
+            responses: {
+                "200": {
+                    description: "List of available routes retrieved successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    routes: {
+                                        type: "array",
+                                        items: {
+                                            type: "string",
+                                        },
+                                        description: "Array of available API routes",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    return paths;
+}
+//# sourceMappingURL=get-system-json-schema-paths.js.map

package/dist/cjs/modules/swagger/utils/helpers/get-system-json-schema-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-system-json-schema-paths.js","sourceRoot":"","sources":["../../../../../../src/modules/swagger/utils/helpers/get-system-json-schema-paths.ts"],"names":[],"mappings":";;AAEA,4DAkEC;AAlED,SAAgB,wBAAwB;IACtC,MAAM,KAAK,GAA0B,EAAE,CAAC;IAExC,KAAK,CAAC,0BAA0B,CAAC,GAAG;QAClC,GAAG,EAAE;YACH,IAAI,EAAE,CAAC,QAAQ,CAAC;YAChB,OAAO,EAAE,yBAAyB;YAClC,WAAW,EACT,sEAAsE;YACxE,WAAW,EAAE,uBAAuB;YACpC,SAAS,EAAE;gBACT,KAAK,EAAE;oBACL,WAAW,EAAE,oDAAoD;oBACjE,OAAO,EAAE;wBACP,kBAAkB,EAAE;4BAClB,MAAM,EAAE;gCACN,IAAI,EAAE,QAAQ;gCACd,UAAU,EAAE;oCACV,IAAI,EAAE;wCACJ,IAAI,EAAE,OAAO;wCACb,KAAK,EAAE;4CACL,IAAI,EAAE,QAAQ;yCACf;wCACD,WAAW,EAAE,uCAAuC;qCACrD;iCACF;6BACF;yBACF;qBACF;iBACF;aACF;SACF;KACF,CAAC;IAEF,KAAK,CAAC,uBAAuB,CAAC,GAAG;QAC/B,GAAG,EAAE;YACH,IAAI,EAAE,CAAC,QAAQ,CAAC;YAChB,OAAO,EAAE,sBAAsB;YAC/B,WAAW,EACT,6EAA6E;YAC/E,WAAW,EAAE,oBAAoB;YACjC,SAAS,EAAE;gBACT,KAAK,EAAE;oBACL,WAAW,EAAE,iDAAiD;oBAC9D,OAAO,EAAE;wBACP,kBAAkB,EAAE;4BAClB,MAAM,EAAE;gCACN,IAAI,EAAE,QAAQ;gCACd,UAAU,EAAE;oCACV,MAAM,EAAE;wCACN,IAAI,EAAE,OAAO;wCACb,KAAK,EAAE;4CACL,IAAI,EAAE,QAAQ;yCACf;wCACD,WAAW,EAAE,+BAA+B;qCAC7C;iCACF;6BACF;yBACF;qBACF;iBACF;aACF;SACF;KACF,CAAC;IAEF,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import { OpenAPIV3 } from \"openapi-types\";\n\nexport function getSystemJsonSchemaPaths() {\n  const paths: OpenAPIV3.PathsObject = {};\n\n  paths[\"/api/available-resources\"] = {\n    get: {\n      tags: [\"System\"],\n      summary: \"Get available resources\",\n      description:\n        \"Returns a comprehensive list of all available API resource endpoints\",\n      operationId: \"getAvailableResources\",\n      responses: {\n        \"200\": {\n          description: \"List of available resources retrieved successfully\",\n          content: {\n            \"application/json\": {\n              schema: {\n                type: \"object\",\n                properties: {\n                  data: {\n                    type: \"array\",\n                    items: {\n                      type: \"string\",\n                    },\n                    description: \"Array of available resource endpoints\",\n                  },\n                },\n              },\n            },\n          },\n        },\n      },\n    },\n  };\n\n  paths[\"/api/available-routes\"] = {\n    get: {\n      tags: [\"System\"],\n      summary: \"Get available routes\",\n      description:\n        \"Returns a comprehensive list of all registered API routes and their methods\",\n      operationId: \"getAvailableRoutes\",\n      responses: {\n        \"200\": {\n          description: \"List of available routes retrieved successfully\",\n          content: {\n            \"application/json\": {\n              schema: {\n                type: \"object\",\n                properties: {\n                  routes: {\n                    type: \"array\",\n                    items: {\n                      type: \"string\",\n                    },\n                    description: \"Array of available API routes\",\n                  },\n                },\n              },\n            },\n          },\n        },\n      },\n    },\n  };\n\n  return paths;\n}\n"]}

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/generate-class-validator-json-schemas.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateClassValidatorJsonSchemas = generateClassValidatorJsonSchemas;
+const class_validator_jsonschema_1 = require("class-validator-jsonschema");
+const global_helpers_1 = require("../../../../../utils/helpers/global.helpers");
+const class_validator_1 = require("class-validator");
+const models_helpers_1 = require("../../../../../utils/helpers/models.helpers");
+const swagger_router_helpers_1 = require("../swagger.router.helpers");
+async function generateClassValidatorJsonSchemas() {
+    const models = (0, models_helpers_1.getModels)();
+    const schemas = {};
+    const { defaultMetadataStorage } = await (0, global_helpers_1.importModule)("class-transformer/cjs/storage");
+    const jsonSchema = (0, class_validator_jsonschema_1.validationMetadatasToSchemas)({
+        classValidatorMetadataStorage: (0, class_validator_1.getMetadataStorage)(),
+        classTransformerMetadataStorage: defaultMetadataStorage,
+        refPointerPrefix: "#/components/schemas/",
+    });
+    Object.entries(jsonSchema).forEach(([className, schema]) => {
+        schemas[className] = schema;
+    });
+    models.forEach((modelName) => {
+        const modelModules = (0, models_helpers_1.getModelModules)(modelName);
+        if (modelModules?.dtos) {
+            Object.entries(modelModules.dtos).forEach(([dtoType, dtoClass]) => {
+                if (dtoClass) {
+                    try {
+                        const schemaName = (0, swagger_router_helpers_1.getCorrectJsonSchemaName)(dtoType, modelName, "Dto");
+                        schemas[schemaName] = jsonSchema[dtoClass.name] || {};
+                        if (schemas[dtoClass.name])
+                            delete schemas[dtoClass.name];
+                    }
+                    catch (error) {
+                        console.warn(`Failed to generate schema for ${dtoType} ${modelName}:`, error);
+                    }
+                }
+            });
+        }
+    });
+    return schemas;
+}
+//# sourceMappingURL=generate-class-validator-json-schemas.js.map

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/generate-class-validator-json-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-class-validator-json-schemas.js","sourceRoot":"","sources":["../../../../../../../src/modules/swagger/utils/helpers/json-schema-generators/generate-class-validator-json-schemas.ts"],"names":[],"mappings":";;AASA,8EA4CC;AArDD,2EAA0E;AAC1E,gFAA2E;AAC3E,qDAAqD;AACrD,gFAGqD;AACrD,sEAAqE;AAE9D,KAAK,UAAU,iCAAiC;IACrD,MAAM,MAAM,GAAG,IAAA,0BAAS,GAAE,CAAC;IAC3B,MAAM,OAAO,GAAwB,EAAE,CAAC;IAExC,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,IAAA,6BAAY,EACnD,+BAA+B,CAChC,CAAC;IAEF,MAAM,UAAU,GAAG,IAAA,yDAA4B,EAAC;QAC9C,6BAA6B,EAAE,IAAA,oCAAkB,GAAE;QACnD,+BAA+B,EAAE,sBAAsB;QACvD,gBAAgB,EAAE,uBAAuB;KAC1C,CAAC,CAAC;IAEH,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,EAAE;QACzD,OAAO,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC;IAC9B,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;QAC3B,MAAM,YAAY,GAAG,IAAA,gCAAe,EAAC,SAAS,CAAC,CAAC;QAEhD,IAAI,YAAY,EAAE,IAAI,EAAE,CAAC;YACvB,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,EAAE;gBAChE,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,CAAC;wBACH,MAAM,UAAU,GAAG,IAAA,iDAAwB,EACzC,OAAO,EACP,SAAS,EACT,KAAK,CACN,CAAC;wBACF,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACtD,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;4BAAE,OAAO,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;oBAC5D,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,OAAO,CAAC,IAAI,CACV,iCAAiC,OAAO,IAAI,SAAS,GAAG,EACxD,KAAK,CACN,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC;AACjB,CAAC","sourcesContent":["import { validationMetadatasToSchemas } from \"class-validator-jsonschema\";\nimport { importModule } from \"../../../../../utils/helpers/global.helpers\";\nimport { getMetadataStorage } from \"class-validator\";\nimport {\n  getModelModules,\n  getModels,\n} from \"../../../../../utils/helpers/models.helpers\";\nimport { getCorrectJsonSchemaName } from \"../swagger.router.helpers\";\n\nexport async function generateClassValidatorJsonSchemas() {\n  const models = getModels();\n  const schemas: Record<string, any> = {};\n\n  const { defaultMetadataStorage } = await importModule(\n    \"class-transformer/cjs/storage\"\n  );\n\n  const jsonSchema = validationMetadatasToSchemas({\n    classValidatorMetadataStorage: getMetadataStorage(),\n    classTransformerMetadataStorage: defaultMetadataStorage,\n    refPointerPrefix: \"#/components/schemas/\",\n  });\n\n  Object.entries(jsonSchema).forEach(([className, schema]) => {\n    schemas[className] = schema;\n  });\n\n  models.forEach((modelName) => {\n    const modelModules = getModelModules(modelName);\n\n    if (modelModules?.dtos) {\n      Object.entries(modelModules.dtos).forEach(([dtoType, dtoClass]) => {\n        if (dtoClass) {\n          try {\n            const schemaName = getCorrectJsonSchemaName(\n              dtoType,\n              modelName,\n              \"Dto\"\n            );\n            schemas[schemaName] = jsonSchema[dtoClass.name] || {};\n            if (schemas[dtoClass.name]) delete schemas[dtoClass.name];\n          } catch (error) {\n            console.warn(\n              `Failed to generate schema for ${dtoType} ${modelName}:`,\n              error\n            );\n          }\n        }\n      });\n    }\n  });\n\n  return schemas;\n}\n"]}

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/generate-prisma-json-schemas.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaJsonSchemas = generatePrismaJsonSchemas;
+const utils_1 = require("../../../../../exports/utils");
+const models_helpers_1 = require("../../../../../utils/helpers/models.helpers");
+async function generatePrismaJsonSchemas() {
+    const schemas = {};
+    const prismaContent = (0, models_helpers_1.getPrismaSchemasContent)();
+    const models = (0, models_helpers_1.getModels)();
+    models.forEach((modelName) => {
+        const pascalModelName = (0, utils_1.pascalCase)(modelName);
+        schemas[`Create${pascalModelName}Schema`] = {
+            type: "object",
+            properties: {},
+        };
+        schemas[`Update${pascalModelName}Schema`] = {
+            type: "object",
+            properties: {},
+        };
+    });
+}
+//# sourceMappingURL=generate-prisma-json-schemas.js.map

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/generate-prisma-json-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-prisma-json-schemas.js","sourceRoot":"","sources":["../../../../../../../src/modules/swagger/utils/helpers/json-schema-generators/generate-prisma-json-schemas.ts"],"names":[],"mappings":";;AAMA,8DAsBC;AA5BD,wDAA0D;AAC1D,gFAGqD;AAE9C,KAAK,UAAU,yBAAyB;IAC7C,MAAM,OAAO,GAAwB,EAAE,CAAC;IACxC,MAAM,aAAa,GAAG,IAAA,wCAAuB,GAAE,CAAC;IAChD,MAAM,MAAM,GAAG,IAAA,0BAAS,GAAE,CAAC;IAE3B,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;QAC3B,MAAM,eAAe,GAAG,IAAA,kBAAU,EAAC,SAAS,CAAC,CAAC;QAE9C,OAAO,CAAC,SAAS,eAAe,QAAQ,CAAC,GAAG;YAC1C,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,EAEX;SACF,CAAC;QAEF,OAAO,CAAC,SAAS,eAAe,QAAQ,CAAC,GAAG;YAC1C,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,EAEX;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { pascalCase } from \"../../../../../exports/utils\";\nimport {\n  getModels,\n  getPrismaSchemasContent,\n} from \"../../../../../utils/helpers/models.helpers\";\n\nexport async function generatePrismaJsonSchemas() {\n  const schemas: Record<string, any> = {};\n  const prismaContent = getPrismaSchemasContent();\n  const models = getModels();\n\n  models.forEach((modelName) => {\n    const pascalModelName = pascalCase(modelName);\n\n    schemas[`Create${pascalModelName}Schema`] = {\n      type: \"object\",\n      properties: {\n        // Omit auto-generated fields like id, createdAt, updatedAt\n      },\n    };\n\n    schemas[`Update${pascalModelName}Schema`] = {\n      type: \"object\",\n      properties: {\n        // Make all fields optional for updates\n      },\n    };\n  });\n}\n"]}

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/generate-zod-json-schema.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodJsonSchemas = generateZodJsonSchemas;
+const models_helpers_1 = require("../../../../../utils/helpers/models.helpers");
+const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+const swagger_router_helpers_1 = require("../swagger.router.helpers");
+async function generateZodJsonSchemas() {
+    const models = (0, models_helpers_1.getModels)();
+    models.forEach((modelName) => {
+        const modelModules = (0, models_helpers_1.getModelModules)(modelName);
+        const schemas = {};
+        if (modelModules?.schemas)
+            Object.entries(modelModules.schemas).forEach(([schemaType, zodSchema]) => {
+                if (zodSchema)
+                    try {
+                        const jsonSchema = (0, zod_to_json_schema_1.default)(zodSchema);
+                        const schemaName = (0, swagger_router_helpers_1.getCorrectJsonSchemaName)(schemaType, modelName, "Schema");
+                        schemas[schemaName] = jsonSchema;
+                    }
+                    catch (error) {
+                        console.warn(`Failed to generate schema for ${schemaType} ${modelName}:`, error);
+                    }
+            });
+    });
+}
+//# sourceMappingURL=generate-zod-json-schema.js.map

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/generate-zod-json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-zod-json-schema.js","sourceRoot":"","sources":["../../../../../../../src/modules/swagger/utils/helpers/json-schema-generators/generate-zod-json-schema.ts"],"names":[],"mappings":";;;;;AAOA,wDA6BC;AApCD,gFAGqD;AACrD,4EAAiD;AACjD,sEAAqE;AAE9D,KAAK,UAAU,sBAAsB;IAC1C,MAAM,MAAM,GAAG,IAAA,0BAAS,GAAE,CAAC;IAE3B,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;QAC3B,MAAM,YAAY,GAAG,IAAA,gCAAe,EAAC,SAAS,CAAC,CAAC;QAChD,MAAM,OAAO,GAAwB,EAAE,CAAC;QAExC,IAAI,YAAY,EAAE,OAAO;YACvB,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,OAAO,CAC1C,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE,EAAE;gBAC1B,IAAI,SAAS;oBACX,IAAI,CAAC;wBACH,MAAM,UAAU,GAAG,IAAA,4BAAe,EAAC,SAAS,CAAC,CAAC;wBAC9C,MAAM,UAAU,GAAG,IAAA,iDAAwB,EACzC,UAAU,EACV,SAAS,EACT,QAAQ,CACT,CAAC;wBAEF,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;oBACnC,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,OAAO,CAAC,IAAI,CACV,iCAAiC,UAAU,IAAI,SAAS,GAAG,EAC3D,KAAK,CACN,CAAC;oBACJ,CAAC;YACL,CAAC,CACF,CAAC;IACN,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  getModelModules,\n  getModels,\n} from \"../../../../../utils/helpers/models.helpers\";\nimport zodToJsonSchema from \"zod-to-json-schema\";\nimport { getCorrectJsonSchemaName } from \"../swagger.router.helpers\";\n\nexport async function generateZodJsonSchemas() {\n  const models = getModels();\n\n  models.forEach((modelName) => {\n    const modelModules = getModelModules(modelName);\n    const schemas: Record<string, any> = {};\n\n    if (modelModules?.schemas)\n      Object.entries(modelModules.schemas).forEach(\n        ([schemaType, zodSchema]) => {\n          if (zodSchema)\n            try {\n              const jsonSchema = zodToJsonSchema(zodSchema);\n              const schemaName = getCorrectJsonSchemaName(\n                schemaType,\n                modelName,\n                \"Schema\"\n              );\n\n              schemas[schemaName] = jsonSchema;\n            } catch (error) {\n              console.warn(\n                `Failed to generate schema for ${schemaType} ${modelName}:`,\n                error\n              );\n            }\n        }\n      );\n  });\n}\n"]}

package/dist/cjs/modules/swagger/utils/helpers/json-schema-generators/prisma-models/generate-prisma-model-main-routes.js

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaModelMainRoutesPaths = generatePrismaModelMainRoutesPaths;
+const swagger_router_helpers_1 = require("../../swagger.router.helpers");
+const pluralize_1 = require("pluralize");
+const base_router_helpers_1 = require("../../../../../base/utils/helpers/base.router.helpers");
+async function generatePrismaModelMainRoutesPaths(paths, routeName, pascalModelName, humanReadableName, humanReadableNamePlural, routerConfig, mode) {
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "createOne")) {
+        if (!paths[`/api/${routeName}`])
+            paths[`/api/${routeName}`] = {};
+        paths[`/api/${routeName}`].post = {
+            tags: [humanReadableNamePlural],
+            summary: `Create a new ${humanReadableName}`,
+            description: `Creates a new ${humanReadableName} record in the system`,
+            operationId: `create${pascalModelName}`,
+            requestBody: {
+                description: `${humanReadableName} data to create`,
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: (0, swagger_router_helpers_1.getSchemaRef)(`Create${pascalModelName}`, mode),
+                        },
+                    },
+                },
+            },
+            responses: {
+                "201": {
+                    description: `${humanReadableName} created successfully`,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: (0, swagger_router_helpers_1.getSchemaRef)(`${pascalModelName}`, mode),
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    description: "Invalid input data provided",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "findMany")) {
+        if (!paths[`/api/${routeName}`])
+            paths[`/api/${routeName}`] = {};
+        paths[`/api/${routeName}`].get = {
+            tags: [humanReadableNamePlural],
+            summary: `Get ${humanReadableNamePlural}`,
+            description: `Retrieves a paginated list of ${humanReadableNamePlural} with optional filtering and sorting`,
+            operationId: `get${(0, pluralize_1.plural)(pascalModelName)}`,
+            parameters: [
+                {
+                    name: "filter",
+                    in: "query",
+                    description: "Filter criteria in JSON format",
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "sort",
+                    in: "query",
+                    description: "Sort field (prefix with '-' for descending order)",
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "page",
+                    in: "query",
+                    description: "Page number (starts from 1)",
+                    schema: {
+                        type: "integer",
+                        minimum: 1,
+                    },
+                },
+                {
+                    name: "limit",
+                    in: "query",
+                    description: "Number of items per page",
+                    schema: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 100,
+                    },
+                },
+                {
+                    name: "fields",
+                    in: "query",
+                    description: "Comma-separated list of fields to include in response",
+                    schema: {
+                        type: "string",
+                    },
+                },
+            ],
+            responses: {
+                "200": {
+                    description: `List of ${humanReadableNamePlural} retrieved successfully`,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    total: {
+                                        type: "integer",
+                                        description: "Total number of records matching the criteria",
+                                    },
+                                    results: {
+                                        type: "integer",
+                                        description: "Number of records returned in current page",
+                                    },
+                                    data: {
+                                        type: "array",
+                                        items: {
+                                            $ref: (0, swagger_router_helpers_1.getSchemaRef)(`FindMany${pascalModelName}`, mode),
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "createMany")) {
+        paths[`/api/${routeName}/many`] = {
+            post: {
+                tags: [humanReadableNamePlural],
+                summary: `Create multiple ${humanReadableNamePlural}`,
+                description: `Creates multiple ${humanReadableNamePlural} records in a single batch operation`,
+                operationId: `createMany${pascalModelName}`,
+                requestBody: {
+                    description: `Array of ${humanReadableName} data to create`,
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "array",
+                                items: {
+                                    $ref: (0, swagger_router_helpers_1.getSchemaRef)(`Create${pascalModelName}`, mode),
+                                },
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    "201": {
+                        description: `${humanReadableNamePlural} created successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        count: {
+                                            type: "integer",
+                                            description: "Number of records created",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    "400": {
+                        description: "Invalid input data provided",
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                    "403": {
+                        description: "Insufficient permissions",
+                    },
+                },
+                security: [{ BearerAuth: [] }],
+            },
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "updateMany")) {
+        if (!paths[`/api/${routeName}/many`])
+            paths[`/api/${routeName}/many`] = {};
+        paths[`/api/${routeName}/many`].patch = {
+            tags: [humanReadableNamePlural],
+            summary: `Update multiple ${humanReadableNamePlural}`,
+            description: `Updates multiple ${humanReadableNamePlural} records that match the specified filter criteria`,
+            operationId: `updateMany${pascalModelName}`,
+            parameters: [
+                {
+                    name: "filter",
+                    in: "query",
+                    description: "Filter criteria in JSON format (required)",
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+            ],
+            requestBody: {
+                description: `Partial ${humanReadableName} data to update`,
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: (0, swagger_router_helpers_1.getSchemaRef)(`Update${pascalModelName}`, mode),
+                        },
+                    },
+                },
+            },
+            responses: {
+                "200": {
+                    description: `${humanReadableNamePlural} updated successfully`,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    count: {
+                                        type: "integer",
+                                        description: "Number of records updated",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    description: "Invalid input data or missing filter criteria",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "deleteMany")) {
+        if (!paths[`/api/${routeName}/many`])
+            paths[`/api/${routeName}/many`] = {};
+        paths[`/api/${routeName}/many`].delete = {
+            tags: [humanReadableNamePlural],
+            summary: `Delete multiple ${humanReadableNamePlural}`,
+            description: `Deletes multiple ${humanReadableNamePlural} records that match the specified filter criteria`,
+            operationId: `deleteMany${pascalModelName}`,
+            parameters: [
+                {
+                    name: "filter",
+                    in: "query",
+                    description: "Filter criteria in JSON format (required)",
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+            ],
+            responses: {
+                "200": {
+                    description: `${humanReadableNamePlural} deleted successfully`,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    count: {
+                                        type: "integer",
+                                        description: "Number of records deleted",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    description: "Missing filter criteria",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "findOne")) {
+        paths[`/api/${routeName}/{id}`] = {
+            get: {
+                tags: [humanReadableNamePlural],
+                summary: `Get ${humanReadableName} by ID`,
+                description: `Retrieves a single ${humanReadableName} record by its unique identifier`,
+                operationId: `get${pascalModelName}ById`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        description: `Unique identifier of the ${humanReadableName}`,
+                        required: true,
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: `${humanReadableName} retrieved successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: (0, swagger_router_helpers_1.getSchemaRef)(`FindOne${pascalModelName}`, mode),
+                                },
+                            },
+                        },
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                    "403": {
+                        description: "Insufficient permissions",
+                    },
+                    "404": {
+                        description: `${humanReadableName} not found`,
+                    },
+                },
+                security: [{ BearerAuth: [] }],
+            },
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "updateOne")) {
+        if (!paths[`/api/${routeName}/{id}`])
+            paths[`/api/${routeName}/{id}`] = {};
+        paths[`/api/${routeName}/{id}`].patch = {
+            tags: [humanReadableNamePlural],
+            summary: `Update ${humanReadableName} by ID`,
+            description: `Updates a single ${humanReadableName} record by its unique identifier`,
+            operationId: `update${pascalModelName}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${humanReadableName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+            ],
+            requestBody: {
+                description: `Partial ${humanReadableName} data to update`,
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: (0, swagger_router_helpers_1.getSchemaRef)(`Update${pascalModelName}`, mode),
+                        },
+                    },
+                },
+            },
+            responses: {
+                "200": {
+                    description: `${humanReadableName} updated successfully`,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: (0, swagger_router_helpers_1.getSchemaRef)(`${pascalModelName}`, mode),
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    description: "Invalid input data provided",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+                "404": {
+                    description: `${humanReadableName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (!(0, base_router_helpers_1.isEndpointDisabled)(routerConfig, "deleteOne")) {
+        if (!paths[`/api/${routeName}/{id}`])
+            paths[`/api/${routeName}/{id}`] = {};
+        paths[`/api/${routeName}/{id}`].delete = {
+            tags: [humanReadableNamePlural],
+            summary: `Delete ${humanReadableName} by ID`,
+            description: `Permanently deletes a single ${humanReadableName} record by its unique identifier`,
+            operationId: `delete${pascalModelName}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${humanReadableName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+            ],
+            responses: {
+                "204": {
+                    description: `${humanReadableName} deleted successfully`,
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+                "404": {
+                    description: `${humanReadableName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+}
+//# sourceMappingURL=generate-prisma-model-main-routes.js.map