fets 0.4.14 → 0.4.15

package/cjs/Response.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = exports.createLazySerializedResponse = exports.isLazySerializedResponse = exports.defaultSerializer = exports.LAZY_SERIALIZED_RESPONSE = void 0;
+const fetch_1 = require("@whatwg-node/fetch");
+exports.LAZY_SERIALIZED_RESPONSE = Symbol('LAZY_SERIALIZED_RESPONSE');
+const defaultSerializer = obj => JSON.stringify(obj);
+exports.defaultSerializer = defaultSerializer;
+function isLazySerializedResponse(response) {
+    return response[exports.LAZY_SERIALIZED_RESPONSE];
+}
+exports.isLazySerializedResponse = isLazySerializedResponse;
+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 fetch_1.Headers(init);
+    }
+    if (!headers.has('content-type')) {
+        headers.set('content-type', JSON_CONTENT_TYPE);
+    }
+    return headers;
+}
+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;
+        },
+        [exports.LAZY_SERIALIZED_RESPONSE]: true,
+        init,
+        resolveWithSerializer(serializer) {
+            const serialized = serializer(jsonObj);
+            init.headers = getHeaders();
+            actualResponse = new fetch_1.Response(serialized, init);
+        },
+        json() {
+            return Promise.resolve(jsonObj);
+        },
+        get status() {
+            return (init?.status || 200);
+        },
+        get headers() {
+            return getHeaders();
+        },
+    };
+}
+exports.createLazySerializedResponse = createLazySerializedResponse;
+// 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
+ */
+exports.Response = new Proxy(fetch_1.Response, {
+    get(OriginalResponse, prop, receiver) {
+        if (prop === 'json') {
+            return createLazySerializedResponse;
+        }
+        return Reflect.get(OriginalResponse, prop, receiver);
+    },
+});

package/cjs/client/auth/oauth.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuthPathErrorType = void 0;
+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 || (exports.OAuthPathErrorType = OAuthPathErrorType = {}));

package/cjs/client/createClient.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = exports.ClientValidationError = void 0;
+const qs_1 = require("qs");
+const fetch_1 = require("@whatwg-node/fetch");
+const qsOptions = {
+    indices: false,
+    arrayFormat: 'repeat',
+};
+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]();
+    }
+}
+exports.ClientValidationError = ClientValidationError;
+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);
+                }
+            }
+        },
+    };
+}
+function createClient({ endpoint, fetchFn = fetch_1.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 = (0, qs_1.stringify)(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 = (0, qs_1.stringify)(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;
+                    };
+                },
+            });
+        },
+    });
+}
+exports.createClient = createClient;

package/cjs/client/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./createClient.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./plugins/useClientCookieStore.js"), exports);

package/cjs/client/plugins/useClientCookieStore.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useClientCookieStore = void 0;
+const cookie_store_1 = require("@whatwg-node/cookie-store");
+const fetch_1 = require("@whatwg-node/fetch");
+function useClientCookieStore(cookieStore) {
+    return {
+        async onRequestInit({ requestInit }) {
+            requestInit.headers = new fetch_1.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 = (0, cookie_store_1.parse)(setCookie);
+                    for (const [, cookie] of cookieMap) {
+                        cookieStore.set(cookie);
+                    }
+                }
+            }
+        },
+    };
+}
+exports.useClientCookieStore = useClientCookieStore;

