@visulima/crud 1.0.0

package/dist/index.js

@@ -0,0 +1,1101 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkFJWRITBOjs = require('./chunk-FJWRITBO.js');
+
+// src/adapter/prisma/index.ts
+var _httperrors = require('http-errors'); var _httperrors2 = _interopRequireDefault(_httperrors);
+
+// src/adapter/prisma/utils/models-to-route-names.ts
+var modelsToRouteNames = (mappingsMap, models) => {
+  const routesMap = {};
+  models == null ? void 0 : models.forEach((model) => {
+    routesMap[model] = mappingsMap[model].plural;
+  });
+  return routesMap;
+};
+var models_to_route_names_default = modelsToRouteNames;
+
+// src/utils/is-primitive.ts
+var primitiveTypes = /* @__PURE__ */ new Set(["string", "boolean", "number"]);
+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
+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
+var parsePrismaRecursiveField = (select, fieldName) => {
+  const parsed = {};
+  Object.keys(select).forEach((field) => {
+    if (select[field] !== true) {
+      parsed[field] = {
+        [fieldName]: parsePrismaRecursiveField(
+          select[field],
+          fieldName
+        )
+      };
+    } else {
+      parsed[field] = true;
+    }
+  });
+  return parsed;
+};
+var parse_recursive_default = parsePrismaRecursiveField;
+
+// src/adapter/prisma/utils/parse-where.ts
+var isObject = (a) => a instanceof Object;
+var operatorsAssociation2 = {
+  $eq: "equals",
+  $neq: "not",
+  $cont: "contains",
+  $ends: "endsWith",
+  $gt: "gt",
+  $gte: "gte",
+  $in: "in",
+  $lt: "lt",
+  $lte: "lte",
+  $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) => {
+  var _a;
+  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 == null ? void 0 : oldParsed.some,
+      ...(_a = formatFields[initialFieldKey]) == null ? void 0 : _a.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 "$or": {
+        if (isObject(value)) {
+          parsed.OR = parseObjectCombination(value, manyRelations);
+        }
+        break;
+      }
+      case "$and": {
+        if (isObject(value)) {
+          parsed.AND = parseObjectCombination(value, manyRelations);
+        }
+        break;
+      }
+      case "$not": {
+        if (isObject(value)) {
+          parsed.NOT = 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 {
+  constructor({
+    primaryKey = "id",
+    prismaClient,
+    manyRelations = {},
+    models
+  }) {
+    this.getPrismaClientModels = async () => {
+      var _a;
+      if (this.prismaClient._dmmf) {
+        this.dmmf = this.prismaClient._dmmf;
+        return (_a = this.dmmf) == null ? void 0 : _a.mappingsMap;
+      }
+      if (this.prismaClient._getDmmf) {
+        this.dmmf = await this.prismaClient._getDmmf();
+        return this.dmmf.mappingsMap;
+      }
+      throw new Error("Couldn't get prisma client models");
+    };
+    this.prismaClient = prismaClient;
+    this.primaryKey = primaryKey;
+    this.manyRelations = manyRelations;
+    this.ctorModels = models;
+  }
+  async init() {
+    const models = this.ctorModels;
+    const prismaDmmfModels = await this.getPrismaClientModels();
+    if (typeof models !== "undefined") {
+      models.forEach((model) => {
+        if (!Object.keys(prismaDmmfModels).includes(model)) {
+          throw new Error(`Model name ${model} is invalid.`);
+        }
+      });
+    }
+    this.models = _nullishCoalesce(models, () => ( Object.keys(prismaDmmfModels)));
+  }
+  async getPaginationData(resourceName, query) {
+    const total = await this.getPrismaDelegate(resourceName).count({
+      where: query.where,
+      distinct: query.distinct
+    });
+    return {
+      total,
+      pageCount: Math.ceil(total / query.take),
+      page: Math.ceil(query.skip / query.take) + 1
+    };
+  }
+  handleError(error) {
+    console.error(error);
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    throw error.constructor.name === "PrismaClientKnownRequestError" || error.constructor.name === "PrismaClientValidationError" ? _httperrors2.default.call(void 0, 400, "invalid request, check your server logs for more info") : _httperrors2.default.call(void 0, 500, "an unknown error occured, check your server logs for more info");
+  }
+  parseQuery(resourceName, query) {
+    var _a, _b;
+    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 ((_a = query.originalQuery) == null ? void 0 : _a.where) {
+      parsed.where = parse_where_default(JSON.parse(query.originalQuery.where), _nullishCoalesce(this.manyRelations[resourceName], () => ( [])));
+    }
+    if (query.orderBy) {
+      parsed.orderBy = parse_order_by_default(query.orderBy);
+    }
+    if (typeof query.limit !== "undefined") {
+      parsed.take = query.limit;
+    }
+    if (typeof query.skip !== "undefined") {
+      parsed.skip = query.skip;
+    }
+    if ((_b = query.originalQuery) == null ? void 0 : _b.cursor) {
+      parsed.cursor = parse_cursor_default(JSON.parse(query.originalQuery.cursor));
+    }
+    if (query.distinct) {
+      parsed.distinct = query.distinct;
+    }
+    return parsed;
+  }
+  async getAll(resourceName, query) {
+    return await this.getPrismaDelegate(resourceName).findMany({
+      select: query.select,
+      include: query.include,
+      where: query.where,
+      orderBy: query.orderBy,
+      cursor: query.cursor,
+      take: query.take,
+      skip: query.skip,
+      distinct: query.distinct
+    });
+  }
+  async getOne(resourceName, resourceId, query) {
+    const delegate = this.getPrismaDelegate(resourceName);
+    const findFunction = delegate.findUnique || delegate.findOne;
+    return findFunction({
+      where: {
+        [this.primaryKey]: resourceId
+      },
+      select: query.select,
+      include: query.include
+    });
+  }
+  async create(resourceName, data, query) {
+    return this.getPrismaDelegate(resourceName).create({
+      data,
+      select: query.select,
+      include: query.include
+    });
+  }
+  async update(resourceName, resourceId, data, query) {
+    return this.getPrismaDelegate(resourceName).update({
+      where: {
+        [this.primaryKey]: resourceId
+      },
+      data,
+      select: query.select,
+      include: query.include
+    });
+  }
+  async delete(resourceName, resourceId, query) {
+    return this.getPrismaDelegate(resourceName).delete({
+      where: {
+        [this.primaryKey]: resourceId
+      },
+      select: query.select,
+      include: query.include
+    });
+  }
+  connect() {
+    return this.prismaClient.$connect();
+  }
+  disconnect() {
+    return this.prismaClient.$disconnect();
+  }
+  get client() {
+    return this.prismaClient;
+  }
+  getModels() {
+    return this.models || [];
+  }
+  getPrismaDelegate(resourceName) {
+    return this.prismaClient[`${resourceName.charAt(0).toLowerCase()}${resourceName.slice(1)}`];
+  }
+  async mapModelsToRouteNames() {
+    return models_to_route_names_default(await this.getPrismaClientModels(), this.getModels());
+  }
+};
+
+// src/swagger/json-schema-parser.ts
+var _prismadmmftransformer = require('@visulima/prisma-dmmf-transformer');
+
+// src/swagger/utils/format-schema-ref.ts
+var formatSchemaReference = (schemaName) => `#/components/schemas/${schemaName}`;
+var format_schema_ref_default = formatSchemaReference;
+
+// src/swagger/json-schema-parser.ts
+var getJSONSchemaScalar = (fieldType) => {
+  switch (fieldType) {
+    case "Int":
+    case "BigInt": {
+      return "integer";
+    }
+    case "DateTime":
+    case "Bytes":
+    case "String": {
+      return "string";
+    }
+    case "Float":
+    case "Decimal": {
+      return "number";
+    }
+    case "Json": {
+      return "object";
+    }
+    case "Boolean": {
+      return "boolean";
+    }
+    case "Null": {
+      return "null";
+    }
+    default: {
+      return "";
+    }
+  }
+};
+var PAGINATION_SCHEMA_NAME = "PaginationData";
+var methodsNames = [
+  { methodStart: "createOne", schemaNameStart: "Create" },
+  { methodStart: "updateOne", schemaNameStart: "Update" }
+];
+var PrismaJsonSchemaParser = class {
+  constructor(dmmf) {
+    this.dmmf = dmmf;
+    this.schemaInputTypes = /* @__PURE__ */ new Map();
+  }
+  parseModels() {
+    var _a;
+    const modelsDefinitions = _prismadmmftransformer.transformDMMF.call(void 0, this.dmmf).definitions;
+    (_a = Object.keys(modelsDefinitions || {})) == null ? void 0 : _a.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;
+  }
+  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 = _prismadmmftransformer.getJSONSchemaProperty.call(void 0, 
+              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,
+                  type: schemaType.filter((type) => type !== "null"),
+                  nullable: true
+                };
+                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] = {
+          type: "object",
+          xml: {
+            name: schemaName
+          },
+          properties
+        };
+        if (requiredProperties.length > 0) {
+          accumulator[schemaName].required = requiredProperties;
+        }
+      });
+      return accumulator;
+    }, {});
+    this.schemaInputTypes.forEach((value, key) => {
+      definitions[key] = {
+        type: "object",
+        xml: {
+          name: key
+        },
+        properties: value
+      };
+    });
+    return definitions;
+  }
+  formatInputTypeData(inputType) {
+    if (inputType.kind === "object") {
+      const reference = format_schema_ref_default(inputType.type.name);
+      if (inputType.isList) {
+        return {
+          type: "array",
+          xml: {
+            name: inputType.type.name,
+            wrapped: true
+          },
+          items: {
+            $ref: reference
+          }
+        };
+      }
+      return { $ref: reference };
+    }
+    const type = getJSONSchemaScalar(inputType.type);
+    if (inputType.isList) {
+      return {
+        type: "array",
+        xml: {
+          name: inputType.type.name,
+          wrapped: true
+        },
+        items: {
+          type
+        }
+      };
+    }
+    return { type };
+  }
+  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) };
+  }
+  getPaginationDataSchema() {
+    return {
+      [PAGINATION_SCHEMA_NAME]: {
+        type: "object",
+        xml: {
+          name: PAGINATION_SCHEMA_NAME
+        },
+        properties: {
+          total: {
+            type: "integer",
+            minimum: 0,
+            description: "Holds the value for the total number of rows in the database"
+          },
+          perPage: {
+            type: "integer",
+            minimum: 0,
+            description: "Returns the value for the limit passed to the paginate method"
+          },
+          page: {
+            type: "integer",
+            minimum: 1,
+            description: "Current page number"
+          },
+          lastPage: {
+            type: "integer",
+            minimum: 0,
+            description: "Returns the value for the last page by taking the total of rows into account"
+          },
+          firstPage: {
+            type: "integer",
+            minimum: 0,
+            description: "Returns the number for the first page. It is always 1"
+          },
+          firstPageUrl: {
+            type: "string",
+            description: "The URL for the first page"
+          },
+          lastPageUrl: {
+            type: "string",
+            description: "The URL for the last page"
+          },
+          nextPageUrl: {
+            type: "string",
+            description: "The URL for the next page"
+          },
+          previousPageUrl: {
+            type: "string",
+            description: "The URL for the previous page"
+          }
+        }
+      }
+    };
+  }
+  getExampleModelsSchemas(modelNames, schemas) {
+    const referenceToSchema = (reference) => {
+      const name = reference.replace("#/components/schemas/", "");
+      const model = schemas[name];
+      const values = {};
+      Object.entries((model == null ? void 0 : model.properties) || {}).forEach(([key, v]) => {
+        const type = v.type;
+        if (type === "array") {
+          values[key] = [arrayItemsToSchema(v.items)];
+        } else {
+          values[key] = type;
+        }
+      });
+      return values;
+    };
+    const objectPropertiesToSchema = (objectProperties) => {
+      const values = {};
+      Object.entries(objectProperties).forEach(([key, value]) => {
+        if (typeof value.$ref !== "undefined") {
+          values[key] = referenceToSchema(value.$ref);
+        } else {
+          values[key] = value.type;
+        }
+      });
+      return values;
+    };
+    const arrayItemsToSchema = (items) => {
+      const values = {};
+      Object.entries(items).forEach(([key, value]) => {
+        if (typeof value.items.$ref !== "undefined") {
+          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}`]: {
+          value
+        },
+        [`${modelName}Page`]: {
+          value: {
+            data: [value],
+            meta
+          }
+        }
+      };
+    }, {});
+  }
+  getPaginatedModelsSchemas(modelNames) {
+    return modelNames.reduce((accumulator, modelName) => {
+      return {
+        ...accumulator,
+        [`${modelName}Page`]: {
+          type: "object",
+          xml: {
+            name: `${modelName}Page`
+          },
+          properties: {
+            data: {
+              type: "array",
+              xml: {
+                name: "Data",
+                wrapped: true
+              },
+              items: {
+                $ref: format_schema_ref_default(modelName)
+              }
+            },
+            meta: {
+              $ref: format_schema_ref_default(PAGINATION_SCHEMA_NAME)
+            }
+          }
+        }
+      };
+    }, {});
+  }
+};
+var json_schema_parser_default = PrismaJsonSchemaParser;
+
+// src/swagger/utils/get-models-accessible-routes.ts
+var getModelsAccessibleRoutes = (modelNames, models, defaultExposeStrategy = "all") => modelNames.reduce((accumulator, modelName) => {
+  if (models == null ? void 0 : models[modelName]) {
+    return {
+      ...accumulator,
+      [modelName]: _chunkFJWRITBOjs.get_accessible_routes_default.call(void 0, models[modelName].only, models[modelName].exclude, defaultExposeStrategy)
+    };
+  }
+  return {
+    ...accumulator,
+    [modelName]: _chunkFJWRITBOjs.get_accessible_routes_default.call(void 0, void 0, void 0, defaultExposeStrategy)
+  };
+}, {});
+var get_models_accessible_routes_default = getModelsAccessibleRoutes;
+
+// src/swagger/parameters.ts
+var queryParameters = {
+  select: {
+    name: "select",
+    description: "Fields to select. For nested fields, chain them separated with a dot, eg: user.posts",
+    schema: {
+      type: "string"
+    }
+  },
+  include: {
+    name: "include",
+    description: "Include relations, same as select",
+    schema: {
+      type: "string"
+    }
+  },
+  where: {
+    name: "where",
+    description: 'Fields to filter. See <a href="https://next-crud.js.org/query-params#where">the docs</a>',
+    schema: {
+      type: "string"
+    }
+  },
+  orderBy: {
+    name: "orderBy",
+    description: 'Field on which to order by a direction. See <a href="https://next-crud.js.org/query-params#orderBy">the docs</a>',
+    schema: {
+      type: "string"
+    }
+  },
+  limit: {
+    name: "limit",
+    description: "Maximum number of elements to retrieve",
+    schema: {
+      type: "integer",
+      minimum: 0
+    }
+  },
+  skip: {
+    name: "skip",
+    description: "Number of rows to skip",
+    schema: {
+      type: "integer",
+      minimum: 0
+    }
+  },
+  distinct: {
+    name: "distinct",
+    description: "Fields to distinctively retrieve",
+    schema: {
+      type: "string"
+    }
+  },
+  page: {
+    name: "page",
+    description: "Page number. Use only for pagination.",
+    schema: {
+      type: "integer",
+      minimum: 1
+    }
+  }
+};
+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];
+  }
+  return [...commonQueryParameters, ...additionalQueryParameters];
+};
+
+// src/swagger/utils/format-example-ref.ts
+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 {
+      type: "array",
+      items: {
+        $ref: format_schema_ref_default(schemaName)
+      }
+    };
+  }
+  return {
+    $ref: format_schema_ref_default(schemaName)
+  };
+};
+var generateSwaggerResponse = (routeType, modelName) => {
+  if (routeType === "CREATE" /* CREATE */) {
+    return {
+      statusCode: 201,
+      content: {
+        description: `${modelName} created`,
+        content: {
+          "application/json": {
+            schema: generateContentForSchema(modelName)
+          }
+        }
+      }
+    };
+  }
+  if (routeType === "DELETE" /* DELETE */) {
+    return {
+      statusCode: 200,
+      content: {
+        description: `${modelName} item deleted`,
+        content: {
+          "application/json": {
+            schema: generateContentForSchema(modelName)
+          }
+        }
+      }
+    };
+  }
+  if (routeType === "READ_ALL" /* READ_ALL */) {
+    return {
+      statusCode: 200,
+      content: {
+        description: `${modelName} list retrieved`,
+        content: {
+          "application/json": {
+            schema: {
+              oneOf: [generateContentForSchema(modelName, true), generateContentForSchema(`${modelName}Page`, false)]
+            },
+            examples: {
+              Default: {
+                $ref: format_example_ref_default(`${modelName}`)
+              },
+              Pagination: {
+                $ref: format_example_ref_default(`${modelName}Page`)
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+  if (routeType === "READ_ONE" /* READ_ONE */) {
+    return {
+      statusCode: 200,
+      content: {
+        description: `${modelName} item retrieved`,
+        content: {
+          "application/json": {
+            schema: generateContentForSchema(modelName)
+          }
+        }
+      }
+    };
+  }
+  if (routeType === "UPDATE" /* UPDATE */) {
+    return {
+      statusCode: 200,
+      content: {
+        description: `${modelName} item updated`,
+        content: {
+          "application/json": {
+            schema: generateContentForSchema(modelName)
+          }
+        }
+      }
+    };
+  }
+  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 "READ_ALL" /* READ_ALL */:
+    case "READ_ONE" /* READ_ONE */: {
+      return "get";
+    }
+    case "UPDATE" /* UPDATE */: {
+      return "put";
+    }
+    case "DELETE" /* DELETE */: {
+      return "delete";
+    }
+    default: {
+      throw new TypeError(`Method for route type ${routeType} was not found.`);
+    }
+  }
+};
+var generateSwaggerPathObject = ({
+  tag,
+  routeTypes,
+  modelName,
+  modelsConfig,
+  hasId
+}) => {
+  const methods = {};
+  routeTypes.forEach((routeType) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    if (routeTypes.includes(routeType)) {
+      const returnType = _nullishCoalesce(_nullishCoalesce(((_d = (_c = (_b = (_a = modelsConfig == null ? void 0 : modelsConfig[modelName]) == null ? void 0 : _a.routeTypes) == null ? void 0 : _b[routeType]) == null ? void 0 : _c.response) == null ? void 0 : _d.name), () => ( ((_f = (_e = modelsConfig == null ? void 0 : modelsConfig[modelName]) == null ? void 0 : _e.type) == null ? void 0 : _f.name))), () => ( modelName));
+      const method = getRouteTypeMethod(routeType);
+      const response = generateSwaggerResponse(routeType, returnType);
+      if (typeof response === "undefined") {
+        throw new TypeError(`Route type ${routeType}; response config was not found.`);
+      }
+      methods[method] = {
+        tags: [tag],
+        summary: (_i = (_h = (_g = modelsConfig == null ? void 0 : modelsConfig[modelName]) == null ? void 0 : _g.routeTypes) == null ? void 0 : _h[routeType]) == null ? void 0 : _i.summary,
+        parameters: getQueryParameters(routeType).map((queryParameter) => {
+          return { ...queryParameter, in: "query" };
+        }),
+        responses: {
+          [response.statusCode]: response.content,
+          ...(_l = (_k = (_j = modelsConfig == null ? void 0 : modelsConfig[modelName]) == null ? void 0 : _j.routeTypes) == null ? void 0 : _k[routeType]) == null ? void 0 : _l.responses
+        }
+      };
+      if (hasId) {
+        methods[method].parameters.push({
+          in: "path",
+          name: "id",
+          description: `ID of the ${modelName}`,
+          required: true,
+          schema: {
+            type: "string"
+          }
+        });
+      }
+      if (routeType === "UPDATE" /* UPDATE */ || routeType === "CREATE" /* CREATE */) {
+        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 = ({
+  routes,
+  models,
+  modelsConfig,
+  routesMap
+}) => Object.keys(routes).reduce((accumulator, value) => {
+  var _a, _b, _c;
+  const routeTypes = routes[value];
+  const resourceName = ((_a = models == null ? void 0 : models[value]) == null ? void 0 : _a.name) ? models[value].name : (routesMap == null ? void 0 : routesMap[value]) || value;
+  const tag = ((_c = (_b = modelsConfig == null ? void 0 : modelsConfig[value]) == null ? void 0 : _b.tag) == null ? void 0 : _c.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({
+      tag,
+      modelName: value,
+      modelsConfig,
+      routeTypes: routeTypesToUse
+    });
+  }
+  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({
+      tag,
+      modelName: value,
+      modelsConfig,
+      routeTypes: routeTypesToUse,
+      hasId: true
+    });
+  }
+  return accumulator;
+}, {});
+var get_swagger_paths_default = getSwaggerPaths;
+
+// src/swagger/utils/get-swagger-tags.ts
+var getSwaggerTags = (modelNames, modelsConfig) => modelNames.map((modelName) => {
+  var _a;
+  if ((_a = modelsConfig == null ? void 0 : modelsConfig[modelName]) == null ? void 0 : _a.tag) {
+    return modelsConfig[modelName].tag;
+  }
+  return {
+    name: modelName
+  };
+});
+var get_swagger_tags_default = getSwaggerTags;
+
+// src/swagger/adapter/prisma/index.ts
+var modelsToOpenApi = async ({
+  prismaClient,
+  models: ctorModels,
+  swagger = { models: {}, allowedMediaTypes: { "application/json": true } },
+  crud = { models: {} },
+  defaultExposeStrategy = "all"
+}) => {
+  let dmmf;
+  let prismaDmmfModels;
+  if (prismaClient._dmmf) {
+    dmmf = prismaClient._dmmf;
+    prismaDmmfModels = dmmf == null ? void 0 : dmmf.mappingsMap;
+  } else if (prismaClient._getDmmf) {
+    dmmf = await prismaClient._getDmmf();
+    prismaDmmfModels = dmmf.mappingsMap;
+  }
+  if (typeof 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 (typeof ctorModels !== "undefined") {
+    ctorModels.forEach((model) => {
+      if (!Object.keys(prismaDmmfModels).includes(model)) {
+        throw new Error(`Model name ${model} is invalid.`);
+      }
+    });
+  }
+  const models = _nullishCoalesce(ctorModels, () => ( Object.keys(prismaDmmfModels)));
+  const swaggerRoutes = get_models_accessible_routes_default(models, crud.models || {}, defaultExposeStrategy);
+  const swaggerTags = get_swagger_tags_default(models, (swagger == null ? void 0 : swagger.models) || {});
+  const swaggerPaths = get_swagger_paths_default({
+    routes: swaggerRoutes,
+    modelsConfig: (swagger == null ? void 0 : swagger.models) || {},
+    models: crud.models || {},
+    routesMap: models_to_route_names_default(prismaDmmfModels, models)
+  });
+  const schemas = JSON.parse(schema.replace(/#\/definitions/g, "#/components/schemas"));
+  return {
+    schemas,
+    examples: parser.getExampleModelsSchemas(dModels, schemas),
+    tags: swaggerTags,
+    paths: swaggerPaths
+  };
+};
+var prisma_default = modelsToOpenApi;
+
+
+
+
+exports.PrismaAdapter = PrismaAdapter; exports.RouteType = _chunkFJWRITBOjs.RouteType; exports.modelsToOpenApi = prisma_default;
+//# sourceMappingURL=index.js.map