fets 0.4.14 → 0.4.15

package/cjs/plugins/ajv.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAjv = void 0;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+const fast_json_stringify_1 = tslib_1.__importDefault(require("@ardatan/fast-json-stringify"));
+const fetch_1 = require("@whatwg-node/fetch");
+const Response_js_1 = require("../Response.js");
+const types_js_1 = require("../zod/types.js");
+const utils_js_1 = require("./utils.js");
+function useAjv({ components = {}, } = {}) {
+    const ajv = new ajv_1.default({
+        strict: false,
+        strictSchema: false,
+        validateSchema: false,
+        allowUnionTypes: true,
+        uriResolver: {
+            parse(uri) {
+                const url = new fetch_1.URL(uri);
+                return {
+                    scheme: url.protocol,
+                    userinfo: url.username + (url.password ? ':' + url.password : ''),
+                    host: url.hostname,
+                    port: url.port,
+                    path: url.pathname,
+                    query: url.search,
+                    fragment: url.hash,
+                };
+            },
+            resolve(base, ref) {
+                return new fetch_1.URL(ref, base).toString();
+            },
+            serialize(components) {
+                return (components.scheme +
+                    '://' +
+                    components.userinfo +
+                    components.host +
+                    components.port +
+                    components.path +
+                    components.query +
+                    components.fragment);
+            },
+        },
+    });
+    (0, ajv_formats_1.default)(ajv);
+    // Required for fast-json-stringify
+    ajv.addKeyword({
+        keyword: 'fjs_type',
+        type: 'object',
+        errors: false,
+        validate: (_type, date) => {
+            return date instanceof Date;
+        },
+    });
+    const serializersByPath = new Map();
+    return {
+        onRoute({ path, schemas, handlers }) {
+            const validationMiddlewares = new Map();
+            if (schemas?.request?.headers && !(0, types_js_1.isZodSchema)(schemas.request.headers)) {
+                const validateFn = ajv.compile({
+                    ...schemas.request.headers,
+                    components,
+                });
+                validationMiddlewares.set('headers', request => {
+                    const headersObj = (0, utils_js_1.getHeadersObj)(request.headers);
+                    const isValid = validateFn(headersObj);
+                    if (!isValid) {
+                        return validateFn.errors;
+                    }
+                    return [];
+                });
+            }
+            if (schemas?.request?.params && !(0, types_js_1.isZodSchema)(schemas.request.params)) {
+                const validateFn = ajv.compile({
+                    ...schemas.request.params,
+                    components,
+                });
+                validationMiddlewares.set('params', request => {
+                    const isValid = validateFn(request.params);
+                    if (!isValid) {
+                        return validateFn.errors;
+                    }
+                    return [];
+                });
+            }
+            if (schemas?.request?.query && !(0, types_js_1.isZodSchema)(schemas.request.query)) {
+                const validateFn = ajv.compile({
+                    ...schemas.request.query,
+                    components,
+                });
+                validationMiddlewares.set('query', request => {
+                    const isValid = validateFn(request.query);
+                    if (!isValid) {
+                        return validateFn.errors;
+                    }
+                    return [];
+                });
+            }
+            if (schemas?.request?.json && !(0, types_js_1.isZodSchema)(schemas.request.json)) {
+                const validateFn = ajv.compile({
+                    ...schemas.request.json,
+                    components,
+                });
+                validationMiddlewares.set('json', async (request) => {
+                    const contentType = request.headers.get('content-type');
+                    if (contentType?.includes('json')) {
+                        const jsonObj = await request.json();
+                        Object.defineProperty(request, 'json', {
+                            value: async () => jsonObj,
+                            configurable: true,
+                        });
+                        const isValid = validateFn(jsonObj);
+                        if (!isValid) {
+                            return validateFn.errors;
+                        }
+                    }
+                    return [];
+                });
+            }
+            if (schemas?.request?.formData && !(0, types_js_1.isZodSchema)(schemas.request.formData)) {
+                const validateFn = ajv.compile({
+                    ...schemas.request.formData,
+                    components,
+                });
+                validationMiddlewares.set('formData', async (request) => {
+                    const contentType = request.headers.get('content-type');
+                    if (contentType?.includes('multipart/form-data') ||
+                        contentType?.includes('application/x-www-form-urlencoded')) {
+                        const formData = await request.formData();
+                        const formDataObj = {};
+                        const jobs = [];
+                        formData.forEach((value, key) => {
+                            if (typeof value === 'string') {
+                                formDataObj[key] = value;
+                            }
+                            else {
+                                jobs.push(value.arrayBuffer().then(buffer => {
+                                    const typedArray = new Uint8Array(buffer);
+                                    const binaryStrParts = [];
+                                    typedArray.forEach((byte, index) => {
+                                        binaryStrParts[index] = String.fromCharCode(byte);
+                                    });
+                                    formDataObj[key] = binaryStrParts.join('');
+                                }));
+                            }
+                        });
+                        await Promise.all(jobs);
+                        Object.defineProperty(request, 'formData', {
+                            value: async () => formData,
+                            configurable: true,
+                        });
+                        const isValid = validateFn(formDataObj);
+                        if (!isValid) {
+                            return validateFn.errors;
+                        }
+                    }
+                    return [];
+                });
+            }
+            if (fast_json_stringify_1.default && schemas?.responses) {
+                const serializerByStatusCode = new Map();
+                for (const statusCode in schemas.responses) {
+                    const schema = schemas.responses[statusCode];
+                    if (!(0, types_js_1.isZodSchema)(schema)) {
+                        const serializer = (0, fast_json_stringify_1.default)({
+                            ...schema,
+                            components,
+                        }, {
+                            ajv,
+                        });
+                        serializerByStatusCode.set(Number(statusCode), serializer);
+                    }
+                }
+                serializersByPath.set(path, serializerByStatusCode);
+            }
+            if (validationMiddlewares.size > 0) {
+                handlers.unshift(async (request) => {
+                    const validationErrorsNonFlat = await Promise.all([...validationMiddlewares.entries()].map(async ([name, fn]) => {
+                        const errors = await fn(request);
+                        if (errors.length > 0) {
+                            return errors.map(error => ({
+                                name,
+                                ...error,
+                            }));
+                        }
+                    }));
+                    const validationErrors = validationErrorsNonFlat.flat().filter(Boolean);
+                    if (validationErrors.length > 0) {
+                        return Response_js_1.Response.json({
+                            errors: validationErrors,
+                        }, {
+                            status: 400,
+                            headers: {
+                                'x-error-type': 'validation',
+                            },
+                        });
+                    }
+                });
+            }
+        },
+        onSerializeResponse({ path, lazyResponse }) {
+            const serializers = serializersByPath.get(path);
+            if (serializers) {
+                const serializer = serializers.get(lazyResponse.init?.status || 200);
+                if (serializer) {
+                    lazyResponse.resolveWithSerializer(serializer);
+                }
+            }
+        },
+    };
+}
+exports.useAjv = useAjv;

