@visulima/api-platform 1.0.2 → 1.0.3

package/src/connect/handler.ts

@@ -1,46 +0,0 @@
-import type {
-    FunctionLike, Nextable, Route, ValueOrPromise,
-} from "@visulima/connect";
-import createHttpError from "http-errors";
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import JsonapiErrorHandler from "../error-handler/jsonapi-error-handler";
-import ProblemErrorHandler from "../error-handler/problem-error-handler";
-import type { ErrorHandler, ErrorHandlers } from "../error-handler/types";
-
-// eslint-disable-next-line unicorn/consistent-function-scoping,max-len
-export const onError = <Request extends IncomingMessage, Response extends ServerResponse>(errorHandlers: ErrorHandlers, showTrace: boolean) => async (error: unknown, request: Request, response: Response): Promise<void> => {
-    const apiFormat: string = request.headers.accept as string;
-
-    let errorHandler: ErrorHandler = ProblemErrorHandler;
-
-    if (apiFormat === "application/vnd.api+json") {
-        errorHandler = JsonapiErrorHandler;
-    }
-
-    // eslint-disable-next-line no-restricted-syntax
-    for (const { regex, handler } of errorHandlers) {
-        if (regex.test(apiFormat)) {
-            errorHandler = handler;
-            break;
-        }
-    }
-
-    // eslint-disable-next-line no-param-reassign
-    (error as { expose: boolean } & Error).expose = showTrace;
-
-    errorHandler(error, request, response);
-};
-
-export const onNoMatch: <Request extends IncomingMessage, Response extends ServerResponse>(
-    request: Request,
-    response: Response,
-    routes: Route<Nextable<FunctionLike>>[],
-) => ValueOrPromise<void> = async (request, response, routes) => {
-    const uniqueMethods = [...new Set(routes.map((route) => route.method))].join(", ");
-
-    response.setHeader("Allow", uniqueMethods);
-    response.statusCode = 405;
-
-    throw createHttpError(405, `No route with [${request.method}] method found.`);
-};

package/src/connect/middleware/cors-middleware.ts

@@ -1,10 +0,0 @@
-import { expressWrapper } from "@visulima/connect";
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { CorsOptions, CorsOptionsDelegate } from "cors";
-import cors from "cors";
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-// eslint-disable-next-line max-len
-const corsMiddleware = <Request extends IncomingMessage, Response extends ServerResponse>(options?: CorsOptions | CorsOptionsDelegate) => expressWrapper<Request, Response>(cors(options));
-
-export default corsMiddleware;

package/src/connect/middleware/http-header-normalizer.ts

