arkos 1.3.1-beta → 1.3.2-beta

package/dist/esm/modules/swagger/utils/helpers/get-authentication-json-schema-paths.js

@@ -1 +1,333 @@
-"use strict";import{getSchemaRef as n,localValidatorFileExists as c}from"./swagger.router.helpers.js";import{getModuleComponents as u}from"../../../../utils/dynamic-loader.js";import{isEndpointDisabled as p}from"../../../base/utils/helpers/base.router.helpers.js";export const getSchemaMode=async(s,e)=>{const r=e.swagger?.mode,a=e.swagger?.strict;return r&&(a||await c(s,"user",e))?r:"prisma"};export default async function d(s){const e={};if(!s.swagger?.mode)return e;const a=u("auth")?.router?.config;if(a?.disable===!0)return e;const i=t=>p(a,t);if(!i("login")){const t=await getSchemaMode("login",s);e["/api/auth/login"]={post:{tags:["Authentication"],summary:"Login to the system",description:"Authenticates a user and returns an access token",operationId:"login",requestBody:{description:"User credentials",required:!0,content:{"application/json":{schema:{$ref:n("Login",t)}}}},responses:{200:{description:"Login successful",content:{"application/json":{schema:{type:"object",properties:{accessToken:{type:"string",description:"JWT access token"}}}}}},400:{description:"Invalid input data"},401:{description:"Invalid credentials"}}}}}if(i("logout")||(e["/api/auth/logout"]={delete:{tags:["Authentication"],summary:"Logout from the system",description:"Invalidates the current user's JWT token",operationId:"logout",security:[{BearerAuth:[]}],responses:{204:{description:"Logout successful"},401:{description:"Authentication required"}}}}),!i("signup")){const t=await getSchemaMode("signup",s),o=await getSchemaMode("user",s);e["/api/auth/signup"]={post:{tags:["Authentication"],summary:"Register a new user",description:"Creates a new user account",operationId:"signup",requestBody:{description:"User registration data",required:!0,content:{"application/json":{schema:{$ref:n("Signup",t)}}}},responses:{201:{description:"User created successfully",content:{"application/json":{schema:{$ref:n("User",o)}}}},400:{description:"Invalid input data"},409:{description:"User already exists"}}}}}if(!i("updatePassword")){const t=await getSchemaMode("updatePassword",s);e["/api/auth/update-password"]={post:{tags:["Authentication"],summary:"Update user password",description:"Changes the password for the authenticated user",operationId:"updatePassword",security:[{BearerAuth:[]}],requestBody:{description:"Current and new password",required:!0,content:{"application/json":{schema:{$ref:n("UpdatePassword",t)}}}},responses:{200:{description:"Password updated successfully",content:{"application/json":{schema:{type:"object",properties:{status:{type:"string",example:"success"},message:{type:"string",example:"Password updated successfully!"}}}}}},400:{description:"Invalid input data or current password incorrect"},401:{description:"Authentication required"}}}}}if(!i("getMe")){const t=await getSchemaMode("getMe",s);e["/api/users/me"]={get:{tags:["Authentication"],summary:"Get current user information",description:"Retrieves information about the currently authenticated user",operationId:"getMe",security:[{BearerAuth:[]}],responses:{200:{description:"User information retrieved successfully",content:{"application/json":{schema:{$ref:n("GetMe",t)}}}},401:{description:"Authentication required"}}}}}if(!i("updateMe")){const t=await getSchemaMode("updateMe",s),o=await getSchemaMode("user",s);e["/api/users/me"]||(e["/api/users/me"]={}),e["/api/users/me"].patch={tags:["Authentication"],summary:"Update current user information",description:"Updates information for the currently authenticated user",operationId:"updateMe",security:[{BearerAuth:[]}],requestBody:{description:"User data to update",required:!0,content:{"application/json":{schema:{$ref:n("UpdateMe",t)}}}},responses:{200:{description:"User updated successfully",content:{"application/json":{schema:{$ref:n("User",o)}}}},400:{description:"Invalid input data"},401:{description:"Authentication required"}}}}return i("deleteMe")||(e["/api/users/me"]||(e["/api/users/me"]={}),e["/api/users/me"].delete={tags:["Authentication"],summary:"Delete current user account",description:"Marks the current user's account as deleted",operationId:"deleteMe",security:[{BearerAuth:[]}],responses:{200:{description:"Account deleted successfully",content:{"application/json":{schema:{type:"object",properties:{message:{type:"string",example:"Account deleted successfully"}}}}}},401:{description:"Authentication required"}}}),i("findManyAuthAction")||(e["/api/auth-actions"]={get:{tags:["Authentication"],summary:"Get all authentication actions",description:"Retrieves a list of all available authentication actions and permissions",operationId:"findManyAuthAction",security:[{BearerAuth:[]}],responses:{200:{description:"Auth actions retrieved successfully",content:{"application/json":{schema:{type:"object",properties:{total:{type:"number",description:"Total number of auth actions"},results:{type:"number",description:"Number of auth actions returned"},data:{type:"array",items:{$ref:"#/components/schemas/FindManyAuthActionSystemSchema"}}}}}}},401:{description:"Authentication required"},403:{description:"Insufficient permissions"}}}}),e}
+import { getSchemaRef, localValidatorFileExists, } from "./swagger.router.helpers.js";
+import { getModuleComponents } from "../../../../utils/dynamic-loader.js";
+import { isEndpointDisabled } from "../../../base/utils/helpers/base.router.helpers.js";
+export const getSchemaMode = async (action, arkosConfig) => {
+    const swaggerMode = arkosConfig.swagger?.mode;
+    const isStrict = arkosConfig.swagger?.strict;
+    if (!swaggerMode)
+        return "prisma";
+    if (isStrict)
+        return swaggerMode;
+    const actionKey = action;
+    const localFileExists = await localValidatorFileExists(actionKey, "user", arkosConfig);
+    if (!localFileExists)
+        return "prisma";
+    return swaggerMode;
+};
+export default async function getAuthenticationJsonSchemaPaths(arkosConfig) {
+    const paths = {};
+    if (!arkosConfig.swagger?.mode)
+        return paths;
+    const AuthModuleComponents = getModuleComponents("auth");
+    const routerConfig = AuthModuleComponents?.router?.config;
+    if (routerConfig?.disable === true)
+        return paths;
+    const isAuthEndpointDisabled = (endpoint) => {
+        return isEndpointDisabled(routerConfig, endpoint);
+    };
+    if (!isAuthEndpointDisabled("login")) {
+        const loginMode = await getSchemaMode("login", arkosConfig);
+        paths["/api/auth/login"] = {
+            post: {
+                tags: ["Authentication"],
+                summary: "Login to the system",
+                description: "Authenticates a user and returns an access token",
+                operationId: "login",
+                requestBody: {
+                    description: "User credentials",
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef("Login", loginMode),
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    "200": {
+                        description: "Login successful",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        accessToken: {
+                                            type: "string",
+                                            description: "JWT access token",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    "400": {
+                        description: "Invalid input data",
+                    },
+                    "401": {
+                        description: "Invalid credentials",
+                    },
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("logout")) {
+        paths["/api/auth/logout"] = {
+            delete: {
+                tags: ["Authentication"],
+                summary: "Logout from the system",
+                description: "Invalidates the current user's JWT token",
+                operationId: "logout",
+                security: [{ BearerAuth: [] }],
+                responses: {
+                    "204": {
+                        description: "Logout successful",
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("signup")) {
+        const signupMode = await getSchemaMode("signup", arkosConfig);
+        const userMode = await getSchemaMode("user", arkosConfig);
+        paths["/api/auth/signup"] = {
+            post: {
+                tags: ["Authentication"],
+                summary: "Register a new user",
+                description: "Creates a new user account",
+                operationId: "signup",
+                requestBody: {
+                    description: "User registration data",
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef("Signup", signupMode),
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    "201": {
+                        description: "User created successfully",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: getSchemaRef("User", userMode),
+                                },
+                            },
+                        },
+                    },
+                    "400": {
+                        description: "Invalid input data",
+                    },
+                    "409": {
+                        description: "User already exists",
+                    },
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("updatePassword")) {
+        const updatePasswordMode = await getSchemaMode("updatePassword", arkosConfig);
+        paths["/api/auth/update-password"] = {
+            post: {
+                tags: ["Authentication"],
+                summary: "Update user password",
+                description: "Changes the password for the authenticated user",
+                operationId: "updatePassword",
+                security: [{ BearerAuth: [] }],
+                requestBody: {
+                    description: "Current and new password",
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef("UpdatePassword", updatePasswordMode),
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    "200": {
+                        description: "Password updated successfully",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        status: {
+                                            type: "string",
+                                            example: "success",
+                                        },
+                                        message: {
+                                            type: "string",
+                                            example: "Password updated successfully!",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    "400": {
+                        description: "Invalid input data or current password incorrect",
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("getMe")) {
+        const findMeMode = await getSchemaMode("getMe", arkosConfig);
+        paths["/api/users/me"] = {
+            get: {
+                tags: ["Authentication"],
+                summary: "Get current user information",
+                description: "Retrieves information about the currently authenticated user",
+                operationId: "getMe",
+                security: [{ BearerAuth: [] }],
+                responses: {
+                    "200": {
+                        description: "User information retrieved successfully",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: getSchemaRef("GetMe", findMeMode),
+                                },
+                            },
+                        },
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("updateMe")) {
+        const updateMeMode = await getSchemaMode("updateMe", arkosConfig);
+        const userMode = await getSchemaMode("user", arkosConfig);
+        if (!paths["/api/users/me"])
+            paths["/api/users/me"] = {};
+        paths["/api/users/me"].patch = {
+            tags: ["Authentication"],
+            summary: "Update current user information",
+            description: "Updates information for the currently authenticated user",
+            operationId: "updateMe",
+            security: [{ BearerAuth: [] }],
+            requestBody: {
+                description: "User data to update",
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: getSchemaRef("UpdateMe", updateMeMode),
+                        },
+                    },
+                },
+            },
+            responses: {
+                "200": {
+                    description: "User updated successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef("User", userMode),
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    description: "Invalid input data",
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("deleteMe")) {
+        if (!paths["/api/users/me"])
+            paths["/api/users/me"] = {};
+        paths["/api/users/me"].delete = {
+            tags: ["Authentication"],
+            summary: "Delete current user account",
+            description: "Marks the current user's account as deleted",
+            operationId: "deleteMe",
+            security: [{ BearerAuth: [] }],
+            responses: {
+                "200": {
+                    description: "Account deleted successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    message: {
+                                        type: "string",
+                                        example: "Account deleted successfully",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "401": {
+                    description: "Authentication required",
+                },
+            },
+        };
+    }
+    if (!isAuthEndpointDisabled("findManyAuthAction")) {
+        paths["/api/auth-actions"] = {
+            get: {
+                tags: ["Authentication"],
+                summary: "Get all authentication actions",
+                description: "Retrieves a list of all available authentication actions and permissions",
+                operationId: "findManyAuthAction",
+                security: [{ BearerAuth: [] }],
+                responses: {
+                    "200": {
+                        description: "Auth actions retrieved successfully",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        total: {
+                                            type: "number",
+                                            description: "Total number of auth actions",
+                                        },
+                                        results: {
+                                            type: "number",
+                                            description: "Number of auth actions returned",
+                                        },
+                                        data: {
+                                            type: "array",
+                                            items: {
+                                                $ref: "#/components/schemas/FindManyAuthActionSystemSchema",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    "401": {
+                        description: "Authentication required",
+                    },
+                    "403": {
+                        description: "Insufficient permissions",
+                    },
+                },
+            },
+        };
+    }
+    return paths;
+}
+//# sourceMappingURL=get-authentication-json-schema-paths.js.map

package/dist/esm/modules/swagger/utils/helpers/get-swagger-default-configs.js

@@ -1 +1,58 @@
-"use strict";import{capitalize as r}from"../../../../utils/helpers/text.helpers.js";import s from"../../../../utils/features/port-and-host-allocator.js";export default async function a(t,o){const e=await s.getHostAndAvailablePort({});return{endpoint:"/docs",mode:"prisma",strict:!1,options:{definition:{openapi:"3.0.0",info:{title:"Powered By Arkos.js",version:"1.0.0",description:"This API was automatically generated by Arkos.js, read more about at www.arkosjs.com"},servers:[{url:`http://${e.host}:${e.port}`,description:`Local ${r(process.env.NODE_ENV||"development")} Server`}],paths:t,components:{schemas:o||{},securitySchemes:{BearerAuth:{type:"http",scheme:"bearer",bearerFormat:"JWT"}}},security:[]},apis:["./src/routers/*.router.{ts,js}","./src/modules/**/*.router.{ts,js}"],deepLinking:!0,tryItOutEnabled:!0,persistAuthorization:!1},scalarApiReferenceConfiguration:{theme:"deepSpace",darkMode:!0,layout:"modern",showSidebar:!0,hideDownloadButton:!1,metaData:{title:"Arkos.js API Documentation",description:"API documentation generated by Arkos.js"},pageTitle:"Arkos.js API Documentation"}}}
+import { capitalize } from "../../../../utils/helpers/text.helpers.js";
+import portAndHostAllocator from "../../../../utils/features/port-and-host-allocator.js";
+export default async function getSwaggerDefaultConfig(defaultModelsPaths, defaultJsonSchemas) {
+    const portAndHost = await portAndHostAllocator.getHostAndAvailablePort({});
+    return {
+        endpoint: "/docs",
+        mode: "prisma",
+        strict: false,
+        options: {
+            definition: {
+                openapi: "3.0.0",
+                info: {
+                    title: "Powered By Arkos.js",
+                    version: "1.0.0",
+                    description: "This API was automatically generated by Arkos.js, read more about at www.arkosjs.com",
+                },
+                servers: [
+                    {
+                        url: `http://${portAndHost.host}:${portAndHost.port}`,
+                        description: `Local ${capitalize(process.env.NODE_ENV || "development")} Server`,
+                    },
+                ],
+                paths: defaultModelsPaths,
+                components: {
+                    schemas: defaultJsonSchemas || {},
+                    securitySchemes: {
+                        BearerAuth: {
+                            type: "http",
+                            scheme: "bearer",
+                            bearerFormat: "JWT",
+                        },
+                    },
+                },
+                security: [],
+            },
+            apis: [
+                "./src/routers/*.router.{ts,js}",
+                "./src/modules/**/*.router.{ts,js}",
+            ],
+            deepLinking: true,
+            tryItOutEnabled: true,
+            persistAuthorization: false,
+        },
+        scalarApiReferenceConfiguration: {
+            theme: "deepSpace",
+            darkMode: true,
+            layout: "modern",
+            showSidebar: true,
+            hideDownloadButton: false,
+            metaData: {
+                title: "Arkos.js API Documentation",
+                description: "API documentation generated by Arkos.js",
+            },
+            pageTitle: "Arkos.js API Documentation",
+        },
+    };
+}
+//# sourceMappingURL=get-swagger-default-configs.js.map

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

@@ -1 +1,34 @@
-"use strict";export function getSystemJsonSchemaPaths(){const e={};return e["/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"}}}}}}}}},e}
+export 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",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    return paths;
+}
+//# sourceMappingURL=get-system-json-schema-paths.js.map

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

@@ -1 +1,42 @@
-"use strict";import{validationMetadatasToSchemas as i}from"class-validator-jsonschema";import{importModule as f}from"../../../../../utils/helpers/global.helpers.js";import{getMetadataStorage as h}from"class-validator";import{getModuleComponents as d}from"../../../../../utils/dynamic-loader.js";import{getCorrectJsonSchemaName as p}from"../swagger.router.helpers.js";import g from"../../../../../utils/prisma/prisma-schema-parser.js";export async function generateClassValidatorJsonSchemas(){const c=[...g.getModelsAsArrayOfStrings(),"auth"],e={},{defaultMetadataStorage:m}=await f("class-transformer/cjs/storage.js"),s=i({classValidatorMetadataStorage:h(),classTransformerMetadataStorage:m,refPointerPrefix:"#/components/schemas/"});return Object.entries(s).forEach(([a,t])=>{e[a]=t}),c.forEach(a=>{const t=d(a);t?.dtos&&Object.entries(t.dtos).forEach(([n,r])=>{if(r)try{const o=p(n,a,"Dto");e[o]=s[r.name]||{},e[r.name]&&delete e[r.name]}catch(o){console.warn(`Failed to generate schema for ${n} ${a}:`,o)}})}),e}
+import { validationMetadatasToSchemas } from "class-validator-jsonschema";
+import { importModule } from "../../../../../utils/helpers/global.helpers.js";
+import { getMetadataStorage } from "class-validator";
+import { getModuleComponents } from "../../../../../utils/dynamic-loader.js";
+import { getCorrectJsonSchemaName } from "../swagger.router.helpers.js";
+import prismaSchemaParser from "../../../../../utils/prisma/prisma-schema-parser.js";
+export async function generateClassValidatorJsonSchemas() {
+    const requiredAppModules = [
+        ...prismaSchemaParser.getModelsAsArrayOfStrings(),
+        "auth",
+    ];
+    const schemas = {};
+    const { defaultMetadataStorage } = await importModule("class-transformer/cjs/storage.js");
+    const jsonSchema = validationMetadatasToSchemas({
+        classValidatorMetadataStorage: getMetadataStorage(),
+        classTransformerMetadataStorage: defaultMetadataStorage,
+        refPointerPrefix: "#/components/schemas/",
+    });
+    Object.entries(jsonSchema).forEach(([className, schema]) => {
+        schemas[className] = schema;
+    });
+    requiredAppModules.forEach((modelName) => {
+        const moduleComponents = getModuleComponents(modelName);
+        if (moduleComponents?.dtos) {
+            Object.entries(moduleComponents.dtos).forEach(([dtoType, dtoClass]) => {
+                if (dtoClass) {
+                    try {
+                        const schemaName = 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/esm/modules/swagger/utils/helpers/json-schema-generators/generate-prisma-json-schemas.js

@@ -1 +1,26 @@
-"use strict";import m from"../../../../../utils/prisma/prisma-json-schema-generator.js";import t from"../../../../../utils/prisma/prisma-schema-parser.js";export async function generatePrismaJsonSchemas(s){const o=[...t.getModelsAsArrayOfStrings(),"auth"];try{return(await Promise.all(o.map(async r=>await m.generateModelSchemas({modelName:r,arkosConfig:s})))).reduce((r,a)=>({...r,...a}),{})}catch(e){throw console.error(e),e}}
+import PrismaJsonSchemaGenerator from "../../../../../utils/prisma/prisma-json-schema-generator.js";
+import prismaSchemaParser from "../../../../../utils/prisma/prisma-schema-parser.js";
+export async function generatePrismaJsonSchemas(arkosConfig) {
+    const requiredAppModules = [
+        ...prismaSchemaParser.getModelsAsArrayOfStrings(),
+        "auth",
+    ];
+    try {
+        const modelSchemasArray = await Promise.all(requiredAppModules.map(async (modelName) => {
+            const modelSchemas = await PrismaJsonSchemaGenerator.generateModelSchemas({
+                modelName,
+                arkosConfig,
+            });
+            return modelSchemas;
+        }));
+        const schemas = modelSchemasArray.reduce((acc, modelSchemas) => {
+            return { ...acc, ...modelSchemas };
+        }, {});
+        return schemas;
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+}
+//# sourceMappingURL=generate-prisma-json-schemas.js.map

package/dist/esm/modules/swagger/utils/helpers/json-schema-generators/generate-system-json-schemas.js

@@ -1 +1,46 @@
-"use strict";export default function i(t){const r=t?.authentication?.mode==="dynamic",e={action:{type:"string",description:"Action name, e.g Create, View, Update, Download, Cancel"},resource:{type:"string",description:"Resource name, e.g user, user-role, product, author"},name:{type:"string",description:"Human-readable name for this permission",nullable:!0},description:{type:"string",description:"Detailed description of what this permission allows",nullable:!0},errorMessage:{type:"string",description:"Error message returned on forbidden response",nullable:!0}};return r||(e.roles={type:"array",description:"Role names that have this permission, e.g Admin, Manager",items:{type:"string"}}),{FindManyAuthActionSystemSchema:{type:"object",properties:e,required:["action","resource"],additionalProperties:!1}}}
+export default function generateSystemJsonSchemas(arkosConfig) {
+    const isDynamicMode = arkosConfig?.authentication?.mode === "dynamic";
+    const baseProperties = {
+        action: {
+            type: "string",
+            description: "Action name, e.g Create, View, Update, Download, Cancel",
+        },
+        resource: {
+            type: "string",
+            description: "Resource name, e.g user, user-role, product, author",
+        },
+        name: {
+            type: "string",
+            description: "Human-readable name for this permission",
+            nullable: true,
+        },
+        description: {
+            type: "string",
+            description: "Detailed description of what this permission allows",
+            nullable: true,
+        },
+        errorMessage: {
+            type: "string",
+            description: "Error message returned on forbidden response",
+            nullable: true,
+        },
+    };
+    if (!isDynamicMode) {
+        baseProperties.roles = {
+            type: "array",
+            description: "Role names that have this permission, e.g Admin, Manager",
+            items: {
+                type: "string",
+            },
+        };
+    }
+    return {
+        FindManyAuthActionSystemSchema: {
+            type: "object",
+            properties: baseProperties,
+            required: ["action", "resource"],
+            additionalProperties: false,
+        },
+    };
+}
+//# sourceMappingURL=generate-system-json-schemas.js.map

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

@@ -1 +1,28 @@
-"use strict";import{getModuleComponents as m}from"../../../../../utils/dynamic-loader.js";import h from"zod-to-json-schema";import{getCorrectJsonSchemaName as f}from"../swagger.router.helpers.js";import i from"../../../../../utils/prisma/prisma-schema-parser.js";export default async function p(){const n=[...i.getModelsAsArrayOfStrings(),"auth"],r={};return n.forEach(o=>{const s=m(o);s?.schemas&&Object.entries(s.schemas).forEach(([t,c])=>{if(c)try{const e=h(c),a=f(t,o,"Schema");r[a]=e}catch(e){console.warn(`Failed to generate schema for ${t} ${o}:`,e)}})}),r}
+import { getModuleComponents } from "../../../../../utils/dynamic-loader.js";
+import zodToJsonSchema from "zod-to-json-schema";
+import { getCorrectJsonSchemaName } from "../swagger.router.helpers.js";
+import prismaSchemaParser from "../../../../../utils/prisma/prisma-schema-parser.js";
+export default async function generateZodJsonSchemas() {
+    const requiredAppModules = [
+        ...prismaSchemaParser.getModelsAsArrayOfStrings(),
+        "auth",
+    ];
+    const schemas = {};
+    requiredAppModules.forEach((modelName) => {
+        const moduleComponents = getModuleComponents(modelName);
+        if (moduleComponents?.schemas)
+            Object.entries(moduleComponents.schemas).forEach(([schemaType, zodSchema]) => {
+                if (zodSchema)
+                    try {
+                        const jsonSchema = zodToJsonSchema(zodSchema);
+                        const schemaName = getCorrectJsonSchemaName(schemaType, modelName, "Schema");
+                        schemas[schemaName] = jsonSchema;
+                    }
+                    catch (error) {
+                        console.warn(`Failed to generate schema for ${schemaType} ${modelName}:`, error);
+                    }
+            });
+    });
+    return schemas;
+}
+//# sourceMappingURL=generate-zod-json-schemas.js.map