1tube 0.1.31 → 0.1.32

package/dist/edge-caller.d.ts

@@ -0,0 +1,30 @@
+export type CallEdgeAuth = "service" | "user" | {
+    bearer: string;
+};
+export interface CallEdgeFunctionOptions {
+    /** HTTP method. Defaults to `"POST"`. */
+    method?: string;
+    /** Optional route path inside the target function, e.g. `/sync`. */
+    path?: string;
+    /** Query parameters appended to the function URL. */
+    query?: Record<string, string | number | boolean | null | undefined>;
+    body?: unknown;
+    auth?: CallEdgeAuth;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export interface EdgeCallerRuntime {
+    getBaseUrl(): string;
+    /** Public prefix in front of the function name. Defaults to `/functions/v1`. */
+    pathPrefix?: string;
+    getServiceRoleToken(): string | null | undefined;
+    getAnonKey?(): string | null | undefined;
+    getUserToken(): string | null | undefined;
+    fetch?: typeof fetch;
+    waitUntil?: (promise: Promise<unknown>) => void;
+}
+export interface EdgeCaller {
+    callEdgeFunction(name: string, options?: CallEdgeFunctionOptions): Promise<Response>;
+    callEdgeFunctionInBackground(name: string, options?: CallEdgeFunctionOptions): void;
+}
+export declare function createEdgeCaller(runtime: EdgeCallerRuntime): EdgeCaller;

package/dist/edge-caller.js

@@ -0,0 +1,77 @@
+function resolveBearerToken(runtime, auth) {
+    if (typeof auth === "object" && auth !== null && "bearer" in auth) {
+        return auth.bearer;
+    }
+    if (auth === "user") {
+        const token = runtime.getUserToken();
+        if (!token) {
+            throw new Error("[callEdgeFunction] auth: 'user' requires an authenticated caller " +
+                "(no user token available).");
+        }
+        return token;
+    }
+    const serviceToken = runtime.getServiceRoleToken();
+    if (!serviceToken) {
+        throw new Error("[callEdgeFunction] service auth requires a service role token.");
+    }
+    return serviceToken;
+}
+function serializeBody(body) {
+    if (body === undefined || body === null)
+        return { body: undefined };
+    if (typeof body === "string") {
+        return { body, contentType: "text/plain;charset=UTF-8" };
+    }
+    if (body instanceof Uint8Array ||
+        body instanceof ArrayBuffer ||
+        body instanceof Blob ||
+        body instanceof FormData ||
+        body instanceof ReadableStream) {
+        return { body: body };
+    }
+    return { body: JSON.stringify(body), contentType: "application/json" };
+}
+function buildRequest(runtime, name, opts) {
+    const pathPrefix = runtime.pathPrefix ?? "/functions/v1";
+    const routePath = opts.path ? `/${opts.path.replace(/^\/+/, "")}` : "";
+    const url = new URL(`${runtime.getBaseUrl().replace(/\/+$/, "")}/${pathPrefix.replace(/^\/+|\/+$/g, "")}/${name}${routePath}`);
+    for (const [key, value] of Object.entries(opts.query ?? {})) {
+        if (value !== undefined && value !== null) {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const token = resolveBearerToken(runtime, opts.auth ?? "service");
+    const { body, contentType } = serializeBody(opts.body);
+    const anonKey = runtime.getAnonKey?.();
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        ...(contentType ? { "Content-Type": contentType } : {}),
+        ...(anonKey ? { apikey: anonKey } : {}),
+        ...opts.headers,
+    };
+    return {
+        url: url.toString(),
+        init: {
+            method: opts.method ?? "POST",
+            headers,
+            body: body ?? null,
+            signal: opts.signal,
+        },
+    };
+}
+export function createEdgeCaller(runtime) {
+    const fetchImpl = runtime.fetch ?? fetch;
+    return {
+        async callEdgeFunction(name, options = {}) {
+            const { url, init } = buildRequest(runtime, name, options);
+            return await fetchImpl(url, init);
+        },
+        callEdgeFunctionInBackground(name, options = {}) {
+            const { url, init } = buildRequest(runtime, name, options);
+            const promise = fetchImpl(url, init).catch((err) => {
+                console.error(`[callEdgeFunctionInBackground] ${name} failed:`, err);
+            });
+            runtime.waitUntil?.(promise);
+        },
+    };
+}

package/dist/edge.d.ts

@@ -0,0 +1,176 @@
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface SchemaLike<T = unknown> {
+    safeParse(value: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: unknown;
+    };
+}
+export interface JsonSchemaAdapter {
+    toJsonSchema(schema: SchemaLike): unknown;
+}
+type SchemaOutput<TSchema> = TSchema extends SchemaLike<infer T> ? T : undefined;
+type ParamsOutput<TSchema> = TSchema extends SchemaLike<infer T> ? T : Record<string, string>;
+type QueryOutput<TSchema> = TSchema extends SchemaLike<infer T> ? T : Record<string, string>;
+export declare enum HttpStatus {
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    UNPROCESSABLE_CONTENT = 422,
+    LOCKED = 423,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504
+}
+export type ErrorHttpStatus = HttpStatus.BAD_REQUEST | HttpStatus.UNAUTHORIZED | HttpStatus.FORBIDDEN | HttpStatus.NOT_FOUND | HttpStatus.METHOD_NOT_ALLOWED | HttpStatus.REQUEST_TIMEOUT | HttpStatus.CONFLICT | HttpStatus.GONE | HttpStatus.PRECONDITION_FAILED | HttpStatus.PAYLOAD_TOO_LARGE | HttpStatus.UNSUPPORTED_MEDIA_TYPE | HttpStatus.UNPROCESSABLE_CONTENT | HttpStatus.LOCKED | HttpStatus.PRECONDITION_REQUIRED | HttpStatus.TOO_MANY_REQUESTS | HttpStatus.INTERNAL_SERVER_ERROR | HttpStatus.NOT_IMPLEMENTED | HttpStatus.BAD_GATEWAY | HttpStatus.SERVICE_UNAVAILABLE | HttpStatus.GATEWAY_TIMEOUT;
+export type RouteResponses = Partial<Record<HttpStatus, SchemaLike>>;
+export interface RouteRequest<TParams extends SchemaLike | undefined, TQuery extends SchemaLike | undefined, TBody extends SchemaLike | undefined, TContext> {
+    req: Request;
+    ctx: TContext;
+    params: ParamsOutput<TParams>;
+    query: QueryOutput<TQuery>;
+    body: SchemaOutput<TBody>;
+}
+export type RouteHandler<TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TContext = unknown> = (input: RouteRequest<TParams, TQuery, TBody, TContext>) => Response | Promise<Response>;
+export interface RouteOptions<TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends RouteResponses = RouteResponses, TContext = unknown> {
+    params?: TParams;
+    query?: TQuery;
+    body?: TBody;
+    responses: TResponses;
+    summary?: string;
+    description?: string;
+    handler: RouteHandler<TParams, TQuery, TBody, TContext>;
+}
+export interface RouteDefinition<TParams extends SchemaLike | undefined = SchemaLike | undefined, TQuery extends SchemaLike | undefined = SchemaLike | undefined, TBody extends SchemaLike | undefined = SchemaLike | undefined, TResponses extends RouteResponses = RouteResponses, TContext = unknown> extends RouteOptions<TParams, TQuery, TBody, TResponses, TContext> {
+    method: HttpMethod;
+    path: string;
+    operationId: string;
+}
+export interface JsonRouteOptions<TBody extends SchemaLike, TResponses extends RouteResponses, TContext> {
+    body: TBody;
+    responses: TResponses;
+    summary?: string;
+    description?: string;
+    handler: RouteHandler<undefined, undefined, TBody, TContext>;
+}
+export declare function createRouteBuilder<TDefaultContext = unknown>(): {
+    get: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TResponses extends RouteResponses = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, undefined, TResponses, TDefaultContext>) => RouteDefinition<TParams, TQuery, undefined, TResponses, TDefaultContext>;
+    post: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends RouteResponses = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, TBody, TResponses, TDefaultContext>) => RouteDefinition<TParams, TQuery, TBody, TResponses, TDefaultContext>;
+    put: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends RouteResponses = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, TBody, TResponses, TDefaultContext>) => RouteDefinition<TParams, TQuery, TBody, TResponses, TDefaultContext>;
+    patch: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends RouteResponses = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, TBody, TResponses, TDefaultContext>) => RouteDefinition<TParams, TQuery, TBody, TResponses, TDefaultContext>;
+    delete: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TResponses extends RouteResponses = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, undefined, TResponses, TDefaultContext>) => RouteDefinition<TParams, TQuery, undefined, TResponses, TDefaultContext>;
+    postJson: <TBody extends SchemaLike, TResponses extends RouteResponses>(path: string, operationId: string, options: JsonRouteOptions<TBody, TResponses, TDefaultContext>) => RouteDefinition<undefined, undefined, TBody, TResponses, TDefaultContext>;
+    putJson: <TBody extends SchemaLike, TResponses extends RouteResponses>(path: string, operationId: string, options: JsonRouteOptions<TBody, TResponses, TDefaultContext>) => RouteDefinition<undefined, undefined, TBody, TResponses, TDefaultContext>;
+    patchJson: <TBody extends SchemaLike, TResponses extends RouteResponses>(path: string, operationId: string, options: JsonRouteOptions<TBody, TResponses, TDefaultContext>) => RouteDefinition<undefined, undefined, TBody, TResponses, TDefaultContext>;
+};
+export declare const route: {
+    get: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>> = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, undefined, TResponses, unknown>) => RouteDefinition<TParams, TQuery, undefined, TResponses, unknown>;
+    post: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>> = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, TBody, TResponses, unknown>) => RouteDefinition<TParams, TQuery, TBody, TResponses, unknown>;
+    put: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>> = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, TBody, TResponses, unknown>) => RouteDefinition<TParams, TQuery, TBody, TResponses, unknown>;
+    patch: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TBody extends SchemaLike | undefined = undefined, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>> = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, TBody, TResponses, unknown>) => RouteDefinition<TParams, TQuery, TBody, TResponses, unknown>;
+    delete: <TParams extends SchemaLike | undefined = undefined, TQuery extends SchemaLike | undefined = undefined, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>> = Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: RouteOptions<TParams, TQuery, undefined, TResponses, unknown>) => RouteDefinition<TParams, TQuery, undefined, TResponses, unknown>;
+    postJson: <TBody extends SchemaLike, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: JsonRouteOptions<TBody, TResponses, unknown>) => RouteDefinition<undefined, undefined, TBody, TResponses, unknown>;
+    putJson: <TBody extends SchemaLike, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: JsonRouteOptions<TBody, TResponses, unknown>) => RouteDefinition<undefined, undefined, TBody, TResponses, unknown>;
+    patchJson: <TBody extends SchemaLike, TResponses extends Partial<Record<HttpStatus, SchemaLike<unknown>>>>(path: string, operationId: string, options: JsonRouteOptions<TBody, TResponses, unknown>) => RouteDefinition<undefined, undefined, TBody, TResponses, unknown>;
+};
+export declare function json(body: unknown, init?: number | ResponseInit): Response;
+export declare function jsonError(status: ErrorHttpStatus, message: string, details?: unknown, init?: Omit<ResponseInit, "status">): Response;
+export declare function empty(status?: HttpStatus, init?: Omit<ResponseInit, "status">): Response;
+export declare function text(body: string, init?: number | ResponseInit): Response;
+export declare function created(body: unknown, init?: Omit<ResponseInit, "status">): Response;
+export declare function accepted(body: unknown, init?: Omit<ResponseInit, "status">): Response;
+export declare function noContent(init?: Omit<ResponseInit, "status">): Response;
+export declare function badRequest(message?: string, details?: unknown): Response;
+export declare function unauthorized(message?: string, details?: unknown): Response;
+export declare function forbidden(message?: string, details?: unknown): Response;
+export declare function notFound(message?: string, details?: unknown): Response;
+export declare function methodNotAllowed(allowedMethods: readonly string[], message?: string): Response;
+export declare function conflict(message?: string, details?: unknown): Response;
+export declare function gone(message?: string, details?: unknown): Response;
+export declare function payloadTooLarge(message?: string, details?: unknown): Response;
+export declare function unsupportedMediaType(message?: string, details?: unknown): Response;
+export declare function unprocessableContent(message?: string, details?: unknown): Response;
+export declare function tooManyRequests(input?: {
+    message?: string;
+    retryAfterSeconds?: number;
+}): Response;
+export declare function internalServerError(message?: string, details?: unknown): Response;
+export declare function badGateway(message?: string, details?: unknown): Response;
+export declare function serviceUnavailable(message?: string, details?: unknown): Response;
+export declare function gatewayTimeout(message?: string, details?: unknown): Response;
+export interface ServeConfig<TContext = unknown> {
+    name: string;
+    require: unknown;
+    timeoutMs?: number;
+    routes: RouteDefinition<SchemaLike | undefined, SchemaLike | undefined, SchemaLike | undefined, RouteResponses, TContext>[];
+    /**
+     * Public prefix in front of the function name. Supabase-compatible hosts use
+     * `/functions/v1`; ASP.NET Core or other reverse proxies may expose a
+     * different prefix while keeping the same function modules.
+     */
+    pathPrefix?: string;
+}
+export interface MatchedRoute {
+    route: RouteDefinition<SchemaLike | undefined, SchemaLike | undefined, SchemaLike | undefined, RouteResponses, any>;
+    params: Record<string, string>;
+}
+export interface RouteDispatcherContext<TContext> {
+    req: Request;
+    ctx: TContext;
+    matched: MatchedRoute;
+    getCorsHeaders?: (req: Request) => HeadersInit;
+}
+export type RouteDispatcher<TContext> = (input: RouteDispatcherContext<TContext>) => Promise<Response>;
+export interface FetchHandlerOptions<TContext> {
+    getContext(req: Request): TContext | Response | Promise<TContext | Response>;
+    getCorsHeaders?: (req: Request) => HeadersInit;
+    onError?: (error: unknown, req: Request) => Response | Promise<Response>;
+    afterResponse?: (response: Response, req: Request) => Response | Promise<Response>;
+}
+export interface StandaloneServe {
+    (handler: (req: Request) => Response | Promise<Response>): void;
+}
+export declare function getStandaloneServe(): StandaloneServe | null;
+export declare function normalizeRoutePath(path: string): string;
+export declare function splitPath(path: string): string[];
+export declare function getRelativePath(req: Request, functionName: string): string;
+export declare function getRelativePathFromParts(pathnameParts: string[], functionName: string, pathPrefix?: string): string;
+export declare function matchRoutePath(routePath: string, requestPath: string): Record<string, string> | null;
+export declare function findRoute<TContext>(config: ServeConfig<TContext>, req: Request): MatchedRoute | Response;
+export declare function queryObject(req: Request): Record<string, string>;
+export declare function parseJsonBody(req: Request): Promise<unknown>;
+export declare function flattenSchemaError(error: unknown): unknown;
+export declare function validateSchema<TSchema extends SchemaLike | undefined>(schema: TSchema, value: unknown, label: "params" | "query" | "body"): SchemaOutput<TSchema> | Response;
+export declare function withCors(req: Request, response: Response, getCorsHeaders?: (req: Request) => HeadersInit): Response;
+export declare function dispatchRoute<TContext>(input: RouteDispatcherContext<TContext>): Promise<Response>;
+export declare function createFetchHandler<TContext>(config: ServeConfig<TContext>, options: FetchHandlerOptions<TContext>): (req: Request) => Promise<Response>;
+export interface OpenApiDocumentOptions {
+    title: string;
+    version: string;
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+    schemaAdapter?: JsonSchemaAdapter;
+}
+export declare function createOpenApiDocument(config: ServeConfig<any>, options: OpenApiDocumentOptions): Record<string, unknown>;
+export {};

