@visulima/crud 1.0.0

package/src/adapter/prisma/utils/models-to-route-names.ts

@@ -0,0 +1,12 @@
+const modelsToRouteNames = <M extends string = string>(mappingsMap: { [key: string]: object }, models: M[]) => {
+    const routesMap: { [key in M]?: string } = {};
+
+    models?.forEach((model) => {
+        // @ts-ignore
+        routesMap[model] = mappingsMap[model].plural;
+    });
+
+    return routesMap;
+};
+
+export default modelsToRouteNames;

package/src/adapter/prisma/utils/parse-cursor.ts

@@ -0,0 +1,26 @@
+import isPrimitive from "../../../utils/is-primitive";
+import type { PrismaCursor } from "../types.d";
+
+const parsePrismaCursor = (
+    cursor: Record<string, string | number | boolean>,
+): PrismaCursor => {
+    const parsed: PrismaCursor = {};
+
+    Object.keys(cursor).forEach((key) => {
+        const value = cursor[key];
+
+        if (isPrimitive(value)) {
+            parsed[key as keyof typeof cursor] = value as string | number | boolean;
+        }
+    });
+
+    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;
+};
+
+export default parsePrismaCursor;

package/src/adapter/prisma/utils/parse-order-by.ts

@@ -0,0 +1,21 @@
+import type { OrderByField, OrderByOperator } from "../../../types.d";
+import type { PrismaOrderBy, PrismaOrderByOperator } from "../types.d";
+
+const operatorsAssociation: Record<OrderByOperator, PrismaOrderByOperator> = {
+    $asc: "asc",
+    $desc: "desc",
+};
+
+const parsePrismaOrderBy = (orderBy: OrderByField): PrismaOrderBy => {
+    const parsed: PrismaOrderBy = {};
+
+    Object.keys(orderBy).forEach((key) => {
+        const value = orderBy[key];
+
+        parsed[key] = operatorsAssociation[value as OrderByOperator];
+    });
+
+    return parsed;
+};
+
+export default parsePrismaOrderBy;

package/src/adapter/prisma/utils/parse-recursive.ts

@@ -0,0 +1,26 @@
+import type { RecursiveField } from "../../../types.d";
+import type { PrismaRecursive, PrismaRecursiveField } from "../types.d";
+
+const parsePrismaRecursiveField = <T extends PrismaRecursiveField>(
+    select: RecursiveField,
+    fieldName: T,
+): PrismaRecursive<T> => {
+    const parsed: PrismaRecursive<T> = {};
+
+    Object.keys(select).forEach((field) => {
+        if (select[field] !== true) {
+            parsed[field] = {
+                [fieldName]: parsePrismaRecursiveField(
+                    select[field] as RecursiveField,
+                    fieldName,
+                ),
+            } as Record<T, PrismaRecursive<T>>;
+        } else {
+            parsed[field] = true;
+        }
+    });
+
+    return parsed;
+};
+
+export default parsePrismaRecursiveField;

package/src/adapter/prisma/utils/parse-where.ts

