@visulima/crud 2.0.43 → 2.0.45

package/dist/index.mjs

@@ -1,3 +1,1085 @@
-import {g,i}from'./chunk-IHNLKSVH.mjs';export{h as RouteType}from'./chunk-IHNLKSVH.mjs';import L from'http-errors';import {createPaginationMetaSchemaObject}from'@visulima/pagination';import {getJSONSchemaProperty,transformDMMF}from'@visulima/prisma-dmmf-transformer';g();g();g();var q=(s,e)=>{let t={};return e.forEach(r=>{t[r]=s[r].plural;}),t},w=q;g();g();var ee=new Set(["boolean","number","string"]),te=s=>ee.has(typeof s),R=te;var re=s=>{let e={};if(Object.keys(s).forEach(t=>{let r=s[t];R(r)&&(e[t]=r);}),Object.keys(e).length!==1)throw new Error("cursor needs to be an object with exactly 1 property with a primitive value");return e},F=re;g();var se={$asc:"asc",$desc:"desc"},ne=s=>{let e={};return Object.keys(s).forEach(t=>{let r=s[t];e[t]=se[r];}),e},k=ne;g();var V=(s,e)=>{let t={};return Object.keys(s).forEach(r=>{t[r]=s[r]===true?true:{[e]:V(s[r],e)};}),t},A=V;g();var C=s=>s instanceof Object,ie={$cont:"contains",$ends:"endsWith",$eq:"equals",$gt:"gt",$gte:"gte",$in:"in",$lt:"lt",$lte:"lte",$neq:"not",$notin:"notIn",$starts:"startsWith"},ae=s=>/^\d{4}-[01]\d-[0-3]\d(?:T[0-2](?:\d:[0-5]){2}\d(?:\.\d+)?(?:Z|[+-][0-2]\d(?::?[0-5]\d)?)?)?$/g.test(s),oe=s=>ae(s)?new Date(s):typeof s=="string"&&s==="$isnull"?null:s,v=(s,e)=>{let t=s.split(".");return t.splice(-1,1),e.includes(t.join("."))},B=s=>{let e=Object.keys(s)[0],t=ie[e];if(t)return {[t]:s[e]}},W=(s,e,t,r)=>{let n=e.split(".").reverse(),a={};n.forEach((m,c)=>{c===0?Q(s,m,a,r):a={[m]:{some:a}};});let i=n.reverse()[0],o=t[i];t[i]={some:{...o?.some,...a[i]?.some}};},T=(s,e)=>{let t={};return Object.keys(s).forEach(r=>{let n=s[r];if(v(r,e))W(n,r,t,e);else if(R(n))t[r]=n;else if(C(n)){let a=B(n);a&&(t[r]=a);}}),t},Q=(s,e,t,r)=>{if(R(s))t[e]=oe(s);else switch(e){case "$and":{C(s)&&(t.AND=T(s,r));break}case "$not":{C(s)&&(t.NOT=T(s,r));break}case "$or":{C(s)&&(t.OR=T(s,r));break}default:{t[e]=B(s);break}}},ce=(s,e)=>{let t={};return Object.keys(s).forEach(r=>{let n=s[r];v(r,e)?W(n,r,t,e):Q(n,r,t,e);}),t},_=ce;var E=class{models;ctorModels;dmmf;manyRelations;primaryKey;prismaClient;constructor({manyRelations:e={},models:t,primaryKey:r="id",prismaClient:n}){this.prismaClient=n,this.primaryKey=r,this.manyRelations=e,this.ctorModels=t;}async connect(){this.prismaClient.$connect();}async create(e,t,r){return await this.getPrismaDelegate(e).create({data:t,include:r.include,select:r.select})}async delete(e,t,r){return await this.getPrismaDelegate(e).delete({include:r.include,select:r.select,where:{[this.primaryKey]:t}})}async disconnect(){await this.prismaClient.$disconnect();}async getAll(e,t){return await this.getPrismaDelegate(e).findMany({cursor:t.cursor,distinct:t.distinct,include:t.include,orderBy:t.orderBy,select:t.select,skip:t.skip,take:t.take,where:t.where})}getModels(){return this.models??[]}async getOne(e,t,r){let n=this.getPrismaDelegate(e);return await(n.findUnique??n.findOne)({include:r.include,select:r.select,where:{[this.primaryKey]:t}})}async getPaginationData(e,t){let r=await this.getPrismaDelegate(e).count({distinct:t.distinct,where:t.where});return {page:Math.ceil((t.skip??0)/(t.take??0))+1,pageCount:Math.ceil(r/(t.take??0)),total:r}}handleError(e){throw console.error(e),e instanceof Error&&e.stack&&console.error(e.stack),e.constructor.name==="PrismaClientKnownRequestError"||e.constructor.name==="PrismaClientValidationError"?L(400,"invalid request, check your server logs for more info"):L(500,"an unknown error occured, check your server logs for more info")}async init(){let e=this.ctorModels,t=await this.getPrismaClientModels();e!==void 0&&e.forEach(r=>{if(!Object.keys(t).includes(r))throw new Error(`Model name ${r} is invalid.`)}),this.models=e??Object.keys(t);}async mapModelsToRouteNames(){return w(await this.getPrismaClientModels(),this.getModels())}parseQuery(e,t){let r={};return t.select&&(r.select=A(t.select,"select")),t.include&&(r.include=A(t.include,"include")),t.originalQuery?.where&&(r.where=_(JSON.parse(t.originalQuery.where),this.manyRelations[e]??[])),t.orderBy&&(r.orderBy=k(t.orderBy)),t.limit!==void 0&&(r.take=t.limit),t.skip!==void 0&&(r.skip=t.skip),t.originalQuery?.cursor&&(r.cursor=F(JSON.parse(t.originalQuery.cursor))),t.distinct&&(r.distinct=t.distinct),r}async update(e,t,r,n){return await this.getPrismaDelegate(e).update({data:r,include:n.include,select:n.select,where:{[this.primaryKey]:t}})}get client(){return this.prismaClient}getPrismaClientModels=async()=>{if(this.prismaClient._dmmf!==void 0)return this.dmmf=this.prismaClient._dmmf,this.dmmf?.mappingsMap;if(this.prismaClient._getDmmf!==void 0)return this.dmmf=await this.prismaClient._getDmmf(),this.dmmf.mappingsMap;throw new Error("Couldn't get prisma client models")};getPrismaDelegate(e){return this.prismaClient[`${e.charAt(0).toLowerCase()}${e.slice(1)}`]}};g();g();g();var pe=s=>`#/components/schemas/${s}`,P=pe;var U=s=>{switch(s){case "BigInt":case "Int":return "integer";case "Boolean":return "boolean";case "Bytes":case "DateTime":case "String":return "string";case "Decimal":case "Float":return "number";case "Json":return "object";case "Null":return "null";default:return ""}},x="PaginationData",ge=[{methodStart:"createOne",schemaNameStart:"Create"},{methodStart:"updateOne",schemaNameStart:"Update"}],$=class{constructor(e){this.dmmf=e;}schemaInputTypes=new Map;formatInputTypeData(e){if(e.kind==="object"){let r=P(e.type.name);return e.isList?{items:{$ref:r},type:"array",xml:{name:e.type.name,wrapped:true}}:{$ref:r}}let t=U(e.type);return e.isList?{items:{type:t},type:"array",xml:{name:e.type.name,wrapped:true}}:{type:t}}getExampleModelsSchemas(e,t){let r=i=>{let o=i.replace("#/components/schemas/",""),m=t[o],c={};return Object.entries(m.properties??{}).forEach(([f,l])=>{let d=l.type;c[f]=d==="array"?[a(l.items)]:d;}),c},n=i=>{let o={};return Object.entries(i).forEach(([m,c])=>{o[m]=c.$ref===void 0?c.type:r(c.$ref);}),o},a=i=>{let o={};return Object.entries(i).forEach(([m,c])=>{c.items.$ref!==void 0?o[m]=[r(c.items.$ref)]:c.type==="array"?o[m]=[a(c.items)]:c.type==="object"?o[m]=n(c.properties):o[m]=c.type;}),o};return e.reduce((i,o)=>{let m={},c=t[o];Object.entries(c.properties).forEach(([d,h])=>{let y=h.type;y==="array"?m[d]=[r(h.items.$ref)]:y==="object"?m[d]=n(h.properties):m[d]=y;});let f=this.getPaginationDataSchema()[x],l={};return Object.entries(f.properties).forEach(([d,h])=>{l[d]=h.type;}),{...i,[`${o}Page`]:{value:{data:[m],meta:l}},[`${o}s`]:{value:[m]},[o]:{value:m}}},{})}getPaginatedModelsSchemas(e){return e.reduce((t,r)=>({...t,[`${r}Page`]:{properties:{data:{items:{$ref:P(r)},type:"array",xml:{name:"data",wrapped:true}},meta:{$ref:P(x)}},type:"object",xml:{name:`${r}Page`}}}),{})}getPaginationDataSchema(){return createPaginationMetaSchemaObject(x)}parseInputTypes(e){let t=e.reduce((r,n)=>(ge.map(i=>({name:`${i.methodStart}${n}`,schemaName:`${i.schemaNameStart}${n}`})).forEach(({name:i,schemaName:o})=>{let m=this.dmmf.mutationType.fieldMap[i].args[0].inputTypes[0].type.fields,c=[],f=m.reduce((l,d)=>{if(d.inputTypes[0].kind==="scalar"){let h=getJSONSchemaProperty(this.dmmf.datamodel,{})({name:d.name,...d.inputTypes[0]}),{type:y}=h[1];y&&Array.isArray(y)?y.includes("null")&&(l[d.name]={...y,nullable:true,type:y.filter(j=>j!=="null")},l[d.name].type.length===1&&(l[d.name]={...l[d.name],type:l[d.name].type[0]})):l[d.name]=h[1];}else {let h=this.parseObjectInputType(d.inputTypes[0]);l[d.name]={...h,nullable:d.isNullable};}return d.isRequired&&c.push(d.name),l},{});r[o]={properties:f,type:"object",xml:{name:o}},c.length>0&&(r[o].required=c);}),r),{});return this.schemaInputTypes.forEach((r,n)=>{t[n]={properties:r,type:"object",xml:{name:n}};}),t}parseModels(){let e=transformDMMF(this.dmmf).definitions;return Object.keys(e).forEach(t=>{let{properties:r}=e[t];Object.keys(r).forEach(n=>{Array.isArray(r[n].type)&&r[n].type.includes("null")&&(r[n].type=r[n].type.filter(a=>a!=="null"),r[n].type.length===1&&(r[n].type=r[n].type[0]),r[n].nullable=true);});}),e}parseObjectInputType(e){return e.kind==="object"?(this.schemaInputTypes.has(e.type.name)||(this.schemaInputTypes.set(e.type.name,{}),e.type.fields.forEach(t=>{let r={};if(t.inputTypes.length>1){let n=false,a=t.inputTypes.map(i=>{let o=this.formatInputTypeData(i);if(o.type==="null"){n=true;return}return o}).filter(Boolean);a.length===1?r=a[0]:r.anyOf=a,n&&(r.nullable=true);}else {let n=t.inputTypes[0];r=this.formatInputTypeData(n);}this.schemaInputTypes.set(e.type.name,{...this.schemaInputTypes.get(e.type.name),[t.name]:r}),t.inputTypes.forEach(n=>{n.kind==="object"&&this.parseObjectInputType(n);});})),{$ref:P(e.type.name)}):{type:U(e.type)}}},H=$;g();var ue=(s,e,t="all")=>s.reduce((r,n)=>e?.[n]?{...r,[n]:i(e[n].only,e[n].exclude,t)}:{...r,[n]:i(void 0,void 0,t)},{}),J=ue;g();g();var O={distinct:{description:"Fields to distinctively retrieve",name:"distinct",schema:{type:"string"}},include:{description:"Include relations, same as select",name:"include",schema:{type:"string"}},limit:{description:"Maximum number of elements to retrieve",name:"limit",schema:{minimum:0,type:"integer"}},orderBy:{description:'Field on which to order by a direction. See <a href="https://next-crud.js.org/query-params#orderBy">the docs</a>',name:"orderBy",schema:{type:"string"}},page:{description:"Page number. Use only for pagination.",name:"page",schema:{minimum:1,type:"integer"}},select:{description:"Fields to select. For nested fields, chain them separated with a dot, eg: user.posts",name:"select",schema:{type:"string"}},skip:{description:"Number of rows to skip",name:"skip",schema:{minimum:0,type:"integer"}},where:{description:'Fields to filter. See <a href="https://next-crud.js.org/query-params#where">the docs</a>',name:"where",schema:{type:"string"}}},G=[O.select,O.include],fe=[...G,O.limit,O.skip,O.where,O.orderBy,O.page,O.distinct],K=(s,e=[])=>s==="READ_ALL"?[...fe,...e].filter(Boolean):[...G,...e].filter(Boolean);g();var he=s=>`#/components/examples/${s}`,b=he;var M=(s,e)=>e?{items:{$ref:P(s)},type:"array"}:{$ref:P(s)},ye=(s,e)=>{if(s==="CREATE")return {content:{content:{"application/json":{example:b(e),schema:M(e)}},description:`${e} created`},statusCode:201};if(s==="DELETE")return {content:{content:{"application/json":{example:b(e),schema:M(e)}},description:`${e} item deleted`},statusCode:200};if(s==="READ_ALL")return {content:{content:{"application/json":{examples:{Default:{$ref:b(`${e}s`)},Pagination:{$ref:b(`${e}Page`)}},schema:{oneOf:[M(e,true),M(`${e}Page`,false)]}}},description:`${e} list retrieved`},statusCode:200};if(s==="READ_ONE")return {content:{content:{"application/json":{example:b(e),schema:M(e)}},description:`${e} item retrieved`},statusCode:200};if(s==="UPDATE")return {content:{content:{"application/json":{example:b(e),schema:M(e)}},description:`${e} item updated`},statusCode:200}},Z=(s,e)=>({content:{"application/json":{schema:{$ref:P(`${s}${e}`)}}}}),Pe=s=>{switch(s){case "CREATE":return "post";case "DELETE":return "delete";case "READ_ALL":case "READ_ONE":return "get";case "UPDATE":return "put";default:throw new TypeError(`Method for route type ${s} was not found.`)}},z=({hasId:s,modelName:e,modelsConfig:t,routeTypes:r,tag:n})=>{let a={};return r.forEach(i=>{if(r.includes(i)){let o=t?.[e]?.routeTypes?.[i]?.response.name??t?.[e]?.type?.name??e,m=Pe(i),c=ye(i,o);if(c===void 0)throw new TypeError(`Route type ${i}; response config was not found.`);a[m]={parameters:K(i).map(f=>({...f,in:"query"})),responses:{[c.statusCode]:c.content,...t?.[e]?.routeTypes?.[i]?.responses},summary:t?.[e]?.routeTypes?.[i]?.summary,tags:[n]},s&&a[m].parameters.push({description:`ID of the ${e}`,in:"path",name:"id",required:true,schema:{type:"string"}}),i==="UPDATE"?a[m].requestBody=Z("Update",o):i==="CREATE"&&(a[m].requestBody=Z("Create",o));}}),a},Oe=({models:s,modelsConfig:e,routes:t,routesMap:r})=>Object.keys(t).reduce((n,a)=>{let i=t[a],o=s?.[a]?.name?s[a].name:r?.[a]??a,m=e?.[a]?.tag.name??a;if(i.includes("CREATE")||i.includes("READ_ALL")){let c=`/${o}`,f=["READ_ALL","CREATE"].filter(l=>i.includes(l));n[c]=z({modelName:a,modelsConfig:e,routeTypes:f,tag:m});}if(i.includes("READ_ONE")||i.includes("UPDATE")||i.includes("DELETE")){let c=`/${o}/{id}`,f=["READ_ONE","UPDATE","DELETE"].filter(l=>i.includes(l));n[c]=z({hasId:true,modelName:a,modelsConfig:e,routeTypes:f,tag:m});}return n},{}),X=Oe;g();var be=(s,e)=>s.map(t=>e?.[t]?.tag?e[t].tag:{name:t}),Y=be;var Me=(s,e)=>(Object.values(s).forEach(t=>{Object.values(t).forEach(r=>{typeof r.responses=="object"&&Object.values(r.responses).forEach(n=>{typeof n.content=="object"&&Object.values(n.content).forEach(a=>{if(typeof a.example=="string"){let i=a.example.replace("#/components/examples/","");e[i]?.value!==void 0&&(a.example=e[i].value);}});});});}),s),Re=async({crud:s={models:{}},defaultExposeStrategy:e="all",models:t,prismaClient:r,swagger:n={allowedMediaTypes:{"application/json":true},models:{}}})=>{let a,i;if(r._dmmf!==void 0?(a=r._dmmf,i=a?.mappingsMap):r._getDmmf!==void 0&&(a=await r._getDmmf(),i=a.mappingsMap),a===void 0)throw new TypeError("Couldn't get prisma client models");let o=new H(a),m=o.parseModels(),c=Object.keys(m),f=JSON.stringify({...m,...o.parseInputTypes(c),...o.getPaginationDataSchema(),...o.getPaginatedModelsSchemas(c)});t!==void 0&&t.forEach(D=>{if(!Object.keys(i).includes(D))throw new Error(`Model name ${D} is invalid.`)});let l=t??Object.keys(i),d=J(l,s.models,e),h=Y(l,n.models),y=X({models:s.models,modelsConfig:n.models,routes:d,routesMap:w(i,l)}),j=JSON.parse(f.replaceAll("#/definitions","#/components/schemas")),I=o.getExampleModelsSchemas(c,j);return {examples:I,paths:Me(y,I),schemas:j,tags:h}},je=Re;
-export{E as PrismaAdapter,je as modelsToOpenApi};//# sourceMappingURL=index.mjs.map
+import { init_esm_shims, get_accessible_routes_default } from './chunk-LBXJKEOF.mjs';
+export { RouteType } from './chunk-LBXJKEOF.mjs';
+import createHttpError from 'http-errors';
+import { createPaginationMetaSchemaObject } from '@visulima/pagination';
+import { getJSONSchemaProperty, transformDMMF } from '@visulima/prisma-dmmf-transformer';
+
+// src/index.ts
+init_esm_shims();
+
+// src/adapter/prisma/index.ts
+init_esm_shims();
+
+// src/adapter/prisma/utils/models-to-route-names.ts
+init_esm_shims();
+var modelsToRouteNames = (mappingsMap, models) => {
+  const routesMap = {};
+  models.forEach((model) => {
+    routesMap[model] = mappingsMap[model].plural;
+  });
+  return routesMap;
+};
+var models_to_route_names_default = modelsToRouteNames;
+
+// src/adapter/prisma/utils/parse-cursor.ts
+init_esm_shims();
+
+// src/utils/is-primitive.ts
+init_esm_shims();
+var primitiveTypes = /* @__PURE__ */ new Set(["boolean", "number", "string"]);
+var isPrimitive = (value) => primitiveTypes.has(typeof value);
+var is_primitive_default = isPrimitive;
+
+// src/adapter/prisma/utils/parse-cursor.ts
+var parsePrismaCursor = (cursor) => {
+  const parsed = {};
+  Object.keys(cursor).forEach((key) => {
+    const value = cursor[key];
+    if (is_primitive_default(value)) {
+      parsed[key] = value;
+    }
+  });
+  if (Object.keys(parsed).length !== 1) {
+    throw new Error("cursor needs to be an object with exactly 1 property with a primitive value");
+  }
+  return parsed;
+};
+var parse_cursor_default = parsePrismaCursor;
+
+// src/adapter/prisma/utils/parse-order-by.ts
+init_esm_shims();
+var operatorsAssociation = {
+  $asc: "asc",
+  $desc: "desc"
+};
+var parsePrismaOrderBy = (orderBy) => {
+  const parsed = {};
+  Object.keys(orderBy).forEach((key) => {
+    const value = orderBy[key];
+    parsed[key] = operatorsAssociation[value];
+  });
+  return parsed;
+};
+var parse_order_by_default = parsePrismaOrderBy;
+
+// src/adapter/prisma/utils/parse-recursive.ts
+init_esm_shims();
+var parsePrismaRecursiveField = (select, fieldName) => {
+  const parsed = {};
+  Object.keys(select).forEach((field) => {
+    parsed[field] = select[field] === true ? true : {
+      [fieldName]: parsePrismaRecursiveField(select[field], fieldName)
+    };
+  });
+  return parsed;
+};
+var parse_recursive_default = parsePrismaRecursiveField;
+
+// src/adapter/prisma/utils/parse-where.ts
+init_esm_shims();
+var isObject = (a) => a instanceof Object;
+var operatorsAssociation2 = {
+  $cont: "contains",
+  $ends: "endsWith",
+  $eq: "equals",
+  $gt: "gt",
+  $gte: "gte",
+  $in: "in",
+  $lt: "lt",
+  $lte: "lte",
+  $neq: "not",
+  $notin: "notIn",
+  $starts: "startsWith"
+};
+var isDateString = (value) => /^\d{4}-[01]\d-[0-3]\d(?:T[0-2](?:\d:[0-5]){2}\d(?:\.\d+)?(?:Z|[+-][0-2]\d(?::?[0-5]\d)?)?)?$/g.test(value);
+var getSearchValue = (originalValue) => {
+  if (isDateString(originalValue)) {
+    return new Date(originalValue);
+  }
+  if (typeof originalValue === "string" && originalValue === "$isnull") {
+    return null;
+  }
+  return originalValue;
+};
+var isRelation = (key, manyRelations) => {
+  const splitKey = key.split(".");
+  splitKey.splice(-1, 1);
+  return manyRelations.includes(splitKey.join("."));
+};
+var parseSimpleField = (value) => {
+  const operator = Object.keys(value)[0];
+  const prismaOperator = operatorsAssociation2[operator];
+  if (prismaOperator) {
+    return {
+      [prismaOperator]: value[operator]
+    };
+  }
+  return void 0;
+};
+var parseRelation = (value, key, parsed, manyRelations) => {
+  const fields = key.split(".").reverse();
+  let formatFields = {};
+  fields.forEach((field, index) => {
+    if (index === 0) {
+      basicParse(value, field, formatFields, manyRelations);
+    } else {
+      formatFields = {
+        [field]: {
+          some: formatFields
+        }
+      };
+    }
+  });
+  const initialFieldKey = fields.reverse()[0];
+  const oldParsed = parsed[initialFieldKey];
+  parsed[initialFieldKey] = {
+    some: {
+      ...oldParsed?.some,
+      ...formatFields[initialFieldKey]?.some
+    }
+  };
+};
+var parseObjectCombination = (object, manyRelations) => {
+  const parsed = {};
+  Object.keys(object).forEach((key) => {
+    const value = object[key];
+    if (isRelation(key, manyRelations)) {
+      parseRelation(value, key, parsed, manyRelations);
+    } else if (is_primitive_default(value)) {
+      parsed[key] = value;
+    } else if (isObject(value)) {
+      const fieldResult = parseSimpleField(value);
+      if (fieldResult) {
+        parsed[key] = fieldResult;
+      }
+    }
+  });
+  return parsed;
+};
+var basicParse = (value, key, parsed, manyRelations) => {
+  if (is_primitive_default(value)) {
+    parsed[key] = getSearchValue(value);
+  } else {
+    switch (key) {
+      case "$and": {
+        if (isObject(value)) {
+          parsed.AND = parseObjectCombination(value, manyRelations);
+        }
+        break;
+      }
+      case "$not": {
+        if (isObject(value)) {
+          parsed.NOT = parseObjectCombination(value, manyRelations);
+        }
+        break;
+      }
+      case "$or": {
+        if (isObject(value)) {
+          parsed.OR = parseObjectCombination(value, manyRelations);
+        }
+        break;
+      }
+      default: {
+        parsed[key] = parseSimpleField(value);
+        break;
+      }
+    }
+  }
+};
+var parsePrismaWhere = (where, manyRelations) => {
+  const parsed = {};
+  Object.keys(where).forEach((key) => {
+    const value = where[key];
+    if (isRelation(key, manyRelations)) {
+      parseRelation(value, key, parsed, manyRelations);
+    } else {
+      basicParse(value, key, parsed, manyRelations);
+    }
+  });
+  return parsed;
+};
+var parse_where_default = parsePrismaWhere;
+
+// src/adapter/prisma/index.ts
+var PrismaAdapter = class {
+  models;
+  ctorModels;
+  dmmf;
+  manyRelations;
+  primaryKey;
+  prismaClient;
+  constructor({ manyRelations = {}, models, primaryKey = "id", prismaClient }) {
+    this.prismaClient = prismaClient;
+    this.primaryKey = primaryKey;
+    this.manyRelations = manyRelations;
+    this.ctorModels = models;
+  }
+  async connect() {
+    this.prismaClient.$connect();
+  }
+  async create(resourceName, data, query) {
+    return await this.getPrismaDelegate(resourceName).create({
+      data,
+      include: query.include,
+      select: query.select
+    });
+  }
+  async delete(resourceName, resourceId, query) {
+    return await this.getPrismaDelegate(resourceName).delete({
+      include: query.include,
+      select: query.select,
+      where: {
+        [this.primaryKey]: resourceId
+      }
+    });
+  }
+  async disconnect() {
+    await this.prismaClient.$disconnect();
+  }
+  async getAll(resourceName, query) {
+    return await this.getPrismaDelegate(resourceName).findMany({
+      cursor: query.cursor,
+      distinct: query.distinct,
+      include: query.include,
+      orderBy: query.orderBy,
+      select: query.select,
+      skip: query.skip,
+      take: query.take,
+      where: query.where
+    });
+  }
+  getModels() {
+    return this.models ?? [];
+  }
+  async getOne(resourceName, resourceId, query) {
+    const delegate = this.getPrismaDelegate(resourceName);
+    const findFunction = delegate.findUnique ?? delegate.findOne;
+    return await findFunction({
+      include: query.include,
+      select: query.select,
+      where: {
+        [this.primaryKey]: resourceId
+      }
+    });
+  }
+  async getPaginationData(resourceName, query) {
+    const total = await this.getPrismaDelegate(resourceName).count({
+      distinct: query.distinct,
+      where: query.where
+    });
+    return {
+      page: Math.ceil((query.skip ?? 0) / (query.take ?? 0)) + 1,
+      pageCount: Math.ceil(total / (query.take ?? 0)),
+      total
+    };
+  }
+  // eslint-disable-next-line class-methods-use-this
+  handleError(error) {
+    console.error(error);
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    throw error.constructor.name === "PrismaClientKnownRequestError" || error.constructor.name === "PrismaClientValidationError" ? createHttpError(400, "invalid request, check your server logs for more info") : createHttpError(500, "an unknown error occured, check your server logs for more info");
+  }
+  async init() {
+    const models = this.ctorModels;
+    const prismaDmmfModels = await this.getPrismaClientModels();
+    if (models !== void 0) {
+      models.forEach((model) => {
+        if (!Object.keys(prismaDmmfModels).includes(model)) {
+          throw new Error(`Model name ${model} is invalid.`);
+        }
+      });
+    }
+    this.models = models ?? Object.keys(prismaDmmfModels);
+  }
+  async mapModelsToRouteNames() {
+    return models_to_route_names_default(await this.getPrismaClientModels(), this.getModels());
+  }
+  parseQuery(resourceName, query) {
+    const parsed = {};
+    if (query.select) {
+      parsed.select = parse_recursive_default(query.select, "select");
+    }
+    if (query.include) {
+      parsed.include = parse_recursive_default(query.include, "include");
+    }
+    if (query.originalQuery?.where) {
+      parsed.where = parse_where_default(JSON.parse(query.originalQuery.where), this.manyRelations[resourceName] ?? []);
+    }
+    if (query.orderBy) {
+      parsed.orderBy = parse_order_by_default(query.orderBy);
+    }
+    if (query.limit !== void 0) {
+      parsed.take = query.limit;
+    }
+    if (query.skip !== void 0) {
+      parsed.skip = query.skip;
+    }
+    if (query.originalQuery?.cursor) {
+      parsed.cursor = parse_cursor_default(JSON.parse(query.originalQuery.cursor));
+    }
+    if (query.distinct) {
+      parsed.distinct = query.distinct;
+    }
+    return parsed;
+  }
+  async update(resourceName, resourceId, data, query) {
+    return await this.getPrismaDelegate(resourceName).update({
+      data,
+      include: query.include,
+      select: query.select,
+      where: {
+        [this.primaryKey]: resourceId
+      }
+    });
+  }
+  get client() {
+    return this.prismaClient;
+  }
+  getPrismaClientModels = async () => {
+    if (this.prismaClient._dmmf !== void 0) {
+      this.dmmf = this.prismaClient._dmmf;
+      return this.dmmf?.mappingsMap;
+    }
+    if (this.prismaClient._getDmmf !== void 0) {
+      this.dmmf = await this.prismaClient._getDmmf();
+      return this.dmmf.mappingsMap;
+    }
+    throw new Error("Couldn't get prisma client models");
+  };
+  getPrismaDelegate(resourceName) {
+    return this.prismaClient[`${resourceName.charAt(0).toLowerCase()}${resourceName.slice(1)}`];
+  }
+};
+
+// src/swagger/adapter/prisma/index.ts
+init_esm_shims();
+
+// src/swagger/json-schema-parser.ts
+init_esm_shims();
+
+// src/swagger/utils/format-schema-ref.ts
+init_esm_shims();
+var formatSchemaReference = (schemaName) => `#/components/schemas/${schemaName}`;
+var format_schema_ref_default = formatSchemaReference;
+
+// src/swagger/json-schema-parser.ts
+var getJSONSchemaScalar = (fieldType) => {
+  switch (fieldType) {
+    case "BigInt":
+    case "Int": {
+      return "integer";
+    }
+    case "Boolean": {
+      return "boolean";
+    }
+    case "Bytes":
+    case "DateTime":
+    case "String": {
+      return "string";
+    }
+    case "Decimal":
+    case "Float": {
+      return "number";
+    }
+    case "Json": {
+      return "object";
+    }
+    case "Null": {
+      return "null";
+    }
+    default: {
+      return "";
+    }
+  }
+};
+var PAGINATION_SCHEMA_NAME = "PaginationData";
+var methodsNames = [
+  { methodStart: "createOne", schemaNameStart: "Create" },
+  { methodStart: "updateOne", schemaNameStart: "Update" }
+];
+var PrismaJsonSchemaParser = class {
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  constructor(dmmf) {
+    this.dmmf = dmmf;
+  }
+  schemaInputTypes = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/explicit-module-boundary-types
+  formatInputTypeData(inputType) {
+    if (inputType.kind === "object") {
+      const reference = format_schema_ref_default(inputType.type.name);
+      if (inputType.isList) {
+        return {
+          items: {
+            $ref: reference
+          },
+          type: "array",
+          xml: {
+            name: inputType.type.name,
+            wrapped: true
+          }
+        };
+      }
+      return { $ref: reference };
+    }
+    const type = getJSONSchemaScalar(inputType.type);
+    if (inputType.isList) {
+      return {
+        items: {
+          type
+        },
+        type: "array",
+        xml: {
+          name: inputType.type.name,
+          wrapped: true
+        }
+      };
+    }
+    return { type };
+  }
+  getExampleModelsSchemas(modelNames, schemas) {
+    const referenceToSchema = (reference) => {
+      const name = reference.replace("#/components/schemas/", "");
+      const model = schemas[name];
+      const values = {};
+      Object.entries(model.properties ?? {}).forEach(([key, v]) => {
+        const type = v.type;
+        values[key] = type === "array" ? [arrayItemsToSchema(v.items)] : type;
+      });
+      return values;
+    };
+    const objectPropertiesToSchema = (objectProperties) => {
+      const values = {};
+      Object.entries(objectProperties).forEach(([key, value]) => {
+        values[key] = value.$ref === void 0 ? value.type : referenceToSchema(value.$ref);
+      });
+      return values;
+    };
+    const arrayItemsToSchema = (items) => {
+      const values = {};
+      Object.entries(items).forEach(([key, value]) => {
+        if (value.items.$ref !== void 0) {
+          values[key] = [referenceToSchema(value.items.$ref)];
+        } else if (value.type === "array") {
+          values[key] = [arrayItemsToSchema(value.items)];
+        } else if (value.type === "object") {
+          values[key] = objectPropertiesToSchema(value.properties);
+        } else {
+          values[key] = value.type;
+        }
+      });
+      return values;
+    };
+    return modelNames.reduce((accumulator, modelName) => {
+      const value = {};
+      const model = schemas[modelName];
+      Object.entries(model.properties).forEach(([key, v]) => {
+        const type = v.type;
+        if (type === "array") {
+          value[key] = [referenceToSchema(v.items.$ref)];
+        } else if (type === "object") {
+          value[key] = objectPropertiesToSchema(v.properties);
+        } else {
+          value[key] = type;
+        }
+      });
+      const pagination = this.getPaginationDataSchema()[PAGINATION_SCHEMA_NAME];
+      const meta = {};
+      Object.entries(pagination.properties).forEach(([key, v]) => {
+        meta[key] = v.type;
+      });
+      return {
+        ...accumulator,
+        [`${modelName}Page`]: {
+          value: {
+            data: [value],
+            meta
+          }
+        },
+        [`${modelName}s`]: {
+          value: [value]
+        },
+        [modelName]: {
+          value
+        }
+      };
+    }, {});
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getPaginatedModelsSchemas(modelNames) {
+    return modelNames.reduce((accumulator, modelName) => {
+      return {
+        ...accumulator,
+        [`${modelName}Page`]: {
+          properties: {
+            data: {
+              items: {
+                $ref: format_schema_ref_default(modelName)
+              },
+              type: "array",
+              xml: {
+                name: "data",
+                wrapped: true
+              }
+            },
+            meta: {
+              $ref: format_schema_ref_default(PAGINATION_SCHEMA_NAME)
+            }
+          },
+          type: "object",
+          xml: {
+            name: `${modelName}Page`
+          }
+        }
+      };
+    }, {});
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getPaginationDataSchema() {
+    return createPaginationMetaSchemaObject(PAGINATION_SCHEMA_NAME);
+  }
+  parseInputTypes(models) {
+    const definitions = models.reduce((accumulator, modelName) => {
+      const methods = methodsNames.map((method) => {
+        return {
+          name: `${method.methodStart}${modelName}`,
+          schemaName: `${method.schemaNameStart}${modelName}`
+        };
+      });
+      methods.forEach(({ name: method, schemaName }) => {
+        const dataFields = this.dmmf.mutationType.fieldMap[method].args[0].inputTypes[0].type.fields;
+        const requiredProperties = [];
+        const properties = dataFields.reduce((propertiesAccumulator, field) => {
+          if (field.inputTypes[0].kind === "scalar") {
+            const schema = getJSONSchemaProperty(
+              this.dmmf.datamodel,
+              {}
+            )({
+              name: field.name,
+              ...field.inputTypes[0]
+            });
+            const { type: schemaType } = schema[1];
+            if (schemaType && Array.isArray(schemaType)) {
+              if (schemaType.includes("null")) {
+                propertiesAccumulator[field.name] = {
+                  ...schemaType,
+                  nullable: true,
+                  type: schemaType.filter((type) => type !== "null")
+                };
+                if (propertiesAccumulator[field.name].type.length === 1) {
+                  propertiesAccumulator[field.name] = {
+                    ...propertiesAccumulator[field.name],
+                    type: propertiesAccumulator[field.name].type[0]
+                  };
+                }
+              }
+            } else {
+              propertiesAccumulator[field.name] = schema[1];
+            }
+          } else {
+            const typeName = this.parseObjectInputType(field.inputTypes[0]);
+            propertiesAccumulator[field.name] = {
+              ...typeName,
+              nullable: field.isNullable
+            };
+          }
+          if (field.isRequired) {
+            requiredProperties.push(field.name);
+          }
+          return propertiesAccumulator;
+        }, {});
+        accumulator[schemaName] = {
+          properties,
+          type: "object",
+          xml: {
+            name: schemaName
+          }
+        };
+        if (requiredProperties.length > 0) {
+          accumulator[schemaName].required = requiredProperties;
+        }
+      });
+      return accumulator;
+    }, {});
+    this.schemaInputTypes.forEach((value, key) => {
+      definitions[key] = {
+        properties: value,
+        type: "object",
+        xml: {
+          name: key
+        }
+      };
+    });
+    return definitions;
+  }
+  parseModels() {
+    const modelsDefinitions = transformDMMF(this.dmmf).definitions;
+    Object.keys(modelsDefinitions).forEach((definition) => {
+      const { properties } = modelsDefinitions[definition];
+      Object.keys(properties).forEach((property) => {
+        if (Array.isArray(properties[property].type) && properties[property].type.includes("null")) {
+          properties[property].type = properties[property].type.filter((type) => type !== "null");
+          if (properties[property].type.length === 1) {
+            properties[property].type = properties[property].type[0];
+          }
+          properties[property].nullable = true;
+        }
+      });
+    });
+    return modelsDefinitions;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  parseObjectInputType(fieldType) {
+    if (fieldType.kind === "object") {
+      if (!this.schemaInputTypes.has(fieldType.type.name)) {
+        this.schemaInputTypes.set(fieldType.type.name, {});
+        fieldType.type.fields.forEach((field) => {
+          let fieldData = {};
+          if (field.inputTypes.length > 1) {
+            let nullable = false;
+            const anyOf = field.inputTypes.map((inputType) => {
+              const inputTypeData = this.formatInputTypeData(inputType);
+              if (inputTypeData.type === "null") {
+                nullable = true;
+                return;
+              }
+              return inputTypeData;
+            }).filter(Boolean);
+            if (anyOf.length === 1) {
+              fieldData = anyOf[0];
+            } else {
+              fieldData.anyOf = anyOf;
+            }
+            if (nullable) {
+              fieldData.nullable = true;
+            }
+          } else {
+            const inputType = field.inputTypes[0];
+            fieldData = this.formatInputTypeData(inputType);
+          }
+          this.schemaInputTypes.set(fieldType.type.name, {
+            ...this.schemaInputTypes.get(fieldType.type.name),
+            [field.name]: fieldData
+          });
+          field.inputTypes.forEach((inputType) => {
+            if (inputType.kind === "object") {
+              this.parseObjectInputType(inputType);
+            }
+          });
+        });
+      }
+      return { $ref: format_schema_ref_default(fieldType.type.name) };
+    }
+    return { type: getJSONSchemaScalar(fieldType.type) };
+  }
+};
+var json_schema_parser_default = PrismaJsonSchemaParser;
+
+// src/swagger/utils/get-models-accessible-routes.ts
+init_esm_shims();
+var getModelsAccessibleRoutes = (modelNames, models, defaultExposeStrategy = "all") => (
+  // eslint-disable-next-line unicorn/no-array-reduce
+  modelNames.reduce((accumulator, modelName) => {
+    if (models?.[modelName]) {
+      return {
+        ...accumulator,
+        [modelName]: get_accessible_routes_default(models[modelName].only, models[modelName].exclude, defaultExposeStrategy)
+      };
+    }
+    return {
+      ...accumulator,
+      [modelName]: get_accessible_routes_default(void 0, void 0, defaultExposeStrategy)
+    };
+  }, {})
+);
+var get_models_accessible_routes_default = getModelsAccessibleRoutes;
+
+// src/swagger/utils/get-swagger-paths.ts
+init_esm_shims();
+
+// src/swagger/parameters.ts
+init_esm_shims();
+var queryParameters = {
+  distinct: {
+    description: "Fields to distinctively retrieve",
+    name: "distinct",
+    schema: {
+      type: "string"
+    }
+  },
+  include: {
+    description: "Include relations, same as select",
+    name: "include",
+    schema: {
+      type: "string"
+    }
+  },
+  limit: {
+    description: "Maximum number of elements to retrieve",
+    name: "limit",
+    schema: {
+      minimum: 0,
+      type: "integer"
+    }
+  },
+  orderBy: {
+    description: 'Field on which to order by a direction. See <a href="https://next-crud.js.org/query-params#orderBy">the docs</a>',
+    name: "orderBy",
+    schema: {
+      type: "string"
+    }
+  },
+  page: {
+    description: "Page number. Use only for pagination.",
+    name: "page",
+    schema: {
+      minimum: 1,
+      type: "integer"
+    }
+  },
+  select: {
+    description: "Fields to select. For nested fields, chain them separated with a dot, eg: user.posts",
+    name: "select",
+    schema: {
+      type: "string"
+    }
+  },
+  skip: {
+    description: "Number of rows to skip",
+    name: "skip",
+    schema: {
+      minimum: 0,
+      type: "integer"
+    }
+  },
+  where: {
+    description: 'Fields to filter. See <a href="https://next-crud.js.org/query-params#where">the docs</a>',
+    name: "where",
+    schema: {
+      type: "string"
+    }
+  }
+};
+var commonQueryParameters = [queryParameters.select, queryParameters.include];
+var listQueryParameters = [
+  ...commonQueryParameters,
+  queryParameters.limit,
+  queryParameters.skip,
+  queryParameters.where,
+  queryParameters.orderBy,
+  queryParameters.page,
+  queryParameters.distinct
+];
+var getQueryParameters = (routeType, additionalQueryParameters = []) => {
+  if (routeType === "READ_ALL" /* READ_ALL */) {
+    return [...listQueryParameters, ...additionalQueryParameters].filter(Boolean);
+  }
+  return [...commonQueryParameters, ...additionalQueryParameters].filter(Boolean);
+};
+
+// src/swagger/utils/format-example-ref.ts
+init_esm_shims();
+var formatExampleReference = (schemaName) => `#/components/examples/${schemaName}`;
+var format_example_ref_default = formatExampleReference;
+
+// src/swagger/utils/get-swagger-paths.ts
+var generateContentForSchema = (schemaName, isArray) => {
+  if (isArray) {
+    return {
+      items: {
+        $ref: format_schema_ref_default(schemaName)
+      },
+      type: "array"
+    };
+  }
+  return {
+    $ref: format_schema_ref_default(schemaName)
+  };
+};
+var generateSwaggerResponse = (routeType, modelName) => {
+  if (routeType === "CREATE" /* CREATE */) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: format_example_ref_default(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} created`
+      },
+      statusCode: 201
+    };
+  }
+  if (routeType === "DELETE" /* DELETE */) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: format_example_ref_default(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} item deleted`
+      },
+      statusCode: 200
+    };
+  }
+  if (routeType === "READ_ALL" /* READ_ALL */) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            examples: {
+              Default: {
+                $ref: format_example_ref_default(`${modelName}s`)
+              },
+              Pagination: {
+                $ref: format_example_ref_default(`${modelName}Page`)
+              }
+            },
+            schema: {
+              oneOf: [generateContentForSchema(modelName, true), generateContentForSchema(`${modelName}Page`, false)]
+            }
+          }
+        },
+        description: `${modelName} list retrieved`
+      },
+      statusCode: 200
+    };
+  }
+  if (routeType === "READ_ONE" /* READ_ONE */) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: format_example_ref_default(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} item retrieved`
+      },
+      statusCode: 200
+    };
+  }
+  if (routeType === "UPDATE" /* UPDATE */) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: format_example_ref_default(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} item updated`
+      },
+      statusCode: 200
+    };
+  }
+  return void 0;
+};
+var generateRequestBody = (schemaStartName, modelName) => {
+  return {
+    content: {
+      "application/json": {
+        schema: {
+          $ref: format_schema_ref_default(`${schemaStartName}${modelName}`)
+        }
+      }
+    }
+  };
+};
+var getRouteTypeMethod = (routeType) => {
+  switch (routeType) {
+    case "CREATE" /* CREATE */: {
+      return "post";
+    }
+    case "DELETE" /* DELETE */: {
+      return "delete";
+    }
+    case "READ_ALL" /* READ_ALL */:
+    case "READ_ONE" /* READ_ONE */: {
+      return "get";
+    }
+    case "UPDATE" /* UPDATE */: {
+      return "put";
+    }
+    default: {
+      throw new TypeError(`Method for route type ${routeType} was not found.`);
+    }
+  }
+};
+var generateSwaggerPathObject = ({
+  hasId,
+  modelName,
+  modelsConfig,
+  routeTypes,
+  tag
+}) => {
+  const methods = {};
+  routeTypes.forEach((routeType) => {
+    if (routeTypes.includes(routeType)) {
+      const returnType = modelsConfig?.[modelName]?.routeTypes?.[routeType]?.response.name ?? modelsConfig?.[modelName]?.type?.name ?? modelName;
+      const method = getRouteTypeMethod(routeType);
+      const response = generateSwaggerResponse(routeType, returnType);
+      if (response === void 0) {
+        throw new TypeError(`Route type ${routeType}; response config was not found.`);
+      }
+      methods[method] = {
+        parameters: getQueryParameters(routeType).map((queryParameter) => {
+          return { ...queryParameter, in: "query" };
+        }),
+        responses: {
+          [response.statusCode]: response.content,
+          ...modelsConfig?.[modelName]?.routeTypes?.[routeType]?.responses
+        },
+        summary: modelsConfig?.[modelName]?.routeTypes?.[routeType]?.summary,
+        tags: [tag]
+      };
+      if (hasId) {
+        methods[method].parameters.push({
+          description: `ID of the ${modelName}`,
+          in: "path",
+          name: "id",
+          required: true,
+          schema: {
+            type: "string"
+          }
+        });
+      }
+      if (routeType === "UPDATE" /* UPDATE */) {
+        methods[method].requestBody = generateRequestBody("Update", returnType);
+      } else if (routeType === "CREATE" /* CREATE */) {
+        methods[method].requestBody = generateRequestBody("Create", returnType);
+      }
+    }
+  });
+  return methods;
+};
+var getSwaggerPaths = ({ models, modelsConfig, routes, routesMap }) => (
+  // eslint-disable-next-line unicorn/no-array-reduce
+  Object.keys(routes).reduce((accumulator, value) => {
+    const routeTypes = routes[value];
+    const resourceName = models?.[value]?.name ? models[value].name : routesMap?.[value] ?? value;
+    const tag = modelsConfig?.[value]?.tag.name ?? value;
+    if (routeTypes.includes("CREATE" /* CREATE */) || routeTypes.includes("READ_ALL" /* READ_ALL */)) {
+      const path = `/${resourceName}`;
+      const routeTypesToUse = ["READ_ALL" /* READ_ALL */, "CREATE" /* CREATE */].filter((routeType) => routeTypes.includes(routeType));
+      accumulator[path] = generateSwaggerPathObject({
+        modelName: value,
+        modelsConfig,
+        routeTypes: routeTypesToUse,
+        tag
+      });
+    }
+    if (routeTypes.includes("READ_ONE" /* READ_ONE */) || routeTypes.includes("UPDATE" /* UPDATE */) || routeTypes.includes("DELETE" /* DELETE */)) {
+      const path = `/${resourceName}/{id}`;
+      const routeTypesToUse = ["READ_ONE" /* READ_ONE */, "UPDATE" /* UPDATE */, "DELETE" /* DELETE */].filter((routeType) => routeTypes.includes(routeType));
+      accumulator[path] = generateSwaggerPathObject({
+        hasId: true,
+        modelName: value,
+        modelsConfig,
+        routeTypes: routeTypesToUse,
+        tag
+      });
+    }
+    return accumulator;
+  }, {})
+);
+var get_swagger_paths_default = getSwaggerPaths;
+
+// src/swagger/utils/get-swagger-tags.ts
+init_esm_shims();
+var getSwaggerTags = (modelNames, modelsConfig) => modelNames.map((modelName) => {
+  if (modelsConfig?.[modelName]?.tag) {
+    return modelsConfig[modelName].tag;
+  }
+  return {
+    name: modelName
+  };
+});
+var get_swagger_tags_default = getSwaggerTags;
+
+// src/swagger/adapter/prisma/index.ts
+var overwritePathsExampleWithModel = (swaggerPaths, examples) => {
+  Object.values(swaggerPaths).forEach((pathSpec) => {
+    Object.values(pathSpec).forEach((methodSpec) => {
+      if (typeof methodSpec.responses === "object") {
+        Object.values(methodSpec.responses).forEach((responseSpec) => {
+          if (typeof responseSpec.content === "object") {
+            Object.values(responseSpec.content).forEach(
+              (contentSpec) => {
+                if (typeof contentSpec.example === "string") {
+                  const example = contentSpec.example.replace("#/components/examples/", "");
+                  if (examples[example]?.value !== void 0) {
+                    contentSpec.example = examples[example].value;
+                  }
+                }
+              }
+            );
+          }
+        });
+      }
+    });
+  });
+  return swaggerPaths;
+};
+var modelsToOpenApi = async ({
+  crud = { models: {} },
+  defaultExposeStrategy = "all",
+  models: ctorModels,
+  prismaClient,
+  swagger = { allowedMediaTypes: { "application/json": true }, models: {} }
+}) => {
+  let dmmf;
+  let prismaDmmfModels;
+  if (prismaClient._dmmf !== void 0) {
+    dmmf = prismaClient._dmmf;
+    prismaDmmfModels = dmmf?.mappingsMap;
+  } else if (prismaClient._getDmmf !== void 0) {
+    dmmf = await prismaClient._getDmmf();
+    prismaDmmfModels = dmmf.mappingsMap;
+  }
+  if (dmmf === void 0) {
+    throw new TypeError("Couldn't get prisma client models");
+  }
+  const parser = new json_schema_parser_default(dmmf);
+  const definitions = parser.parseModels();
+  const dModels = Object.keys(definitions);
+  const schema = JSON.stringify({
+    ...definitions,
+    ...parser.parseInputTypes(dModels),
+    ...parser.getPaginationDataSchema(),
+    ...parser.getPaginatedModelsSchemas(dModels)
+  });
+  if (ctorModels !== void 0) {
+    ctorModels.forEach((model) => {
+      if (!Object.keys(prismaDmmfModels).includes(model)) {
+        throw new Error(`Model name ${model} is invalid.`);
+      }
+    });
+  }
+  const models = ctorModels ?? Object.keys(prismaDmmfModels);
+  const swaggerRoutes = get_models_accessible_routes_default(models, crud.models, defaultExposeStrategy);
+  const swaggerTags = get_swagger_tags_default(models, swagger.models);
+  const swaggerPaths = get_swagger_paths_default({
+    models: crud.models,
+    modelsConfig: swagger.models,
+    routes: swaggerRoutes,
+    routesMap: models_to_route_names_default(prismaDmmfModels, models)
+  });
+  const schemas = JSON.parse(schema.replaceAll("#/definitions", "#/components/schemas"));
+  const examples = parser.getExampleModelsSchemas(dModels, schemas);
+  return {
+    examples,
+    paths: overwritePathsExampleWithModel(swaggerPaths, examples),
+    schemas,
+    tags: swaggerTags
+  };
+};
+var prisma_default = modelsToOpenApi;
+
+export { PrismaAdapter, prisma_default as modelsToOpenApi };
+//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map