fets 0.4.14 → 0.4.15

package/esm/plugins/ajv.js

@@ -0,0 +1,208 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import jsonSerializerFactory from '@ardatan/fast-json-stringify';
+import { URL } from '@whatwg-node/fetch';
+import { Response } from '../Response.js';
+import { isZodSchema } from '../zod/types.js';
+import { getHeadersObj } from './utils.js';
+export function useAjv({ components = {}, } = {}) {
+    const ajv = new Ajv({
+        strict: false,
+        strictSchema: false,
+        validateSchema: false,
+        allowUnionTypes: true,
+        uriResolver: {
+            parse(uri) {
+                const url = new 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 URL(ref, base).toString();
+            },
+            serialize(components) {
+                return (components.scheme +
+                    '://' +
+                    components.userinfo +
+                    components.host +
+                    components.port +
+                    components.path +
+                    components.query +
+                    components.fragment);
+            },
+        },
+    });
+    addFormats(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 && !isZodSchema(schemas.request.headers)) {
+                const validateFn = ajv.compile({
+                    ...schemas.request.headers,
+                    components,
+                });
+                validationMiddlewares.set('headers', request => {
+                    const headersObj = getHeadersObj(request.headers);
+                    const isValid = validateFn(headersObj);
+                    if (!isValid) {
+                        return validateFn.errors;
+                    }
+                    return [];
+                });
+            }
+            if (schemas?.request?.params && !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 && !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 && !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 && !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 (jsonSerializerFactory && schemas?.responses) {
+                const serializerByStatusCode = new Map();
+                for (const statusCode in schemas.responses) {
+                    const schema = schemas.responses[statusCode];
+                    if (!isZodSchema(schema)) {
+                        const serializer = jsonSerializerFactory({
+                            ...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.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);
+                }
+            }
+        },
+    };
+}

package/esm/plugins/openapi.js

@@ -0,0 +1,166 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { Response } from '../Response.js';
+import swaggerUiHtml from '../swagger-ui-html.js';
+import { isZodSchema } from '../zod/types.js';
+export 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.json(router.openAPIDocument),
+                });
+            }
+            if (swaggerUIEndpoint) {
+                router.route({
+                    method: 'GET',
+                    path: swaggerUIEndpoint,
+                    internal: true,
+                    handler: () => new Response(swaggerUiHtml.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 (isZodSchema(responseSchema)) {
+                            responseSchema = 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 (isZodSchema(headersSchema)) {
+                        headersSchema = 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 (isZodSchema(paramsSchema)) {
+                        paramsSchema = 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 (isZodSchema(queriesSchema)) {
+                        queriesSchema = 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 (isZodSchema(requestJsonSchema)) {
+                        requestJsonSchema = 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 (isZodSchema(requestFormDataSchema)) {
+                        requestFormDataSchema = zodToJsonSchema(requestFormDataSchema, {
+                            target: 'openApi3',
+                        });
+                    }
+                    requestBodyContent['multipart/form-data'] = {
+                        schema: requestFormDataSchema,
+                    };
+                }
+            }
+        },
+    };
+}

package/esm/plugins/utils.js

@@ -0,0 +1,27 @@
+export 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,
+            };
+        },
+    });
+}

package/esm/swagger-ui-html.js

@@ -0,0 +1 @@
+export 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/esm/utils.js

@@ -0,0 +1,69 @@
+// 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);
+    }
+}
+export 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,
+    });
+}

package/esm/zod/types.js

@@ -0,0 +1,3 @@
+export function isZodSchema(value) {
+    return value && typeof value === 'object' && typeof value.safeParse === 'function';
+}

package/esm/zod/zod.js

@@ -0,0 +1,88 @@
+import { getHeadersObj } from '../plugins/utils.js';
+import { Response } from '../Response.js';
+import { isZodSchema } from './types.js';
+export function useZod() {
+    return {
+        onRoute({ schemas, handlers }) {
+            if (schemas) {
+                const validationMiddlewares = new Map();
+                const requestSchemas = schemas.request;
+                if (requestSchemas) {
+                    if (isZodSchema(requestSchemas.headers)) {
+                        const headersSchema = requestSchemas.headers;
+                        validationMiddlewares.set('headers', request => {
+                            const headersObj = getHeadersObj(request.headers);
+                            const result = headersSchema.safeParse(headersObj);
+                            if (!result.success) {
+                                return result.error.issues;
+                            }
+                            return [];
+                        });
+                    }
+                    if (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 (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 (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.json({
+                                    errors: validationErrors,
+                                }, {
+                                    status: 400,
+                                    headers: {
+                                        'x-error-type': 'validation',
+                                    },
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fets",
-  "version": "0.4.14",
+  "version": "0.4.15",
   "description": "TypeScript HTTP Framework focusing on e2e type-safety, easy setup, performance & great developer experience",
   "sideEffects": false,
   "dependencies": {

package/typings/Response.d.cts

@@ -0,0 +1,28 @@
+import { StatusCode, TypedResponse, TypedResponseCtor } from './typed-fetch.cjs';
+import { JSONSerializer } from './types.cjs';
+export declare const LAZY_SERIALIZED_RESPONSE: unique symbol;
+export declare const defaultSerializer: JSONSerializer;
+export interface LazySerializedResponse {
+    [LAZY_SERIALIZED_RESPONSE]: true;
+    resolveWithSerializer(serializer: JSONSerializer): void;
+    init?: ResponseInit;
+    actualResponse: Response;
+    jsonObj: any;
+    json: () => Promise<any>;
+    status: StatusCode;
+    headers: Headers;
+}
+export declare function isLazySerializedResponse(response: any): response is LazySerializedResponse;
+export declare function createLazySerializedResponse(jsonObj: any, init?: ResponseInit): LazySerializedResponse;
+/**
+ * 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 declare const Response: TypedResponseCtor;
+export type Response<TJSON = any, THeaders extends Record<string, string> = Record<string, string>, TStatusCode extends StatusCode = StatusCode> = TypedResponse<TJSON, THeaders, TStatusCode>;

package/typings/Response.d.ts

@@ -0,0 +1,28 @@
+import { StatusCode, TypedResponse, TypedResponseCtor } from './typed-fetch.js';
+import { JSONSerializer } from './types.js';
+export declare const LAZY_SERIALIZED_RESPONSE: unique symbol;
+export declare const defaultSerializer: JSONSerializer;
+export interface LazySerializedResponse {
+    [LAZY_SERIALIZED_RESPONSE]: true;
+    resolveWithSerializer(serializer: JSONSerializer): void;
+    init?: ResponseInit;
+    actualResponse: Response;
+    jsonObj: any;
+    json: () => Promise<any>;
+    status: StatusCode;
+    headers: Headers;
+}
+export declare function isLazySerializedResponse(response: any): response is LazySerializedResponse;
+export declare function createLazySerializedResponse(jsonObj: any, init?: ResponseInit): LazySerializedResponse;
+/**
+ * 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 declare const Response: TypedResponseCtor;
+export type Response<TJSON = any, THeaders extends Record<string, string> = Record<string, string>, TStatusCode extends StatusCode = StatusCode> = TypedResponse<TJSON, THeaders, TStatusCode>;