package/dist/edge.js

@@ -0,0 +1,435 @@
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["UNPROCESSABLE_CONTENT"] = 422] = "UNPROCESSABLE_CONTENT";
+    HttpStatus[HttpStatus["LOCKED"] = 423] = "LOCKED";
+    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+})(HttpStatus || (HttpStatus = {}));
+function defineRoute(method, path, operationId, options) {
+    return { method, path: normalizeRoutePath(path), operationId, ...options };
+}
+function defineJsonRoute(method, path, operationId, options) {
+    return defineRoute(method, path, operationId, options);
+}
+export function createRouteBuilder() {
+    return {
+        get: (path, operationId, options) => defineRoute("GET", path, operationId, options),
+        post: (path, operationId, options) => defineRoute("POST", path, operationId, options),
+        put: (path, operationId, options) => defineRoute("PUT", path, operationId, options),
+        patch: (path, operationId, options) => defineRoute("PATCH", path, operationId, options),
+        delete: (path, operationId, options) => defineRoute("DELETE", path, operationId, options),
+        postJson: (path, operationId, options) => defineJsonRoute("POST", path, operationId, options),
+        putJson: (path, operationId, options) => defineJsonRoute("PUT", path, operationId, options),
+        patchJson: (path, operationId, options) => defineJsonRoute("PATCH", path, operationId, options),
+    };
+}
+export const route = createRouteBuilder();
+export function json(body, init = HttpStatus.OK) {
+    const responseInit = typeof init === "number"
+        ? { status: init }
+        : init;
+    const headers = new Headers(responseInit.headers);
+    if (!headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    return new Response(JSON.stringify(body), { ...responseInit, headers });
+}
+export function jsonError(status, message, details, init = {}) {
+    return json({ error: message, ...(details === undefined ? {} : { details }) }, { ...init, status });
+}
+export function empty(status = HttpStatus.NO_CONTENT, init = {}) {
+    return new Response(null, { ...init, status });
+}
+export function text(body, init = HttpStatus.OK) {
+    const responseInit = typeof init === "number"
+        ? { status: init }
+        : init;
+    const headers = new Headers(responseInit.headers);
+    if (!headers.has("Content-Type")) {
+        headers.set("Content-Type", "text/plain;charset=UTF-8");
+    }
+    return new Response(body, { ...responseInit, headers });
+}
+export function created(body, init = {}) {
+    return json(body, { ...init, status: HttpStatus.CREATED });
+}
+export function accepted(body, init = {}) {
+    return json(body, { ...init, status: HttpStatus.ACCEPTED });
+}
+export function noContent(init = {}) {
+    return empty(HttpStatus.NO_CONTENT, init);
+}
+export function badRequest(message = "Bad request", details) {
+    return jsonError(HttpStatus.BAD_REQUEST, message, details);
+}
+export function unauthorized(message = "Unauthorized", details) {
+    return jsonError(HttpStatus.UNAUTHORIZED, message, details);
+}
+export function forbidden(message = "Forbidden", details) {
+    return jsonError(HttpStatus.FORBIDDEN, message, details);
+}
+export function notFound(message = "Not found", details) {
+    return jsonError(HttpStatus.NOT_FOUND, message, details);
+}
+export function methodNotAllowed(allowedMethods, message = "Method not allowed") {
+    return jsonError(HttpStatus.METHOD_NOT_ALLOWED, message, undefined, {
+        headers: { Allow: [...allowedMethods].sort().join(", ") },
+    });
+}
+export function conflict(message = "Conflict", details) {
+    return jsonError(HttpStatus.CONFLICT, message, details);
+}
+export function gone(message = "Gone", details) {
+    return jsonError(HttpStatus.GONE, message, details);
+}
+export function payloadTooLarge(message = "Payload too large", details) {
+    return jsonError(HttpStatus.PAYLOAD_TOO_LARGE, message, details);
+}
+export function unsupportedMediaType(message = "Unsupported media type", details) {
+    return jsonError(HttpStatus.UNSUPPORTED_MEDIA_TYPE, message, details);
+}
+export function unprocessableContent(message = "Unprocessable content", details) {
+    return jsonError(HttpStatus.UNPROCESSABLE_CONTENT, message, details);
+}
+export function tooManyRequests(input = {}) {
+    const headers = input.retryAfterSeconds === undefined
+        ? undefined
+        : { "Retry-After": String(input.retryAfterSeconds) };
+    return json({
+        error: input.message ?? "Rate limit exceeded",
+        ...(input.retryAfterSeconds === undefined
+            ? {}
+            : { retryAfterSeconds: input.retryAfterSeconds }),
+    }, { status: HttpStatus.TOO_MANY_REQUESTS, headers });
+}
+export function internalServerError(message = "Internal server error", details) {
+    return jsonError(HttpStatus.INTERNAL_SERVER_ERROR, message, details);
+}
+export function badGateway(message = "Bad gateway", details) {
+    return jsonError(HttpStatus.BAD_GATEWAY, message, details);
+}
+export function serviceUnavailable(message = "Service unavailable", details) {
+    return jsonError(HttpStatus.SERVICE_UNAVAILABLE, message, details);
+}
+export function gatewayTimeout(message = "Gateway timeout", details) {
+    return jsonError(HttpStatus.GATEWAY_TIMEOUT, message, details);
+}
+export function getStandaloneServe() {
+    const runtime = globalThis;
+    const standaloneServe = runtime.Deno?.serve;
+    return typeof standaloneServe === "function"
+        ? standaloneServe.bind(runtime.Deno)
+        : null;
+}
+export function normalizeRoutePath(path) {
+    const trimmed = path.trim();
+    if (!trimmed || trimmed === "/")
+        return "/";
+    return `/${trimmed.replace(/^\/+|\/+$/g, "")}`;
+}
+export function splitPath(path) {
+    return path.split("/").filter(Boolean);
+}
+export function getRelativePath(req, functionName) {
+    const parts = splitPath(new URL(req.url).pathname);
+    return getRelativePathFromParts(parts, functionName);
+}
+export function getRelativePathFromParts(pathnameParts, functionName, pathPrefix) {
+    const prefixParts = pathPrefix ? splitPath(pathPrefix) : ["functions", "v1"];
+    const hasPrefix = prefixParts.length > 0 &&
+        prefixParts.every((part, index) => pathnameParts[index] === part);
+    const parts = hasPrefix
+        ? pathnameParts.slice(prefixParts.length)
+        : pathnameParts;
+    if (parts[0] === functionName) {
+        return normalizeRoutePath(parts.slice(1).join("/"));
+    }
+    if (pathnameParts[0] === "functions" && pathnameParts[1] === "v1" &&
+        pathnameParts[2] === functionName) {
+        return normalizeRoutePath(pathnameParts.slice(3).join("/"));
+    }
+    return normalizeRoutePath(parts.join("/"));
+}
+export function matchRoutePath(routePath, requestPath) {
+    const routeParts = splitPath(routePath);
+    const requestParts = splitPath(requestPath);
+    if (routeParts.length !== requestParts.length)
+        return null;
+    const params = {};
+    for (let i = 0; i < routeParts.length; i++) {
+        const expected = routeParts[i];
+        const actual = requestParts[i];
+        if (expected.startsWith(":")) {
+            params[expected.slice(1)] = decodeURIComponent(actual);
+            continue;
+        }
+        if (expected !== actual)
+            return null;
+    }
+    return params;
+}
+export function findRoute(config, req) {
+    const requestPath = getRelativePathFromParts(splitPath(new URL(req.url).pathname), config.name, config.pathPrefix);
+    const pathMatches = config.routes
+        .map((routeDef) => ({
+        route: routeDef,
+        params: matchRoutePath(routeDef.path, requestPath),
+    }))
+        .filter((match) => match.params !== null);
+    if (pathMatches.length === 0) {
+        return notFound();
+    }
+    const allowedMethods = [
+        ...new Set(pathMatches.map((match) => match.route.method)),
+    ].sort();
+    if (req.method === "OPTIONS") {
+        return new Response(null, {
+            status: HttpStatus.NO_CONTENT,
+            headers: { Allow: allowedMethods.join(", ") },
+        });
+    }
+    const method = req.method.toUpperCase();
+    const match = pathMatches.find((candidate) => candidate.route.method === method);
+    if (!match) {
+        return methodNotAllowed(allowedMethods);
+    }
+    return match;
+}
+export function queryObject(req) {
+    return Object.fromEntries(new URL(req.url).searchParams.entries());
+}
+export async function parseJsonBody(req) {
+    try {
+        return await req.json();
+    }
+    catch {
+        throw new Error("Invalid JSON body");
+    }
+}
+export function flattenSchemaError(error) {
+    if (error &&
+        typeof error === "object" &&
+        "flatten" in error &&
+        typeof error.flatten === "function") {
+        return error.flatten();
+    }
+    return error;
+}
+export function validateSchema(schema, value, label) {
+    if (!schema)
+        return value;
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        return jsonError(HttpStatus.BAD_REQUEST, `Invalid ${label}`, flattenSchemaError(parsed.error));
+    }
+    return parsed.data;
+}
+export function withCors(req, response, getCorsHeaders) {
+    if (!getCorsHeaders)
+        return response;
+    const headers = new Headers(response.headers);
+    for (const [key, value] of new Headers(getCorsHeaders(req)).entries()) {
+        headers.set(key, value);
+    }
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+export async function dispatchRoute(input) {
+    const { req, ctx, matched } = input;
+    const { route: routeDef, params: rawParams } = matched;
+    const params = validateSchema(routeDef.params, rawParams, "params");
+    if (params instanceof Response) {
+        return withCors(req, params, input.getCorsHeaders);
+    }
+    const query = validateSchema(routeDef.query, queryObject(req), "query");
+    if (query instanceof Response) {
+        return withCors(req, query, input.getCorsHeaders);
+    }
+    const rawBody = routeDef.body ? await parseJsonBody(req) : undefined;
+    const body = validateSchema(routeDef.body, rawBody, "body");
+    if (body instanceof Response) {
+        return withCors(req, body, input.getCorsHeaders);
+    }
+    return withCors(req, await routeDef.handler({ req, ctx, params, query, body }), input.getCorsHeaders);
+}
+async function defaultOnError(error) {
+    const message = error instanceof Error && error.message === "Invalid JSON body"
+        ? "Invalid JSON body"
+        : "Internal server error";
+    return message === "Invalid JSON body"
+        ? badRequest(message)
+        : internalServerError(message);
+}
+export function createFetchHandler(config, options) {
+    return async (req) => {
+        try {
+            const matched = findRoute(config, req);
+            if (matched instanceof Response) {
+                const response = withCors(req, matched, options.getCorsHeaders);
+                return options.afterResponse
+                    ? await options.afterResponse(response, req)
+                    : response;
+            }
+            const context = await options.getContext(req);
+            if (context instanceof Response) {
+                const response = withCors(req, context, options.getCorsHeaders);
+                return options.afterResponse
+                    ? await options.afterResponse(response, req)
+                    : response;
+            }
+            const response = await dispatchRoute({
+                req,
+                ctx: context,
+                matched,
+                getCorsHeaders: options.getCorsHeaders,
+            });
+            return options.afterResponse
+                ? await options.afterResponse(response, req)
+                : response;
+        }
+        catch (error) {
+            const response = withCors(req, options.onError
+                ? await options.onError(error, req)
+                : await defaultOnError(error), options.getCorsHeaders);
+            return options.afterResponse
+                ? await options.afterResponse(response, req)
+                : response;
+        }
+    };
+}
+function schemaToOpenApi(schema, adapter) {
+    if (!schema || !adapter)
+        return undefined;
+    return adapter.toJsonSchema(schema);
+}
+function pathToOpenApiPath(path) {
+    return normalizeRoutePath(path).replace(/:([^/]+)/g, "{$1}");
+}
+function pathParameterNames(path) {
+    return splitPath(path)
+        .filter((part) => part.startsWith(":"))
+        .map((part) => part.slice(1));
+}
+function objectSchemaProperties(schema) {
+    if (schema &&
+        typeof schema === "object" &&
+        "properties" in schema &&
+        typeof schema.properties === "object" &&
+        schema.properties !== null) {
+        return schema.properties;
+    }
+    return {};
+}
+function objectSchemaRequired(schema) {
+    if (schema &&
+        typeof schema === "object" &&
+        "required" in schema &&
+        Array.isArray(schema.required)) {
+        return new Set(schema.required);
+    }
+    return new Set();
+}
+function responseObject(status, schema) {
+    if (status === String(HttpStatus.NO_CONTENT) || !schema) {
+        return { description: `${status} response` };
+    }
+    return {
+        description: `${status} response`,
+        content: {
+            "application/json": { schema },
+        },
+    };
+}
+export function createOpenApiDocument(config, options) {
+    const paths = {};
+    for (const routeDef of config.routes) {
+        const path = pathToOpenApiPath(routeDef.path);
+        const pathItem = paths[path] ?? {};
+        const paramsSchema = schemaToOpenApi(routeDef.params, options.schemaAdapter);
+        const paramsProperties = objectSchemaProperties(paramsSchema);
+        const parameters = pathParameterNames(routeDef.path).map((name) => ({
+            name,
+            in: "path",
+            required: true,
+            schema: paramsProperties[name] ?? { type: "string" },
+        }));
+        const querySchema = schemaToOpenApi(routeDef.query, options.schemaAdapter);
+        if (querySchema) {
+            const queryProperties = objectSchemaProperties(querySchema);
+            const queryRequired = objectSchemaRequired(querySchema);
+            for (const [name, schema] of Object.entries(queryProperties)) {
+                parameters.push({
+                    name,
+                    in: "query",
+                    required: queryRequired.has(name),
+                    schema,
+                });
+            }
+            if (Object.keys(queryProperties).length === 0) {
+                parameters.push({
+                    name: "query",
+                    in: "query",
+                    required: false,
+                    schema: querySchema,
+                });
+            }
+        }
+        pathItem[routeDef.method.toLowerCase()] = {
+            operationId: routeDef.operationId,
+            ...(routeDef.summary ? { summary: routeDef.summary } : {}),
+            ...(routeDef.description ? { description: routeDef.description } : {}),
+            ...(parameters.length > 0 ? { parameters } : {}),
+            ...(routeDef.body
+                ? {
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: schemaToOpenApi(routeDef.body, options.schemaAdapter) ??
+                                    {},
+                            },
+                        },
+                    },
+                }
+                : {}),
+            responses: Object.fromEntries(Object.entries(routeDef.responses).map(([status, schema]) => [
+                status,
+                responseObject(status, schemaToOpenApi(schema, options.schemaAdapter)),
+            ])),
+        };
+        paths[path] = pathItem;
+    }
+    return {
+        openapi: "3.1.0",
+        info: {
+            title: options.title,
+            version: options.version,
+        },
+        ...(options.servers ? { servers: options.servers } : {}),
+        paths,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway for Deno, plus an ESLint plugin for consumers",
   "license": "MIT",
@@ -14,8 +14,16 @@
     "url": "https://github.com/lofcz/1tube/issues"
   },
   "exports": {
-    "./edge": "./src/edge.ts",
-    "./edge-caller": "./src/edge-caller.ts",
+    "./edge": {
+      "types": "./dist/edge.d.ts",
+      "import": "./dist/edge.js",
+      "default": "./dist/edge.js"
+    },
+    "./edge-caller": {
+      "types": "./dist/edge-caller.d.ts",
+      "import": "./dist/edge-caller.js",
+      "default": "./dist/edge-caller.js"
+    },
     "./eslint-plugin": "./eslint-plugin.js",
     "./package.json": "./package.json"
   },
@@ -24,6 +32,7 @@
   },
   "files": [
     "eslint-plugin.js",
+    "dist",
     "scripts/npm-cli.js",
     "src",
     "deno.json",
@@ -38,10 +47,12 @@
   "scripts": {
     "dev": "deno task dev",
     "serve": "deno task serve",
+    "build:edge": "deno run -A npm:typescript@latest/tsc --target ES2022 --module ESNext --moduleResolution Bundler --declaration --outDir dist src/edge.ts src/edge-caller.ts",
+    "prepack": "bun run build:edge",
     "typecheck": "deno check src/server.ts src/cli.ts src/edge.ts src/edge-caller.ts eslint-plugin.js",
     "check": "deno cache --allow-scripts=npm:protobufjs src/server.ts",
     "smoke:bin": "node ./scripts/npm-cli.js --version",
-    "prepublishOnly": "bun run typecheck && bun run check && bun run smoke:bin"
+    "prepublishOnly": "bun run build:edge && bun run typecheck && bun run check && bun run smoke:bin"
   },
   "dependencies": {
     "hono": "^4.12.18"