@@ -1,93 +0,0 @@
-import type { NextHandler } from "@visulima/connect";
-import type { IncomingHttpHeaders, IncomingMessage } from "node:http";
-
-const exceptions = {
-    alpn: "ALPN",
-    "c-pep": "C-PEP",
-    "c-pep-info": "C-PEP-Info",
-    "caldav-timezones": "CalDAV-Timezones",
-    "content-id": "Content-ID",
-    "content-md5": "Content-MD5",
-    dasl: "DASL",
-    dav: "DAV",
-    dnt: "DNT",
-    etag: "ETag",
-    getprofile: "GetProfile",
-    "http2-settings": "HTTP2-Settings",
-    "last-event-id": "Last-Event-ID",
-    "mime-version": "MIME-Version",
-    "optional-www-authenticate": "Optional-WWW-Authenticate",
-    "sec-websocket-accept": "Sec-WebSocket-Accept",
-    "sec-websocket-extensions": "Sec-WebSocket-Extensions",
-    "sec-webSocket-key": "Sec-WebSocket-Key",
-    "sec-webSocket-protocol": "Sec-WebSocket-Protocol",
-    "sec-webSocket-version": "Sec-WebSocket-Version",
-    slug: "SLUG",
-    tcn: "TCN",
-    te: "TE",
-    ttl: "TTL",
-    "www-authenticate": "WWW-Authenticate",
-    "x-att-deviceid": "X-ATT-DeviceId",
-    "x-dnsprefetch-control": "X-DNSPrefetch-Control",
-    "x-uidh": "X-UIDH",
-};
-
-const normalizeHeaderKey = (key: string, canonical: boolean) => {
-    const lowerCaseKey = key.toLowerCase();
-
-    if (!canonical) {
-        return lowerCaseKey;
-    }
-
-    if (exceptions[lowerCaseKey as keyof typeof exceptions]) {
-        return exceptions[lowerCaseKey as keyof typeof exceptions];
-    }
-
-    return (
-        lowerCaseKey
-            .split("-")
-            // eslint-disable-next-line no-unsafe-optional-chaining
-            .map((text) => text[0]?.toUpperCase() + text.slice(1))
-            .join("-")
-    );
-};
-
-const defaults = {
-    canonical: false,
-    normalizeHeaderKey,
-};
-
-/**
- * HTTP headers are case-insensitive.
- * That's why NodeJS makes them lower case by default.
- * While sensible, sometimes, for example for compatibility reasons, you might need them in their more common form.
- */
-const httpHeaderNormalizerMiddleware = (options_?: { canonical?: boolean; normalizeHeaderKey?: (key: string, canonical: boolean) => string }) => {
-    const options = { ...defaults, ...options_ };
-
-    return async <Request extends IncomingMessage>(request: Request, _: any, next: NextHandler) => {
-        if (request.headers) {
-            const rawHeaders: IncomingHttpHeaders = {};
-            const headers: IncomingHttpHeaders = {};
-
-            Object.keys(request.headers).forEach((key) => {
-                rawHeaders[key] = request.headers[key];
-
-                const normalizedKey = options.normalizeHeaderKey(key, options.canonical);
-
-                if (typeof normalizedKey !== "undefined") {
-                    headers[normalizedKey] = request.headers[key];
-                }
-            });
-
-            request.headers = headers;
-            // @TODO at type `request.rawHeaders` to global scope
-            // @ts-ignore
-            request.rawHeaders = rawHeaders;
-        }
-
-        return next();
-    };
-};
-
-export default httpHeaderNormalizerMiddleware;

package/src/connect/middleware/rate-limiter-middleware.ts

@@ -1,43 +0,0 @@
-import type { NextHandler } from "@visulima/connect";
-import createHttpError from "http-errors";
-import type { NextApiResponse } from "next";
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RateLimiterAbstract, RateLimiterRes } from "rate-limiter-flexible";
-
-// eslint-disable-next-line max-len
-const getIP: (request: IncomingMessage & { ip?: string }) => string | undefined = (request) => request?.ip
-    || (request.headers["x-forwarded-for"] as string | undefined)
-    || (request.headers["x-real-ip"] as string | undefined)
-    || request.connection.remoteAddress;
-
-type HeaderValue = string | number | ReadonlyArray<string>;
-
-// eslint-disable-next-line max-len
-const rateLimiterMiddleware = (rateLimiter: RateLimiterAbstract, headers?: (limiterResponse: RateLimiterRes) => { [key: string]: HeaderValue }) => async <Request extends IncomingMessage, Response extends ServerResponse>(request: Request, response: Response | NextApiResponse, next: NextHandler) => {
-    const ip = getIP(request);
-
-    if (typeof ip === "undefined") {
-        throw createHttpError(400, "Missing IP");
-    }
-
-    try {
-        const limiter = await rateLimiter.consume(ip);
-
-        const mergedHeaders: { [key: string]: HeaderValue } = {
-            "Retry-After": Math.round(limiter.msBeforeNext / 1000) || 1,
-            "X-RateLimit-Remaining": limiter.remainingPoints,
-            "X-RateLimit-Reset": new Date(Date.now() + limiter.msBeforeNext).toISOString(),
-            ...headers,
-        };
-
-        Object.keys(mergedHeaders).forEach((key) => {
-            response.setHeader(key, mergedHeaders[key] as HeaderValue);
-        });
-
-        await next();
-    } catch {
-        throw createHttpError(429, "Too Many Requests");
-    }
-};
-
-export default rateLimiterMiddleware;

