fets 0.4.14 → 0.4.15

package/esm/client/auth/oauth.js

@@ -0,0 +1,31 @@
+export var OAuthPathErrorType;
+(function (OAuthPathErrorType) {
+    /**
+     * The request is missing a parameter so the server can’t proceed with the request.
+     * This may also be returned if the request includes an unsupported parameter or repeats a parameter.
+     */
+    OAuthPathErrorType["invalid_request"] = "invalid_request";
+    /**
+     * Client authentication failed, such as if the request contains an invalid client ID or secret.
+     * Send an HTTP 401 response in this case.
+     */
+    OAuthPathErrorType["invalid_client"] = "invalid_client";
+    /**
+     * The authorization code (or user’s password for the password grant type) is invalid or expired.
+     * This is also the error you would return if the redirect URL given in the authorization grant does not match the URL provided in this access token request.
+     */
+    OAuthPathErrorType["invalid_grant"] = "invalid_grant";
+    /**
+     * For access token requests that include a scope (password or client_credentials grants), this error indicates an invalid scope value in the request.
+     */
+    OAuthPathErrorType["invalid_scope"] = "invalid_scope";
+    /**
+     * This client is not authorized to use the requested grant type. For example, if you restrict which applications can use the Implicit grant, you would return this error for the other apps.
+     */
+    OAuthPathErrorType["unauthorized_client"] = "unauthorized_client";
+    /**
+     * If a grant type is requested that the authorization server doesn’t recognize, use this code.
+     * Note that unknown grant types also use this specific error code rather than using the `invalid_request` above.
+     */
+    OAuthPathErrorType["unsupported_grant_type"] = "unsupported_grant_type";
+})(OAuthPathErrorType || (OAuthPathErrorType = {}));

package/esm/client/createClient.js

@@ -0,0 +1,128 @@
+import { stringify as qsStringify } from 'qs';
+import { fetch } from '@whatwg-node/fetch';
+const qsOptions = {
+    indices: false,
+    arrayFormat: 'repeat',
+};
+export class ClientValidationError extends Error {
+    constructor(path, method, errors, response) {
+        super(`Validation failed for ${method} ${path}`);
+        this.path = path;
+        this.method = method;
+        this.errors = errors;
+        this.response = response;
+    }
+    [Symbol.iterator]() {
+        return this.errors[Symbol.iterator]();
+    }
+}
+function useValidationErrors() {
+    return {
+        async onResponse({ path, method, response }) {
+            if (response.status === 400 && response.headers.get('x-error-type') === 'validation') {
+                const resJson = await response.json();
+                if (resJson.errors) {
+                    throw new ClientValidationError(path, method, resJson.errors, response);
+                }
+            }
+        },
+    };
+}
+export function createClient({ endpoint, fetchFn = fetch, plugins = [] }) {
+    plugins.unshift(useValidationErrors());
+    const onRequestInitHooks = [];
+    const onFetchHooks = [];
+    const onResponseHooks = [];
+    for (const plugin of plugins) {
+        if (plugin.onRequestInit) {
+            onRequestInitHooks.push(plugin.onRequestInit);
+        }
+        if (plugin.onFetch) {
+            onFetchHooks.push(plugin.onFetch);
+        }
+        if (plugin.onResponse) {
+            onResponseHooks.push(plugin.onResponse);
+        }
+    }
+    return new Proxy({}, {
+        get(_target, path) {
+            return new Proxy({}, {
+                get(_target, method) {
+                    return async function (requestParams = {}) {
+                        for (const pathParamKey in requestParams?.params || {}) {
+                            const value = requestParams?.params?.[pathParamKey];
+                            if (value) {
+                                path = path.replace(`{${pathParamKey}}`, value).replace(`:${pathParamKey}`, value);
+                            }
+                        }
+                        if (!path.startsWith('/') && !path.startsWith('http')) {
+                            path = `/${path}`;
+                        }
+                        const requestInit = {
+                            method,
+                            headers: requestParams?.headers || {},
+                        };
+                        if (requestParams?.json) {
+                            requestInit.body = JSON.stringify(requestParams.json);
+                            requestInit.headers['Content-Type'] = 'application/json';
+                        }
+                        if (requestParams?.formData) {
+                            requestInit.body = requestParams.formData;
+                        }
+                        if (requestParams?.formUrlEncoded) {
+                            requestInit.body = qsStringify(requestParams.formUrlEncoded, qsOptions);
+                            requestInit.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                        }
+                        let response;
+                        for (const onRequestParamsHook of onRequestInitHooks) {
+                            await onRequestParamsHook({
+                                path,
+                                method,
+                                requestParams,
+                                requestInit,
+                                endResponse(res) {
+                                    response = res;
+                                },
+                            });
+                        }
+                        let finalUrl = path;
+                        if (endpoint && !path.startsWith('http')) {
+                            finalUrl = `${endpoint}${path}`;
+                        }
+                        if (requestParams?.query) {
+                            const searchParams = qsStringify(requestParams.query, qsOptions);
+                            if (finalUrl.includes('?')) {
+                                finalUrl += '&' + searchParams;
+                            }
+                            else {
+                                finalUrl += '?' + searchParams;
+                            }
+                        }
+                        let currentFetchFn = fetchFn;
+                        for (const onFetchHook of onFetchHooks) {
+                            await onFetchHook({
+                                url: finalUrl,
+                                init: requestInit,
+                                fetchFn: currentFetchFn,
+                                setFetchFn(newFetchFn) {
+                                    currentFetchFn = newFetchFn;
+                                },
+                            });
+                        }
+                        response ||= await currentFetchFn(finalUrl, requestInit);
+                        for (const onResponseHook of onResponseHooks) {
+                            await onResponseHook({
+                                path,
+                                method,
+                                requestParams,
+                                requestInit,
+                                response,
+                            });
+                        }
+                        return response;
+                    };
+                },
+            });
+        },
+    });
+}

