@hypequery/serve 0.0.4 → 0.0.5

package/dist/adapters/fetch.d.ts

@@ -0,0 +1,3 @@
+import type { FetchHandler, ServeHandler } from "../types.js";
+export declare const createFetchHandler: (handler: ServeHandler) => FetchHandler;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/adapters/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/adapters/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAc,YAAY,EAAgB,MAAM,aAAa,CAAC;AAQxF,eAAO,MAAM,kBAAkB,GAAI,SAAS,YAAY,KAAG,YA4B1D,CAAC"}

package/dist/adapters/fetch.js

@@ -0,0 +1,26 @@
+import { normalizeHeaders, parseQueryParams, parseRequestBody, serializeResponseBody, } from "./utils.js";
+export const createFetchHandler = (handler) => {
+    return async (request) => {
+        const url = new URL(request.url);
+        const headers = normalizeHeaders(request.headers);
+        const contentType = headers["content-type"];
+        const serveRequest = {
+            method: (request.method ?? "GET").toUpperCase(),
+            path: url.pathname,
+            query: parseQueryParams(url.searchParams),
+            headers,
+            body: await parseRequestBody(request, contentType),
+            raw: request,
+        };
+        const response = await handler(serveRequest);
+        const responseHeaders = {
+            "content-type": "application/json; charset=utf-8",
+            ...response.headers,
+        };
+        const body = serializeResponseBody(response.body);
+        return new Response(body, {
+            status: response.status,
+            headers: responseHeaders,
+        });
+    };
+};

package/dist/adapters/node.d.ts