package/src/connect/middleware/serializers-middleware.ts

@@ -1,121 +0,0 @@
-import type { NextHandler } from "@visulima/connect";
-import accepts from "accepts";
-import { header as headerCase } from "case";
-import type { NextApiResponse } from "next";
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import type { Serializer } from "../serializers/types";
-import xmlTransformer from "../serializers/xml";
-import yamlTransformer from "../serializers/yaml";
-
-function hasJsonStructure(string_: any): boolean {
-    if (typeof string_ !== "string") {
-        return false;
-    }
-
-    try {
-        const result = JSON.parse(string_);
-        const type = Object.prototype.toString.call(result);
-
-        return type === "[object Object]" || type === "[object Array]";
-    } catch {
-        return false;
-    }
-}
-
-const contentTypeKey = "Content-Type";
-
-// eslint-disable-next-line max-len
-const serialize = <Request extends IncomingMessage, Response extends ServerResponse>(
-    serializers: Serializers,
-    request: Request,
-    response: Response | NextApiResponse,
-    data: any,
-    options: {
-        defaultContentType: string;
-    },
-    // eslint-disable-next-line radar/cognitive-complexity
-) => {
-    const contentType = response.getHeader(contentTypeKey) as string | undefined;
-
-    // skip serialization when Content-Type is already set
-    if (typeof contentType === "string") {
-        return data;
-    }
-
-    const accept = accepts(request);
-    const types: string[] = [...(accept.types() as string[]), options.defaultContentType];
-
-    let serializedData = data;
-
-    // eslint-disable-next-line no-restricted-syntax
-    types.every((type) => {
-        let breakTypes = false;
-
-        serializers.forEach(({ regex, serializer }) => {
-            if (!regex.test(type)) {
-                return;
-            }
-
-            response.setHeader(contentTypeKey, type);
-            serializedData = serializer(serializedData);
-            breakTypes = true;
-        });
-
-        if (!breakTypes) {
-            if (/yaml|yml/.test(type)) {
-                response.setHeader(contentTypeKey, type);
-
-                serializedData = yamlTransformer(hasJsonStructure(data) ? JSON.parse(data) : data);
-            } else if (/xml/.test(type)) {
-                response.setHeader(contentTypeKey, type);
-
-                serializedData = xmlTransformer({
-                    [headerCase(`${request.url?.replace("/api/", "")}`.trim())]: hasJsonStructure(data) ? JSON.parse(data) : data,
-                });
-            }
-        }
-
-        return breakTypes;
-    });
-
-    // eslint-disable-next-line no-param-reassign
-    return serializedData;
-};
-
-// eslint-disable-next-line max-len
-const serializersMiddleware = (serializers: Serializers = [], defaultContentType: string = "application/json; charset=utf-8") => async <Request extends IncomingMessage, Response extends ServerResponse>(request: Request, response: Response | NextApiResponse, next: NextHandler) => {
-    if (typeof (response as NextApiResponse)?.send === "function") {
-        const oldSend = (response as NextApiResponse).send;
-
-        (response as NextApiResponse).send = (data) => {
-            (response as NextApiResponse).send = oldSend;
-
-            // eslint-disable-next-line no-param-reassign
-            data = serialize<Request, Response>(serializers, request, response, data, { defaultContentType });
-
-            return (response as NextApiResponse).send(data);
-        };
-    } else {
-        const oldEnd = response.end;
-
-        // @ts-ignore
-        response.end = (data, ...arguments_) => {
-            response.end = oldEnd;
-
-            // eslint-disable-next-line no-param-reassign
-            data = serialize<Request, Response>(serializers, request, response, data, { defaultContentType });
-
-            // @ts-ignore
-            return response.end(data, ...arguments_);
-        };
-    }
-
-    return next();
-};
-
-export type Serializers = {
-    regex: RegExp;
-    serializer: Serializer;
-}[];
-export default serializersMiddleware;