package/esm/client/index.js

@@ -0,0 +1,3 @@
+export * from './createClient.js';
+export * from './types.js';
+export * from './plugins/useClientCookieStore.js';

package/esm/client/plugins/useClientCookieStore.js

@@ -0,0 +1,27 @@
+import { parse } from '@whatwg-node/cookie-store';
+import { Headers } from '@whatwg-node/fetch';
+export function useClientCookieStore(cookieStore) {
+    return {
+        async onRequestInit({ requestInit }) {
+            requestInit.headers = new Headers(requestInit.headers);
+            let cookieHeader = requestInit.headers.get('cookie') || '';
+            if (cookieHeader) {
+                cookieHeader += '; ';
+            }
+            const cookies = await cookieStore.getAll();
+            cookieHeader += cookies.map(cookie => `${cookie.name}=${cookie.value}`).join('; ');
+            requestInit.headers.set('cookie', cookieHeader);
+        },
+        onResponse({ response }) {
+            const setCookies = response.headers.getSetCookie?.();
+            if (setCookies) {
+                for (const setCookie of setCookies) {
+                    const cookieMap = parse(setCookie);
+                    for (const [, cookie] of cookieMap) {
+                        cookieStore.set(cookie);
+                    }
+                }
+            }
+        },
+    };
+}

package/esm/createRouter.js

