@visulima/crud 3.0.0-alpha.7 → 3.0.0-alpha.9

package/dist/packem_shared/modelsToOpenApi-Bq98YsFg.mjs

@@ -0,0 +1,706 @@
+import { m as modelsToRouteNames } from './models-to-route-names-CdwsK0V1.mjs';
+import { createPaginationMetaSchemaObject } from '@visulima/pagination';
+import { getJSONSchemaProperty, transformDMMF } from '@visulima/prisma-dmmf-transformer';
+import { g as getAccessibleRoutes } from './get-accessible-routes-sV5SDdFn.mjs';
+import { RouteType } from './RouteType-CB2xrWdf.mjs';
+
+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 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: 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(models[modelName].only, models[modelName].exclude, defaultExposeStrategy)
+      };
+    }
+    return {
+      ...accumulator,
+      [modelName]: 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];
+const listQueryParameters = [
+  ...commonQueryParameters,
+  queryParameters.limit,
+  queryParameters.skip,
+  queryParameters.where,
+  queryParameters.orderBy,
+  queryParameters.page,
+  queryParameters.distinct
+];
+const getQueryParameters = (routeType, additionalQueryParameters = []) => {
+  if (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.CREATE) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: formatExampleReference(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} created`
+      },
+      statusCode: 201
+    };
+  }
+  if (routeType === RouteType.DELETE) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: formatExampleReference(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} item deleted`
+      },
+      statusCode: 200
+    };
+  }
+  if (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.READ_ONE) {
+    return {
+      content: {
+        content: {
+          "application/json": {
+            example: formatExampleReference(modelName),
+            schema: generateContentForSchema(modelName)
+          }
+        },
+        description: `${modelName} item retrieved`
+      },
+      statusCode: 200
+    };
+  }
+  if (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.CREATE: {
+      return "post";
+    }
+    case RouteType.DELETE: {
+      return "delete";
+    }
+    case RouteType.READ_ALL:
+    case RouteType.READ_ONE: {
+      return "get";
+    }
+    case 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.UPDATE) {
+        methods[method].requestBody = generateRequestBody("Update", returnType);
+      } else if (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 ? models[value].name : routesMap?.[value] ?? value;
+    const tag = modelsConfig?.[value]?.tag.name ?? value;
+    if (routeTypes.includes(RouteType.CREATE) || routeTypes.includes(RouteType.READ_ALL)) {
+      const path = `/${resourceName}`;
+      const routeTypesToUse = [RouteType.READ_ALL, RouteType.CREATE].filter((routeType) => routeTypes.includes(routeType));
+      accumulator[path] = generateSwaggerPathObject({
+        modelName: value,
+        modelsConfig,
+        routeTypes: routeTypesToUse,
+        tag
+      });
+    }
+    if (routeTypes.includes(RouteType.READ_ONE) || routeTypes.includes(RouteType.UPDATE) || routeTypes.includes(RouteType.DELETE)) {
+      const path = `/${resourceName}/{id}`;
+      const routeTypesToUse = [RouteType.READ_ONE, RouteType.UPDATE, 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(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
+  };
+};
+
+export { modelsToOpenApi as default };