package/src/connect/serializers/types.d.ts

@@ -1 +0,0 @@
-export type Serializer = (data: any) => string | Buffer | Uint8Array;

package/src/connect/serializers/xml.ts

@@ -1,13 +0,0 @@
-import type { XmlElement } from "jstoxml";
-import { toXML } from "jstoxml";
-
-import type { Serializer } from "./types";
-
-const config = {
-    header: true,
-    indent: "  ",
-};
-
-const xmlTransformer: Serializer = (data?: XmlElement | XmlElement[]) => toXML(data, config);
-
-export default xmlTransformer;

package/src/connect/serializers/yaml.ts

@@ -1,7 +0,0 @@
-import { stringify } from "yaml";
-
-import type { Serializer } from "./types";
-
-const yamlTransformer: Serializer = (data) => stringify(data, { indent: 2 });
-
-export default yamlTransformer;

package/src/error-handler/jsonapi-error-handler.ts

@@ -1,46 +0,0 @@
-import { HttpError } from "http-errors";
-import { getReasonPhrase } from "http-status-codes";
-import { ErrorSerializer, JapiError } from "ts-japi";
-
-import type { ErrorHandler } from "./types";
-import { addStatusCodeToResponse, sendJson, setErrorHeaders } from "./utils";
-
-const defaultTitle = "An error occurred";
-
-const jsonapiErrorHandler: ErrorHandler = (error: HttpError | JapiError | Error, _request, response) => {
-    addStatusCodeToResponse(response, error);
-
-    setErrorHeaders(response, error);
-
-    if (error instanceof JapiError || JapiError.isLikeJapiError(error)) {
-        const serializer = new ErrorSerializer();
-
-        sendJson(response, serializer.serialize(error));
-    } else if (error instanceof HttpError) {
-        const { statusCode, title, message } = error;
-
-        sendJson(response, {
-            errors: [
-                {
-                    code: statusCode,
-                    title: title || getReasonPhrase(statusCode) || defaultTitle,
-                    detail: message,
-                },
-            ],
-        });
-    } else {
-        const { message } = error;
-
-        sendJson(response, {
-            errors: [
-                {
-                    code: "500",
-                    title: getReasonPhrase(response.statusCode) || defaultTitle,
-                    detail: message,
-                },
-            ],
-        });
-    }
-};
-
-export default jsonapiErrorHandler;

package/src/error-handler/problem-error-handler.ts

@@ -1,44 +0,0 @@
-import { HttpError } from "http-errors";
-import { getReasonPhrase } from "http-status-codes";
-
-import type { ErrorHandler } from "./types";
-import { addStatusCodeToResponse, sendJson, setErrorHeaders } from "./utils";
-
-const defaultType = "https://tools.ietf.org/html/rfc2616#section-10";
-const defaultTitle = "An error occurred";
-/**
- * Normalizes errors according to the API Problem spec (RFC 7807).
- *
- * @see https://tools.ietf.org/html/rfc7807
- */
-const problemErrorHandler: ErrorHandler = (error: HttpError | Error, _request, response) => {
-    const { stack, message } = error;
-
-    if (error instanceof HttpError) {
-        const {
-            statusCode, expose, title, type,
-        } = error;
-
-        response.statusCode = statusCode;
-
-        setErrorHeaders(response, error);
-
-        sendJson(response, {
-            type: type || defaultType,
-            title: title || getReasonPhrase(statusCode) || defaultTitle,
-            details: message,
-            ...(expose ? { trace: stack } : {}),
-        });
-    } else {
-        addStatusCodeToResponse(response, error);
-
-        sendJson(response, {
-            type: defaultType,
-            title: getReasonPhrase(response.statusCode) || defaultTitle,
-            details: message,
-            ...((error as { expose: boolean } & Error).expose ? { trace: stack } : {}),
-        });
-    }
-};
-
-export default problemErrorHandler;

