arkos 1.3.1-beta → 1.3.2-beta

package/dist/esm/modules/swagger/utils/helpers/json-schema-generators/prisma-models/generate-prisma-model-parent-routes-paths.js

@@ -1 +1,566 @@
-"use strict";import y from"pluralize";import{kebabCase as g,pascalCase as c}from"../../../../../../exports/utils/index.js";import{getSchemaRef as u,kebabToHuman as I,localValidatorFileExists as M}from"../../swagger.router.helpers.js";import{getModuleComponents as b}from"../../../../../../utils/dynamic-loader.js";export default async function A($,r,h){const q=g($),n=y.plural(q),o=c($),i=I(q),t=y.plural(i),l=b($)?.router?.config;if(l?.disable===!0||!l?.parent)return;const d=l.parent.model,s=y.plural(g(d)),e=I(g(d)),p=a=>{const m=l?.parent?.endpoints;return!m||m==="*"?!0:Array.isArray(m)?m.includes(a):!1},f=async a=>{const m=h.swagger?.mode;return h.swagger?.strict?m||"prisma":await M(a,$,h)&&m||"prisma"};if(p("createOne")){const a=await f("create");r[`/api/${s}/{id}/${n}`]={post:{tags:[t],summary:`Create ${i} for ${e}`,description:`Creates a new ${i} record associated with the specified ${e}`,operationId:`create${o}For${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}}],requestBody:{description:`${i} data to create`,required:!0,content:{"application/json":{schema:{$ref:u(`Create${o}`,a)}}}},responses:{201:{description:`${i} created successfully`,content:{"application/json":{schema:{$ref:u(`${o}`,a)}}}},400:{description:"Invalid input data provided"},401:{description:"Authentication required"},403:{description:"Insufficient permissions"},404:{description:`${e} not found`}},security:[{BearerAuth:[]}]}}}if(p("findMany")){r[`/api/${s}/{id}/${n}`]||(r[`/api/${s}/{id}/${n}`]={});const a=await f("findMany");r[`/api/${s}/{id}/${n}`].get={tags:[t],summary:`Get ${t} for ${e}`,description:`Retrieves all ${t} associated with the specified ${e}`,operationId:`get${y.plural(o)}For${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}},{name:"filters",in:"query",description:"Additional filters 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 ${t} 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:u(`FindMany${o}`,a)}}}}}}},401:{description:"Authentication required"},403:{description:"Insufficient permissions"},404:{description:`${e} not found`}},security:[{BearerAuth:[]}]}}if(p("createMany")){const a=await f("createMany");r[`/api/${s}/{id}/${n}/many`]={post:{tags:[t],summary:`Create multiple ${t} for ${e}`,description:`Creates multiple ${t} records associated with the specified ${e}`,operationId:`createMany${o}For${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}}],requestBody:{description:`Array of ${i} data to create`,required:!0,content:{"application/json":{schema:{type:"array",items:{$ref:u(`CreateMany${o}`,a)}}}}},responses:{201:{description:`${t} 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"},404:{description:`${e} not found`}},security:[{BearerAuth:[]}]}}}if(p("updateMany")){r[`/api/${s}/{id}/${n}/many`]||(r[`/api/${s}/{id}/${n}/many`]={});const a=await f("updateMany");r[`/api/${s}/{id}/${n}/many`].patch={tags:[t],summary:`Update multiple ${t} for ${e}`,description:`Updates multiple ${t} records associated with the specified ${e}`,operationId:`updateMany${o}For${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}},{name:"filters",in:"query",description:"Additional filters criteria in JSON format",schema:{type:"string"}}],requestBody:{description:`Partial ${i} data to update`,required:!0,content:{"application/json":{schema:{$ref:u(`UpdateMany${o}`,a)}}}},responses:{200:{description:`${t} updated successfully`,content:{"application/json":{schema:{type:"object",properties:{count:{type:"integer",description:"Number of records updated"}}}}}},400:{description:"Invalid input data provided"},401:{description:"Authentication required"},403:{description:"Insufficient permissions"},404:{description:`${e} not found`}},security:[{BearerAuth:[]}]}}if(p("deleteMany")&&(r[`/api/${s}/{id}/${n}/many`]||(r[`/api/${s}/{id}/${n}/many`]={}),r[`/api/${s}/{id}/${n}/many`].delete={tags:[t],summary:`Delete multiple ${t} for ${e}`,description:`Deletes multiple ${t} records associated with the specified ${e}`,operationId:`deleteMany${o}For${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}},{name:"filters",in:"query",description:"Additional filters criteria in JSON format",schema:{type:"string"}}],responses:{200:{description:`${t} 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"},404:{description:`${e} not found`}},security:[{BearerAuth:[]}]}),p("findOne")){const a=await f("findOne");r[`/api/${s}/{id}/${n}/{childId}`]={get:{tags:[t],summary:`Get ${i} by ID for ${e}`,description:`Retrieves a single ${i} record by its unique identifier associated with the specified ${e}`,operationId:`get${o}ByIdFor${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}},{name:"childId",in:"path",description:`Unique identifier of the ${i}`,required:!0,schema:{type:"string"}}],responses:{200:{description:`${i} retrieved successfully`,content:{"application/json":{schema:{$ref:u(`FindOne${o}`,a)}}}},401:{description:"Authentication required"},403:{description:"Insufficient permissions"},404:{description:`${i} or ${e} not found`}},security:[{BearerAuth:[]}]}}}if(p("updateOne")){r[`/api/${s}/{id}/${n}/{childId}`]||(r[`/api/${s}/{id}/${n}/{childId}`]={});const a=await f("update");r[`/api/${s}/{id}/${n}/{childId}`].patch={tags:[t],summary:`Update ${i} by ID for ${e}`,description:`Updates a single ${i} record by its unique identifier associated with the specified ${e}`,operationId:`update${o}ByIdFor${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}},{name:"childId",in:"path",description:`Unique identifier of the ${i}`,required:!0,schema:{type:"string"}}],requestBody:{description:`Partial ${i} data to update`,required:!0,content:{"application/json":{schema:{$ref:u(`Update${o}`,a)}}}},responses:{200:{description:`${i} updated successfully`,content:{"application/json":{schema:{$ref:u(`${o}`,a)}}}},400:{description:"Invalid input data provided"},401:{description:"Authentication required"},403:{description:"Insufficient permissions"},404:{description:`${i} or ${e} not found`}},security:[{BearerAuth:[]}]}}p("deleteOne")&&(r[`/api/${s}/{id}/${n}/{childId}`]||(r[`/api/${s}/{id}/${n}/{childId}`]={}),r[`/api/${s}/{id}/${n}/{childId}`].delete={tags:[t],summary:`Delete ${i} by ID for ${e}`,description:`Permanently deletes a single ${i} record by its unique identifier associated with the specified ${e}`,operationId:`delete${o}ByIdFor${c(d)}`,parameters:[{name:"id",in:"path",description:`Unique identifier of the ${e}`,required:!0,schema:{type:"string"}},{name:"childId",in:"path",description:`Unique identifier of the ${i}`,required:!0,schema:{type:"string"}}],responses:{204:{description:`${i} deleted successfully`},401:{description:"Authentication required"},403:{description:"Insufficient permissions"},404:{description:`${i} or ${e} not found`}},security:[{BearerAuth:[]}]})}
+import pluralize from "pluralize";
+import { kebabCase, pascalCase } from "../../../../../../exports/utils/index.js";
+import { getSchemaRef, kebabToHuman, localValidatorFileExists, } from "../../swagger.router.helpers.js";
+import { getModuleComponents } from "../../../../../../utils/dynamic-loader.js";
+export default async function generatePrismaModelParentRoutesPaths(model, paths, arkosConfig) {
+    const modelName = kebabCase(model);
+    const routeName = pluralize.plural(modelName);
+    const pascalModelName = pascalCase(model);
+    const humanReadableName = kebabToHuman(modelName);
+    const humanReadableNamePlural = pluralize.plural(humanReadableName);
+    const moduleComponents = getModuleComponents(model);
+    const routerConfig = moduleComponents?.router?.config;
+    if (routerConfig?.disable === true)
+        return;
+    if (!routerConfig?.parent)
+        return;
+    const parentModel = routerConfig.parent.model;
+    const parentRouteName = pluralize.plural(kebabCase(parentModel));
+    const parentHumanName = kebabToHuman(kebabCase(parentModel));
+    const isParentEndpointAllowed = (endpoint) => {
+        const parentEndpoints = routerConfig?.parent?.endpoints;
+        if (!parentEndpoints || parentEndpoints === "*")
+            return true;
+        if (Array.isArray(parentEndpoints))
+            return parentEndpoints.includes(endpoint);
+        return false;
+    };
+    const getSchemaMode = async (action) => {
+        const swaggerMode = arkosConfig.swagger?.mode;
+        const isStrict = arkosConfig.swagger?.strict;
+        if (isStrict) {
+            return swaggerMode || "prisma";
+        }
+        const actionKey = action;
+        const localFileExists = await localValidatorFileExists(actionKey, model, arkosConfig);
+        if (!localFileExists)
+            return "prisma";
+        return swaggerMode || "prisma";
+    };
+    if (isParentEndpointAllowed("createOne")) {
+        const createMode = await getSchemaMode("create");
+        paths[`/api/${parentRouteName}/{id}/${routeName}`] = {
+            post: {
+                tags: [humanReadableNamePlural],
+                summary: `Create ${humanReadableName} for ${parentHumanName}`,
+                description: `Creates a new ${humanReadableName} record associated with the specified ${parentHumanName}`,
+                operationId: `create${pascalModelName}For${pascalCase(parentModel)}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        description: `Unique identifier of the ${parentHumanName}`,
+                        required: true,
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                ],
+                requestBody: {
+                    description: `${humanReadableName} data to create`,
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef(`Create${pascalModelName}`, createMode),
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    "201": {
+                        description: `${humanReadableName} created successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: getSchemaRef(`${pascalModelName}`, createMode),
+                                },
+                            },
+                        },
+                    },
+                    "400": {
+                        description: "Invalid input data provided",
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                    "403": {
+                        description: "Insufficient permissions",
+                    },
+                    "404": {
+                        description: `${parentHumanName} not found`,
+                    },
+                },
+                security: [{ BearerAuth: [] }],
+            },
+        };
+    }
+    if (isParentEndpointAllowed("findMany")) {
+        if (!paths[`/api/${parentRouteName}/{id}/${routeName}`])
+            paths[`/api/${parentRouteName}/{id}/${routeName}`] = {};
+        const findManyMode = await getSchemaMode("findMany");
+        paths[`/api/${parentRouteName}/{id}/${routeName}`].get = {
+            tags: [humanReadableNamePlural],
+            summary: `Get ${humanReadableNamePlural} for ${parentHumanName}`,
+            description: `Retrieves all ${humanReadableNamePlural} associated with the specified ${parentHumanName}`,
+            operationId: `get${pluralize.plural(pascalModelName)}For${pascalCase(parentModel)}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${parentHumanName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "filters",
+                    in: "query",
+                    description: "Additional filters 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: getSchemaRef(`FindMany${pascalModelName}`, findManyMode),
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+                "404": {
+                    description: `${parentHumanName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (isParentEndpointAllowed("createMany")) {
+        const createManyMode = await getSchemaMode("createMany");
+        paths[`/api/${parentRouteName}/{id}/${routeName}/many`] = {
+            post: {
+                tags: [humanReadableNamePlural],
+                summary: `Create multiple ${humanReadableNamePlural} for ${parentHumanName}`,
+                description: `Creates multiple ${humanReadableNamePlural} records associated with the specified ${parentHumanName}`,
+                operationId: `createMany${pascalModelName}For${pascalCase(parentModel)}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        description: `Unique identifier of the ${parentHumanName}`,
+                        required: true,
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                ],
+                requestBody: {
+                    description: `Array of ${humanReadableName} data to create`,
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "array",
+                                items: {
+                                    $ref: getSchemaRef(`CreateMany${pascalModelName}`, createManyMode),
+                                },
+                            },
+                        },
+                    },
+                },
+                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",
+                    },
+                    "404": {
+                        description: `${parentHumanName} not found`,
+                    },
+                },
+                security: [{ BearerAuth: [] }],
+            },
+        };
+    }
+    if (isParentEndpointAllowed("updateMany")) {
+        if (!paths[`/api/${parentRouteName}/{id}/${routeName}/many`])
+            paths[`/api/${parentRouteName}/{id}/${routeName}/many`] = {};
+        const updateManyMode = await getSchemaMode("updateMany");
+        paths[`/api/${parentRouteName}/{id}/${routeName}/many`].patch = {
+            tags: [humanReadableNamePlural],
+            summary: `Update multiple ${humanReadableNamePlural} for ${parentHumanName}`,
+            description: `Updates multiple ${humanReadableNamePlural} records associated with the specified ${parentHumanName}`,
+            operationId: `updateMany${pascalModelName}For${pascalCase(parentModel)}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${parentHumanName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "filters",
+                    in: "query",
+                    description: "Additional filters criteria in JSON format",
+                    schema: {
+                        type: "string",
+                    },
+                },
+            ],
+            requestBody: {
+                description: `Partial ${humanReadableName} data to update`,
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: getSchemaRef(`UpdateMany${pascalModelName}`, updateManyMode),
+                        },
+                    },
+                },
+            },
+            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 provided",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+                "404": {
+                    description: `${parentHumanName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (isParentEndpointAllowed("deleteMany")) {
+        if (!paths[`/api/${parentRouteName}/{id}/${routeName}/many`])
+            paths[`/api/${parentRouteName}/{id}/${routeName}/many`] = {};
+        paths[`/api/${parentRouteName}/{id}/${routeName}/many`].delete = {
+            tags: [humanReadableNamePlural],
+            summary: `Delete multiple ${humanReadableNamePlural} for ${parentHumanName}`,
+            description: `Deletes multiple ${humanReadableNamePlural} records associated with the specified ${parentHumanName}`,
+            operationId: `deleteMany${pascalModelName}For${pascalCase(parentModel)}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${parentHumanName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "filters",
+                    in: "query",
+                    description: "Additional filters criteria in JSON format",
+                    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",
+                },
+                "404": {
+                    description: `${parentHumanName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (isParentEndpointAllowed("findOne")) {
+        const findOneMode = await getSchemaMode("findOne");
+        paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`] = {
+            get: {
+                tags: [humanReadableNamePlural],
+                summary: `Get ${humanReadableName} by ID for ${parentHumanName}`,
+                description: `Retrieves a single ${humanReadableName} record by its unique identifier associated with the specified ${parentHumanName}`,
+                operationId: `get${pascalModelName}ByIdFor${pascalCase(parentModel)}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        description: `Unique identifier of the ${parentHumanName}`,
+                        required: true,
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                    {
+                        name: "childId",
+                        in: "path",
+                        description: `Unique identifier of the ${humanReadableName}`,
+                        required: true,
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: `${humanReadableName} retrieved successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: getSchemaRef(`FindOne${pascalModelName}`, findOneMode),
+                                },
+                            },
+                        },
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                    "403": {
+                        description: "Insufficient permissions",
+                    },
+                    "404": {
+                        description: `${humanReadableName} or ${parentHumanName} not found`,
+                    },
+                },
+                security: [{ BearerAuth: [] }],
+            },
+        };
+    }
+    if (isParentEndpointAllowed("updateOne")) {
+        if (!paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`])
+            paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`] = {};
+        const updateMode = await getSchemaMode("update");
+        paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`].patch = {
+            tags: [humanReadableNamePlural],
+            summary: `Update ${humanReadableName} by ID for ${parentHumanName}`,
+            description: `Updates a single ${humanReadableName} record by its unique identifier associated with the specified ${parentHumanName}`,
+            operationId: `update${pascalModelName}ByIdFor${pascalCase(parentModel)}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${parentHumanName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "childId",
+                    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: getSchemaRef(`Update${pascalModelName}`, updateMode),
+                        },
+                    },
+                },
+            },
+            responses: {
+                "200": {
+                    description: `${humanReadableName} updated successfully`,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef(`${pascalModelName}`, updateMode),
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    description: "Invalid input data provided",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+                "403": {
+                    description: "Insufficient permissions",
+                },
+                "404": {
+                    description: `${humanReadableName} or ${parentHumanName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+    if (isParentEndpointAllowed("deleteOne")) {
+        if (!paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`])
+            paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`] = {};
+        paths[`/api/${parentRouteName}/{id}/${routeName}/{childId}`].delete = {
+            tags: [humanReadableNamePlural],
+            summary: `Delete ${humanReadableName} by ID for ${parentHumanName}`,
+            description: `Permanently deletes a single ${humanReadableName} record by its unique identifier associated with the specified ${parentHumanName}`,
+            operationId: `delete${pascalModelName}ByIdFor${pascalCase(parentModel)}`,
+            parameters: [
+                {
+                    name: "id",
+                    in: "path",
+                    description: `Unique identifier of the ${parentHumanName}`,
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                },
+                {
+                    name: "childId",
+                    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} or ${parentHumanName} not found`,
+                },
+            },
+            security: [{ BearerAuth: [] }],
+        };
+    }
+}
+//# sourceMappingURL=generate-prisma-model-parent-routes-paths.js.map