@@ -0,0 +1,197 @@
+import type {
+    Condition, SearchCondition, WhereCondition, WhereField, WhereOperator,
+} from "../../../types.d";
+import isPrimitive from "../../../utils/is-primitive";
+import type {
+    PrismaFieldFilter, PrismaRelationFilter, PrismaWhereField, PrismaWhereOperator,
+} from "../types.d";
+
+const isObject = (a: any) => a instanceof Object;
+
+const operatorsAssociation: {
+    [key in WhereOperator]?: PrismaWhereOperator;
+} = {
+    $eq: "equals",
+    $neq: "not",
+    $cont: "contains",
+    $ends: "endsWith",
+    $gt: "gt",
+    $gte: "gte",
+    $in: "in",
+    $lt: "lt",
+    $lte: "lte",
+    $notin: "notIn",
+    $starts: "startsWith",
+};
+
+const isDateString = (value: string) => /^\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);
+
+const getSearchValue = (originalValue: any): SearchCondition => {
+    if (isDateString(originalValue)) {
+        return new Date(originalValue);
+    }
+
+    if (typeof originalValue === "string" && originalValue === "$isnull") {
+        return null;
+    }
+
+    return originalValue;
+};
+
+const isRelation = (key: string, manyRelations: string[]): boolean => {
+    // Get the key containing . and remove the property name
+    const splitKey = key.split(".");
+    splitKey.splice(-1, 1);
+
+    return manyRelations.includes(splitKey.join("."));
+};
+
+const parseSimpleField = (value: Condition): undefined | { [key: string]: Condition } => {
+    const operator = Object.keys(value)[0];
+    const prismaOperator: undefined | PrismaWhereOperator = operatorsAssociation[operator as keyof typeof operatorsAssociation];
+
+    if (prismaOperator) {
+        return {
+            [prismaOperator]: value[operator as string],
+        };
+    }
+
+    return undefined;
+};
+
+const parseRelation = (
+    value: string | number | boolean | Date | Condition | WhereCondition,
+    key: string,
+    parsed: PrismaWhereField,
+    manyRelations: string[],
+) => {
+    // Reverse the keys so that we can format our object by nesting
+    const fields = key.split(".").reverse();
+
+    let formatFields: { [key: string]: any } = {};
+
+    fields.forEach((field, index) => {
+        // If we iterate over the property name, which is index 0, we parse it like a normal field
+        if (index === 0) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            basicParse(value, field, formatFields, manyRelations);
+            // Else we format the relation filter in the prisma way
+        } else {
+            formatFields = {
+                [field]: {
+                    some: formatFields,
+                },
+            };
+        }
+    });
+
+    // Retrieve the main relation field
+    const initialFieldKey = fields.reverse()[0] as string;
+    // Retrieve the old parsed version
+    const oldParsed = parsed[initialFieldKey] as PrismaRelationFilter;
+
+    // Format correctly in the prisma way
+    // eslint-disable-next-line no-param-reassign
+    parsed[initialFieldKey] = {
+        some: {
+            ...(oldParsed?.some as object),
+            ...(formatFields[initialFieldKey as string]?.some as object),
+        },
+    };
+};
+
+const parseObjectCombination = (object: Condition, manyRelations: string[]): PrismaFieldFilter => {
+    const parsed: PrismaFieldFilter = {};
+
+    Object.keys(object).forEach((key) => {
+        const value = object[key];
+
+        if (isRelation(key, manyRelations)) {
+            parseRelation(value, key, parsed, manyRelations);
+        } else if (isPrimitive(value)) {
+            parsed[key] = value as SearchCondition;
+        } else if (isObject(value)) {
+            const fieldResult = parseSimpleField(value as Condition);
+
+            if (fieldResult) {
+                parsed[key] = fieldResult;
+            }
+        }
+    });
+
+    return parsed;
+};
+
+const basicParse = (value: string | number | boolean | Condition | Date | WhereCondition, key: string, parsed: PrismaWhereField, manyRelations: string[]) => {
+    if (isPrimitive(value)) {
+        // eslint-disable-next-line no-param-reassign
+        parsed[key] = getSearchValue(value);
+    } else {
+        switch (key) {
+            case "$or": {
+                if (isObject(value)) {
+                    // eslint-disable-next-line no-param-reassign
+                    parsed.OR = parseObjectCombination(value as Condition, manyRelations);
+                }
+                break;
+            }
+            case "$and": {
+                if (isObject(value)) {
+                    // eslint-disable-next-line no-param-reassign
+                    parsed.AND = parseObjectCombination(value as Condition, manyRelations);
+                }
+                break;
+            }
+            case "$not": {
+                if (isObject(value)) {
+                    // eslint-disable-next-line no-param-reassign
+                    parsed.NOT = parseObjectCombination(value as Condition, manyRelations);
+                }
+                break;
+            }
+            default: {
+                // eslint-disable-next-line no-param-reassign
+                parsed[key] = parseSimpleField(value as Condition);
+                break;
+            }
+        }
+    }
+};
+
+const parsePrismaWhere = (where: WhereField, manyRelations: string[]): PrismaWhereField => {
+    const parsed: PrismaWhereField = {};
+
+    Object.keys(where).forEach((key) => {
+        const value = where[key];
+        /**
+         * If the key without property name is a relation
+         *
+         * We want the following example input:
+         *
+         * posts.author.id: 1
+         *
+         * to output
+         *
+         * {
+         *  posts: {
+         *    some: {
+         *      author: {
+         *        some: {
+         *          id: 1
+         *        }
+         *      }
+         *    }
+         *  }
+         * }
+         */
+        if (isRelation(key, manyRelations)) {
+            parseRelation(value, key, parsed, manyRelations);
+        } else {
+            basicParse(value, key, parsed, manyRelations);
+        }
+    });
+
+    return parsed;
+};
+
+export default parsePrismaWhere;

