@hypequery/serve 0.0.7 → 0.0.9

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,192 @@
+import type { AuthContext, AuthContextWithRoles, AuthContextWithScopes, AuthStrategy, ServeMiddleware, 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>;
+/**
+ * Result of an authorization check.
+ * Returns { ok: true } if authorization succeeds, or { ok: false, missing } with details.
+ */
+export type AuthorizationResult = {
+    ok: true;
+} | {
+    ok: false;
+    missing: string[];
+    reason: 'MISSING_ROLE' | 'MISSING_SCOPE';
+};
+/**
+ * Check if the authenticated user has at least one of the required roles (OR semantics).
+ *
+ * @param auth - The auth context from the request
+ * @param requiredRoles - Array of role names, any one of which grants access
+ * @returns { ok: true } if user has a role, or { ok: false, missing, reason } with details
+ *
+ * @example
+ * ```ts
+ * const result = checkRoleAuthorization(auth, ['admin', 'editor']);
+ * if (!result.ok) {
+ *   console.log('Missing roles:', result.missing); // ['admin', 'editor'] (all required)
+ * }
+ * ```
+ */
+export declare const checkRoleAuthorization: (auth: AuthContext | null, requiredRoles: string[]) => AuthorizationResult;
+/**
+ * Check if the authenticated user has all of the required scopes (AND semantics).
+ *
+ * @param auth - The auth context from the request
+ * @param requiredScopes - Array of scope names, all of which are required
+ * @returns { ok: true } if user has all scopes, or { ok: false, missing, reason } with details
+ *
+ * @example
+ * ```ts
+ * const result = checkScopeAuthorization(auth, ['read:metrics', 'write:metrics']);
+ * if (!result.ok) {
+ *   console.log('Missing scopes:', result.missing); // ['read:metrics', 'write:metrics'] (all required)
+ * }
+ * ```
+ */
+export declare const checkScopeAuthorization: (auth: AuthContext | null, requiredScopes: string[]) => AuthorizationResult;
+/**
+ * Middleware that requires the user to be authenticated.
+ * Returns 401 if no auth context is present.
+ *
+ * @deprecated Use `query.requireAuth()` instead for per-endpoint authentication.
+ *             This middleware is kept for complex use cases where guards aren't suitable.
+ *             See: https://hypequery.com/docs/serve/authentication#middleware-helpers
+ *
+ * Use this as a global middleware via `api.use(requireAuthMiddleware())`.
+ * For per-query guards, prefer `query.requireAuth()`.
+ */
+export declare const requireAuthMiddleware: <TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext>() => ServeMiddleware<any, any, TContext, TAuth>;
+/**
+ * Middleware that requires the user to have at least one of the specified roles.
+ * Returns 403 if the user lacks the required role.
+ *
+ * @deprecated Use `query.requireRole(...)` instead for per-endpoint authorization.
+ *             This middleware is kept for complex use cases where guards aren't suitable.
+ *             See: https://hypequery.com/docs/serve/authentication#middleware-helpers
+ *
+ * Use this as a global or per-query middleware via `api.use(requireRoleMiddleware('admin'))`.
+ * For per-query guards, prefer `query.requireRole('admin')`.
+ */
+export declare const requireRoleMiddleware: <TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext>(...roles: string[]) => ServeMiddleware<any, any, TContext, TAuth>;
+/**
+ * Middleware that requires the user to have all of the specified scopes.
+ * Returns 403 if the user lacks a required scope.
+ *
+ * @deprecated Use `query.requireScope(...)` instead for per-endpoint authorization.
+ *             This middleware is kept for complex use cases where guards aren't suitable.
+ *             See: https://hypequery.com/docs/serve/authentication#middleware-helpers
+ *
+ * Use this as a global or per-query middleware via `api.use(requireScopeMiddleware('read:metrics'))`.
+ * For per-query guards, prefer `query.requireScope('read:metrics')`.
+ */
+export declare const requireScopeMiddleware: <TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext>(...scopes: string[]) => ServeMiddleware<any, any, TContext, TAuth>;
+/**
+ * Configuration options for creating a typed auth system.
+ * Enables compile-time safety for roles and scopes.
+ */
+export interface CreateAuthSystemOptions<TRoles extends string = string, TScopes extends string = string> {
+    /**
+     * List of valid roles for your application.
+     * @example
+     * ```ts
+     * roles: ['admin', 'editor', 'viewer'] as const
+     * ```
+     */
+    roles?: readonly TRoles[];
+    /**
+     * List of valid scopes for your application.
+     * @example
+     * ```ts
+     * scopes: ['read:metrics', 'write:metrics', 'delete:metrics'] as const
+     * ```
+     */
+    scopes?: readonly TScopes[];
+}
+/**
+ * Result type from createAuthSystem.
+ * Combines role and scope constraints into a single auth context type.
+ */
+export type TypedAuthContext<TRoles extends string, TScopes extends string> = AuthContextWithRoles<TRoles> & AuthContextWithScopes<TScopes>;
+/**
+ * Creates a typed auth system with compile-time role and scope safety.
+ *
+ * This helper provides:
+ * - Type-safe auth context (combines AuthContextWithRoles and AuthContextWithScopes)
+ * - A `useAuth` wrapper for auth strategies
+ * - Helper to extract the typed auth type
+ *
+ * @example
+ * ```ts
+ * import { createAuthSystem, defineServe, query } from '@hypequery/serve';
+ *
+ * // Define your roles and scopes up front
+ * const { useAuth, TypedAuth } = createAuthSystem({
+ *   roles: ['admin', 'editor', 'viewer'] as const,
+ *   scopes: ['read:metrics', 'write:metrics', 'delete:metrics'] as const,
+ * });
+ *
+ * // Extract the typed auth type for use with defineServe
+ * type AppAuth = TypedAuth;
+ *
+ * const api = defineServe<AppAuth>({
+ *   auth: useAuth(jwtStrategy),
+ *   queries: {
+ *     adminOnly: query.requireRole('admin').query(async ({ ctx }) => {
+ *       // ✅ TypeScript autocomplete for 'admin'
+ *       // ❌ Compile error on typo like 'admn'
+ *       return { secret: true };
+ *     }),
+ *     writeData: query.requireScope('write:metrics').query(async ({ ctx }) => {
+ *       // ✅ TypeScript autocomplete for 'write:metrics'
+ *       return { success: true };
+ *     }),
+ *   },
+ * });
+ * ```
+ */
+export declare const createAuthSystem: <TRoles extends string = string, TScopes extends string = string>(options?: CreateAuthSystemOptions<TRoles, TScopes>) => {
+    /**
+     * Type-safe wrapper for auth strategies.
+     * Ensures the strategy returns auth context with the correct role/scope types.
+     *
+     * @example
+     * ```ts
+     * const jwtStrategy: AuthStrategy<AppAuth> = async ({ request }) => {
+     *   const token = request.headers.authorization?.slice(7);
+     *   const payload = await verifyJwt(token);
+     *   return {
+     *     userId: payload.sub,
+     *     roles: payload.roles, // ✅ Type-checked against ['admin', 'editor', 'viewer']
+     *     scopes: payload.scopes, // ✅ Type-checked against ['read:metrics', 'write:metrics']
+     *   };
+     * };
+     *
+     * const api = defineServe<AppAuth>({
+     *   auth: useAuth(jwtStrategy),
+     *   // ...
+     * });
+     * ```
+     */
+    useAuth: <TAuth extends AuthContext>(strategy: AuthStrategy<TAuth>) => AuthStrategy<TAuth>;
+    /**
+     * The combined typed auth context type.
+     * Use this to type your defineServe generic parameter.
+     *
+     * @example
+     * ```ts
+     * type AppAuth = typeof TypedAuth;
+     * ```
+     */
+    TypedAuth: TypedAuthContext<TRoles, TScopes>;
+};
+//# 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":"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"}