package/src/error-handler/types.d.ts

@@ -1,14 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-export type ErrorHandler = <Request extends IncomingMessage, Response extends ServerResponse>(
-    error: any,
-    request: Request,
-    response: Response,
-) => any | Promise<any>;
-
-export type ErrorHandlers = {
-    regex: RegExp;
-    handler: ErrorHandler;
-}[];
-
-export type ApiFormat = "jsonapi" | "problem";

package/src/error-handler/utils.ts

@@ -1,39 +0,0 @@
-import { StatusCodes } from "http-status-codes";
-import type { ServerResponse } from "node:http";
-
-export const setErrorHeaders = (response: ServerResponse, error: any) => {
-    const headers: { [key: string]: number | string | ReadonlyArray<string> } = error.headers || {};
-
-    Object.keys(headers).forEach((header: string) => {
-        response.setHeader(header, headers[header] as number | string | ReadonlyArray<string>);
-    });
-};
-
-/**
- * Send `JSON` object
- * @param response response object
- * @param jsonBody of data
- */
-export const sendJson = (response: ServerResponse, jsonBody: any): void => {
-    // Set header to application/json
-    response.setHeader("content-type", "application/json; charset=utf-8");
-
-    response.end(JSON.stringify(jsonBody));
-};
-
-export const addStatusCodeToResponse = (response: ServerResponse, error: any): void => {
-    // respect err.statusCode
-    if (typeof error.statusCode !== "undefined") {
-        response.statusCode = error.statusCode;
-    }
-
-    // respect err.status
-    if (typeof error.status !== "undefined") {
-        response.statusCode = error.status;
-    }
-
-    // default status code to 500
-    if (response.statusCode < 400) {
-        response.statusCode = StatusCodes.INTERNAL_SERVER_ERROR;
-    }
-};

package/src/index-browser.tsx

@@ -1 +0,0 @@
-export * as zod from "./zod";

package/src/index-server.ts

@@ -1,75 +0,0 @@
-export * from "./index-browser";
-
-export {
-    default as createHttpError,
-    BadRequest,
-    Forbidden,
-    BadGateway,
-    BandwidthLimitExceeded,
-    Conflict,
-    ExpectationFailed,
-    FailedDependency,
-    GatewayTimeout,
-    Gone,
-    HTTPVersionNotSupported,
-    ImATeapot,
-    InsufficientStorage,
-    InternalServerError,
-    VariantAlsoNegotiates,
-    ProxyAuthenticationRequired,
-    NetworkAuthenticationRequire,
-    LengthRequired,
-    LoopDetected,
-    Locked,
-    MethodNotAllowed,
-    MisdirectedRequest,
-    NotAcceptable,
-    NotExtended,
-    NotFound,
-    NotImplemented,
-    PayloadTooLarge,
-    RequestHeaderFieldsTooLarge,
-    PaymentRequired,
-    PreconditionFailed,
-    PreconditionRequired,
-    RangeNotSatisfiable,
-    RequestTimeout,
-    ServiceUnavailable,
-    TooManyRequests,
-    Unauthorized,
-    UnorderedCollection,
-    UnprocessableEntity,
-    UnavailableForLegalReasons,
-    UnsupportedMediaType,
-    UpgradeRequired,
-    URITooLong,
-} from "http-errors";
-
-export { default as createNodeRouter } from "./connect/create-node-router";
-export { onError, onNoMatch } from "./connect/handler";
-export type {
-    EdgeRequestHandler,
-    ExpressRequestHandler,
-    NodeRequestHandler,
-    Route,
-    HandlerOptions,
-    NextHandler,
-    FunctionLike,
-    Nextable,
-    ValueOrPromise,
-    FindResult,
-    RouteShortcutMethod,
-    HttpMethod,
-} from "@visulima/connect";
-export {
-    createEdgeRouter, EdgeRouter, expressWrapper, NodeRouter, Router, withZod, sendJson,
-} from "@visulima/connect";
-
-export { default as rateLimiterMiddleware } from "./connect/middleware/rate-limiter-middleware";
-export { default as corsMiddleware } from "./connect/middleware/cors-middleware";
-export { default as serializersMiddleware } from "./connect/middleware/serializers-middleware";
-export { default as httpHeaderNormalizerMiddleware } from "./connect/middleware/http-header-normalizer";
-
-export { default as swaggerHandler } from "./swagger/swagger-handler";
-
-export { dateIn, dateOut } from "./zod";

