arkos 1.3.1-beta → 1.3.2-beta

package/dist/esm/utils/prisma/prisma-json-schema-generator.js

@@ -1 +1,448 @@
-"use strict";import h from"../helpers/deepmerge.helper.js";import{getModuleComponents as f}from"../dynamic-loader.js";import y from"./prisma-schema-parser.js";import{localValidatorFileExists as c}from"../../modules/swagger/utils/helpers/swagger.router.helpers.js";export class PrismaJsonSchemaGenerator{constructor(){this.schema=y.parse()}async generateModelSchemas(t){const{modelName:a,arkosConfig:n,schemasToGenerate:s=["model","login","signup","getMe","updateMe","updatePassword","create","createOne","createMany","update","updateOne","updateMany","query","findOne","findMany"]}=t,e=f(a),i=e?.router?.config||{},r=e?.prismaQueryOptions||{},o=["auth","me","password","signup","login"].includes(a.toLowerCase());if(n?.swagger?.strict&&n.swagger.mode!=="prisma")return{};if(i?.disable===!0)return{};const d=this.schema.models.find(l=>l.name.toLowerCase()===a.toLowerCase());if(!d&&!o)return{};const u={};return o?await this.generateAuthSchemas(this.schema.models.find(l=>l.name.toLowerCase()==="user"),u,n,s,r):d&&await this.generateCrudSchemas(d,u,n,s,r,i),{...u}}async generateAuthSchemas(t,a,n,s,e,i){const r="Auth";if(!n?.authentication)return a;s.includes("login")&&!this.isEndpointDisabled("login",i)&&!await c("login",r,n)&&(a.LoginSchema=this.generateLoginSchema(n)),s.includes("signup")&&!this.isEndpointDisabled("signup",i)&&!await c("signup",r,n)&&(a.SignupSchema=this.generateSignupSchema(t,e?.signup)),s.includes("updateMe")&&!this.isEndpointDisabled("updateMe",i)&&!await c("updateMe",r,n)&&(a.UpdateMeSchema=this.generateUpdateMeSchema(t,e?.updateMe)),s.includes("updatePassword")&&!this.isEndpointDisabled("updatePassword",i)&&!await c("updatePassword",r,n)&&(a.UpdatePasswordSchema=this.generateUpdatePasswordSchema(t,e?.updatePassword)),s.includes("getMe")&&!this.isEndpointDisabled("getMe",i)&&!await c("getMe",r,n)&&(a.GetMeSchema=this.generateResponseSchema(t,e?.getMe||{},"findOne"))}async generateCrudSchemas(t,a,n,s,e,i){const r=t.name,p=async(o,d)=>{const u=n.validation?.resolver==="zod"?"Schema":"Dto";if(await c(o==="Create"?"createOne":"updateOne",d,n))return`${o}${d}${u}`;{const m=`${o}${d}ModelSchema`;return a[m]||(o==="Create"?a[m]=this.generateCreateSchema(t,this.resolvePrismaQueryOptions(e,"createOne")):o==="Update"&&(a[m]=this.generateUpdateSchema(t,this.resolvePrismaQueryOptions(e,"updateOne")))),m}};if(s.includes("createOne")&&!this.isEndpointDisabled("createOne",i)&&!await c("createOne",r,n)&&(a[`Create${r}ModelSchema`]=this.generateCreateSchema(t,this.resolvePrismaQueryOptions(e,"createOne"))),s.includes("createMany")&&!this.isEndpointDisabled("createMany",i)&&!await c("createMany",r,n)){const o=await p("Create",r);a[`CreateMany${r}ModelSchema`]={type:"array",items:{$ref:`#/components/schemas/${o}`}}}if(s.includes("updateOne")&&!this.isEndpointDisabled("updateOne",i)&&!await c("updateOne",r,n)&&(a[`Update${r}ModelSchema`]=this.generateUpdateSchema(t,this.resolvePrismaQueryOptions(e,"updateOne"))),s.includes("updateMany")&&!this.isEndpointDisabled("updateMany",i)&&!await c("updateMany",r,n)){const o=await p("Update",r);a[`UpdateMany${r}ModelSchema`]={type:"object",properties:{data:{type:"object",$ref:`#/components/schemas/${o}`},where:{type:"object"}},required:["data"]}}s.includes("findOne")&&!this.isEndpointDisabled("findOne",i)&&!await c("findOne",r,n)&&(a[`FindOne${r}ModelSchema`]=this.generateResponseSchema(t,this.resolvePrismaQueryOptions(e,"findOne"),"findOne")),s.includes("findMany")&&!this.isEndpointDisabled("findMany",i)&&!await c("findMany",r,n)&&(a[`FindMany${r}ModelSchema`]={type:"array",items:this.generateResponseSchema(t,this.resolvePrismaQueryOptions(e,"findMany"),"findMany")})}generateCreateSchema(t,a){const n={},s=[],e=["createdAt","updatedAt","deletedAt","id"];t.name.toLowerCase()==="auth"&&e.push("roles","role","isActive","isStaff","isSuperUser","passwordChangedAt","deletedSelfAccountAt","lastLoginAt");for(const i of t.fields){if(i.isId||e.includes(i.name))continue;if(this.isModelRelation(i.type)){!i.isArray&&i.connectionField&&(n[i.connectionField]={type:this.mapPrismaTypeToJsonSchema(t.fields.find(p=>p.name===i.connectionField)?.type||"String")},!i.isOptional&&i.defaultValue===void 0&&s.push(i.name));continue}const r=this.convertFieldToJsonSchema(i);n[i.name]=r,!i.isOptional&&i.defaultValue===void 0&&!i.isArray&&s.push(i.name)}return{type:"object",properties:n,required:s}}generateUpdateSchema(t,a){const n={},s=["createdAt","updatedAt","deletedAt","id"];for(const e of t.fields){if(e.isId||s.includes(e.name))continue;if(this.isModelRelation(e.type)){!e.isArray&&e.connectionField&&(n[e.connectionField]={type:this.mapPrismaTypeToJsonSchema(t.fields.find(r=>r.name===e.connectionField)?.type||"String")});continue}const i=this.convertFieldToJsonSchema(e);n[e.name]=i}return{type:"object",properties:n,required:[]}}generateResponseSchema(t,a,n){const s={},e=[],i=a?.select,r=a?.omit,p=a?.include;for(const o of t.fields){if(o.name==="password"||r&&r[o.name]||i&&!i[o.name])continue;if(this.isModelRelation(o.type)){if(p?.[o.name]){const u=this.schema.models.find(l=>l.name===o.type);if(u){const l=this.generateNestedRelationSchema(u,p[o.name]);s[o.name]=o.isArray?{type:"array",items:l}:l}}continue}const d=this.convertFieldToJsonSchema(o);s[o.name]=d,o.isOptional||e.push(o.name)}return{type:"object",properties:s,required:e}}generateNestedRelationSchema(t,a){const n={},s=[],e=a?.select,i=a?.include;for(const r of t.fields){if(r.name.toLowerCase().includes("password")||e&&!e[r.name])continue;if(this.isModelRelation(r.type)){if(i?.[r.name]){const o=this.schema.models.find(d=>d.name===r.type);if(o){const d=this.generateNestedRelationSchema(o,i[r.name]);n[r.name]=r.isArray?{type:"array",items:d}:d}}continue}const p=this.convertFieldToJsonSchema(r);n[r.name]=p,r.isOptional||s.push(r.name)}return{type:"object",properties:n,required:s}}generateLoginSchema(t){const a=t?.authentication?.login?.allowedUsernames||[],n=e=>e.includes(".")&&e.split(".").pop()||e,s={type:"object",properties:{password:{type:"string",minLength:8}},required:["password"]};if(a.forEach(e=>{const i=n(e);s.properties[i]={type:"string",format:"string",description:`Username field: ${e}`}}),a.length>0){const e=a.map(n);return{...s,anyOf:e.map(()=>({required:[...s.required]}))}}return s}generateSignupSchema(t,a){const n=this.generateCreateSchema(t,a||{});return["roles","role","isActive","isStaff","isSuperUser","passwordChangedAt","deletedSelfAccountAt","lastLoginAt"].forEach(e=>{delete n?.properties?.[e]}),n}generateUpdateMeSchema(t,a){const n=this.generateUpdateSchema(t,a||{});return["roles","role","isActive","isStaff","isSuperUser","passwordChangedAt","deletedSelfAccountAt","password","lastLoginAt"].forEach(e=>{delete n?.properties?.[e]}),n}generateUpdatePasswordSchema(t,a){return{type:"object",properties:{currentPassword:{type:"string"},newPassword:{type:"string",minLength:8}},required:["currentPassword","newPassword"]}}resolvePrismaQueryOptions(t,a){if(!t||!a)return{};const n=t,s=n[a]||{};let e=n.queryOptions||{};n.global&&(e=h(e,n.global));const i=this.getGeneralOptionsForAction(n,a);return i&&(e=h(e,i)),s&&(e=h(e,s)),e}getGeneralOptionsForAction(t,a){const n={find:["findOne","findMany"],create:["createOne","createMany"],update:["updateOne","updateMany"],delete:["deleteOne","deleteMany"],save:["createOne","createMany","updateOne","updateMany"],saveOne:["createOne","updateOne"],saveMany:["createMany","updateMany"]};for(const[s,e]of Object.entries(n))if(e.includes(a)&&t[s])return t[s];return null}isEndpointDisabled(t,a){return a?.disable?typeof a.disable=="boolean"?a.disable:a.disable[t]||!1:!1}isModelRelation(t){return this.schema.models.some(a=>a.name===t)}convertFieldToJsonSchema(t){const n={type:this.mapPrismaTypeToJsonSchema(t.type)};if(t.isArray&&(n.type="array",n.items={type:this.mapPrismaTypeToJsonSchema(t.type)}),t.defaultValue!==void 0&&(n.default=t.defaultValue),t.type==="DateTime"&&(n.format="date-time"),this.isEnum(t.type)){const s=this.schema.enums.find(e=>e.name===t.type);s&&(n.enum=s.values)}return n}mapPrismaTypeToJsonSchema(t){const a={String:"string",Int:"number",Float:"number",Boolean:"boolean",DateTime:"string",Json:"object",Bytes:"string"};return a[t]?a[t]:this.isEnum(t)?"string":this.isModelRelation(t)?"object":"string"}isEnum(t){return this.schema.enums.some(a=>a.name===t)}}const S=new PrismaJsonSchemaGenerator;export default S;
+import deepmerge from "../helpers/deepmerge.helper.js";
+import { getModuleComponents, } from "../dynamic-loader.js";
+import prismaSchemaParser from "./prisma-schema-parser.js";
+import { localValidatorFileExists } from "../../modules/swagger/utils/helpers/swagger.router.helpers.js";
+export class PrismaJsonSchemaGenerator {
+    constructor() {
+        this.schema = prismaSchemaParser.parse();
+    }
+    async generateModelSchemas(config) {
+        const { modelName, arkosConfig, schemasToGenerate = [
+            "model",
+            "login",
+            "signup",
+            "getMe",
+            "updateMe",
+            "updatePassword",
+            "create",
+            "createOne",
+            "createMany",
+            "update",
+            "updateOne",
+            "updateMany",
+            "query",
+            "findOne",
+            "findMany",
+        ], } = config;
+        const moduleComponents = getModuleComponents(modelName);
+        const routerConfig = moduleComponents?.router?.config || {};
+        const prismaQueryOptions = moduleComponents?.prismaQueryOptions || {};
+        const authModuleModel = ["auth", "me", "password", "signup", "login"];
+        const isAuthModule = authModuleModel.includes(modelName.toLowerCase());
+        if (arkosConfig?.swagger?.strict && arkosConfig.swagger.mode !== "prisma")
+            return {};
+        if (routerConfig?.disable === true)
+            return {};
+        const model = this.schema.models.find((m) => m.name.toLowerCase() === modelName.toLowerCase());
+        if (!model && !isAuthModule)
+            return {};
+        const schemas = {};
+        if (isAuthModule) {
+            await this.generateAuthSchemas(this.schema.models.find((m) => m.name.toLowerCase() === "user"), schemas, arkosConfig, schemasToGenerate, prismaQueryOptions);
+        }
+        else {
+            if (model)
+                await this.generateCrudSchemas(model, schemas, arkosConfig, schemasToGenerate, prismaQueryOptions, routerConfig);
+        }
+        return { ...schemas };
+    }
+    async generateAuthSchemas(model, schemas, arkosConfig, schemasToGenerate, queryOptions, routerConfig) {
+        const modelName = "Auth";
+        if (!arkosConfig?.authentication)
+            return schemas;
+        if (schemasToGenerate.includes("login") &&
+            !this.isEndpointDisabled("login", routerConfig) &&
+            !(await localValidatorFileExists("login", modelName, arkosConfig))) {
+            schemas[`LoginSchema`] = this.generateLoginSchema(arkosConfig);
+        }
+        if (schemasToGenerate.includes("signup") &&
+            !this.isEndpointDisabled("signup", routerConfig) &&
+            !(await localValidatorFileExists("signup", modelName, arkosConfig))) {
+            schemas[`SignupSchema`] = this.generateSignupSchema(model, queryOptions?.signup);
+        }
+        if (schemasToGenerate.includes("updateMe") &&
+            !this.isEndpointDisabled("updateMe", routerConfig) &&
+            !(await localValidatorFileExists("updateMe", modelName, arkosConfig))) {
+            schemas[`UpdateMeSchema`] = this.generateUpdateMeSchema(model, queryOptions?.updateMe);
+        }
+        if (schemasToGenerate.includes("updatePassword") &&
+            !this.isEndpointDisabled("updatePassword", routerConfig) &&
+            !(await localValidatorFileExists("updatePassword", modelName, arkosConfig))) {
+            schemas[`UpdatePasswordSchema`] = this.generateUpdatePasswordSchema(model, queryOptions?.updatePassword);
+        }
+        if (schemasToGenerate.includes("getMe") &&
+            !this.isEndpointDisabled("getMe", routerConfig) &&
+            !(await localValidatorFileExists("getMe", modelName, arkosConfig))) {
+            schemas[`GetMeSchema`] = this.generateResponseSchema(model, queryOptions?.getMe || {}, "findOne");
+        }
+    }
+    async generateCrudSchemas(model, schemas, arkosConfig, schemasToGenerate, queryOptions, routerConfig) {
+        const modelName = model.name;
+        const ensureBaseSchemaReference = async (operation, modelName) => {
+            const suffix = arkosConfig.validation?.resolver === "zod" ? "Schema" : "Dto";
+            const singleOpName = operation === "Create" ? "createOne" : "updateOne";
+            const hasLocalValidator = await localValidatorFileExists(singleOpName, modelName, arkosConfig);
+            if (hasLocalValidator) {
+                return `${operation}${modelName}${suffix}`;
+            }
+            else {
+                const modelSchemaKey = `${operation}${modelName}ModelSchema`;
+                if (!schemas[modelSchemaKey]) {
+                    if (operation === "Create") {
+                        schemas[modelSchemaKey] = this.generateCreateSchema(model, this.resolvePrismaQueryOptions(queryOptions, "createOne"));
+                    }
+                    else if (operation === "Update") {
+                        schemas[modelSchemaKey] = this.generateUpdateSchema(model, this.resolvePrismaQueryOptions(queryOptions, "updateOne"));
+                    }
+                }
+                return modelSchemaKey;
+            }
+        };
+        if (schemasToGenerate.includes("createOne") &&
+            !this.isEndpointDisabled("createOne", routerConfig) &&
+            !(await localValidatorFileExists("createOne", modelName, arkosConfig))) {
+            schemas[`Create${modelName}ModelSchema`] = this.generateCreateSchema(model, this.resolvePrismaQueryOptions(queryOptions, "createOne"));
+        }
+        if (schemasToGenerate.includes("createMany") &&
+            !this.isEndpointDisabled("createMany", routerConfig) &&
+            !(await localValidatorFileExists("createMany", modelName, arkosConfig))) {
+            const baseSchemaKey = await ensureBaseSchemaReference("Create", modelName);
+            schemas[`CreateMany${modelName}ModelSchema`] = {
+                type: "array",
+                items: { $ref: `#/components/schemas/${baseSchemaKey}` },
+            };
+        }
+        if (schemasToGenerate.includes("updateOne") &&
+            !this.isEndpointDisabled("updateOne", routerConfig) &&
+            !(await localValidatorFileExists("updateOne", modelName, arkosConfig))) {
+            schemas[`Update${modelName}ModelSchema`] = this.generateUpdateSchema(model, this.resolvePrismaQueryOptions(queryOptions, "updateOne"));
+        }
+        if (schemasToGenerate.includes("updateMany") &&
+            !this.isEndpointDisabled("updateMany", routerConfig) &&
+            !(await localValidatorFileExists("updateMany", modelName, arkosConfig))) {
+            const baseSchemaKey = await ensureBaseSchemaReference("Update", modelName);
+            schemas[`UpdateMany${modelName}ModelSchema`] = {
+                type: "object",
+                properties: {
+                    data: {
+                        type: "object",
+                        $ref: `#/components/schemas/${baseSchemaKey}`,
+                    },
+                    where: { type: "object" },
+                },
+                required: ["data"],
+            };
+        }
+        if (schemasToGenerate.includes("findOne") &&
+            !this.isEndpointDisabled("findOne", routerConfig) &&
+            !(await localValidatorFileExists("findOne", modelName, arkosConfig))) {
+            schemas[`FindOne${modelName}ModelSchema`] = this.generateResponseSchema(model, this.resolvePrismaQueryOptions(queryOptions, "findOne"), "findOne");
+        }
+        if (schemasToGenerate.includes("findMany") &&
+            !this.isEndpointDisabled("findMany", routerConfig) &&
+            !(await localValidatorFileExists("findMany", modelName, arkosConfig))) {
+            schemas[`FindMany${modelName}ModelSchema`] = {
+                type: "array",
+                items: this.generateResponseSchema(model, this.resolvePrismaQueryOptions(queryOptions, "findMany"), "findMany"),
+            };
+        }
+    }
+    generateCreateSchema(model, _) {
+        const properties = {};
+        const required = [];
+        const restrictedFields = ["createdAt", "updatedAt", "deletedAt", "id"];
+        if (model.name.toLowerCase() === "auth")
+            restrictedFields.push("roles", "role", "isActive", "isStaff", "isSuperUser", "passwordChangedAt", "deletedSelfAccountAt", "lastLoginAt");
+        for (const field of model.fields) {
+            if (field.isId || restrictedFields.includes(field.name))
+                continue;
+            if (this.isModelRelation(field.type)) {
+                if (!field.isArray && field.connectionField) {
+                    properties[field.connectionField] = {
+                        type: this.mapPrismaTypeToJsonSchema(model.fields.find((_field) => _field.name === field.connectionField)?.type || "String"),
+                    };
+                    if (!field.isOptional && field.defaultValue === undefined)
+                        required.push(field.name);
+                }
+                continue;
+            }
+            const property = this.convertFieldToJsonSchema(field);
+            properties[field.name] = property;
+            if (!field.isOptional &&
+                field.defaultValue === undefined &&
+                !field.isArray) {
+                required.push(field.name);
+            }
+        }
+        return {
+            type: "object",
+            properties,
+            required,
+        };
+    }
+    generateUpdateSchema(model, _) {
+        const properties = {};
+        const autoFillFields = ["createdAt", "updatedAt", "deletedAt", "id"];
+        for (const field of model.fields) {
+            if (field.isId || autoFillFields.includes(field.name))
+                continue;
+            if (this.isModelRelation(field.type)) {
+                if (!field.isArray && field.connectionField)
+                    properties[field.connectionField] = {
+                        type: this.mapPrismaTypeToJsonSchema(model.fields.find((_field) => _field.name === field.connectionField)?.type || "String"),
+                    };
+                continue;
+            }
+            const property = this.convertFieldToJsonSchema(field);
+            properties[field.name] = property;
+        }
+        return {
+            type: "object",
+            properties,
+            required: [],
+        };
+    }
+    generateResponseSchema(model, options, _) {
+        const properties = {};
+        const required = [];
+        const selectFields = options?.select;
+        const omittedFields = options?.omit;
+        const includeRelations = options?.include;
+        for (const field of model.fields) {
+            if (field.name === "password")
+                continue;
+            if (omittedFields && omittedFields[field.name])
+                continue;
+            if (selectFields && !selectFields[field.name])
+                continue;
+            if (this.isModelRelation(field.type)) {
+                if (includeRelations?.[field.name]) {
+                    const relationModel = this.schema.models.find((m) => m.name === field.type);
+                    if (relationModel) {
+                        const relationSchema = this.generateNestedRelationSchema(relationModel, includeRelations[field.name]);
+                        properties[field.name] = field.isArray
+                            ? { type: "array", items: relationSchema }
+                            : relationSchema;
+                    }
+                }
+                continue;
+            }
+            const property = this.convertFieldToJsonSchema(field);
+            properties[field.name] = property;
+            if (!field.isOptional)
+                required.push(field.name);
+        }
+        return {
+            type: "object",
+            properties,
+            required,
+        };
+    }
+    generateNestedRelationSchema(model, includeOptions) {
+        const properties = {};
+        const required = [];
+        const selectFields = includeOptions?.select;
+        const nestedIncludes = includeOptions?.include;
+        for (const field of model.fields) {
+            if (field.name.toLowerCase().includes("password")) {
+                continue;
+            }
+            if (selectFields && !selectFields[field.name]) {
+                continue;
+            }
+            if (this.isModelRelation(field.type)) {
+                if (nestedIncludes?.[field.name]) {
+                    const relationModel = this.schema.models.find((m) => m.name === field.type);
+                    if (relationModel) {
+                        const nestedSchema = this.generateNestedRelationSchema(relationModel, nestedIncludes[field.name]);
+                        properties[field.name] = field.isArray
+                            ? { type: "array", items: nestedSchema }
+                            : nestedSchema;
+                    }
+                }
+                continue;
+            }
+            const property = this.convertFieldToJsonSchema(field);
+            properties[field.name] = property;
+            if (!field.isOptional) {
+                required.push(field.name);
+            }
+        }
+        return {
+            type: "object",
+            properties,
+            required,
+        };
+    }
+    generateLoginSchema(arkosConfig) {
+        const userNameFields = arkosConfig?.authentication?.login?.allowedUsernames || [];
+        const getDisplayName = (field) => {
+            if (field.includes("."))
+                return field.split(".").pop() || field;
+            return field;
+        };
+        const baseSchema = {
+            type: "object",
+            properties: {
+                password: {
+                    type: "string",
+                    minLength: 8,
+                },
+            },
+            required: ["password"],
+        };
+        userNameFields.forEach((field) => {
+            const displayName = getDisplayName(field);
+            baseSchema.properties[displayName] = {
+                type: "string",
+                format: "string",
+                description: `Username field: ${field}`,
+            };
+        });
+        if (userNameFields.length > 0) {
+            const usernameDisplayNames = userNameFields.map(getDisplayName);
+            return {
+                ...baseSchema,
+                anyOf: usernameDisplayNames.map(() => ({
+                    required: [...baseSchema.required],
+                })),
+            };
+        }
+        return baseSchema;
+    }
+    generateSignupSchema(model, options) {
+        const singupSchema = this.generateCreateSchema(model, options || {});
+        const restrictedFields = [
+            "roles",
+            "role",
+            "isActive",
+            "isStaff",
+            "isSuperUser",
+            "passwordChangedAt",
+            "deletedSelfAccountAt",
+            "lastLoginAt",
+        ];
+        restrictedFields.forEach((field) => {
+            delete singupSchema?.properties?.[field];
+        });
+        return singupSchema;
+    }
+    generateUpdateMeSchema(model, options) {
+        const updateSchema = this.generateUpdateSchema(model, options || {});
+        const restrictedFields = [
+            "roles",
+            "role",
+            "isActive",
+            "isStaff",
+            "isSuperUser",
+            "passwordChangedAt",
+            "deletedSelfAccountAt",
+            "password",
+            "lastLoginAt",
+        ];
+        restrictedFields.forEach((field) => {
+            delete updateSchema?.properties?.[field];
+        });
+        return updateSchema;
+    }
+    generateUpdatePasswordSchema(_, _1) {
+        return {
+            type: "object",
+            properties: {
+                currentPassword: { type: "string" },
+                newPassword: { type: "string", minLength: 8 },
+            },
+            required: ["currentPassword", "newPassword"],
+        };
+    }
+    resolvePrismaQueryOptions(prismaQueryOptions, action) {
+        if (!prismaQueryOptions || !action) {
+            return {};
+        }
+        const options = prismaQueryOptions;
+        const actionOptions = options[action] || {};
+        let mergedOptions = options.queryOptions || {};
+        if (options.global)
+            mergedOptions = deepmerge(mergedOptions, options.global);
+        const generalOptions = this.getGeneralOptionsForAction(options, action);
+        if (generalOptions)
+            mergedOptions = deepmerge(mergedOptions, generalOptions);
+        if (actionOptions)
+            mergedOptions = deepmerge(mergedOptions, actionOptions);
+        return mergedOptions;
+    }
+    getGeneralOptionsForAction(options, action) {
+        const actionMap = {
+            find: ["findOne", "findMany"],
+            create: ["createOne", "createMany"],
+            update: ["updateOne", "updateMany"],
+            delete: ["deleteOne", "deleteMany"],
+            save: ["createOne", "createMany", "updateOne", "updateMany"],
+            saveOne: ["createOne", "updateOne"],
+            saveMany: ["createMany", "updateMany"],
+        };
+        for (const [optionKey, actions] of Object.entries(actionMap)) {
+            if (actions.includes(action) && options[optionKey]) {
+                return options[optionKey];
+            }
+        }
+        return null;
+    }
+    isEndpointDisabled(endpoint, routerConfig) {
+        if (!routerConfig?.disable)
+            return false;
+        if (typeof routerConfig.disable === "boolean") {
+            return routerConfig.disable;
+        }
+        return (routerConfig.disable[endpoint] ||
+            false);
+    }
+    isModelRelation(typeName) {
+        return this.schema.models.some((m) => m.name === typeName);
+    }
+    convertFieldToJsonSchema(field) {
+        const baseType = this.mapPrismaTypeToJsonSchema(field.type);
+        const property = { type: baseType };
+        if (field.isArray) {
+            property.type = "array";
+            property.items = { type: this.mapPrismaTypeToJsonSchema(field.type) };
+        }
+        if (field.defaultValue !== undefined) {
+            property.default = field.defaultValue;
+        }
+        if (field.type === "DateTime") {
+            property.format = "date-time";
+        }
+        if (this.isEnum(field.type)) {
+            const enumDef = this.schema.enums.find((e) => e.name === field.type);
+            if (enumDef) {
+                property.enum = enumDef.values;
+            }
+        }
+        return property;
+    }
+    mapPrismaTypeToJsonSchema(prismaType) {
+        const typeMap = {
+            String: "string",
+            Int: "number",
+            Float: "number",
+            Boolean: "boolean",
+            DateTime: "string",
+            Json: "object",
+            Bytes: "string",
+        };
+        if (typeMap[prismaType])
+            return typeMap[prismaType];
+        if (this.isEnum(prismaType))
+            return "string";
+        if (this.isModelRelation(prismaType))
+            return "object";
+        return "string";
+    }
+    isEnum(typeName) {
+        return this.schema.enums.some((e) => e.name === typeName);
+    }
+}
+const prismaJsonSchemaGenerator = new PrismaJsonSchemaGenerator();
+export default prismaJsonSchemaGenerator;
+//# sourceMappingURL=prisma-json-schema-generator.js.map