@visulima/crud 1.0.1 → 1.0.3

package/src/base-crud-handler.ts

@@ -1,181 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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;

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

@@ -1,27 +0,0 @@
-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

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

package/src/query-parser.ts

@@ -1,94 +0,0 @@
-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

@@ -1,95 +0,0 @@
-// 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;