package/cjs/plugins/openapi.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenAPI = void 0;
+const tslib_1 = require("tslib");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const Response_js_1 = require("../Response.js");
+const swagger_ui_html_js_1 = tslib_1.__importDefault(require("../swagger-ui-html.js"));
+const types_js_1 = require("../zod/types.js");
+function useOpenAPI({ oasEndpoint, swaggerUIEndpoint, swaggerUIOpts, }) {
+    let paths;
+    return {
+        onRouterInit(router) {
+            paths = router.openAPIDocument.paths = router.openAPIDocument.paths || {};
+            if (oasEndpoint) {
+                router.route({
+                    method: 'GET',
+                    path: oasEndpoint,
+                    internal: true,
+                    handler: () => Response_js_1.Response.json(router.openAPIDocument),
+                });
+            }
+            if (swaggerUIEndpoint) {
+                router.route({
+                    method: 'GET',
+                    path: swaggerUIEndpoint,
+                    internal: true,
+                    handler: () => new Response_js_1.Response(swagger_ui_html_js_1.default.replace('__SWAGGER_UI_OPTIONS__', JSON.stringify({
+                        spec: router.openAPIDocument,
+                        dom_id: '#swagger-ui',
+                        displayOperationId: true,
+                        tryItOutEnabled: true,
+                        requestSnippetsEnabled: true,
+                        displayRequestDuration: true,
+                        defaultModelRendering: 'model',
+                        defaultModelExpandDepth: 3,
+                        defaultModelsExpandDepth: 3,
+                        ...swaggerUIOpts,
+                    })), {
+                        headers: {
+                            'Content-Type': 'text/html',
+                        },
+                    }),
+                });
+            }
+        },
+        onRoute({ method, path, operationId, description, tags, schemas }) {
+            if (schemas) {
+                let pathForOAS = path.replace(/:([^/]+)/g, '{$1}');
+                if (!pathForOAS.startsWith('/')) {
+                    pathForOAS = `/${pathForOAS}`;
+                }
+                const pathObj = (paths[pathForOAS] = paths[pathForOAS] || {});
+                const lowerCasedMethod = method.toLowerCase();
+                pathObj[lowerCasedMethod] = pathObj[lowerCasedMethod] || {};
+                const operation = pathObj[lowerCasedMethod];
+                operation.operationId = operationId;
+                operation.description = description;
+                operation.tags = tags;
+                if (schemas.responses) {
+                    for (const statusCode in schemas.responses) {
+                        let responseSchema = schemas.responses[statusCode];
+                        if ((0, types_js_1.isZodSchema)(responseSchema)) {
+                            responseSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(responseSchema, {
+                                target: 'openApi3',
+                            });
+                        }
+                        operation.responses = operation.responses || {};
+                        operation.responses[statusCode] = {
+                            description: '',
+                            content: {
+                                'application/json': {
+                                    schema: responseSchema,
+                                },
+                            },
+                        };
+                    }
+                }
+                else {
+                    operation.responses = {
+                        default: {
+                            description: '',
+                        },
+                    };
+                }
+                if (schemas.request?.headers) {
+                    let headersSchema = schemas.request.headers;
+                    if ((0, types_js_1.isZodSchema)(headersSchema)) {
+                        headersSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(headersSchema, {
+                            target: 'openApi3',
+                        });
+                    }
+                    for (const headerName in headersSchema.properties) {
+                        const headerSchema = headersSchema.properties[headerName];
+                        operation.parameters = operation.parameters || [];
+                        operation.parameters.push({
+                            name: headerName,
+                            in: 'header',
+                            required: headersSchema.required?.includes(headerName),
+                            schema: headerSchema,
+                        });
+                    }
+                }
+                if (schemas.request?.params) {
+                    let paramsSchema = schemas.request.params;
+                    if ((0, types_js_1.isZodSchema)(paramsSchema)) {
+                        paramsSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(paramsSchema, {
+                            target: 'openApi3',
+                        });
+                    }
+                    for (const paramName in paramsSchema.properties) {
+                        const paramSchema = paramsSchema.properties[paramName];
+                        operation.parameters = operation.parameters || [];
+                        operation.parameters.push({
+                            name: paramName,
+                            in: 'path',
+                            required: paramsSchema.required?.includes(paramName),
+                            schema: paramSchema,
+                        });
+                    }
+                }
+                if (schemas.request?.query) {
+                    let queriesSchema = schemas.request.query;
+                    if ((0, types_js_1.isZodSchema)(queriesSchema)) {
+                        queriesSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(queriesSchema, {
+                            target: 'openApi3',
+                        });
+                    }
+                    for (const queryName in queriesSchema.properties) {
+                        const querySchema = queriesSchema.properties[queryName];
+                        operation.parameters = operation.parameters || [];
+                        operation.parameters.push({
+                            name: queryName,
+                            in: 'query',
+                            required: queriesSchema.required?.includes(queryName),
+                            schema: querySchema,
+                        });
+                    }
+                }
+                if (schemas.request?.json) {
+                    let requestJsonSchema = schemas.request.json;
+                    if ((0, types_js_1.isZodSchema)(requestJsonSchema)) {
+                        requestJsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(requestJsonSchema, {
+                            target: 'openApi3',
+                        });
+                    }
+                    const requestBody = (operation.requestBody = (operation.requestBody || {}));
+                    requestBody.required = true;
+                    const requestBodyContent = (requestBody.content = (requestBody.content || {}));
+                    requestBodyContent['application/json'] = {
+                        schema: requestJsonSchema,
+                    };
+                }
+                if (schemas.request?.formData) {
+                    const requestBody = (operation.requestBody = (operation.requestBody || {}));
+                    requestBody.required = true;
+                    const requestBodyContent = (requestBody.content = (requestBody.content || {}));
+                    let requestFormDataSchema = schemas.request.formData;
+                    if ((0, types_js_1.isZodSchema)(requestFormDataSchema)) {
+                        requestFormDataSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(requestFormDataSchema, {
+                            target: 'openApi3',
+                        });
+                    }
+                    requestBodyContent['multipart/form-data'] = {
+                        schema: requestFormDataSchema,
+                    };
+                }
+            }
+        },
+    };
+}
+exports.useOpenAPI = useOpenAPI;