package/src/base-crud-handler.ts

@@ -0,0 +1,181 @@
+import type { HttpError } from "http-errors";
+import createHttpError from "http-errors";
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { ApiError } from "next/dist/server/api-utils";
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import createHandler from "./handler/create";
+import deleteHandler from "./handler/delete";
+import listHandler from "./handler/list";
+import readHandler from "./handler/read";
+import updateHandler from "./handler/update";
+import parseQuery from "./query-parser";
+import type {
+    Adapter, ExecuteHandler, HandlerOptions, HandlerParameters, ParsedQueryParameters,
+} from "./types.d";
+import { RouteType } from "./types.d";
+import formatResourceId from "./utils/format-resource-id";
+import getAccessibleRoutes from "./utils/get-accessible-routes";
+import { getResourceNameFromUrl } from "./utils/get-resource-name-from-url";
+import getRouteType from "./utils/get-route-type";
+import validateAdapterMethods from "./utils/validate-adapter-methods";
+
+type ResponseConfig = { status: number; data: any };
+
+async function baseHandler<R extends Request, Context extends unknown, T, Q extends ParsedQueryParameters = any, M extends string = string>(
+    responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>,
+    finalExecutor: (responseOrContext: Context) => Promise<void>,
+    adapter: Adapter<T, Q>,
+    options?: HandlerOptions<M>,
+): Promise<ExecuteHandler<R, Context>>;
+
+async function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = any, M extends string = string>(
+    responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>,
+    finalExecutor: (responseOrContext: RResponse) => Promise<void>,
+    adapter: Adapter<T, Q>,
+    options?: HandlerOptions<M>,
+): Promise<ExecuteHandler<R, RResponse>>;
+
+// eslint-disable-next-line radar/cognitive-complexity,max-len
+async function baseHandler<R extends { url: string; method: string }, RResponse, T, Q extends ParsedQueryParameters = any, M extends string = string>(
+    responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<RResponse>,
+    finalExecutor: (responseOrContext: RResponse) => Promise<void>,
+    adapter: Adapter<T, Q>,
+    options?: HandlerOptions<M>,
+): Promise<ExecuteHandler<R, RResponse>> {
+    try {
+        validateAdapterMethods(adapter);
+    } catch (error_: any) {
+        const error = error_ as HttpError;
+
+        throw new ApiError(error.statusCode, error.message);
+    }
+
+    await adapter.init?.();
+
+    const config = {
+        formatResourceId,
+        pagination: {
+            perPage: 20,
+        },
+        ...options,
+    };
+
+    const routeNames = await adapter.mapModelsToRouteNames?.();
+    const modelRoutes: { [key in M]?: string } = {};
+
+    adapter.getModels().forEach((modelName) => {
+        modelRoutes[modelName as M] = config?.models?.[modelName as M]?.name || routeNames?.[modelName] || modelName;
+    });
+
+    return async (request, responseOrContext) => {
+        const { resourceName, modelName } = getResourceNameFromUrl(request.url as string, modelRoutes);
+
+        if (!resourceName) {
+            if (process.env.NODE_ENV === "development") {
+                const mappedModels = await adapter.mapModelsToRouteNames?.();
+
+                if (typeof mappedModels === "object") {
+                    throw createHttpError(404, `Resource not found, possible models: ${Object.values(mappedModels).join(", ")}`);
+                }
+            }
+
+            throw createHttpError(404, `Resource not found: ${request.url}`);
+        }
+
+        const { routeType, resourceId } = getRouteType(request.method as string, request.url as string, resourceName);
+
+        if (routeType === null) {
+            throw createHttpError(404, `Route not found: ${request.url}`);
+        }
+
+        const modelConfig = options?.models?.[modelName as M];
+
+        const accessibleRoutes = getAccessibleRoutes(modelConfig?.only, modelConfig?.exclude, options?.exposeStrategy || "all");
+
+        if (!accessibleRoutes.includes(routeType)) {
+            throw createHttpError(404, `Route not found: ${request.url}`);
+        }
+
+        try {
+            const resourceIdFormatted = modelConfig?.formatResourceId?.(resourceId as string) ?? config.formatResourceId(resourceId as string);
+
+            await adapter.connect?.();
+
+            const parsedQuery = parseQuery((request.url as string).split("?")[1]);
+            const parameters: HandlerParameters<T, Q> = {
+                adapter,
+                query: adapter.parseQuery(modelName as M, parsedQuery),
+                resourceName: modelName as string,
+            };
+
+            try {
+                let responseConfig: ResponseConfig;
+
+                switch (routeType) {
+                    case RouteType.READ_ONE: {
+                        responseConfig = await (config?.handlers?.get || readHandler)<T, Q>({
+                            ...parameters,
+                            resourceId: resourceIdFormatted,
+                        });
+                        break;
+                    }
+                    case RouteType.READ_ALL: {
+                        responseConfig = await (config?.handlers?.list || listHandler)<T, Q>({
+                            ...parameters,
+                            query: {
+                                ...parameters.query,
+                                page: parsedQuery.page ? Number(parsedQuery.page) : undefined,
+                                limit: parsedQuery.limit ? Number(parsedQuery.limit) : undefined,
+                            },
+                            pagination: config.pagination,
+                        });
+                        break;
+                    }
+                    case RouteType.CREATE: {
+                        responseConfig = await (config?.handlers?.create || createHandler)<T, Q, R>({
+                            ...parameters,
+                            request: request as R & { body: Record<string, any> },
+                        });
+                        break;
+                    }
+                    case RouteType.UPDATE: {
+                        responseConfig = await (config?.handlers?.update || updateHandler)<T, Q, R>({
+                            ...parameters,
+                            resourceId: resourceIdFormatted,
+                            request: request as R & { body: Partial<T> },
+                        });
+                        break;
+                    }
+                    case RouteType.DELETE: {
+                        responseConfig = await (config?.handlers?.delete || deleteHandler)<T, Q>({
+                            ...parameters,
+                            resourceId: resourceIdFormatted,
+                        });
+                        break;
+                    }
+                    default: {
+                        responseConfig = {
+                            status: 404,
+                            data: "Method not found",
+                        };
+                    }
+                }
+
+                await responseExecutor(responseOrContext, responseConfig);
+            } catch (error: any) {
+                if (adapter.handleError && !(error instanceof ApiError)) {
+                    adapter.handleError(error);
+                } else {
+                    throw error;
+                }
+            }
+        } finally {
+            await adapter.disconnect?.();
+
+            await finalExecutor(responseOrContext);
+        }
+    };
+}
+
+export default baseHandler;