package/cjs/createRouter.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = exports.createRouterBase = void 0;
+const tslib_1 = require("tslib");
+const DefaultFetchAPI = tslib_1.__importStar(require("@whatwg-node/fetch"));
+const server_1 = require("@whatwg-node/server");
+const openapi_js_1 = require("./plugins/openapi.js");
+const Response_js_1 = require("./Response.js");
+const utils_js_1 = require("./utils.js");
+const zod_js_1 = require("./zod/zod.js");
+const HTTP_METHODS = [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'CONNECT',
+    'OPTIONS',
+    'TRACE',
+    'PATCH',
+];
+const EMPTY_OBJECT = {};
+const EMPTY_MATCH = { pathname: { groups: {} } };
+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 ((0, Response_js_1.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 ((0, server_1.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 ((0, server_1.isPromise)(handlerResult$)) {
+                                return handlerResult$.then(handlerResult => {
+                                    if (handlerResult) {
+                                        return processHandlerResult(handlerResult, {
+                                            routerRequest,
+                                            context,
+                                            pattern,
+                                        });
+                                    }
+                                });
+                            }
+                            if (handlerResult$) {
+                                return processHandlerResult(handlerResult$, {
+                                    routerRequest,
+                                    context,
+                                    pattern,
+                                });
+                            }
+                        });
+                    }
+                });
+                if ((0, server_1.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) {
+                    (0, utils_js_1.addHandlersToMethod)({
+                        operationId,
+                        description,
+                        method,
+                        path,
+                        schemas,
+                        handlers,
+                        tags,
+                        internal,
+                        // Router specific
+                        onRouteHooks,
+                        openAPIDocument,
+                        basePath,
+                        fetchAPI,
+                        handlersByPatternByMethod,
+                        internalPatternsByMethod,
+                        patternHandlerObjByMethod,
+                    });
+                }
+            }
+            else {
+                (0, utils_js_1.addHandlersToMethod)({
+                    operationId,
+                    description,
+                    method,
+                    path,
+                    schemas,
+                    handlers,
+                    tags,
+                    internal,
+                    // Router specific
+                    onRouteHooks,
+                    openAPIDocument,
+                    basePath,
+                    fetchAPI,
+                    handlersByPatternByMethod,
+                    internalPatternsByMethod,
+                    patternHandlerObjByMethod,
+                });
+            }
+            return this;
+        },
+        __client: {},
+        __onRouterInitHooks,
+    };
+}
+exports.createRouterBase = createRouterBase;
+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
+            ? [
+                (0, openapi_js_1.useOpenAPI)({
+                    oasEndpoint,
+                    swaggerUIEndpoint,
+                    swaggerUIOpts,
+                }),
+            ]
+            : []),
+        (0, zod_js_1.useZod)(),
+        ...userPlugins,
+    ];
+    const finalOpts = {
+        ...options,
+        swaggerUI: {
+            endpoint: swaggerUIEndpoint,
+            ...swaggerUIOpts,
+        },
+        base,
+        plugins,
+    };
+    const routerBaseObject = createRouterBase(finalOpts, openAPIDocument);
+    const router = (0, server_1.createServerAdapter)(routerBaseObject, finalOpts);
+    for (const onRouterInitHook of routerBaseObject.__onRouterInitHooks) {
+        onRouterInitHook(router);
+    }
+    return router;
+}
+exports.createRouter = createRouter;

package/cjs/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAjv = exports.HTTPError = exports.useErrorHandling = exports.useCORS = exports.URLPattern = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./createRouter.js"), exports);
+var fetch_1 = require("@whatwg-node/fetch");
+Object.defineProperty(exports, "URLPattern", { enumerable: true, get: function () { return fetch_1.URLPattern; } });
+var server_1 = require("@whatwg-node/server");
+Object.defineProperty(exports, "useCORS", { enumerable: true, get: function () { return server_1.useCORS; } });
+Object.defineProperty(exports, "useErrorHandling", { enumerable: true, get: function () { return server_1.useErrorHandling; } });
+Object.defineProperty(exports, "HTTPError", { enumerable: true, get: function () { return server_1.HTTPError; } });
+tslib_1.__exportStar(require("./client/index.js"), exports);
+tslib_1.__exportStar(require("./Response.js"), exports);
+var ajv_js_1 = require("./plugins/ajv.js");
+Object.defineProperty(exports, "useAjv", { enumerable: true, get: function () { return ajv_js_1.useAjv; } });