@visulima/crud 3.0.0-alpha.14 → 3.0.0-alpha.16

package/dist/packem_shared/modelsToOpenApi-DypKlIy4.cjs

@@ -1,708 +0,0 @@
-'use strict';
-
-const modelsToRouteNames = require('./models-to-route-names-Dv94PzhE.cjs');
-const pagination = require('@visulima/pagination');
-const prismaDmmfTransformer = require('@visulima/prisma-dmmf-transformer');
-const getAccessibleRoutes = require('./get-accessible-routes-C6NF9Iry.cjs');
-const RouteType = require('./RouteType-Bk3uAK0x.cjs');
-
-const formatSchemaReference = (schemaName) => `#/components/schemas/${schemaName}`;
-
-const 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 "";
-    }
-  }
-};
-const PAGINATION_SCHEMA_NAME = "PaginationData";
-const methodsNames = [
-  { methodStart: "createOne", schemaNameStart: "Create" },
-  { methodStart: "updateOne", schemaNameStart: "Update" }
-];
-class PrismaJsonSchemaParser {
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  constructor(dmmf) {
-    this.dmmf = 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 = formatSchemaReference(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: formatSchemaReference(modelName)
-              },
-              type: "array",
-              xml: {
-                name: "data",
-                wrapped: true
-              }
-            },
-            meta: {
-              $ref: formatSchemaReference(PAGINATION_SCHEMA_NAME)
-            }
-          },
-          type: "object",
-          xml: {
-            name: `${modelName}Page`
-          }
-        }
-      };
-    }, {});
-  }
-  // eslint-disable-next-line class-methods-use-this
-  getPaginationDataSchema() {
-    return pagination.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 = prismaDmmfTransformer.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 = prismaDmmfTransformer.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: formatSchemaReference(fieldType.type.name) };
-    }
-    return { type: getJSONSchemaScalar(fieldType.type) };
-  }
-}
-
-const getModelsAccessibleRoutes = (modelNames, models, defaultExposeStrategy = "all") => (
-  // eslint-disable-next-line unicorn/no-array-reduce
-  modelNames.reduce((accumulator, modelName) => {
-    if (models?.[modelName]) {
-      return {
-        ...accumulator,
-        [modelName]: getAccessibleRoutes.getAccessibleRoutes(models[modelName].only, models[modelName].exclude, defaultExposeStrategy)
-      };
-    }
-    return {
-      ...accumulator,
-      [modelName]: getAccessibleRoutes.getAccessibleRoutes(void 0, void 0, defaultExposeStrategy)
-    };
-  }, {})
-);
-
-const 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"
-    }
-  }
-};
-const commonQueryParameters = [queryParameters.select, queryParameters.include].filter(Boolean);
-const listQueryParameters = [
-  ...commonQueryParameters,
-  queryParameters.limit,
-  queryParameters.skip,
-  queryParameters.where,
-  queryParameters.orderBy,
-  queryParameters.page,
-  queryParameters.distinct
-].filter(Boolean);
-const getQueryParameters = (routeType, additionalQueryParameters = []) => {
-  if (routeType === RouteType.RouteType.READ_ALL) {
-    return [...listQueryParameters, ...additionalQueryParameters].filter(Boolean);
-  }
-  return [...commonQueryParameters, ...additionalQueryParameters].filter(Boolean);
-};
-
-const formatExampleReference = (schemaName) => `#/components/examples/${schemaName}`;
-
-const generateContentForSchema = (schemaName, isArray) => {
-  if (isArray) {
-    return {
-      items: {
-        $ref: formatSchemaReference(schemaName)
-      },
-      type: "array"
-    };
-  }
-  return {
-    $ref: formatSchemaReference(schemaName)
-  };
-};
-const generateSwaggerResponse = (routeType, modelName) => {
-  if (routeType === RouteType.RouteType.CREATE) {
-    return {
-      content: {
-        content: {
-          "application/json": {
-            example: formatExampleReference(modelName),
-            schema: generateContentForSchema(modelName)
-          }
-        },
-        description: `${modelName} created`
-      },
-      statusCode: 201
-    };
-  }
-  if (routeType === RouteType.RouteType.DELETE) {
-    return {
-      content: {
-        content: {
-          "application/json": {
-            example: formatExampleReference(modelName),
-            schema: generateContentForSchema(modelName)
-          }
-        },
-        description: `${modelName} item deleted`
-      },
-      statusCode: 200
-    };
-  }
-  if (routeType === RouteType.RouteType.READ_ALL) {
-    return {
-      content: {
-        content: {
-          "application/json": {
-            examples: {
-              Default: {
-                $ref: formatExampleReference(`${modelName}s`)
-              },
-              Pagination: {
-                $ref: formatExampleReference(`${modelName}Page`)
-              }
-            },
-            schema: {
-              oneOf: [generateContentForSchema(modelName, true), generateContentForSchema(`${modelName}Page`, false)]
-            }
-          }
-        },
-        description: `${modelName} list retrieved`
-      },
-      statusCode: 200
-    };
-  }
-  if (routeType === RouteType.RouteType.READ_ONE) {
-    return {
-      content: {
-        content: {
-          "application/json": {
-            example: formatExampleReference(modelName),
-            schema: generateContentForSchema(modelName)
-          }
-        },
-        description: `${modelName} item retrieved`
-      },
-      statusCode: 200
-    };
-  }
-  if (routeType === RouteType.RouteType.UPDATE) {
-    return {
-      content: {
-        content: {
-          "application/json": {
-            example: formatExampleReference(modelName),
-            schema: generateContentForSchema(modelName)
-          }
-        },
-        description: `${modelName} item updated`
-      },
-      statusCode: 200
-    };
-  }
-  return void 0;
-};
-const generateRequestBody = (schemaStartName, modelName) => {
-  return {
-    content: {
-      "application/json": {
-        schema: {
-          $ref: formatSchemaReference(`${schemaStartName}${modelName}`)
-        }
-      }
-    }
-  };
-};
-const getRouteTypeMethod = (routeType) => {
-  switch (routeType) {
-    case RouteType.RouteType.CREATE: {
-      return "post";
-    }
-    case RouteType.RouteType.DELETE: {
-      return "delete";
-    }
-    case RouteType.RouteType.READ_ALL:
-    case RouteType.RouteType.READ_ONE: {
-      return "get";
-    }
-    case RouteType.RouteType.UPDATE: {
-      return "put";
-    }
-    default: {
-      throw new TypeError(`Method for route type ${routeType} was not found.`);
-    }
-  }
-};
-const 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 === RouteType.RouteType.UPDATE) {
-        methods[method].requestBody = generateRequestBody("Update", returnType);
-      } else if (routeType === RouteType.RouteType.CREATE) {
-        methods[method].requestBody = generateRequestBody("Create", returnType);
-      }
-    }
-  });
-  return methods;
-};
-const 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 ?? routesMap?.[value] ?? value;
-    const tag = modelsConfig?.[value]?.tag.name ?? value;
-    if (routeTypes.includes(RouteType.RouteType.CREATE) || routeTypes.includes(RouteType.RouteType.READ_ALL)) {
-      const path = `/${resourceName}`;
-      const routeTypesToUse = [RouteType.RouteType.READ_ALL, RouteType.RouteType.CREATE].filter((routeType) => routeTypes.includes(routeType));
-      accumulator[path] = generateSwaggerPathObject({
-        modelName: value,
-        modelsConfig,
-        routeTypes: routeTypesToUse,
-        tag
-      });
-    }
-    if (routeTypes.includes(RouteType.RouteType.READ_ONE) || routeTypes.includes(RouteType.RouteType.UPDATE) || routeTypes.includes(RouteType.RouteType.DELETE)) {
-      const path = `/${resourceName}/{id}`;
-      const routeTypesToUse = [RouteType.RouteType.READ_ONE, RouteType.RouteType.UPDATE, RouteType.RouteType.DELETE].filter((routeType) => routeTypes.includes(routeType));
-      accumulator[path] = generateSwaggerPathObject({
-        hasId: true,
-        modelName: value,
-        modelsConfig,
-        routeTypes: routeTypesToUse,
-        tag
-      });
-    }
-    return accumulator;
-  }, {})
-);
-
-const getSwaggerTags = (modelNames, modelsConfig) => modelNames.map((modelName) => {
-  if (modelsConfig?.[modelName]?.tag) {
-    return modelsConfig[modelName].tag;
-  }
-  return {
-    name: modelName
-  };
-});
-
-const 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;
-};
-const 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 PrismaJsonSchemaParser(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 = getModelsAccessibleRoutes(models, crud.models, defaultExposeStrategy);
-  const swaggerTags = getSwaggerTags(models, swagger.models);
-  const swaggerPaths = getSwaggerPaths({
-    models: crud.models,
-    modelsConfig: swagger.models,
-    routes: swaggerRoutes,
-    routesMap: modelsToRouteNames.modelsToRouteNames(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
-  };
-};
-
-module.exports = modelsToOpenApi;