package/cjs/plugins/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHeadersObj = void 0;
+function getHeadersObj(headers) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return headers.get(prop) || undefined;
+        },
+        set(_target, prop, value) {
+            headers.set(prop, value);
+            return true;
+        },
+        has(_target, prop) {
+            return headers.has(prop);
+        },
+        deleteProperty(_target, prop) {
+            headers.delete(prop);
+            return true;
+        },
+        ownKeys() {
+            return [...headers.keys()];
+        },
+        getOwnPropertyDescriptor() {
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        },
+    });
+}
+exports.getHeadersObj = getHeadersObj;

package/cjs/swagger-ui-html.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = "<!doctype html><html lang=en><head><meta charset=utf-8><meta name=viewport content=\"width=device-width,initial-scale=1\"><meta name=description content=SwaggerUI><title>SwaggerUI</title><style>@import url(https://cdn.jsdelivr.net/gh/Itz-fork/Fastapi-Swagger-UI-Dark/assets/swagger_ui_dark.min.css) (prefers-color-scheme: dark);@import url(https://unpkg.com/swagger-ui-dist/swagger-ui.css) (prefers-color-scheme: light);@media (prefers-color-scheme:dark){.swagger-ui textarea{background:hsl(358.8deg 1.05% 1.91% / 80%)!important}.swagger-ui .scheme-container{background:#1e1e2e}.swagger-ui select{background:rgba(0,0,0,.2)}}</style></head><body><div id=swagger-ui></div><script src=https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js crossorigin></script><script>window.onload=()=>{window.ui=SwaggerUIBundle(__SWAGGER_UI_OPTIONS__)}</script></body></html>";