@@ -0,0 +1,293 @@
+import * as DefaultFetchAPI from '@whatwg-node/fetch';
+import { createServerAdapter, isPromise } from '@whatwg-node/server';
+import { useOpenAPI } from './plugins/openapi.js';
+import { isLazySerializedResponse } from './Response.js';
+import { addHandlersToMethod } from './utils.js';
+import { useZod } from './zod/zod.js';
+const HTTP_METHODS = [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'CONNECT',
+    'OPTIONS',
+    'TRACE',
+    'PATCH',
+];
+const EMPTY_OBJECT = {};
+const EMPTY_MATCH = { pathname: { groups: {} } };
+export function createRouterBase({ fetchAPI: givenFetchAPI, base: basePath = '/', plugins = [], swaggerUI, } = {}, openAPIDocument) {
+    const fetchAPI = {
+        ...DefaultFetchAPI,
+        ...givenFetchAPI,
+    };
+    const __onRouterInitHooks = [];
+    const onRouteHooks = [];
+    const onSerializeResponseHooks = [];
+    for (const plugin of plugins) {
+        if (plugin.onRouterInit) {
+            __onRouterInitHooks.push(plugin.onRouterInit);
+        }
+        if (plugin.onRoute) {
+            onRouteHooks.push(plugin.onRoute);
+        }
+        if (plugin.onSerializeResponse) {
+            onSerializeResponseHooks.push(plugin.onSerializeResponse);
+        }
+    }
+    const handlersByPatternByMethod = new Map();
+    const internalPatternsByMethod = new Map();
+    // Use this in `handle` for iteration to get better performance
+    const patternHandlerObjByMethod = new Map();
+    function handleUnhandledRoute() {
+        if (swaggerUI?.endpoint) {
+            return new fetchAPI.Response(null, {
+                status: 302,
+                headers: {
+                    location: swaggerUI.endpoint,
+                },
+            });
+        }
+        return new fetchAPI.Response(null, { status: 404 });
+    }
+    function processHandlerResult(handlerResult, opts) {
+        if (handlerResult) {
+            if (isLazySerializedResponse(handlerResult)) {
+                const onSerializeResponseHookPayload = {
+                    request: opts.routerRequest,
+                    path: opts.pattern.pathname,
+                    lazyResponse: handlerResult,
+                    serverContext: opts.context,
+                };
+                for (const onSerializeResponseHook of onSerializeResponseHooks) {
+                    onSerializeResponseHook(onSerializeResponseHookPayload);
+                }
+                return (handlerResult.actualResponse ||
+                    fetchAPI.Response.json(handlerResult.jsonObj, handlerResult.init));
+            }
+            return handlerResult;
+        }
+    }
+    function asyncIterationUntilReturn(iterable, callback) {
+        const iterator = iterable[Symbol.iterator]();
+        function iterate() {
+            const { value, done } = iterator.next();
+            if (done) {
+                return;
+            }
+            if (value) {
+                const callbackResult$ = callback(value);
+                if (isPromise(callbackResult$)) {
+                    return callbackResult$.then(callbackResult => {
+                        if (callbackResult) {
+                            return callbackResult;
+                        }
+                        return iterate();
+                    });
+                }
+                if (callbackResult$) {
+                    return callbackResult$;
+                }
+                return iterate();
+            }
+        }
+        return iterate();
+    }
+    return {
+        openAPIDocument,
+        handle(request, context) {
+            let url = new Proxy(EMPTY_OBJECT, {
+                get(_target, prop, _receiver) {
+                    url = new fetchAPI.URL(request.url, 'http://localhost');
+                    return Reflect.get(url, prop, url);
+                },
+            });
+            const methodPatternMaps = patternHandlerObjByMethod.get(request.method);
+            if (methodPatternMaps) {
+                const queryProxy = new Proxy({}, {
+                    get(_, prop) {
+                        if (prop !== 'then' && !url.searchParams.has(prop)) {
+                            return undefined;
+                        }
+                        const allQueries = url.searchParams.getAll(prop.toString());
+                        if (allQueries.length === 0) {
+                            return '';
+                        }
+                        return allQueries.length === 1 ? allQueries[0] : allQueries;
+                    },
+                    has(_, prop) {
+                        return url.searchParams.has(prop.toString());
+                    },
+                });
+                const iterationResult$ = asyncIterationUntilReturn(methodPatternMaps, ({ pattern, handlers }) => {
+                    // Do not parse URL if not needed
+                    let match = null;
+                    if (pattern.isPattern) {
+                        match = pattern.exec(url);
+                    }
+                    else if (request.url.endsWith(pattern.pathname) ||
+                        url.pathname === pattern.pathname) {
+                        match = EMPTY_MATCH;
+                    }
+                    if (match != null) {
+                        const routerRequest = new Proxy(request, {
+                            get(target, prop) {
+                                if (prop === 'parsedUrl') {
+                                    return url;
+                                }
+                                if (prop === 'params') {
+                                    return new Proxy(match.pathname.groups, {
+                                        get(_, prop) {
+                                            const value = match.pathname.groups[prop.toString()];
+                                            if (value != null) {
+                                                return decodeURIComponent(value);
+                                            }
+                                            return value;
+                                        },
+                                    });
+                                }
+                                if (prop === 'query') {
+                                    return queryProxy;
+                                }
+                                const targetProp = target[prop];
+                                if (typeof targetProp === 'function') {
+                                    return targetProp.bind(target);
+                                }
+                                return targetProp;
+                            },
+                            has(target, prop) {
+                                return (prop in target || prop === 'parsedUrl' || prop === 'params' || prop === 'query');
+                            },
+                        });
+                        return asyncIterationUntilReturn(handlers, handler => {
+                            const handlerResult$ = handler(routerRequest, context);
+                            if (isPromise(handlerResult$)) {
+                                return handlerResult$.then(handlerResult => {
+                                    if (handlerResult) {
+                                        return processHandlerResult(handlerResult, {
+                                            routerRequest,
+                                            context,
+                                            pattern,
+                                        });
+                                    }
+                                });
+                            }
+                            if (handlerResult$) {
+                                return processHandlerResult(handlerResult$, {
+                                    routerRequest,
+                                    context,
+                                    pattern,
+                                });
+                            }
+                        });
+                    }
+                });
+                if (isPromise(iterationResult$)) {
+                    return iterationResult$.then(iterationResult => {
+                        if (iterationResult) {
+                            return iterationResult;
+                        }
+                        return handleUnhandledRoute();
+                    });
+                }
+                if (iterationResult$) {
+                    return iterationResult$;
+                }
+            }
+            return handleUnhandledRoute();
+        },
+        route(opts) {
+            const { operationId, description, method, path, schemas, tags, internal, handler } = opts;
+            const handlers = Array.isArray(handler) ? handler : [handler];
+            if (!method) {
+                for (const method of HTTP_METHODS) {
+                    addHandlersToMethod({
+                        operationId,
+                        description,
+                        method,
+                        path,
+                        schemas,
+                        handlers,
+                        tags,
+                        internal,
+                        // Router specific
+                        onRouteHooks,
+                        openAPIDocument,
+                        basePath,
+                        fetchAPI,
+                        handlersByPatternByMethod,
+                        internalPatternsByMethod,
+                        patternHandlerObjByMethod,
+                    });
+                }
+            }
+            else {
+                addHandlersToMethod({
+                    operationId,
+                    description,
+                    method,
+                    path,
+                    schemas,
+                    handlers,
+                    tags,
+                    internal,
+                    // Router specific
+                    onRouteHooks,
+                    openAPIDocument,
+                    basePath,
+                    fetchAPI,
+                    handlersByPatternByMethod,
+                    internalPatternsByMethod,
+                    patternHandlerObjByMethod,
+                });
+            }
+            return this;
+        },
+        __client: {},
+        __onRouterInitHooks,
+    };
+}
+export function createRouter(options = {}) {
+    const { openAPI: { endpoint: oasEndpoint = '/openapi.json', ...openAPIDocument } = {}, swaggerUI: { endpoint: swaggerUIEndpoint = '/docs', ...swaggerUIOpts } = {}, plugins: userPlugins = [], base = '/', } = options;
+    openAPIDocument.openapi = openAPIDocument.openapi || '3.0.1';
+    const oasInfo = (openAPIDocument.info ||= {});
+    oasInfo.title ||= 'feTS API';
+    oasInfo.description ||= 'An API written with feTS';
+    oasInfo.version ||= '1.0.0';
+    if (base !== '/') {
+        openAPIDocument.servers = openAPIDocument.servers || [
+            {
+                url: base,
+            },
+        ];
+    }
+    const plugins = [
+        ...(oasEndpoint || swaggerUIEndpoint
+            ? [
+                useOpenAPI({
+                    oasEndpoint,
+                    swaggerUIEndpoint,
+                    swaggerUIOpts,
+                }),
+            ]
+            : []),
+        useZod(),
+        ...userPlugins,
+    ];
+    const finalOpts = {
+        ...options,
+        swaggerUI: {
+            endpoint: swaggerUIEndpoint,
+            ...swaggerUIOpts,
+        },
+        base,
+        plugins,
+    };
+    const routerBaseObject = createRouterBase(finalOpts, openAPIDocument);
+    const router = createServerAdapter(routerBaseObject, finalOpts);
+    for (const onRouterInitHook of routerBaseObject.__onRouterInitHooks) {
+        onRouterInitHook(router);
+    }
+    return router;
+}

package/esm/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './createRouter.js';
+export { URLPattern } from '@whatwg-node/fetch';
+export { useCORS, useErrorHandling, HTTPError } from '@whatwg-node/server';
+export * from './client/index.js';
+export * from './Response.js';
+export { useAjv } from './plugins/ajv.js';