@toapi/server 0.12.1

package/dist/cache.d.ts

@@ -0,0 +1,32 @@
+export type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+export interface CacheEntry {
+    data?: Json | null;
+    attachment?: Uint8Array | null;
+}
+export type Subscription = (tags: string[], meta?: Json) => void;
+export interface Cache {
+    get(key: string): Promise<CacheEntry | null>;
+    set(input: CacheEntry & {
+        key: string;
+        ttl: number;
+        tags: string[];
+    }): Promise<void>;
+    delete(tags: string[], meta?: Json): Promise<void>;
+    subscribe(callback: Subscription): () => void;
+}
+export declare class PubSub implements Cache {
+    subscribers: Set<Subscription>;
+    get(_key: string): Promise<CacheEntry | null>;
+    set(_: CacheEntry & {
+        key: string;
+        ttl: number;
+        tags: string[];
+    }): Promise<void>;
+    delete(tags: string[], meta?: {
+        clientId?: string;
+    }): Promise<void>;
+    subscribe(callback: Subscription): () => void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GACZ,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,IAAI,EAAE,GACN;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE5B,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACnB,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;AAEjE,MAAM,WAAW,KAAK;IACpB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAC7C,GAAG,CACD,KAAK,EAAE,UAAU,GAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,GAC/D,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,SAAS,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,IAAI,CAAC;CAC/C;AAED,qBAAa,MAAO,YAAW,KAAK;IAClC,WAAW,oBAA2B;IAEhC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAInD,GAAG,CACD,CAAC,EAAE,UAAU,GAAG;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,GACA,OAAO,CAAC,IAAI,CAAC;IAIhB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQnE,SAAS,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,IAAI;CAO9C"}

package/dist/cache.js

@@ -0,0 +1,21 @@
+export class PubSub {
+    subscribers = new Set();
+    async get(_key) {
+        return null;
+    }
+    set(_) {
+        return Promise.resolve();
+    }
+    delete(tags, meta) {
+        for (const callback of this.subscribers) {
+            callback(tags, meta ?? {});
+        }
+        return Promise.resolve();
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+}

package/dist/create-local-client.d.ts

@@ -0,0 +1,6 @@
+import type { ApiDefinition } from "./define-api.js";
+import type { Path } from "@toapi/common";
+import type { BaseRoute } from "@toapi/common";
+import type { MaybePromise } from "@toapi/common";
+export declare function createLocalClient<Routes extends Record<Path, MaybePromise<BaseRoute>>>(api: ApiDefinition<Routes>, init?: RequestInit): import("../../2-toapi-client/dist/index.js").Client<Routes>;
+//# sourceMappingURL=create-local-client.d.ts.map

package/dist/create-local-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-local-client.d.ts","sourceRoot":"","sources":["../src/create-local-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,wBAAgB,iBAAiB,CAC/B,MAAM,SAAS,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,EACpD,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,IAAI,GAAE,WAAgB,+DAgBnD"}

package/dist/create-local-client.js

@@ -0,0 +1,19 @@
+import { createFetchClient } from "../../2-toapi-client/dist/index.js";
+import { createRequestHandler } from "./create-request-handler.js";
+export function createLocalClient(api, init = {}) {
+    const handler = createRequestHandler(api);
+    return createFetchClient("http://localhost", {
+        fetch(url, localInit) {
+            const headers = new Headers(init.headers);
+            new Headers(localInit.headers).forEach((value, key) => {
+                headers.set(key, value);
+            });
+            const req = new Request(url, {
+                ...init,
+                ...localInit,
+                headers,
+            });
+            return handler(req);
+        },
+    });
+}

package/dist/create-request-handler.d.ts

@@ -0,0 +1,17 @@
+import type { MaybePromise } from "@toapi/common";
+import type { Path as BasePath } from "@toapi/common";
+import type { BaseRoute } from "@toapi/common";
+import type { ApiDefinition } from "./define-api.js";
+import type { Handler } from "@toapi/common";
+import type { TRequest } from "@toapi/common";
+interface Options {
+    /** the root path for all API routes */
+    basePath?: string;
+    /** the default maximum time-to-live (TTL) for cached responses */
+    defaultTTL?: number;
+}
+export declare function createRequestHandler(api: ApiDefinition<Record<BasePath, MaybePromise<BaseRoute>>>, options?: Options): (req: Request) => Promise<Response>;
+export declare function compilePathRegex(path: string): RegExp;
+export declare function executeHandler<Body>(handler: Handler<any, any, any, Body>, req: TRequest<any, any, any, Body>): Promise<import("@toapi/common").TResponse<any>>;
+export {};
+//# sourceMappingURL=create-request-handler.d.ts.map

package/dist/create-request-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-request-handler.d.ts","sourceRoot":"","sources":["../src/create-request-handler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAK9C,UAAU,OAAO;IACf,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAWD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,EAC7D,OAAO,GAAE,OAAY,IAmBP,KAAK,OAAO,uBAqL3B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD;AAuGD,wBAAsB,cAAc,CAAC,IAAI,EACvC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EACrC,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,mDAOnC"}

package/dist/create-request-handler.js

@@ -0,0 +1,289 @@
+import { ZodError, z } from "zod/v4";
+import { INVALIDATIONS_ROUTE, OPENAPI_ROUTE, SESSION_COOKIE_NAME, } from "@toapi/common";
+import { HttpError } from "@toapi/common";
+import { CookieStore } from "@toapi/common";
+import { generateOpenAPISchema } from "./openapi.js";
+import { streamRevalidatedTags } from "./revalidation-stream.js";
+const DEFAULT_TTL = 60 * 60 * 24 * 14;
+const authUsed = Symbol("TApi.authUsed");
+const headersSchema = z
+    .tuple([z.string(), z.string()])
+    .array()
+    .optional()
+    .nullable();
+export function createRequestHandler(api, options = {}) {
+    const errorLog = api.logger?.error ??
+        ((error) => {
+            console.error(error);
+        });
+    const basePath = options.basePath ?? "";
+    const routes = [];
+    for (const [path, route] of Object.entries(api.routes)) {
+        const pattern = compilePathRegex(basePath + path);
+        routes.push({ pattern, route });
+    }
+    let openapiJson;
+    return async (req) => {
+        const url = new URL(req.url);
+        if (url.pathname === `${basePath}${INVALIDATIONS_ROUTE}`) {
+            return streamRevalidatedTags({
+                cache: api.cache,
+            });
+        }
+        if (api.oas && url.pathname === `${basePath}${OPENAPI_ROUTE}`) {
+            if (!openapiJson) {
+                const spec = await generateOpenAPISchema(api, { info: api.oas });
+                openapiJson = JSON.stringify(spec);
+            }
+            return new Response(openapiJson, {
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        for (const { pattern, route: routePromise } of routes) {
+            const match = url.pathname.match(pattern);
+            const route = await routePromise;
+            if (match) {
+                const params = match.groups || {};
+                switch (req.method) {
+                    case "HEAD":
+                    case "GET": {
+                        try {
+                            const handler = route[req.method];
+                            if (!handler)
+                                return new Response("Not Found", { status: 404 });
+                            // calls the authorizer, throws if unauthorized
+                            const treq = await prepareRequestWithoutBody(handler, url, params, req, api.cache);
+                            try {
+                                // get matching cache entry
+                                const cached = await api.cache?.get(req.url);
+                                if (cached) {
+                                    // serve from cache
+                                    const body = req.method === "HEAD"
+                                        ? null
+                                        : new ReadableStream({
+                                            start(controller) {
+                                                controller.enqueue(cached.attachment);
+                                                controller.close();
+                                            },
+                                        });
+                                    const headers = await headersSchema.parseAsync(cached.data);
+                                    return new Response(body, {
+                                        headers: headers ?? undefined,
+                                    });
+                                }
+                            }
+                            catch (error) {
+                                // catches errors while retrieving from cache
+                                // errors are logged but response is still served
+                                errorLog(error);
+                            }
+                            const res = await executeHandler(handler, treq);
+                            if (res.cache) {
+                                if (treq[authUsed] !== true) {
+                                    // cache fresh response according to cache options
+                                    try {
+                                        const cloned = res.clone();
+                                        api.cache
+                                            ?.set({
+                                            key: req.url,
+                                            data: Array.from(res.headers.entries()),
+                                            attachment: new Uint8Array(await cloned.arrayBuffer()),
+                                            ttl: res.cache.ttl ?? options.defaultTTL ?? DEFAULT_TTL,
+                                            tags: res.cache.tags ?? [],
+                                        })
+                                            // catches errors while caching if cache.set is async (redis cache)
+                                            .catch(errorLog);
+                                    }
+                                    catch (error) {
+                                        // catches errors while caching if cache.set is sync (in-memory cache)
+                                        errorLog(error);
+                                    }
+                                }
+                            }
+                            return res;
+                        }
+                        catch (error) {
+                            // catches errors while actually handling the request
+                            await errorLog(error);
+                            return handleError(error);
+                        }
+                    }
+                    case "DELETE": {
+                        const handler = route[req.method];
+                        if (!handler)
+                            return new Response("Not Found", { status: 404 });
+                        try {
+                            const treq = await prepareRequestWithoutBody(handler, url, params, req, api.cache);
+                            const res = await executeHandler(handler, treq);
+                            if (res.cache?.tags) {
+                                try {
+                                    const clientId = await treq
+                                        .cookies()
+                                        .get(SESSION_COOKIE_NAME);
+                                    api.cache
+                                        ?.delete(res.cache.tags, clientId ? { clientId: clientId.value } : undefined)
+                                        .catch(errorLog);
+                                }
+                                catch (error) {
+                                    errorLog(error);
+                                }
+                            }
+                            return res;
+                        }
+                        catch (error) {
+                            await errorLog(error);
+                            return handleError(error);
+                        }
+                    }
+                    case "POST":
+                    case "PUT":
+                    case "PATCH": {
+                        const handler = route[req.method];
+                        if (!handler)
+                            return new Response("Not Found", {
+                                status: 404,
+                                statusText: "Not Found",
+                            });
+                        try {
+                            const treq = await prepareRequestWithBody(handler, url, params, req, api.cache);
+                            const res = await executeHandler(handler, treq);
+                            if (res.cache?.tags) {
+                                try {
+                                    const clientId = await treq
+                                        .cookies()
+                                        .get(SESSION_COOKIE_NAME);
+                                    api.cache
+                                        ?.delete(res.cache.tags, clientId ? { clientId: clientId.value } : undefined)
+                                        .catch(errorLog);
+                                }
+                                catch (error) {
+                                    errorLog(error);
+                                }
+                            }
+                            return res;
+                        }
+                        catch (error) {
+                            await errorLog(error);
+                            return handleError(error);
+                        }
+                    }
+                    default:
+                        return new Response("Not Found", {
+                            status: 404,
+                            statusText: "Not Found",
+                        });
+                }
+            }
+        }
+        return new Response("Not Found", { status: 404, statusText: "Not Found" });
+    };
+}
+export function compilePathRegex(path) {
+    // Handle wildcards: *name captures as named group, * catches all without capturing
+    const pattern = path
+        .replaceAll(/\*(\w+)/g, "(?<$1>.+)") // *name -> named capture group
+        .replaceAll(/\*/g, ".+") // * -> match everything including /
+        .replaceAll(/:(\w+)/g, "(?<$1>[^\\/]+)"); // :param -> named capture group
+    return new RegExp(`^${pattern}$`);
+}
+async function prepareRequestWithoutBody(handler, url, params, req, cache) {
+    const treq = req;
+    treq.params = () => {
+        const decodedParams = Object.fromEntries(Object.entries(params).map(([key, value]) => [
+            key,
+            decodeURIComponent(value),
+        ]));
+        if (handler.schema.params) {
+            const schema = z.object(handler.schema.params);
+            return schema.parse(decodedParams);
+        }
+        treq.params = () => decodedParams;
+        return decodedParams;
+    };
+    treq.query = () => {
+        const params = collectData(url.searchParams.entries());
+        if (handler.schema.query) {
+            const schema = z.object(handler.schema.query);
+            return schema.parse(params);
+        }
+        treq.query = () => params;
+        return params;
+    };
+    treq.cookies = () => {
+        const cookieStore = new CookieStore(req);
+        treq.cookies = () => cookieStore;
+        return cookieStore;
+    };
+    treq.invalidate = async (tags) => {
+        const clientId = await treq.cookies().get(SESSION_COOKIE_NAME);
+        cache.delete(tags, clientId ? { clientId: clientId.value } : undefined);
+    };
+    const auth = await handler.schema.authorize(treq);
+    if (!auth) {
+        throw new HttpError(401, "Unauthorized");
+    }
+    treq.auth = () => {
+        treq[authUsed] = true;
+        return auth;
+    };
+    return treq;
+}
+async function prepareRequestWithBody(handler, url, params, req, cache) {
+    const treq = await prepareRequestWithoutBody(handler, url, params, req, cache);
+    if (handler.schema.body) {
+        treq.data = async () => handler.schema.body?.parseAsync(await req.json());
+    }
+    else {
+        treq.data = () => {
+            console.error("Unexpected call to TRequest.data() method: no body parser specified");
+            throw new HttpError(500, "Internal Server Error");
+        };
+    }
+    return treq;
+}
+function collectData(input) {
+    const params = {};
+    for (const [key, value] of input) {
+        if (params[key]) {
+            if (Array.isArray(params[key])) {
+                params[key].push(value);
+            }
+            else {
+                params[key] = [params[key], value];
+            }
+        }
+        else {
+            params[key] = value;
+        }
+    }
+    return params;
+}
+export async function executeHandler(handler, req) {
+    const res = await handler.handler(req);
+    if (handler.schema.response) {
+        await handler.schema.response.parseAsync(res.data);
+    }
+    return res;
+}
+function handleError(error) {
+    if (error instanceof ZodError) {
+        return Response.json(error.issues, {
+            status: 400,
+            headers: {
+                "Content-Type": "application/json+zodissues",
+            },
+        });
+    }
+    if (error instanceof HttpError) {
+        return Response.json({
+            message: error.message,
+            data: error.data,
+        }, {
+            status: error.status,
+            headers: {
+                "Content-Type": "application/json+httperror",
+            },
+        });
+    }
+    return new Response("Internal Server Error", { status: 500 });
+}

package/dist/define-api.d.ts

@@ -0,0 +1,26 @@
+import type { MaybePromise } from "@toapi/common";
+import type { Logger } from "@toapi/common";
+import type { Path as BasePath, StrictParams } from "@toapi/common";
+import type { Route } from "@toapi/common";
+import { type Cache } from "./cache.js";
+export interface OasInfo {
+    title: string;
+    version: string;
+}
+interface Options {
+    cache?: Cache;
+    oas?: OasInfo;
+    logger?: Logger;
+}
+export declare function defineApi(options?: Options): ApiDefinition<{}>;
+export declare class ApiDefinition<Routes extends Record<BasePath, unknown>> {
+    routes: Routes;
+    cache: Cache;
+    oas?: OasInfo | undefined;
+    logger?: Logger | undefined;
+    constructor(routes: Routes, cache: Cache, oas?: OasInfo | undefined, logger?: Logger | undefined);
+    invalidate(tags: string[]): Promise<void>;
+    route<Path extends BasePath, GetResponse = never, GetQuery extends Record<string, unknown> = never, PostResponse = never, PostQuery extends Record<string, unknown> = never, PostBody = never, DeleteResponse = never, DeleteQuery extends Record<string, unknown> = never, PutResponse = never, PutQuery extends Record<string, unknown> = never, PutBody = never, PatchResponse = never, PatchQuery extends Record<string, unknown> = never, PatchBody = never>(path: Path, route: MaybePromise<Route<StrictParams<Path>, GetResponse, GetQuery, PostResponse, PostQuery, PostBody, DeleteResponse, DeleteQuery, PutResponse, PutQuery, PutBody, PatchResponse, PatchQuery, PatchBody>>): ApiDefinition<Routes & { [path in Path]: MaybePromise<Route<StrictParams<Path>, GetResponse, GetQuery, PostResponse, PostQuery, PostBody, DeleteResponse, DeleteQuery, PutResponse, PutQuery, PutBody, PatchResponse, PatchQuery, PatchBody>>; }>;
+}
+export {};
+//# sourceMappingURL=define-api.d.ts.map

package/dist/define-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-api.d.ts","sourceRoot":"","sources":["../src/define-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,KAAK,KAAK,EAAU,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,OAAO;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,SAAS,CAAC,OAAO,GAAE,OAAY,qBAE9C;AAED,qBAAa,aAAa,CAAC,MAAM,SAAS,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC;IAExD,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,KAAK;IACZ,GAAG,CAAC,EAAE,OAAO;IACb,MAAM,CAAC,EAAE,MAAM;gBAHf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,GAAG,CAAC,EAAE,OAAO,YAAA,EACb,MAAM,CAAC,EAAE,MAAM,YAAA;IAGlB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE;IAI/B,KAAK,CACH,IAAI,SAAS,QAAQ,EACrB,WAAW,GAAG,KAAK,EACnB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EAChD,YAAY,GAAG,KAAK,EACpB,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EACjD,QAAQ,GAAG,KAAK,EAChB,cAAc,GAAG,KAAK,EACtB,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EACnD,WAAW,GAAG,KAAK,EACnB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EAChD,OAAO,GAAG,KAAK,EACf,aAAa,GAAG,KAAK,EACrB,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EAClD,SAAS,GAAG,KAAK,EAEjB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,YAAY,CACjB,KAAK,CACH,YAAY,CAAC,IAAI,CAAC,EAClB,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,cAAc,EACd,WAAW,EACX,WAAW,EACX,QAAQ,EACR,OAAO,EACP,aAAa,EACb,UAAU,EACV,SAAS,CACV,CACF,GAGyB,aAAa,CACrC,MAAM,GAAG,GACN,IAAI,IAAI,IAAI,GAAG,YAAY,CAC1B,KAAK,CACH,YAAY,CAAC,IAAI,CAAC,EAClB,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,cAAc,EACd,WAAW,EACX,WAAW,EACX,QAAQ,EACR,OAAO,EACP,aAAa,EACb,UAAU,EACV,SAAS,CACV,CACF,GACF,CACF;CAEJ"}

package/dist/define-api.js

@@ -0,0 +1,23 @@
+import { PubSub } from "./cache.js";
+export function defineApi(options = {}) {
+    return new ApiDefinition({}, options?.cache ?? new PubSub(), options?.oas, options?.logger);
+}
+export class ApiDefinition {
+    routes;
+    cache;
+    oas;
+    logger;
+    constructor(routes, cache, oas, logger) {
+        this.routes = routes;
+        this.cache = cache;
+        this.oas = oas;
+        this.logger = logger;
+    }
+    async invalidate(tags) {
+        await this.cache.delete(tags);
+    }
+    route(path, route) {
+        this.routes[path] = route;
+        return this;
+    }
+}

package/dist/define-api.mock.d.ts

@@ -0,0 +1,86 @@
+export declare const api: import("./define-api.js").ApiDefinition<{
+    "/books": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, {
+        id: string;
+        title: string;
+    }[], {}, {
+        id: string;
+        title: string;
+    }, {}, {
+        id: string;
+        title: string;
+    }, never, never, never, never, never, never, never, never>>;
+} & {
+    "/books/:id": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{
+        id: string;
+    }, {
+        id: string;
+        title: string;
+    }, {
+        test: string;
+    }, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/movies/:id": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{
+        id: string;
+    }, {
+        id: string;
+        title: string;
+    }, {
+        test: string;
+    }, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/movies": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, never, never, {
+        id: string;
+        title: string;
+    }, {}, {
+        id: string;
+        title: string;
+    }, never, never, never, never, never, never, never, never>>;
+} & {
+    "/formData": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, never, never, {
+        [k: string]: FormDataEntryValue;
+    }, {}, undefined, never, never, never, never, never, never, never, never>>;
+} & {
+    "/authorized": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, {
+        authorized: boolean;
+    }, {}, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/files/*path": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{
+        path: string;
+    }, {
+        path: string;
+        message: string;
+    }, {}, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/wildcard/*": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, {
+        pathname: string;
+    }, {}, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/method": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, {
+        method: string;
+    }, {}, {
+        method: string;
+    }, {}, undefined, {
+        method: string;
+    }, {}, {
+        method: string;
+    }, {}, undefined, {
+        method: string;
+    }, {}, undefined>>;
+} & {
+    "/error/not-found": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, unknown, {}, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/cached": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, {
+        data: string;
+    }, {}, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/stream": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, AsyncGenerator<{
+        value: number;
+    }, void, unknown>, {}, never, never, never, never, never, never, never, never, never, never, never>>;
+} & {
+    "/optionalQuery": import("@toapi/common").MaybePromise<import("@toapi/common").Route<{}, {
+        optional: string | undefined;
+    }, {
+        optional: string | undefined;
+    }, never, never, never, never, never, never, never, never, never, never, never>>;
+}>;
+//# sourceMappingURL=define-api.mock.d.ts.map

package/dist/define-api.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-api.mock.d.ts","sourceRoot":"","sources":["../src/define-api.mock.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwLZ,CAAC"}

package/dist/define-api.mock.js

@@ -0,0 +1,127 @@
+import { z } from "zod/v4";
+import { defineApi } from "./define-api.js";
+import { defineHandler } from "./define-handler.js";
+import { TResponse } from "@toapi/common";
+import { HttpError } from "@toapi/common";
+export const api = defineApi()
+    .route("/books", {
+    GET: defineHandler({ authorize: () => true }, async () => TResponse.json([
+        { id: "1", title: "Book 1" },
+        { id: "2", title: "Book 2" },
+    ])),
+    POST: defineHandler({
+        authorize: () => true,
+        body: z.object({
+            id: z.string(),
+            title: z.string(),
+        }),
+    }, async (req) => TResponse.json(await req.data())),
+})
+    .route("/books/:id", {
+    GET: defineHandler({
+        params: { id: z.string() },
+        query: { test: z.string() },
+        authorize: () => true,
+    }, async (req) => TResponse.json({
+        id: req.params().id,
+        title: `Book ${req.params().id}`,
+    })),
+})
+    .route("/movies/:id", {
+    GET: defineHandler({
+        params: { id: z.string() },
+        query: { test: z.string() },
+        authorize: () => true,
+    }, async (req) => TResponse.json({
+        id: req.params().id,
+        title: `Movie ${req.params().id}`,
+    }, {
+        cache: {
+            tags: ["movies"],
+        },
+    })),
+})
+    .route("/movies", {
+    POST: defineHandler({
+        body: z.object({ id: z.string(), title: z.string() }),
+        authorize: () => true,
+    }, async (req) => TResponse.json(await req.data(), { cache: { tags: ["movies"] } })),
+})
+    .route("/formData", {
+    POST: defineHandler({
+        authorize: () => true,
+    }, async (req) => TResponse.json(Object.fromEntries(await req.formData()), {
+        cache: { tags: ["movies"] },
+    })),
+})
+    .route("/authorized", {
+    GET: defineHandler({
+        authorize: (req) => {
+            const header = req.headers.get("Authorization");
+            return header === "Bearer token";
+        },
+    }, async () => TResponse.json({ authorized: true })),
+})
+    .route("/files/*path", {
+    GET: defineHandler({
+        params: { path: z.string() },
+        authorize: () => true,
+    }, async (req) => TResponse.json({
+        path: req.params().path,
+        message: `Accessing file: ${req.params().path}`,
+    })),
+})
+    .route("/wildcard/*", {
+    GET: defineHandler({
+        authorize: () => true,
+    }, async (req) => TResponse.json({ pathname: req.url })),
+})
+    .route("/method", {
+    GET: defineHandler({
+        authorize: () => true,
+    }, async () => TResponse.json({ method: "GET" })),
+    POST: defineHandler({
+        authorize: () => true,
+    }, async () => TResponse.json({ method: "POST" })),
+    PUT: defineHandler({
+        authorize: () => true,
+    }, async () => TResponse.json({ method: "PUT" })),
+    PATCH: defineHandler({
+        authorize: () => true,
+    }, async () => TResponse.json({ method: "PATCH" })),
+    DELETE: defineHandler({
+        authorize: () => true,
+    }, async () => TResponse.json({ method: "DELETE" })),
+})
+    .route("/error/not-found", {
+    GET: defineHandler({
+        authorize: () => true,
+    }, async () => {
+        throw new HttpError(404, "Not Found");
+    }),
+})
+    .route("/cached", {
+    GET: defineHandler({ authorize: () => true }, async () => TResponse.json({ data: "cached" }, { cache: { tags: ["cached"], ttl: 60 } })),
+})
+    .route("/stream", {
+    GET: defineHandler({
+        authorize: () => true,
+    }, async () => {
+        async function* stream() {
+            for (let i = 0; i < 5; i++) {
+                yield { value: i };
+            }
+        }
+        return TResponse.ndjson(stream());
+    }),
+})
+    .route("/optionalQuery", {
+    GET: defineHandler({
+        query: {
+            optional: z.string().optional(),
+        },
+        authorize: () => true,
+    }, async (req) => {
+        return TResponse.json(req.query());
+    }),
+});

package/dist/define-handler.d.ts

@@ -0,0 +1,4 @@
+import type { Handler, HandlerFn } from "@toapi/common";
+import type { Schema } from "@toapi/common";
+export declare function defineHandler<Response, AuthData, Params extends Record<string, string> = {}, Query extends Record<string, unknown> = {}, Body = undefined>(schema: Schema<Response, AuthData, Params, Query, Body>, handler: HandlerFn<Response, AuthData, Params, Query, Body>): Handler<Response, Params, Query, Body>;
+//# sourceMappingURL=define-handler.d.ts.map

package/dist/define-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-handler.d.ts","sourceRoot":"","sources":["../src/define-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,wBAAgB,aAAa,CAC3B,QAAQ,EACR,QAAQ,EACR,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,EAC1C,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAC1C,IAAI,GAAG,SAAS,EAEhB,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EACvD,OAAO,EAAE,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,GAC1D,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAKxC"}

package/dist/define-handler.js

@@ -0,0 +1,6 @@
+export function defineHandler(schema, handler) {
+    return {
+        schema,
+        handler,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { createRequestHandler } from "./create-request-handler.js";
+export { createLocalClient } from "./create-local-client.js";
+export { defineApi } from "./define-api.js";
+export { defineHandler } from "./define-handler.js";
+export { HttpError } from "@toapi/common";
+export { TResponse } from "@toapi/common";
+export type { TRequest } from "@toapi/common";
+export { generateOpenAPISchema } from "./openapi.js";
+export type { ApiDefinition } from "./define-api.js";
+export type { CookieStore } from "@toapi/common";
+export { streamRevalidatedTags } from "./revalidation-stream.js";
+export { PubSub, type Cache } from "./cache.js";
+export { INVALIDATIONS_ROUTE } from "@toapi/common";
+export type { Logger } from "@toapi/common";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { createRequestHandler } from "./create-request-handler.js";
+export { createLocalClient } from "./create-local-client.js";
+export { defineApi } from "./define-api.js";
+export { defineHandler } from "./define-handler.js";
+export { HttpError } from "@toapi/common";
+export { TResponse } from "@toapi/common";
+export { generateOpenAPISchema } from "./openapi.js";
+export { streamRevalidatedTags } from "./revalidation-stream.js";
+export { PubSub } from "./cache.js";
+export { INVALIDATIONS_ROUTE } from "@toapi/common";

package/dist/openapi.d.ts

@@ -0,0 +1,14 @@
+import { createDocument } from "zod-openapi";
+import type { MaybePromise } from "@toapi/common";
+import type { Path } from "@toapi/common";
+import type { BaseRoute } from "@toapi/common";
+import { ApiDefinition } from "./define-api.js";
+interface Options {
+    info: {
+        title: string;
+        version: string;
+    };
+}
+export declare function generateOpenAPISchema(apiDefinition: ApiDefinition<Record<Path, MaybePromise<BaseRoute>>>, options: Options): Promise<ReturnType<typeof createDocument>>;
+export {};
+//# sourceMappingURL=openapi.d.ts.map

package/dist/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../src/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,UAAU,OAAO;IACf,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,EACnE,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAgD5C"}

package/dist/openapi.js

@@ -0,0 +1,49 @@
+import { createDocument } from "zod-openapi";
+import z from "zod/v4";
+import { ApiDefinition } from "./define-api.js";
+export async function generateOpenAPISchema(apiDefinition, options) {
+    return createDocument({
+        openapi: "3.1.1",
+        info: options.info,
+        paths: Object.fromEntries(await Promise.all(Object.entries(apiDefinition.routes).map(async ([path, route]) => [
+            transformPath(path),
+            Object.fromEntries(Object.entries(await route)
+                .filter((entry) => entry[1] != null &&
+                typeof entry[1] === "object" &&
+                "schema" in entry[1] &&
+                "handler" in entry[1])
+                .map(([method, handler]) => [
+                method.toLowerCase(),
+                {
+                    requestParams: {
+                        path: z.object(handler.schema.params),
+                        query: z.object(handler.schema.query),
+                    },
+                    requestBody: handler.schema.body && {
+                        content: {
+                            "application/json": {
+                                schema: handler.schema.body,
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": {
+                            description: "200 OK",
+                            content: {
+                                "application/json": {
+                                    schema: handler.schema.response || z.any(),
+                                },
+                            },
+                        },
+                    },
+                },
+            ])),
+        ]))),
+    });
+}
+function transformPath(path) {
+    return path
+        .split("/")
+        .map((segment) => segment.replace(/^:(.+)$/, "{$1}"))
+        .join("/");
+}

package/dist/request-handler.mock.d.ts

@@ -0,0 +1,2 @@
+export declare const requestHandler: (req: Request) => Promise<Response>;
+//# sourceMappingURL=request-handler.mock.d.ts.map

package/dist/request-handler.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-handler.mock.d.ts","sourceRoot":"","sources":["../src/request-handler.mock.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,qCAAkD,CAAC"}

package/dist/request-handler.mock.js

@@ -0,0 +1,3 @@
+import { createRequestHandler } from "./create-request-handler.js";
+import { api } from "./define-api.mock.js";
+export const requestHandler = createRequestHandler(api, { basePath: "/api" });

package/dist/revalidation-stream.d.ts

@@ -0,0 +1,7 @@
+import type { Cache } from "./cache.js";
+interface Options {
+    cache: Cache;
+}
+export declare function streamRevalidatedTags({ cache }: Options): Response;
+export {};
+//# sourceMappingURL=revalidation-stream.d.ts.map

package/dist/revalidation-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidation-stream.d.ts","sourceRoot":"","sources":["../src/revalidation-stream.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAIxC,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAED,wBAAgB,qBAAqB,CAAC,EAAE,KAAK,EAAE,EAAE,OAAO,YAwCvD"}

package/dist/revalidation-stream.js

@@ -0,0 +1,39 @@
+import { SESSION_COOKIE_NAME, TAGS_CONTENT_TYPE, } from "@toapi/common";
+const KEEPALIVE_INTERVAL = 10 * 1000;
+export function streamRevalidatedTags({ cache }) {
+    const id = crypto.randomUUID();
+    let interval = null;
+    let unsubscribe = () => { };
+    const stream = new ReadableStream({
+        async start(controller) {
+            const textEncoder = new TextEncoder();
+            // subscribe to tag invalidations
+            unsubscribe = cache.subscribe((tags, meta) => {
+                // ignore our own invalidations
+                if (meta &&
+                    typeof meta === "object" &&
+                    "clientId" in meta &&
+                    meta.clientId === id)
+                    return;
+                // send tags to client
+                controller.enqueue(textEncoder.encode(`${tags.join(" ")}\n`));
+            });
+            // keepalive
+            interval = setInterval(() => {
+                controller.enqueue("\n");
+            }, KEEPALIVE_INTERVAL);
+        },
+        cancel() {
+            if (interval)
+                clearInterval(interval);
+            unsubscribe();
+        },
+    });
+    const headers = new Headers({
+        "Set-Cookie": `${SESSION_COOKIE_NAME}=${id}; Path=/; HttpOnly; SameSite=Strict`,
+        "Content-Type": TAGS_CONTENT_TYPE,
+    });
+    return new Response(stream, {
+        headers,
+    });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@toapi/server",
+  "version": "0.12.1",
+  "author": {
+    "name": "Michel Smola",
+    "email": "michel.smola@farbenmeer.de"
+  },
+  "type": "module",
+  "module": "dist/index.js",
+  "main": "dist/index.js",
+  "private": false,
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "zod-openapi": "^6.0.0",
+    "@toapi/client": "^0.12.1",
+    "@toapi/common": "^0.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "vitest": "^4.0.16",
+    "zod": "^4.0.17",
+    "@farbenmeer/tag-based-cache": "0.3.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5 || ^6.0.0",
+    "zod": "^4.0.17"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/farbenmeer/tapi.git"
+  },
+  "scripts": {
+    "build": "tsc --noEmit false",
+    "release": "pnpm build && pnpm publish --no-git-checks",
+    "test": "vitest"
+  }
+}