package/cjs/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHandlersToMethod = void 0;
+// This is used on runtime for optimization
+function preparePatternHandlerObjByMethod({ handlersByPatternByMethod, patternHandlerObjByMethod, }) {
+    for (const [method, patternHandlersMap] of handlersByPatternByMethod) {
+        const patternHandlerObjList = [];
+        for (const [pattern, handlers] of patternHandlersMap) {
+            patternHandlerObjList.push({
+                pattern,
+                handlers,
+            });
+        }
+        patternHandlerObjByMethod.set(method, patternHandlerObjList);
+    }
+}
+function addHandlersToMethod({ operationId, description, tags, method, path, schemas, handlers, internal, onRouteHooks, openAPIDocument, basePath, fetchAPI, handlersByPatternByMethod, internalPatternsByMethod, patternHandlerObjByMethod, }) {
+    for (const onRouteHook of onRouteHooks) {
+        onRouteHook({
+            operationId,
+            description,
+            tags,
+            openAPIDocument,
+            method,
+            path,
+            schemas,
+            handlers,
+        });
+    }
+    let methodPatternMaps = handlersByPatternByMethod.get(method);
+    if (!methodPatternMaps) {
+        methodPatternMaps = new Map();
+        handlersByPatternByMethod.set(method, methodPatternMaps);
+    }
+    let fullPath = '';
+    if (basePath === '/') {
+        fullPath = path;
+    }
+    else if (path === '/') {
+        fullPath = basePath;
+    }
+    else {
+        fullPath = `${basePath}${path}`;
+    }
+    const pattern = new fetchAPI.URLPattern({ pathname: fullPath });
+    pattern.isPattern = fullPath.includes(':') || fullPath.includes('*');
+    methodPatternMaps.set(pattern, handlers);
+    // TODO: Better logic to make sure internal routes are always last
+    let internalPatterns = internalPatternsByMethod.get(method);
+    if (internal) {
+        if (!internalPatterns) {
+            internalPatterns = new Set();
+            internalPatternsByMethod.set(method, internalPatterns);
+        }
+        internalPatterns.add(pattern);
+    }
+    if (internalPatterns?.size) {
+        handlersByPatternByMethod.set(method, new Map([...methodPatternMaps.entries()].sort(([a], [b]) => {
+            if (internalPatterns.has(a)) {
+                return 1;
+            }
+            else if (internalPatterns.has(b)) {
+                return -1;
+            }
+            return 0;
+        })));
+    }
+    preparePatternHandlerObjByMethod({
+        handlersByPatternByMethod,
+        patternHandlerObjByMethod,
+    });
+}
+exports.addHandlersToMethod = addHandlersToMethod;