@@ -0,0 +1,8 @@
+import { type IncomingMessage, type ServerResponse } from "http";
+import type { ServeHandler, StartServerOptions } from "../types.js";
+export declare const createNodeHandler: (handler: ServeHandler) => (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare const startNodeServer: (handler: ServeHandler, options?: StartServerOptions) => Promise<{
+    server: import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
+    stop: () => Promise<void>;
+}>;
+//# sourceMappingURL=node.d.ts.map

package/dist/adapters/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/adapters/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,MAAM,CAAC;AAG/E,OAAO,KAAK,EAEV,YAAY,EAGZ,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAyErB,eAAO,MAAM,iBAAiB,GAAI,SAAS,YAAY,MACvC,KAAK,eAAe,EAAE,KAAK,cAAc,kBASxD,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,SAAS,YAAY,EACrB,UAAS,kBAAuB;;;EA8CjC,CAAC"}

package/dist/adapters/node.js

@@ -0,0 +1,105 @@
+import { createServer } from "http";
+import { once } from "node:events";
+import { normalizeHeaders, parseQueryParams, parseRequestBody, serializeResponseBody, } from "./utils.js";
+const readRequestBody = async (req) => {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+};
+const buildServeRequest = async (req) => {
+    const method = (req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const bodyBuffer = await readRequestBody(req);
+    const headers = normalizeHeaders(req.headers);
+    const contentType = headers["content-type"] ?? headers["Content-Type"];
+    const body = await parseRequestBody(bodyBuffer, contentType);
+    return {
+        method,
+        path: url.pathname,
+        query: parseQueryParams(url.searchParams),
+        headers,
+        body,
+        raw: req,
+    };
+};
+const sendResponse = (res, response) => {
+    res.statusCode = response.status;
+    const headers = response.headers ?? {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value !== undefined) {
+            res.setHeader(key, value);
+        }
+    }
+    if (!res.hasHeader("content-type")) {
+        res.setHeader("content-type", "application/json; charset=utf-8");
+    }
+    const serialized = serializeResponseBody(response.body);
+    res.end(serialized);
+};
+const sendError = (res, error) => {
+    const payload = error && typeof error === "object" && "status" in error
+        ? error
+        : {
+            status: 500,
+            body: {
+                error: {
+                    type: "INTERNAL_SERVER_ERROR",
+                    message: error instanceof Error ? error.message : "Unexpected error",
+                },
+            },
+        };
+    sendResponse(res, payload);
+};
+export const createNodeHandler = (handler) => {
+    return async (req, res) => {
+        try {
+            const request = await buildServeRequest(req);
+            const response = await handler(request);
+            sendResponse(res, response);
+        }
+        catch (error) {
+            sendError(res, error);
+        }
+    };
+};
+export const startNodeServer = async (handler, options = {}) => {
+    const listener = createNodeHandler(handler);
+    const server = createServer(listener);
+    const port = options.port ?? 3000;
+    const hostname = options.hostname ?? "0.0.0.0";
+    const onAbort = () => {
+        server.close();
+    };
+    if (options.signal) {
+        if (options.signal.aborted) {
+            server.close();
+            throw new Error("Start signal already aborted");
+        }
+        options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    server.listen(port, hostname);
+    await once(server, "listening");
+    if (!options.quiet) {
+        const address = server.address();
+        const display = typeof address === "object" && address
+            ? `${address.address}:${address.port}`
+            : `${hostname}:${port}`;
+        console.log(`hypequery serve listening on ${display}`);
+    }
+    const stop = () => new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    return {
+        server,
+        stop,
+    };
+};

package/dist/adapters/utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared utilities for HTTP adapters (Node.js, Fetch API, etc.)
+ * These functions eliminate code duplication across different adapter implementations.
+ */
+/**
+ * Normalizes headers from various sources into a consistent format.
+ * Handles both Node.js IncomingMessage headers and Web API Headers.
+ *
+ * @param headers - Headers from Node.js (Record with string | string[]) or Web Headers
+ * @returns Normalized headers as Record<string, string | undefined>
+ */
+export declare function normalizeHeaders(headers: Record<string, string | string[] | undefined> | Headers): Record<string, string | undefined>;
+/**
+ * Parses URL search parameters into a structured query object.
+ * Handles multiple values for the same parameter by creating arrays.
+ *
+ * @param searchParams - URLSearchParams instance
+ * @returns Query parameters with support for arrays
+ */
+export declare function parseQueryParams(searchParams: URLSearchParams): Record<string, string | string[] | undefined>;
+/**
+ * Parses request body based on content type.
+ * Supports Node.js Buffer and Web API Request.
+ *
+ * @param input - Buffer (Node.js) or Request (Web API)
+ * @param contentType - Content-Type header value
+ * @returns Parsed body (JSON object, string, ArrayBuffer, or undefined)
+ */
+export declare function parseRequestBody(input: Buffer | Request, contentType?: string): Promise<unknown>;
+/**
+ * Serializes response body to string based on content type.
+ * Handles JSON serialization and string passthrough.
+ *
+ * @param body - Response body (any type)
+ * @param contentType - Content-Type header value
+ * @returns Serialized body as string
+ */
+export declare function serializeResponseBody(body: unknown): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/adapters/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/adapters/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,GAAG,OAAO,GAC/D,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAoBpC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,eAAe,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAc/C;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,GAAG,OAAO,EACvB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,CAAC,CAuClB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,OAAO,GACZ,MAAM,CAQR"}

package/dist/adapters/utils.js

@@ -0,0 +1,114 @@
+/**
+ * Shared utilities for HTTP adapters (Node.js, Fetch API, etc.)
+ * These functions eliminate code duplication across different adapter implementations.
+ */
+/**
+ * Normalizes headers from various sources into a consistent format.
+ * Handles both Node.js IncomingMessage headers and Web API Headers.
+ *
+ * @param headers - Headers from Node.js (Record with string | string[]) or Web Headers
+ * @returns Normalized headers as Record<string, string | undefined>
+ */
+export function normalizeHeaders(headers) {
+    const normalized = {};
+    if (headers instanceof Headers || (typeof Headers !== 'undefined' && headers instanceof Headers)) {
+        // Web API Headers
+        headers.forEach((value, key) => {
+            normalized[key] = value;
+        });
+    }
+    else {
+        // Node.js headers (Record<string, string | string[] | undefined>)
+        for (const [key, value] of Object.entries(headers)) {
+            if (Array.isArray(value)) {
+                normalized[key] = value.join(", ");
+            }
+            else if (typeof value === "string") {
+                normalized[key] = value;
+            }
+        }
+    }
+    return normalized;
+}
+/**
+ * Parses URL search parameters into a structured query object.
+ * Handles multiple values for the same parameter by creating arrays.
+ *
+ * @param searchParams - URLSearchParams instance
+ * @returns Query parameters with support for arrays
+ */
+export function parseQueryParams(searchParams) {
+    const params = {};
+    for (const [key, value] of searchParams.entries()) {
+        if (params[key] === undefined) {
+            params[key] = value;
+        }
+        else if (Array.isArray(params[key])) {
+            params[key].push(value);
+        }
+        else {
+            params[key] = [params[key], value];
+        }
+    }
+    return params;
+}
+/**
+ * Parses request body based on content type.
+ * Supports Node.js Buffer and Web API Request.
+ *
+ * @param input - Buffer (Node.js) or Request (Web API)
+ * @param contentType - Content-Type header value
+ * @returns Parsed body (JSON object, string, ArrayBuffer, or undefined)
+ */
+export async function parseRequestBody(input, contentType) {
+    // Node.js Buffer handling
+    if (Buffer.isBuffer(input)) {
+        if (!input.length) {
+            return undefined;
+        }
+        if (contentType && contentType.includes("application/json")) {
+            try {
+                return JSON.parse(input.toString("utf8"));
+            }
+            catch {
+                // If JSON parsing fails, return as string
+                return input.toString("utf8");
+            }
+        }
+        // Non-JSON content
+        return input.length ? input.toString("utf8") : undefined;
+    }
+    // Web API Request handling
+    if (!contentType) {
+        return undefined;
+    }
+    if (contentType.includes("application/json")) {
+        try {
+            return await input.json();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (contentType.includes("text/")) {
+        return await input.text();
+    }
+    // Binary data (images, files, etc.)
+    return await input.arrayBuffer();
+}
+/**
+ * Serializes response body to string based on content type.
+ * Handles JSON serialization and string passthrough.
+ *
+ * @param body - Response body (any type)
+ * @param contentType - Content-Type header value
+ * @returns Serialized body as string
+ */
+export function serializeResponseBody(body) {
+    // If already a string, pass through as-is
+    if (typeof body === "string") {
+        return body;
+    }
+    // Otherwise, JSON stringify for JSON content-type or default
+    return JSON.stringify(body ?? null);
+}

package/dist/adapters/vercel.d.ts

@@ -0,0 +1,7 @@
+import type { ServeHandler } from "../types.js";
+type VercelEdgeHandler = (request: Request) => Promise<Response>;
+type VercelNodeHandler = (req: unknown, res: unknown) => Promise<void> | void;
+export declare const createVercelEdgeHandler: (handler: ServeHandler) => VercelEdgeHandler;
+export declare const createVercelNodeHandler: (handler: ServeHandler) => VercelNodeHandler;
+export {};
+//# sourceMappingURL=vercel.d.ts.map

package/dist/adapters/vercel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../src/adapters/vercel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AACjE,KAAK,iBAAiB,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE9E,eAAO,MAAM,uBAAuB,GAAI,SAAS,YAAY,KAAG,iBAG/D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,SAAS,YAAY,KAAG,iBAM/D,CAAC"}

package/dist/adapters/vercel.js

@@ -0,0 +1,13 @@
+import { createFetchHandler } from "./fetch.js";
+import { createNodeHandler } from "./node.js";
+export const createVercelEdgeHandler = (handler) => {
+    const fetchHandler = createFetchHandler(handler);
+    return async (request) => fetchHandler(request);
+};
+export const createVercelNodeHandler = (handler) => {
+    const nodeHandler = createNodeHandler(handler);
+    return async (req, res) => {
+        // Vercel's Node runtime passes standard Node req/res objects.
+        await nodeHandler(req, res);
+    };
+};

package/dist/auth.d.ts

@@ -0,0 +1,14 @@
+import type { AuthContext, AuthStrategy, ServeRequest } from "./types.js";
+export interface ApiKeyStrategyOptions<TAuth extends AuthContext = AuthContext> {
+    header?: string;
+    queryParam?: string;
+    validate: (key: string, request: ServeRequest) => Promise<TAuth | null> | TAuth | null;
+}
+export declare const createApiKeyStrategy: <TAuth extends AuthContext = AuthContext>(options: ApiKeyStrategyOptions<TAuth>) => AuthStrategy<TAuth>;
+export interface BearerTokenStrategyOptions<TAuth extends AuthContext = AuthContext> {
+    header?: string;
+    prefix?: string;
+    validate: (token: string, request: ServeRequest) => Promise<TAuth | null> | TAuth | null;
+}
+export declare const createBearerTokenStrategy: <TAuth extends AuthContext = AuthContext>(options: BearerTokenStrategyOptions<TAuth>) => AuthStrategy<TAuth>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1E,MAAM,WAAW,qBAAqB,CAAC,KAAK,SAAS,WAAW,GAAG,WAAW;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;CACxF;AAED,eAAO,MAAM,oBAAoB,GAAI,KAAK,SAAS,WAAW,GAAG,WAAW,EAC1E,SAAS,qBAAqB,CAAC,KAAK,CAAC,KACpC,YAAY,CAAC,KAAK,CA0BpB,CAAC;AAEF,MAAM,WAAW,0BAA0B,CAAC,KAAK,SAAS,WAAW,GAAG,WAAW;IACjF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;CAC1F;AAED,eAAO,MAAM,yBAAyB,GAAI,KAAK,SAAS,WAAW,GAAG,WAAW,EAC/E,SAAS,0BAA0B,CAAC,KAAK,CAAC,KACzC,YAAY,CAAC,KAAK,CAepB,CAAC"}

package/dist/auth.js

@@ -0,0 +1,37 @@
+export const createApiKeyStrategy = (options) => {
+    const headerName = options.header ?? "authorization";
+    const queryParam = options.queryParam;
+    return async ({ request }) => {
+        let key;
+        if (queryParam && typeof request.query[queryParam] === "string") {
+            key = request.query[queryParam];
+        }
+        if (!key) {
+            const headerValue = request.headers[headerName] ?? request.headers[headerName.toLowerCase()];
+            if (typeof headerValue === "string") {
+                key = headerValue.startsWith("Bearer ")
+                    ? headerValue.slice("Bearer ".length)
+                    : headerValue;
+            }
+        }
+        if (!key) {
+            return null;
+        }
+        return options.validate(key, request);
+    };
+};
+export const createBearerTokenStrategy = (options) => {
+    const headerName = options.header ?? "authorization";
+    const prefix = options.prefix ?? "Bearer ";
+    return async ({ request }) => {
+        const raw = request.headers[headerName] ?? request.headers[headerName.toLowerCase()];
+        if (typeof raw !== "string" || !raw.startsWith(prefix)) {
+            return null;
+        }
+        const token = raw.slice(prefix.length).trim();
+        if (!token) {
+            return null;
+        }
+        return options.validate(token, request);
+    };
+};

package/dist/builder.d.ts

@@ -0,0 +1,3 @@
+import type { AuthContext, QueryProcedureBuilder } from './types.js';
+export declare const createProcedureBuilder: <TContext extends Record<string, unknown>, TAuth extends AuthContext>() => QueryProcedureBuilder<TContext, TAuth>;
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EAEX,qBAAqB,EAStB,MAAM,YAAY,CAAC;AAuBpB,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,OACtB,qBAAqB,CAAC,QAAQ,EAAE,KAAK,CA6CzC,CAAC"}

package/dist/builder.js

@@ -0,0 +1,41 @@
+import { mergeTags } from './utils.js';
+const defaultState = () => ({
+    tags: [],
+    middlewares: [],
+});
+export const createProcedureBuilder = () => {
+    const build = (state) => ({
+        input: (schema) => build({ ...state, inputSchema: schema }),
+        output: (schema) => build({ ...state, outputSchema: schema }),
+        describe: (description) => build({ ...state, description }),
+        name: (name) => build({ ...state, name }),
+        summary: (summary) => build({ ...state, summary }),
+        tag: (tag) => build({ ...state, tags: mergeTags(state.tags, [tag]) }),
+        tags: (tags) => build({ ...state, tags: mergeTags(state.tags, tags) }),
+        method: (method) => build({ ...state, method }),
+        cache: (ttlMs) => build({ ...state, cacheTtlMs: ttlMs }),
+        auth: (strategy) => build({ ...state, auth: strategy }),
+        tenant: (config) => build({ ...state, tenant: config }),
+        custom: (custom) => build({ ...state, custom: { ...(state.custom ?? {}), ...custom } }),
+        use: (...middlewares) => build({ ...state, middlewares: [...state.middlewares, ...middlewares] }),
+        query: (executable) => {
+            const config = {
+                description: state.description,
+                name: state.name,
+                summary: state.summary,
+                tags: state.tags,
+                method: state.method,
+                inputSchema: state.inputSchema,
+                outputSchema: state.outputSchema,
+                cacheTtlMs: state.cacheTtlMs,
+                auth: typeof state.auth === 'undefined' ? null : state.auth,
+                tenant: state.tenant,
+                custom: state.custom,
+                middlewares: state.middlewares,
+                query: executable,
+            };
+            return config;
+        },
+    });
+    return build(defaultState());
+};

package/dist/client-config.d.ts

@@ -0,0 +1,44 @@
+import type { ServeBuilder, HttpMethod, AuthContext } from "./types.js";
+/**
+ * Configuration for a single query's client-side behavior
+ */
+export interface QueryClientConfig {
+    method: HttpMethod;
+}
+/**
+ * Map of query names to their client configurations
+ */
+export type ApiClientConfig = Record<string, QueryClientConfig>;
+/**
+ * Extract serializable client configuration from a ServeBuilder.
+ * This generates a runtime object that can be used client-side to configure
+ * HTTP methods and paths for each query.
+ *
+ * Prioritizes route-level method configuration over endpoint defaults.
+ *
+ * @example
+ * // Server-side (e.g., in api/config/route.ts)
+ * import { api } from '@/analytics/queries';
+ * import { extractClientConfig } from '@hypequery/serve';
+ *
+ * export async function GET() {
+ *   return Response.json(extractClientConfig(api));
+ * }
+ *
+ * // Client-side
+ * const config = await fetch('/api/config').then(r => r.json());
+ * createHooks<Api>({ baseUrl: '/api/hypequery', config });
+ */
+export declare function extractClientConfig<TQueries extends Record<string, any>, TContext extends Record<string, unknown>, TAuth extends AuthContext>(api: ServeBuilder<TQueries, TContext, TAuth>): ApiClientConfig;
+/**
+ * Type-safe helper to manually define client configuration.
+ * Use this when you can't access the api object client-side.
+ *
+ * @example
+ * const config = defineClientConfig({
+ *   hello: { method: 'GET' },
+ *   createUser: { method: 'POST' },
+ * });
+ */
+export declare function defineClientConfig<T extends ApiClientConfig>(config: T): T;
+//# sourceMappingURL=client-config.d.ts.map

package/dist/client-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-config.d.ts","sourceRoot":"","sources":["../src/client-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACpC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,EACzB,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAoB/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,eAAe,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAE1E"}

package/dist/client-config.js

@@ -0,0 +1,53 @@
+/**
+ * Extract serializable client configuration from a ServeBuilder.
+ * This generates a runtime object that can be used client-side to configure
+ * HTTP methods and paths for each query.
+ *
+ * Prioritizes route-level method configuration over endpoint defaults.
+ *
+ * @example
+ * // Server-side (e.g., in api/config/route.ts)
+ * import { api } from '@/analytics/queries';
+ * import { extractClientConfig } from '@hypequery/serve';
+ *
+ * export async function GET() {
+ *   return Response.json(extractClientConfig(api));
+ * }
+ *
+ * // Client-side
+ * const config = await fetch('/api/config').then(r => r.json());
+ * createHooks<Api>({ baseUrl: '/api/hypequery', config });
+ */
+export function extractClientConfig(api) {
+    const config = {};
+    // Prefer route-level config if available
+    if (api._routeConfig) {
+        for (const [key, routeConfig] of Object.entries(api._routeConfig)) {
+            config[key] = {
+                method: routeConfig.method,
+            };
+        }
+    }
+    else {
+        // Fallback to endpoint method
+        for (const [key, endpoint] of Object.entries(api.queries)) {
+            config[key] = {
+                method: endpoint.method,
+            };
+        }
+    }
+    return config;
+}
+/**
+ * Type-safe helper to manually define client configuration.
+ * Use this when you can't access the api object client-side.
+ *
+ * @example
+ * const config = defineClientConfig({
+ *   hello: { method: 'GET' },
+ *   createUser: { method: 'POST' },
+ * });
+ */
+export function defineClientConfig(config) {
+    return config;
+}

package/dist/dev.d.ts

@@ -0,0 +1,9 @@
+import type { ServeBuilder, StartServerOptions } from "./types.js";
+export interface ServeDevOptions extends StartServerOptions {
+    logger?: (message: string) => void;
+}
+export declare const serveDev: <TQueries extends Record<string, any>, TAuth extends Record<string, unknown>>(api: ServeBuilder<TQueries, TAuth>, options?: ServeDevOptions) => Promise<{
+    server: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    stop: () => Promise<void>;
+}>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAMD,eAAO,MAAM,QAAQ,GACnB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACpC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAErC,KAAK,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC,EAClC,UAAS,eAAoB;;;EAwB9B,CAAC"}

package/dist/dev.js

@@ -0,0 +1,24 @@
+import { startNodeServer } from "./adapters/node.js";
+const defaultLogger = (message) => {
+    console.log(message);
+};
+export const serveDev = async (api, options = {}) => {
+    const port = options.port ?? Number(process.env.PORT ?? 4000);
+    const hostname = options.hostname ?? "localhost";
+    const logger = options.logger ?? defaultLogger;
+    const server = await startNodeServer(api.handler, {
+        ...options,
+        hostname,
+        port,
+        quiet: true,
+    });
+    if (!options.quiet) {
+        const address = server.server.address();
+        const display = typeof address === "object" && address
+            ? `${address.address}:${address.port}`
+            : `${hostname}:${port}`;
+        logger(`hypequery dev server running at http://${display}`);
+        logger(`Docs available at http://${display}/docs`);
+    }
+    return server;
+};

package/dist/docs-ui.d.ts

@@ -0,0 +1,3 @@
+import type { DocsOptions } from "./types.js";
+export declare const buildDocsHtml: (openapiUrl: string, options?: DocsOptions) => string;
+//# sourceMappingURL=docs-ui.d.ts.map

package/dist/docs-ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs-ui.d.ts","sourceRoot":"","sources":["../src/docs-ui.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAO9C,eAAO,MAAM,aAAa,GAAI,YAAY,MAAM,EAAE,UAAU,WAAW,WAgCtE,CAAC"}

package/dist/docs-ui.js

@@ -0,0 +1,34 @@
+const REDOC_CDN = "https://cdn.jsdelivr.net/npm/redoc@latest/bundles/redoc.standalone.js";
+const sanitize = (value, fallback = "") => (value ?? fallback).replace(/</g, "&lt;").replace(/>/g, "&gt;");
+export const buildDocsHtml = (openapiUrl, options) => {
+    const title = sanitize(options?.title, "hypequery");
+    const subtitle = sanitize(options?.subtitle);
+    const darkClass = options?.darkMode ? "hq-docs--dark" : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${title}</title>
+    <style>
+      body, html { margin: 0; padding: 0; height: 100%; font-family: Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+      .hq-docs { display: flex; flex-direction: column; height: 100%; }
+      .hq-docs__header { padding: 1.25rem 1.5rem; border-bottom: 1px solid rgba(0,0,0,0.08); }
+      .hq-docs--dark .hq-docs__header { border-color: rgba(255,255,255,0.12); }
+      .hq-docs__title { margin: 0; font-size: 1.25rem; }
+      .hq-docs__subtitle { margin: 0.25rem 0 0; color: #555; }
+      .hq-docs--dark { background: #0f1115; color: #f8f8f2; }
+      .hq-docs--dark .hq-docs__subtitle { color: #b4b6c2; }
+      redoc { flex: 1; }
+    </style>
+  </head>
+  <body class="hq-docs ${darkClass}">
+    <header class="hq-docs__header">
+      <h1 class="hq-docs__title">${title}</h1>
+      ${subtitle ? `<p class="hq-docs__subtitle">${subtitle}</p>` : ""}
+    </header>
+    <redoc spec-url="${openapiUrl}"></redoc>
+    <script src="${REDOC_CDN}"></script>
+  </body>
+</html>`;
+};

package/dist/endpoint.d.ts

@@ -0,0 +1,5 @@
+import type { AuthContext, ServeEndpoint, ServeQueryConfig } from "./types.js";
+type EndpointFromDefinition<TDefinition extends ServeQueryConfig<any, any, TContext, TAuth, any>, TContext extends Record<string, unknown>, TAuth extends AuthContext> = TDefinition extends ServeQueryConfig<infer TInputSchema, infer TOutputSchema, TContext, TAuth, infer TResult> ? ServeEndpoint<TInputSchema, TOutputSchema, TContext, TAuth, TResult> : ServeEndpoint<any, any, TContext, TAuth>;
+export declare const createEndpoint: <TContext extends Record<string, unknown>, TAuth extends AuthContext, TDefinition extends ServeQueryConfig<any, any, TContext, TAuth, any>>(key: string, definition: TDefinition) => EndpointFromDefinition<TDefinition, TContext, TAuth>;
+export {};
+//# sourceMappingURL=endpoint.d.ts.map

package/dist/endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint.d.ts","sourceRoot":"","sources":["../src/endpoint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EAUX,aAAa,EACb,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAIpB,KAAK,sBAAsB,CACzB,WAAW,SAAS,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,EACpE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,IACvB,WAAW,SAAS,gBAAgB,CACtC,MAAM,YAAY,EAClB,MAAM,aAAa,EACnB,QAAQ,EACR,KAAK,EACL,MAAM,OAAO,CACd,GACG,aAAa,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,GACpE,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AA8B7C,eAAO,MAAM,cAAc,GACzB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,EACzB,WAAW,SAAS,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,EAEpE,KAAK,MAAM,EACX,YAAY,WAAW,KACtB,sBAAsB,CAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,CAsDrD,CAAC"}