package/src/handler/create.ts

@@ -0,0 +1,21 @@
+import type { HandlerParameters } from "../types.d";
+
+const createHandler: Handler = async ({
+    adapter, query, resourceName, request,
+}) => {
+    const resources = await adapter.create(resourceName, request.body, query);
+
+    return {
+        data: resources,
+        status: 201,
+    };
+};
+
+export type Handler = <T, Q, Request>(
+    parameters: HandlerParameters<T, Q> & { request: Request & { body: Record<string, any> } },
+) => Promise<{
+    data: any;
+    status: number;
+}>;
+
+export default createHandler;

package/src/handler/delete.ts

@@ -0,0 +1,27 @@
+import createHttpError from "http-errors";
+
+import type { UniqueResourceHandlerParameters } from "../types.d";
+
+const deleteHandler: Handler = async ({
+    adapter, query, resourceName, resourceId,
+}) => {
+    const resource = await adapter.getOne(resourceName, resourceId, query);
+
+    if (resource) {
+        const deletedResource = await adapter.delete(resourceName, resourceId, query);
+
+        return {
+            data: deletedResource,
+            status: 200,
+        };
+    }
+    throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+};
+
+export type Handler = <T, Q>(
+    parameters: UniqueResourceHandlerParameters<T, Q>,
+) => Promise<{
+    data: any;
+    status: number;
+}>;
+export default deleteHandler;

package/src/handler/list.ts