package/cjs/zod/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZodSchema = void 0;
+function isZodSchema(value) {
+    return value && typeof value === 'object' && typeof value.safeParse === 'function';
+}
+exports.isZodSchema = isZodSchema;

package/cjs/zod/zod.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useZod = void 0;
+const utils_js_1 = require("../plugins/utils.js");
+const Response_js_1 = require("../Response.js");
+const types_js_1 = require("./types.js");
+function useZod() {
+    return {
+        onRoute({ schemas, handlers }) {
+            if (schemas) {
+                const validationMiddlewares = new Map();
+                const requestSchemas = schemas.request;
+                if (requestSchemas) {
+                    if ((0, types_js_1.isZodSchema)(requestSchemas.headers)) {
+                        const headersSchema = requestSchemas.headers;
+                        validationMiddlewares.set('headers', request => {
+                            const headersObj = (0, utils_js_1.getHeadersObj)(request.headers);
+                            const result = headersSchema.safeParse(headersObj);
+                            if (!result.success) {
+                                return result.error.issues;
+                            }
+                            return [];
+                        });
+                    }
+                    if ((0, types_js_1.isZodSchema)(requestSchemas.params)) {
+                        const paramsSchema = requestSchemas.params;
+                        validationMiddlewares.set('params', request => {
+                            const result = paramsSchema.safeParse(request.params);
+                            if (!result.success) {
+                                return result.error.issues;
+                            }
+                            return [];
+                        });
+                    }
+                    if ((0, types_js_1.isZodSchema)(requestSchemas.query)) {
+                        const querySchema = requestSchemas.query;
+                        validationMiddlewares.set('query', request => {
+                            const result = querySchema.safeParse(request.query);
+                            if (!result.success) {
+                                return result.error.issues;
+                            }
+                            return [];
+                        });
+                    }
+                    if ((0, types_js_1.isZodSchema)(requestSchemas.json)) {
+                        const jsonSchema = requestSchemas.json;
+                        validationMiddlewares.set('json', async (request) => {
+                            const contentType = request.headers.get('content-type');
+                            if (contentType?.includes('json')) {
+                                const jsonObj = await request.json();
+                                Object.defineProperty(request, 'json', {
+                                    value: async () => jsonObj,
+                                    configurable: true,
+                                });
+                                const result = jsonSchema.safeParse(jsonObj);
+                                if (!result.success) {
+                                    return result.error.issues;
+                                }
+                            }
+                            return [];
+                        });
+                    }
+                    if (validationMiddlewares.size > 0) {
+                        handlers.unshift(async (request) => {
+                            const validationErrorsNonFlat = await Promise.all([...validationMiddlewares.entries()].map(async ([name, fn]) => {
+                                const errors = await fn(request);
+                                if (errors.length > 0) {
+                                    return errors.map(error => ({
+                                        name,
+                                        ...error,
+                                    }));
+                                }
+                            }));
+                            const validationErrors = validationErrorsNonFlat.flat().filter(Boolean);
+                            if (validationErrors.length > 0) {
+                                return Response_js_1.Response.json({
+                                    errors: validationErrors,
+                                }, {
+                                    status: 400,
+                                    headers: {
+                                        'x-error-type': 'validation',
+                                    },
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+        },
+    };
+}
+exports.useZod = useZod;

package/esm/Response.js

@@ -0,0 +1,74 @@
+import { Headers, Response as OriginalResponse } from '@whatwg-node/fetch';
+export const LAZY_SERIALIZED_RESPONSE = Symbol('LAZY_SERIALIZED_RESPONSE');
+export const defaultSerializer = obj => JSON.stringify(obj);
+export function isLazySerializedResponse(response) {
+    return response[LAZY_SERIALIZED_RESPONSE];
+}
+function isHeadersLike(headers) {
+    return headers?.get && headers?.forEach;
+}
+const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
+function getHeadersFromHeadersInit(init) {
+    let headers;
+    if (isHeadersLike(init)) {
+        headers = init;
+    }
+    else {
+        headers = new Headers(init);
+    }
+    if (!headers.has('content-type')) {
+        headers.set('content-type', JSON_CONTENT_TYPE);
+    }
+    return headers;
+}
+export function createLazySerializedResponse(jsonObj, init = {}) {
+    let actualResponse;
+    let headers;
+    function getHeaders() {
+        if (headers == null) {
+            headers = getHeadersFromHeadersInit(init.headers);
+        }
+        return headers;
+    }
+    return {
+        jsonObj,
+        get actualResponse() {
+            return actualResponse;
+        },
+        [LAZY_SERIALIZED_RESPONSE]: true,
+        init,
+        resolveWithSerializer(serializer) {
+            const serialized = serializer(jsonObj);
+            init.headers = getHeaders();
+            actualResponse = new OriginalResponse(serialized, init);
+        },
+        json() {
+            return Promise.resolve(jsonObj);
+        },
+        get status() {
+            return (init?.status || 200);
+        },
+        get headers() {
+            return getHeaders();
+        },
+    };
+}
+// This allows us to hook into serialization of the response body
+/**
+ * The Response interface of the Fetch API represents the response to a request.
+ * It contains the status of the response, as well as the response headers, and
+ * an optional response body.
+ *
+ * @param body An object defining a body for the response. This can be null (which is the default value), or a Blob, BufferSource, FormData, Node.js Readable stream, URLSearchParams, or USVString object. The USVString is handled as UTF-8.
+ * @param options An options object containing any custom settings that you want to apply to the response, or an empty object (which is the default value).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response
+ */
+export const Response = new Proxy(OriginalResponse, {
+    get(OriginalResponse, prop, receiver) {
+        if (prop === 'json') {
+            return createLazySerializedResponse;
+        }
+        return Reflect.get(OriginalResponse, prop, receiver);
+    },
+});