package/src/next/cli/index.ts

@@ -1,2 +0,0 @@
-// eslint-disable-next-line import/prefer-default-export
-export { default as listCommand } from "./list/list-command";

package/src/next/cli/list/api-route-file-parser.ts

@@ -1,74 +0,0 @@
-import type { OpenApiObject } from "@visulima/jsdoc-open-api";
-import { jsDocumentCommentsToOpenApi, parseFile, swaggerJsDocumentCommentsToOpenApi } from "@visulima/jsdoc-open-api";
-import fs from "node:fs";
-import process from "node:process";
-
-import type { Route } from "./types";
-
-const extensionRegex = /\.(js|ts|mjs|cjs)$/;
-
-const apiRouteFileParser = (apiRouteFile: string, cwdPath: string, verbose: boolean = false): Route[] => {
-    let specs: OpenApiObject[] = [];
-
-    const parsedJsDocumentFile = parseFile(apiRouteFile, jsDocumentCommentsToOpenApi, verbose);
-
-    specs = [...specs, ...parsedJsDocumentFile.map((item) => item.spec)];
-
-    const parsedSwaggerJsDocumentFile = parseFile(apiRouteFile, swaggerJsDocumentCommentsToOpenApi, verbose);
-
-    specs = [...specs, ...parsedSwaggerJsDocumentFile.map((item) => item.spec)];
-
-    const routes: Route[] = [];
-
-    if (specs.length === 0) {
-        const apiRouteFileContent = fs.readFileSync(apiRouteFile, "utf8");
-
-        apiRouteFileContent.split(/\r?\n/).forEach((line) => {
-            const match = line.match(/[=aces|]+\s["'|](GET|POST|PUT|PATCH|HEAD|DELETE|OPTIONS)["'|]/);
-
-            if (match) {
-                let [, method] = match;
-
-                if (method === "GET") {
-                    method = "GET|HEAD";
-                }
-
-                routes.push({
-                    method: method as string,
-                    path: apiRouteFile.replace(cwdPath, "").replace(extensionRegex, ""),
-                    tags: [],
-                    file: apiRouteFile.replace(`${process.cwd()}/`, ""),
-                });
-            }
-        });
-
-        if (routes.length === 0) {
-            routes.push({
-                method: "GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS",
-                path: apiRouteFile.replace(cwdPath, "").replace(extensionRegex, ""),
-                tags: [],
-                file: apiRouteFile.replace(`${process.cwd()}/`, ""),
-            });
-        }
-
-        return routes;
-    }
-
-    specs.forEach((spec) => {
-        const paths = Object.entries(spec.paths);
-
-        paths.forEach(([path, pathSpec]) => {
-            const methods = Object.entries(pathSpec);
-
-            methods.forEach(([method, methodSpec]) => {
-                routes.push({
-                    path, method: method.toUpperCase(), tags: methodSpec.tags, file: apiRouteFile.replace(`${process.cwd()}/`, ""),
-                });
-            });
-        });
-    });
-
-    return routes;
-};
-
-export default apiRouteFileParser;