@@ -0,0 +1,62 @@
+import { paginate } from "@visulima/pagination";
+
+import type { HandlerParameters, PaginationConfig, ParsedQueryParameters } from "../types.d";
+
+type PaginationOptions = {
+    page: number;
+    perPage: number;
+};
+
+const listHandler: Handler = async ({
+    adapter, query, resourceName, pagination,
+}) => {
+    let isPaginated = false;
+    let paginationOptions: PaginationOptions | undefined;
+
+    if (typeof query?.page !== "undefined") {
+        if (query?.page <= 0) {
+            throw new Error("page query must be a strictly positive number");
+        }
+
+        paginationOptions = {
+            page: query?.page,
+            perPage: query?.limit || pagination.perPage,
+        };
+    }
+
+    if (paginationOptions) {
+        isPaginated = true;
+
+        // eslint-disable-next-line no-param-reassign
+        query.skip = (paginationOptions.page - 1) * paginationOptions.perPage;
+        // eslint-disable-next-line no-param-reassign
+        query.limit = paginationOptions.perPage;
+    }
+
+    const resources = await adapter.getAll(resourceName, query);
+
+    if (isPaginated) {
+        const { page, total } = await adapter.getPaginationData(resourceName, query);
+
+        const paginator = paginate(page, (paginationOptions as PaginationOptions).perPage as number, total, resources);
+
+        return {
+            data: paginator.toJSON(),
+            status: 200,
+        };
+    }
+
+    return {
+        data: resources,
+        status: 200,
+    };
+};
+
+export type Handler = <T, Q extends ParsedQueryParameters>(
+    parameters: HandlerParameters<T, Q> & { pagination: PaginationConfig },
+) => Promise<{
+    data: any;
+    status: number;
+}>;
+
+export default listHandler;

package/src/handler/read.ts

@@ -0,0 +1,27 @@
+import createHttpError from "http-errors";
+
+import type { UniqueResourceHandlerParameters } from "../types.d";
+
+const readHandler: Handler = async ({
+    adapter, query, resourceName, resourceId,
+}) => {
+    const resource = await adapter.getOne(resourceName, resourceId, query);
+
+    if (!resource) {
+        throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+    }
+
+    return {
+        data: resource,
+        status: 200,
+    };
+};
+
+export type Handler = <T, Q>(
+    parameters: UniqueResourceHandlerParameters<T, Q>,
+) => Promise<{
+    data: any;
+    status: number;
+}>;
+
+export default readHandler;

package/src/handler/update.ts

@@ -0,0 +1,29 @@
+import createHttpError from "http-errors";
+
+import type { UniqueResourceHandlerParameters } from "../types.d";
+
+const updateHandler: Handler = async ({
+    adapter, query, resourceName, resourceId, request,
+}) => {
+    const resource = await adapter.getOne(resourceName, resourceId, query);
+
+    if (resource) {
+        const updatedResource = await adapter.update(resourceName, resourceId, request.body, query);
+
+        return {
+            status: 201,
+            data: updatedResource,
+        };
+    }
+
+    throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+};
+
+export type Handler = <T, Q, Request>(
+    parameters: UniqueResourceHandlerParameters<T, Q> & { request: Request & { body: Partial<T> } },
+) => Promise<{
+    data: any;
+    status: number;
+}>;
+
+export default updateHandler;

package/src/index.ts

@@ -0,0 +1,27 @@
+export { default as PrismaAdapter } from "./adapter/prisma";
+
+export { RouteType } from "./types.d";
+export type {
+    ParsedQueryParameters,
+    PaginationConfig,
+    HandlerParameters,
+    Adapter,
+    ModelsOptions,
+    HandlerOptions as CrudHandlerOptions,
+    ModelOption,
+    UniqueResourceHandlerParameters,
+    Condition,
+    OrderByField,
+    OrderByOperator,
+    RecursiveField,
+    WhereField,
+    WhereOperator,
+    WhereCondition,
+    SearchCondition,
+    PaginationData,
+} from "./types.d";
+
+export type { SwaggerModelsConfig } from "./swagger/types.d";
+
+export type { ModelsToOpenApiParameters } from "./swagger/adapter/prisma";
+export { default as modelsToOpenApi } from "./swagger/adapter/prisma";

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

@@ -0,0 +1,23 @@
+import baseHandler from "../../../base-crud-handler";
+import type {
+    Adapter, ExecuteHandler, HandlerOptions, ParsedQueryParameters,
+} from "../../../types.d";
+
+async function handler<T, R extends Request, Context, Q extends ParsedQueryParameters = any, M extends string = string>(
+    adapter: Adapter<T, Q>,
+    options?: HandlerOptions<M>,
+): Promise<ExecuteHandler<R, Context>> {
+    return baseHandler<R, Context, T, Q, M>(
+        async (_, responseConfig) => new Response(JSON.stringify(responseConfig.data), {
+            status: responseConfig.status,
+            headers: {
+                "content-type": "application/json; charset=utf-8",
+            },
+        }),
+        async () => {},
+        adapter,
+        options,
+    );
+}
+
+export default handler;