@visulima/crud 1.0.0

package/src/next/api/node/index.ts

@@ -0,0 +1,27 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import baseHandler from "../../../base-crud-handler";
+import type {
+    Adapter, ExecuteHandler, HandlerOptions, ParsedQueryParameters,
+} from "../../../types.d";
+
+async function handler<
+    T,
+    Q extends ParsedQueryParameters = any,
+    R extends NextApiRequest = NextApiRequest,
+    Response extends NextApiResponse = NextApiResponse,
+    M extends string = string,
+>(adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Response>> {
+    return baseHandler<R, Response, T, Q, M>(
+        async (response, responseConfig) => {
+            response.status(responseConfig.status).send(responseConfig.data);
+        },
+        async (response) => {
+            (response as Response).end();
+        },
+        adapter,
+        options,
+    );
+}
+
+export default handler;

package/src/next/index.ts

@@ -0,0 +1,2 @@
+export { default as edgeHandler } from "./api/edge";
+export { default as nodeHandler } from "./api/node";

package/src/query-parser.ts

@@ -0,0 +1,94 @@
+import set from "lodash.set";
+import { parse } from "qs";
+
+import type {
+    OrderByField, ParsedQueryParameters, RecursiveField, WhereField,
+} from "./types.d";
+
+const parseRecursive = (select: string): RecursiveField => {
+    if (typeof select === "string") {
+        const selectFields: RecursiveField = {};
+
+        const fields = select.split(",");
+
+        fields.forEach((field) => {
+            set(selectFields, field, true);
+        });
+
+        return selectFields;
+    }
+
+    throw new Error("select query param must be a string");
+};
+
+const parseWhere = (where: string): WhereField => {
+    const whereObject = JSON.parse(where);
+    const parsed: WhereField = {};
+
+    Object.keys(whereObject).forEach((key) => {
+        set(parsed, key, whereObject[key]);
+    });
+
+    return parsed;
+};
+
+const parseOrderBy = (orderBy: string): OrderByField => {
+    const parsed: OrderByField = {};
+    const orderByObject = JSON.parse(orderBy);
+
+    if (Object.keys(orderByObject).length > 0) {
+        const key = Object.keys(orderByObject)[0];
+
+        if (orderByObject[key as keyof typeof orderByObject] === "$asc" || orderByObject[key as keyof typeof orderByObject] === "$desc") {
+            parsed[key as string] = orderByObject[key as keyof typeof orderByObject];
+        }
+    }
+
+    if (Object.keys(parsed).length !== 1) {
+        throw new Error("orderBy needs to be an object with exactly 1 property with either $asc or $desc value");
+    }
+
+    return parsed;
+};
+
+// eslint-disable-next-line radar/cognitive-complexity
+const parseQuery = (queryString?: string): ParsedQueryParameters => {
+    if (queryString) {
+        const query = parse(queryString);
+        const parsedQuery: ParsedQueryParameters = {};
+
+        if (query.select) {
+            parsedQuery.select = parseRecursive(query.select as string);
+        }
+        if (query.include) {
+            parsedQuery.include = parseRecursive(query.include as string);
+        }
+        if (query.where) {
+            parsedQuery.where = parseWhere(query.where as string);
+        }
+        if (query.orderBy) {
+            parsedQuery.orderBy = parseOrderBy(query.orderBy as string);
+        }
+        if (typeof query.limit !== "undefined") {
+            parsedQuery.limit = Number.isFinite(+query.limit) ? +query.limit : undefined;
+        }
+        if (typeof query.skip !== "undefined") {
+            parsedQuery.skip = Number.isFinite(+query.skip) ? +query.skip : undefined;
+        }
+        if (query.distinct) {
+            parsedQuery.distinct = query.distinct as string;
+        }
+        if (query.page) {
+            parsedQuery.page = Number.isFinite(+query.page) ? +query.page : undefined;
+        }
+
+        return {
+            originalQuery: query,
+            ...parsedQuery,
+        };
+    }
+
+    return {};
+};
+
+export default parseQuery;

package/src/swagger/adapter/prisma/index.ts

@@ -0,0 +1,95 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import {
+    // @ts-ignore
+    PrismaClient,
+} from "@prisma/client";
+
+import modelsToRouteNames from "../../../adapter/prisma/utils/models-to-route-names";
+import type { ModelsOptions } from "../../../types.d";
+import PrismaJsonSchemaParser from "../../json-schema-parser";
+import type { SwaggerModelsConfig } from "../../types.d";
+import getModelsAccessibleRoutes from "../../utils/get-models-accessible-routes";
+import getSwaggerPaths from "../../utils/get-swagger-paths";
+import getSwaggerTags from "../../utils/get-swagger-tags";
+
+const modelsToOpenApi = async <M extends string = string>({
+    prismaClient,
+    models: ctorModels,
+    swagger = { models: {}, allowedMediaTypes: { "application/json": true } },
+    crud = { models: {} },
+    defaultExposeStrategy = "all",
+}: ModelsToOpenApiParameters<M>) => {
+    let dmmf: any;
+    let prismaDmmfModels: any;
+
+    // eslint-disable-next-line no-underscore-dangle
+    if (prismaClient._dmmf) {
+        // eslint-disable-next-line no-underscore-dangle
+        dmmf = prismaClient._dmmf;
+        prismaDmmfModels = dmmf?.mappingsMap;
+        // eslint-disable-next-line no-underscore-dangle
+    } else if (prismaClient._getDmmf) {
+        // eslint-disable-next-line no-underscore-dangle
+        dmmf = await prismaClient._getDmmf();
+        prismaDmmfModels = dmmf.mappingsMap;
+    }
+
+    if (typeof dmmf === undefined) {
+        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 (typeof ctorModels !== "undefined") {
+        ctorModels.forEach((model) => {
+            if (!Object.keys(prismaDmmfModels).includes(model)) {
+                throw new Error(`Model name ${model} is invalid.`);
+            }
+        });
+    }
+
+    // @ts-ignore
+    const models = ctorModels ?? (Object.keys(prismaDmmfModels) as M[]);
+
+    const swaggerRoutes = getModelsAccessibleRoutes(models, crud.models || {}, defaultExposeStrategy);
+    const swaggerTags = getSwaggerTags(models, swagger?.models || {});
+    const swaggerPaths = getSwaggerPaths({
+        routes: swaggerRoutes,
+        modelsConfig: swagger?.models || {},
+        models: crud.models || {},
+        routesMap: modelsToRouteNames(prismaDmmfModels, models),
+    });
+    const schemas = JSON.parse(schema.replace(/#\/definitions/g, "#/components/schemas"));
+
+    return {
+        schemas,
+        examples: parser.getExampleModelsSchemas(dModels, schemas),
+        tags: swaggerTags,
+        paths: swaggerPaths,
+    };
+};
+
+export interface ModelsToOpenApiParameters<M extends string = string> {
+    prismaClient: PrismaClient;
+    defaultExposeStrategy?: "all" | "none";
+    models?: M[];
+    swagger?: Partial<{
+        models: SwaggerModelsConfig<M>;
+        allowedMediaTypes: { [key: string]: boolean };
+    }>;
+    crud?: {
+        models: ModelsOptions<M>;
+    };
+}
+
+export default modelsToOpenApi;

package/src/swagger/json-schema-parser.ts

@@ -0,0 +1,456 @@
+import { getJSONSchemaProperty, transformDMMF } from "@visulima/prisma-dmmf-transformer";
+import type { JSONSchema7 } from "json-schema";
+import type { OpenAPIV3 } from "openapi-types";
+
+import formatSchemaReference from "./utils/format-schema-ref";
+
+const getJSONSchemaScalar = (fieldType: string | object) => {
+    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 "";
+        }
+    }
+};
+
+const PAGINATION_SCHEMA_NAME = "PaginationData";
+
+const methodsNames = [
+    { methodStart: "createOne", schemaNameStart: "Create" },
+    { methodStart: "updateOne", schemaNameStart: "Update" },
+];
+
+class PrismaJsonSchemaParser {
+    schemaInputTypes: Map<string, any> = new Map<string, any>();
+
+    constructor(private dmmf: any) {}
+
+    public parseModels(): {
+        [key: string]: JSONSchema7;
+    } {
+        const modelsDefinitions = transformDMMF(this.dmmf).definitions as {
+            [key: string]: JSONSchema7;
+        };
+
+        Object.keys(modelsDefinitions || {})?.forEach((definition: string | number) => {
+            // @TODO: added the correct type
+            // @ts-ignore
+            const { properties } = modelsDefinitions[definition];
+
+            Object.keys(properties).forEach((property: string) => {
+                if (Array.isArray(properties[property].type) && properties[property].type.includes("null")) {
+                    properties[property].type = properties[property].type.filter((type: string) => type !== "null");
+
+                    if (properties[property].type.length === 1) {
+                        // eslint-disable-next-line prefer-destructuring
+                        properties[property].type = properties[property].type[0];
+                    }
+
+                    properties[property].nullable = true;
+                }
+            });
+        });
+
+        return modelsDefinitions;
+    }
+
+    // eslint-disable-next-line radar/cognitive-complexity
+    public parseInputTypes(models: string[]) {
+        // eslint-disable-next-line radar/cognitive-complexity
+        const definitions = models.reduce((accumulator: { [key: string]: any }, modelName) => {
+            const methods = methodsNames.map((method) => {
+                return {
+                    name: `${method.methodStart}${modelName}`,
+                    schemaName: `${method.schemaNameStart}${modelName}`,
+                };
+            });
+
+            methods.forEach(({ name: method, schemaName }) => {
+                // @ts-ignore
+                const dataFields = this.dmmf.mutationType.fieldMap[method].args[0].inputTypes[0].type.fields;
+                const requiredProperties: string[] = [];
+                const properties = dataFields.reduce((propertiesAccumulator: any, field: any) => {
+                    if (field.inputTypes[0].kind === "scalar") {
+                        const schema = getJSONSchemaProperty(
+                            this.dmmf.datamodel,
+                            {},
+                        )({
+                            name: field.name,
+                            ...field.inputTypes[0],
+                        });
+
+                        // @TODO: added the correct type
+                        // @ts-ignore
+                        const { type: schemaType } = schema[1];
+
+                        if (schemaType && Array.isArray(schemaType)) {
+                            if (schemaType.includes("null")) {
+                                // eslint-disable-next-line no-param-reassign
+                                propertiesAccumulator[field.name] = {
+                                    ...schemaType,
+                                    type: schemaType.filter((type: string) => type !== "null"),
+                                    nullable: true,
+                                };
+                                if (propertiesAccumulator[field.name].type.length === 1) {
+                                    // eslint-disable-next-line no-param-reassign
+                                    propertiesAccumulator[field.name] = {
+                                        ...propertiesAccumulator[field.name],
+                                        type: propertiesAccumulator[field.name].type[0],
+                                    };
+                                }
+                            }
+                        } else {
+                            // eslint-disable-next-line no-param-reassign,prefer-destructuring
+                            propertiesAccumulator[field.name] = schema[1];
+                        }
+                    } else {
+                        const typeName = this.parseObjectInputType(field.inputTypes[0]);
+
+                        // eslint-disable-next-line no-param-reassign
+                        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;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    public formatInputTypeData(inputType: any) {
+        if (inputType.kind === "object") {
+            const reference = formatSchemaReference(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 };
+    }
+
+    // eslint-disable-next-line radar/cognitive-complexity
+    public parseObjectInputType(fieldType: any) {
+        if (fieldType.kind === "object") {
+            if (!this.schemaInputTypes.has(fieldType.type.name)) {
+                this.schemaInputTypes.set(fieldType.type.name, {});
+
+                fieldType.type.fields.forEach((field: any) => {
+                    let fieldData: Record<string, any> = {};
+
+                    if (field.inputTypes.length > 1) {
+                        let nullable = false;
+
+                        const anyOf = field.inputTypes
+                            .map((inputType: any) => {
+                                const inputTypeData = this.formatInputTypeData(inputType);
+
+                                if (inputTypeData.type === "null") {
+                                    nullable = true;
+
+                                    return;
+                                }
+
+                                // eslint-disable-next-line consistent-return
+                                return inputTypeData;
+                            })
+                            .filter(Boolean);
+
+                        if (anyOf.length === 1) {
+                            // eslint-disable-next-line prefer-destructuring
+                            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: any) => {
+                        if (inputType.kind === "object") {
+                            this.parseObjectInputType(inputType);
+                        }
+                    });
+                });
+            }
+
+            return { $ref: formatSchemaReference(fieldType.type.name) };
+        }
+
+        return { type: getJSONSchemaScalar(fieldType.type) };
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    public 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",
+                    },
+                },
+            },
+        };
+    }
+
+    public getExampleModelsSchemas(
+        modelNames: string[],
+        schemas: {
+            [key: string]: OpenAPIV3.SchemaObject;
+        },
+    ) {
+        const referenceToSchema = (reference: string) => {
+            const name = reference.replace("#/components/schemas/", "");
+            const model = schemas[name] as OpenAPIV3.SchemaObject;
+
+            const values: { [key: string]: string | object[] } = {};
+
+            Object.entries((model?.properties as OpenAPIV3.SchemaObject) || {}).forEach(([key, v]) => {
+                const type = (v as OpenAPIV3.SchemaObject).type as string;
+
+                if (type === "array") {
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    values[key] = [arrayItemsToSchema(v.items)];
+                } else {
+                    values[key] = type;
+                }
+            });
+
+            return values;
+        };
+
+        const objectPropertiesToSchema = (objectProperties: { [name: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject }) => {
+            const values: { [key: string]: string | object | object[] } = {};
+
+            Object.entries(objectProperties).forEach(([key, value]) => {
+                if (typeof (value as OpenAPIV3.ReferenceObject).$ref !== "undefined") {
+                    values[key] = referenceToSchema((value as OpenAPIV3.ReferenceObject).$ref);
+                } else {
+                    values[key] = (value as OpenAPIV3.SchemaObject).type as string;
+                }
+            });
+
+            return values;
+        };
+
+        const arrayItemsToSchema = (items: OpenAPIV3.ArraySchemaObject) => {
+            const values: { [key: string]: object | object[] } = {};
+
+            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: { [key: string]: string | object | object[] } = {};
+            const model = schemas[modelName] as OpenAPIV3.SchemaObject;
+
+            Object.entries(model.properties as OpenAPIV3.SchemaObject).forEach(([key, v]) => {
+                const type = (v as OpenAPIV3.SchemaObject).type as string;
+
+                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: { [key: string]: string } = {};
+
+            Object.entries(pagination.properties as OpenAPIV3.SchemaObject).forEach(([key, v]) => {
+                meta[key] = (v as OpenAPIV3.SchemaObject).type as string;
+            });
+
+            return {
+                ...accumulator,
+                [`${modelName}`]: {
+                    value,
+                },
+                [`${modelName}Page`]: {
+                    value: {
+                        data: [value],
+                        meta,
+                    },
+                },
+            };
+        }, {});
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    public getPaginatedModelsSchemas(modelNames: string[]) {
+        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: formatSchemaReference(modelName),
+                            },
+                        },
+                        meta: {
+                            $ref: formatSchemaReference(PAGINATION_SCHEMA_NAME),
+                        },
+                    },
+                },
+            };
+        }, {});
+    }
+}
+
+export default PrismaJsonSchemaParser;