@hypequery/serve 0.0.2 → 0.0.5

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/pipeline.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import type { AuthContext, AuthStrategy, DocsOptions, OpenApiOptions, ServeContextFactory, ServeEndpoint, ServeHandler, ServeLifecycleHooks, ServeMiddleware, ServeRequest, ServeResponse, TenantConfig } from './types.js';
+export interface ExecuteEndpointOptions<TContext extends Record<string, unknown>, TAuth extends AuthContext> {
+    endpoint: ServeEndpoint<any, any, TContext, TAuth>;
+    request: ServeRequest;
+    requestId?: string;
+    authStrategies: AuthStrategy<TAuth>[];
+    contextFactory?: ServeContextFactory<TContext, TAuth>;
+    globalMiddlewares: ServeMiddleware<any, any, TContext, TAuth>[];
+    tenantConfig?: TenantConfig<TAuth>;
+    hooks?: ServeLifecycleHooks<TAuth>;
+    additionalContext?: Partial<TContext>;
+}
+export declare const executeEndpoint: <TContext extends Record<string, unknown>, TAuth extends AuthContext>(options: ExecuteEndpointOptions<TContext, TAuth>) => Promise<ServeResponse>;
+interface HandlerOptions<TContext extends Record<string, unknown>, TAuth extends AuthContext> {
+    router: import('./router.js').ServeRouter;
+    globalMiddlewares: ServeMiddleware<any, any, TContext, TAuth>[];
+    authStrategies: AuthStrategy<TAuth>[];
+    tenantConfig?: TenantConfig<TAuth>;
+    contextFactory?: ServeContextFactory<TContext, TAuth>;
+    hooks?: ServeLifecycleHooks<TAuth>;
+}
+export declare const createServeHandler: <TContext extends Record<string, unknown>, TAuth extends AuthContext>({ router, globalMiddlewares, authStrategies, tenantConfig, contextFactory, hooks, }: HandlerOptions<TContext, TAuth>) => ServeHandler;
+export declare const createOpenApiEndpoint: (path: string, getEndpoints: () => ServeEndpoint<any, any, any, any>[], options?: OpenApiOptions) => {
+    key: string;
+    method: "GET";
+    inputSchema: undefined;
+    outputSchema: z.ZodAny;
+    handler: () => Promise<unknown>;
+    query: undefined;
+    middlewares: never[];
+    auth: null;
+    metadata: {
+        path: string;
+        method: "GET";
+        name: string;
+        summary: string;
+        description: string;
+        tags: string[];
+        requiresAuth: false;
+        deprecated: false;
+        visibility: "internal";
+    };
+    cacheTtlMs: null;
+};
+export declare const createDocsEndpoint: (path: string, openapiPath: string, options?: DocsOptions) => {
+    key: string;
+    method: "GET";
+    inputSchema: undefined;
+    outputSchema: z.ZodString;
+    handler: () => Promise<string>;
+    query: undefined;
+    middlewares: never[];
+    auth: null;
+    metadata: {
+        path: string;
+        method: "GET";
+        name: string;
+        summary: string;
+        description: string;
+        tags: string[];
+        requiresAuth: false;
+        deprecated: false;
+        visibility: "internal";
+    };
+    cacheTtlMs: null;
+    defaultHeaders: {
+        'content-type': string;
+    };
+};
+export {};
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAmB,MAAM,KAAK,CAAC;AAEzC,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EAKX,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,YAAY,EACZ,aAAa,EACb,YAAY,EAEb,MAAM,YAAY,CAAC;AAiIpB,MAAM,WAAW,sBAAsB,CACrC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW;IAEzB,QAAQ,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACnD,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;IACtC,cAAc,CAAC,EAAE,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACtD,iBAAiB,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC;IAChE,YAAY,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,CAAC,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACnC,iBAAiB,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACvC;AAED,eAAO,MAAM,eAAe,GAC1B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,EAEzB,SAAS,sBAAsB,CAAC,QAAQ,EAAE,KAAK,CAAC,KAC/C,OAAO,CAAC,aAAa,CA0LvB,CAAC;AAEF,UAAU,cAAc,CACtB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW;IAEzB,MAAM,EAAE,OAAO,aAAa,EAAE,WAAW,CAAC;IAC1C,iBAAiB,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC;IAChE,cAAc,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;IACtC,YAAY,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,cAAc,CAAC,EAAE,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACtD,KAAK,CAAC,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,EACzB,qFAOC,cAAc,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAG,YAqBpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,cAAc,MAAM,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EACvD,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;CA8BzB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,MAAM,MAAM,EACZ,aAAa,MAAM,EACnB,UAAU,WAAW;;;;;;;;;;;;;;;;;;;;;;;;CAyBmD,CAAC"}

package/dist/pipeline.js

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+import { createTenantScope, warnTenantMisconfiguration } from './tenant.js';
+import { generateRequestId } from './utils.js';
+import { buildOpenApiDocument } from './openapi.js';
+import { buildDocsHtml } from './docs-ui.js';
+const safeInvokeHook = async (name, hook, payload) => {
+    if (!hook)
+        return;
+    try {
+        await hook(payload);
+    }
+    catch (error) {
+        console.error(`[hypequery/serve] ${name} hook failed`, error);
+    }
+};
+const createErrorResponse = (status, type, message, details) => ({
+    status,
+    body: { error: { type, message, ...(details ? { details } : {}) } },
+});
+const buildContextInput = (request) => {
+    if (request.body !== undefined && request.body !== null) {
+        return request.body;
+    }
+    if (request.query && Object.keys(request.query).length > 0) {
+        return request.query;
+    }
+    return {};
+};
+const runMiddlewares = async (middlewares, ctx, handler) => {
+    let current = handler;
+    for (let i = middlewares.length - 1; i >= 0; i -= 1) {
+        const middleware = middlewares[i];
+        const next = current;
+        current = () => middleware(ctx, next);
+    }
+    return current();
+};
+const authenticateRequest = async (strategies, request, metadata) => {
+    for (const strategy of strategies) {
+        const result = await strategy({ request, endpoint: metadata });
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+};
+const gatherAuthStrategies = (endpointStrategy, globalStrategies) => {
+    const combined = [];
+    if (endpointStrategy)
+        combined.push(endpointStrategy);
+    combined.push(...globalStrategies);
+    return combined;
+};
+const computeRequiresAuth = (metadata, endpointStrategy, globalStrategies) => {
+    if (typeof metadata.requiresAuth === 'boolean') {
+        return metadata.requiresAuth;
+    }
+    if (endpointStrategy) {
+        return true;
+    }
+    return globalStrategies.length > 0;
+};
+const validateInput = (schema, payload) => {
+    if (!schema) {
+        return { success: true, data: payload };
+    }
+    const result = schema.safeParse(payload);
+    return result.success
+        ? { success: true, data: result.data }
+        : { success: false, error: result.error };
+};
+const cloneContext = (ctx) => (ctx ? { ...ctx } : {});
+const resolveContext = async (factory, request, auth) => {
+    if (!factory) {
+        return {};
+    }
+    if (typeof factory === 'function') {
+        const value = await factory({ request, auth });
+        return cloneContext(value);
+    }
+    return cloneContext(factory);
+};
+const resolveRequestId = (request, provided) => provided ?? request.headers['x-request-id'] ?? request.headers['x-trace-id'] ?? generateRequestId();
+export const executeEndpoint = async (options) => {
+    const { endpoint, request, requestId: explicitRequestId, authStrategies, contextFactory, globalMiddlewares, tenantConfig, hooks = {}, additionalContext, } = options;
+    const requestId = resolveRequestId(request, explicitRequestId);
+    const locals = {};
+    let cacheTtlMs = endpoint.cacheTtlMs ?? null;
+    const setCacheTtl = (ttl) => {
+        cacheTtlMs = ttl;
+    };
+    const context = {
+        request,
+        input: buildContextInput(request),
+        auth: null,
+        metadata: endpoint.metadata,
+        locals,
+        setCacheTtl,
+    };
+    const startedAt = Date.now();
+    await safeInvokeHook('onRequestStart', hooks.onRequestStart, {
+        requestId,
+        queryKey: endpoint.key,
+        metadata: endpoint.metadata,
+        request,
+        auth: context.auth,
+    });
+    try {
+        const endpointAuth = endpoint.auth ?? null;
+        const strategies = gatherAuthStrategies(endpointAuth, authStrategies ?? []);
+        const requiresAuth = computeRequiresAuth(endpoint.metadata, endpointAuth, authStrategies ?? []);
+        const metadataWithAuth = {
+            ...endpoint.metadata,
+            requiresAuth,
+        };
+        context.metadata = metadataWithAuth;
+        const authContext = await authenticateRequest(strategies, request, metadataWithAuth);
+        if (!authContext && requiresAuth) {
+            await safeInvokeHook('onAuthFailure', hooks.onAuthFailure, {
+                requestId,
+                queryKey: endpoint.key,
+                metadata: metadataWithAuth,
+                request,
+                auth: context.auth,
+                reason: 'MISSING',
+            });
+            return createErrorResponse(401, 'UNAUTHORIZED', 'Authentication required', {
+                reason: 'missing_credentials',
+                strategies_attempted: strategies.length,
+                endpoint: endpoint.metadata.path,
+            });
+        }
+        context.auth = authContext;
+        const resolvedContext = await resolveContext(contextFactory, request, authContext);
+        Object.assign(context, resolvedContext, additionalContext);
+        const activeTenantConfig = endpoint.tenant ?? tenantConfig;
+        if (activeTenantConfig) {
+            const tenantRequired = activeTenantConfig.required !== false;
+            const tenantId = authContext ? activeTenantConfig.extract(authContext) : null;
+            if (!tenantId && tenantRequired) {
+                const errorMessage = activeTenantConfig.errorMessage ??
+                    'Tenant context is required but could not be determined from authentication';
+                await safeInvokeHook('onError', hooks.onError, {
+                    requestId,
+                    queryKey: endpoint.key,
+                    metadata: metadataWithAuth,
+                    request,
+                    auth: context.auth,
+                    durationMs: Date.now() - startedAt,
+                    error: new Error(errorMessage),
+                });
+                return createErrorResponse(403, 'UNAUTHORIZED', errorMessage, {
+                    reason: 'missing_tenant_context',
+                    tenant_required: true,
+                });
+            }
+            if (tenantId) {
+                context.tenantId = tenantId;
+                const mode = activeTenantConfig.mode ?? 'manual';
+                const column = activeTenantConfig.column;
+                if (mode === 'auto-inject' && column) {
+                    const contextValues = context;
+                    for (const key of Object.keys(contextValues)) {
+                        const value = contextValues[key];
+                        if (value && typeof value === 'object' && 'table' in value && typeof value.table === 'function') {
+                            contextValues[key] = createTenantScope(value, {
+                                tenantId,
+                                column,
+                            });
+                        }
+                    }
+                }
+                else if (mode === 'manual') {
+                    warnTenantMisconfiguration({
+                        queryKey: endpoint.key,
+                        hasTenantConfig: true,
+                        hasTenantId: true,
+                        mode: 'manual',
+                    });
+                }
+            }
+            else if (!tenantRequired) {
+                warnTenantMisconfiguration({
+                    queryKey: endpoint.key,
+                    hasTenantConfig: true,
+                    hasTenantId: false,
+                    mode: activeTenantConfig.mode,
+                });
+            }
+        }
+        const validationResult = validateInput(endpoint.inputSchema, context.input);
+        if (!validationResult.success) {
+            await safeInvokeHook('onError', hooks.onError, {
+                requestId,
+                queryKey: endpoint.key,
+                metadata: metadataWithAuth,
+                request,
+                auth: context.auth,
+                durationMs: Date.now() - startedAt,
+                error: validationResult.error,
+            });
+            return createErrorResponse(400, 'VALIDATION_ERROR', 'Request validation failed', {
+                issues: validationResult.error.issues,
+            });
+        }
+        context.input = validationResult.data;
+        const pipeline = [
+            ...(globalMiddlewares ?? []),
+            ...endpoint.middlewares,
+        ];
+        const result = await runMiddlewares(pipeline, context, () => endpoint.handler(context));
+        const headers = { ...(endpoint.defaultHeaders ?? {}) };
+        if (typeof cacheTtlMs === 'number') {
+            headers['cache-control'] = cacheTtlMs > 0 ? `public, max-age=${Math.floor(cacheTtlMs / 1000)}` : 'no-store';
+        }
+        const durationMs = Date.now() - startedAt;
+        await safeInvokeHook('onRequestEnd', hooks.onRequestEnd, {
+            requestId,
+            queryKey: endpoint.key,
+            metadata: metadataWithAuth,
+            request,
+            auth: context.auth,
+            durationMs,
+            result,
+        });
+        return {
+            status: 200,
+            headers,
+            body: result,
+        };
+    }
+    catch (error) {
+        await safeInvokeHook('onError', hooks.onError, {
+            requestId,
+            queryKey: endpoint.key,
+            metadata: context.metadata,
+            request,
+            auth: context.auth,
+            durationMs: Date.now() - startedAt,
+            error,
+        });
+        const message = error instanceof Error ? error.message : 'Unexpected error';
+        return createErrorResponse(500, 'INTERNAL_SERVER_ERROR', message);
+    }
+};
+export const createServeHandler = ({ router, globalMiddlewares, authStrategies, tenantConfig, contextFactory, hooks, }) => {
+    return async (request) => {
+        const endpoint = router.match(request.method, request.path);
+        if (!endpoint) {
+            return createErrorResponse(404, 'NOT_FOUND', `No endpoint registered for ${request.method} ${request.path}`);
+        }
+        return executeEndpoint({
+            endpoint,
+            request,
+            authStrategies,
+            contextFactory,
+            globalMiddlewares,
+            tenantConfig,
+            hooks,
+        });
+    };
+};
+export const createOpenApiEndpoint = (path, getEndpoints, options) => {
+    let cachedDocument = null;
+    return {
+        key: '__hypequery_openapi__',
+        method: 'GET',
+        inputSchema: undefined,
+        outputSchema: z.any(),
+        handler: async () => {
+            if (!cachedDocument) {
+                cachedDocument = buildOpenApiDocument(getEndpoints(), options);
+            }
+            return cachedDocument;
+        },
+        query: undefined,
+        middlewares: [],
+        auth: null,
+        metadata: {
+            path,
+            method: 'GET',
+            name: 'OpenAPI schema',
+            summary: 'OpenAPI schema',
+            description: 'Generated OpenAPI specification for the registered endpoints',
+            tags: ['docs'],
+            requiresAuth: false,
+            deprecated: false,
+            visibility: 'internal',
+        },
+        cacheTtlMs: null,
+    };
+};
+export const createDocsEndpoint = (path, openapiPath, options) => ({
+    key: '__hypequery_docs__',
+    method: 'GET',
+    inputSchema: undefined,
+    outputSchema: z.string(),
+    handler: async () => buildDocsHtml(openapiPath, options),
+    query: undefined,
+    middlewares: [],
+    auth: null,
+    metadata: {
+        path,
+        method: 'GET',
+        name: 'Docs',
+        summary: 'API documentation',
+        description: 'Auto-generated documentation for your hypequery endpoints',
+        tags: ['docs'],
+        requiresAuth: false,
+        deprecated: false,
+        visibility: 'internal',
+    },
+    cacheTtlMs: null,
+    defaultHeaders: {
+        'content-type': 'text/html; charset=utf-8',
+    },
+});

package/dist/query-logger.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Backend-agnostic query event logger for the serve layer.
+ *
+ * Fires for every endpoint execution regardless of the underlying
+ * query backend (ClickHouse, BigQuery, mock data, etc.).
+ */
+/**
+ * Event emitted by the serve-layer query logger.
+ */
+export interface ServeQueryEvent {
+    requestId: string;
+    endpointKey: string;
+    path: string;
+    method: string;
+    status: 'started' | 'completed' | 'error';
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    input?: unknown;
+    responseStatus?: number;
+    error?: Error;
+    result?: unknown;
+}
+/**
+ * Callback for serve query events.
+ */
+export type ServeQueryEventCallback = (event: ServeQueryEvent) => void;
+/**
+ * Serve-layer query event emitter.
+ *
+ * Created per `defineServe()` call — not a singleton.
+ * Emits events at the request lifecycle level so that dev tools,
+ * logging, and analytics work with any query backend.
+ */
+export declare class ServeQueryLogger {
+    private listeners;
+    /**
+     * Subscribe to query events.
+     * @returns Unsubscribe function.
+     */
+    on(callback: ServeQueryEventCallback): () => void;
+    /**
+     * Emit a query event to all listeners.
+     */
+    emit(event: ServeQueryEvent): void;
+    /**
+     * Number of active listeners.
+     */
+    get listenerCount(): number;
+    /**
+     * Remove all listeners.
+     */
+    removeAll(): void;
+}
+/**
+ * Format a query event as a human-readable log line.
+ * Returns null for 'started' events (only logs completions).
+ */
+export declare function formatQueryEvent(event: ServeQueryEvent): string | null;
+/**
+ * Format a query event as a structured JSON string for log aggregators.
+ * Returns null for 'started' events (only logs completions).
+ */
+export declare function formatQueryEventJSON(event: ServeQueryEvent): string | null;
+//# sourceMappingURL=query-logger.d.ts.map

package/dist/query-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-logger.d.ts","sourceRoot":"","sources":["../src/query-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAEvE;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAsC;IAEvD;;;OAGG;IACH,EAAE,CAAC,QAAQ,EAAE,uBAAuB,GAAG,MAAM,IAAI;IAOjD;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAUlC;;OAEG;IACH,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED;;OAEG;IACH,SAAS,IAAI,IAAI;CAGlB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAYtE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAiB1E"}

package/dist/query-logger.js

@@ -0,0 +1,91 @@
+/**
+ * Backend-agnostic query event logger for the serve layer.
+ *
+ * Fires for every endpoint execution regardless of the underlying
+ * query backend (ClickHouse, BigQuery, mock data, etc.).
+ */
+/**
+ * Serve-layer query event emitter.
+ *
+ * Created per `defineServe()` call — not a singleton.
+ * Emits events at the request lifecycle level so that dev tools,
+ * logging, and analytics work with any query backend.
+ */
+export class ServeQueryLogger {
+    constructor() {
+        this.listeners = new Set();
+    }
+    /**
+     * Subscribe to query events.
+     * @returns Unsubscribe function.
+     */
+    on(callback) {
+        this.listeners.add(callback);
+        return () => {
+            this.listeners.delete(callback);
+        };
+    }
+    /**
+     * Emit a query event to all listeners.
+     */
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Ignore listener errors
+            }
+        }
+    }
+    /**
+     * Number of active listeners.
+     */
+    get listenerCount() {
+        return this.listeners.size;
+    }
+    /**
+     * Remove all listeners.
+     */
+    removeAll() {
+        this.listeners.clear();
+    }
+}
+/**
+ * Format a query event as a human-readable log line.
+ * Returns null for 'started' events (only logs completions).
+ */
+export function formatQueryEvent(event) {
+    if (event.status === 'started')
+        return null;
+    const status = event.status === 'completed' ? '✓' : '✗';
+    const duration = event.durationMs != null ? `${event.durationMs}ms` : '?';
+    const code = event.responseStatus ?? (event.status === 'error' ? 500 : 200);
+    let line = `  ${status} ${event.method} ${event.path} → ${code} (${duration})`;
+    if (event.status === 'error' && event.error) {
+        line += ` — ${event.error.message}`;
+    }
+    return line;
+}
+/**
+ * Format a query event as a structured JSON string for log aggregators.
+ * Returns null for 'started' events (only logs completions).
+ */
+export function formatQueryEventJSON(event) {
+    if (event.status === 'started')
+        return null;
+    return JSON.stringify({
+        level: event.status === 'error' ? 'error' : 'info',
+        msg: `${event.method} ${event.path}`,
+        requestId: event.requestId,
+        endpoint: event.endpointKey,
+        path: event.path,
+        method: event.method,
+        status: event.responseStatus ?? (event.status === 'error' ? 500 : 200),
+        durationMs: event.durationMs,
+        ...(event.status === 'error' && event.error
+            ? { error: event.error.message }
+            : {}),
+        timestamp: new Date(event.endTime ?? event.startTime).toISOString(),
+    });
+}

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,WAAW,EAaX,YAAY,EACZ,WAAW,EACX,mBAAmB,EAEnB,gBAAgB,EAEhB,gBAAgB,EAGhB,eAAe,EAShB,MAAM,YAAY,CAAC;AA0iBpB,eAAO,MAAM,WAAW,GACtB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,KAAK,CAAC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAE1F,QAAQ,WAAW,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,KAC7C,YAAY,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CAkM3E,CAAC;AA8BF,KAAK,uBAAuB,CAC1B,QAAQ,EACR,KAAK,SAAS,WAAW,IACvB,QAAQ,SAAS,mBAAmB,CAAC,MAAM,QAAQ,EAAE,KAAK,CAAC,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEnF,KAAK,uBAAuB,CAC1B,QAAQ,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAChD,KAAK,SAAS,WAAW,IACvB,IAAI,CACN,WAAW,CACT,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EACxC,KAAK,EACL,eAAe,CAAC,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CACjE,EACD,SAAS,GAAG,SAAS,CACtB,GAAG;IAAE,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;AAQ1B,eAAO,MAAM,SAAS,GACpB,QAAQ,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAChD,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,SAAS,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAG,gBAAgB,CACpE,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EACxC,KAAK,CAsBN,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,WAAW,EAIX,YAAY,EACZ,WAAW,EACX,mBAAmB,EAEnB,gBAAgB,EAEhB,gBAAgB,EAIhB,eAAe,EAMhB,MAAM,YAAY,CAAC;AAWpB,eAAO,MAAM,WAAW,GACtB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,KAAK,CAAC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAE1F,QAAQ,WAAW,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,KAC7C,YAAY,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CAgL3E,CAAC;AA8BF,KAAK,uBAAuB,CAC1B,QAAQ,EACR,KAAK,SAAS,WAAW,IACvB,QAAQ,SAAS,mBAAmB,CAAC,MAAM,QAAQ,EAAE,KAAK,CAAC,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEnF,KAAK,uBAAuB,CAC1B,QAAQ,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAChD,KAAK,SAAS,WAAW,IACvB,IAAI,CACN,WAAW,CACT,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EACxC,KAAK,EACL,eAAe,CAAC,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CACjE,EACD,SAAS,GAAG,SAAS,CACtB,GAAG;IAAE,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;AAQ1B,eAAO,MAAM,SAAS,GACpB,QAAQ,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAChD,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,SAAS,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAG,gBAAgB,CACpE,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EACxC,KAAK,CAsBN,CAAC"}

package/dist/server.js

@@ -1,394 +1,12 @@
-import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { startNodeServer } from "./adapters/node.js";
 import { createEndpoint } from "./endpoint.js";
-import { buildOpenApiDocument } from "./openapi.js";
 import { applyBasePath, normalizeRoutePath, ServeRouter } from "./router.js";
-import { buildDocsHtml } from "./docs-ui.js";
-import { createTenantScope, warnTenantMisconfiguration } from "./tenant.js";
-const ensureArray = (value) => {
-    if (!value) {
-        return [];
-    }
-    return Array.isArray(value) ? value : [value];
-};
-const generateRequestId = () => {
-    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-};
-const createProcedureBuilder = () => {
-    const build = (state) => {
-        return {
-            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: Array.from(new Set([...state.tags, tag])),
-            }),
-            tags: (tags) => build({
-                ...state,
-                tags: Array.from(new Set([...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 base = {
-                    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 base;
-            },
-        };
-    };
-    return build({ tags: [], middlewares: [] });
-};
-const getRequestId = (request) => {
-    return (request.headers["x-request-id"] ??
-        request.headers["x-trace-id"] ??
-        generateRequestId());
-};
-const safeInvokeHook = async (name, hook, payload) => {
-    if (!hook) {
-        return;
-    }
-    try {
-        await hook(payload);
-    }
-    catch (error) {
-        console.error(`[hypequery/serve] ${name} hook failed`, error);
-    }
-};
-const mergeTags = (existing, next) => {
-    const merged = [...existing, ...(next ?? [])];
-    return Array.from(new Set(merged.filter(Boolean)));
-};
-const createErrorResponse = (status, type, message, details) => {
-    return {
-        status,
-        body: {
-            error: {
-                type,
-                message,
-                ...(details ? { details } : {}),
-            },
-        },
-    };
-};
-const buildContextInput = (request) => {
-    if (request.body !== undefined && request.body !== null) {
-        return request.body;
-    }
-    if (request.query && Object.keys(request.query).length > 0) {
-        return request.query;
-    }
-    return {};
-};
-const runMiddlewares = async (middlewares, ctx, handler) => {
-    let index = middlewares.length - 1;
-    let next = handler;
-    while (index >= 0) {
-        const middleware = middlewares[index];
-        const downstream = next;
-        next = () => middleware(ctx, downstream);
-        index -= 1;
-    }
-    return next();
-};
-const authenticateRequest = async (strategies, request, metadata) => {
-    for (const strategy of strategies) {
-        const result = await strategy({
-            request,
-            endpoint: metadata,
-        });
-        if (result) {
-            return result;
-        }
-    }
-    return null;
-};
-const gatherAuthStrategies = (endpointStrategy, globalStrategies) => {
-    const strategies = [];
-    if (endpointStrategy) {
-        strategies.push(endpointStrategy);
-    }
-    return [...strategies, ...globalStrategies];
-};
-const computeRequiresAuth = (metadata, endpointStrategy, globalStrategies) => {
-    if (typeof metadata.requiresAuth === "boolean") {
-        return metadata.requiresAuth;
-    }
-    if (endpointStrategy) {
-        return true;
-    }
-    return globalStrategies.length > 0;
-};
-const validateInput = (schema, payload) => {
-    if (!schema) {
-        return { success: true, data: payload };
-    }
-    const result = schema.safeParse(payload);
-    return result.success
-        ? { success: true, data: result.data }
-        : { success: false, error: result.error };
-};
-const createOpenApiEndpoint = (path, getEndpoints, openapiOptions) => {
-    // Cache the OpenAPI document to avoid rebuilding on every request
-    let cachedDocument = null;
-    return {
-        key: "__hypequery_openapi__",
-        method: "GET",
-        inputSchema: undefined,
-        outputSchema: z.any(),
-        handler: async () => {
-            if (!cachedDocument) {
-                cachedDocument = buildOpenApiDocument(getEndpoints(), openapiOptions);
-            }
-            return cachedDocument;
-        },
-        query: undefined,
-        middlewares: [],
-        auth: null,
-        metadata: {
-            path,
-            method: "GET",
-            name: "OpenAPI schema",
-            summary: "OpenAPI schema",
-            description: "Generated OpenAPI specification for the registered endpoints",
-            tags: ["docs"],
-            requiresAuth: false,
-            deprecated: false,
-            visibility: "internal",
-        },
-        cacheTtlMs: null,
-    };
-};
-const createDocsEndpoint = (path, openapiPath, options) => ({
-    key: "__hypequery_docs__",
-    method: "GET",
-    inputSchema: undefined,
-    outputSchema: z.string(),
-    handler: async () => buildDocsHtml(openapiPath, options),
-    query: undefined,
-    middlewares: [],
-    auth: null,
-    metadata: {
-        path,
-        method: "GET",
-        name: "Docs",
-        summary: "API documentation",
-        description: "Auto-generated documentation for your hypequery endpoints",
-        tags: ["docs"],
-        requiresAuth: false,
-        deprecated: false,
-        visibility: "internal",
-    },
-    cacheTtlMs: null,
-    defaultHeaders: {
-        "content-type": "text/html; charset=utf-8",
-    },
-});
-const cloneContext = (ctx) => (ctx ? { ...ctx } : {});
-const resolveContext = async (factory, request, auth) => {
-    if (!factory) {
-        return {};
-    }
-    if (typeof factory === "function") {
-        const value = await factory({ request, auth });
-        return cloneContext(value);
-    }
-    return cloneContext(factory);
-};
-const executeEndpoint = async (options) => {
-    const { endpoint, request, requestId, authStrategies, contextFactory, globalMiddlewares, globalTenantConfig, hooks, additionalContext, } = options;
-    const locals = {};
-    let cacheTtlMs = endpoint.cacheTtlMs ?? null;
-    const setCacheTtl = (ttl) => {
-        cacheTtlMs = ttl;
-    };
-    const context = {
-        request,
-        input: buildContextInput(request),
-        auth: null,
-        metadata: endpoint.metadata,
-        locals,
-        setCacheTtl,
-    };
-    const startedAt = Date.now();
-    await safeInvokeHook("onRequestStart", hooks.onRequestStart, {
-        requestId,
-        queryKey: endpoint.key,
-        metadata: endpoint.metadata,
-        request,
-        auth: context.auth,
-    });
-    try {
-        const endpointAuth = endpoint.auth ?? null;
-        const strategies = gatherAuthStrategies(endpointAuth, authStrategies);
-        const requiresAuth = computeRequiresAuth(endpoint.metadata, endpointAuth, authStrategies);
-        const metadataWithAuth = {
-            ...endpoint.metadata,
-            requiresAuth,
-        };
-        context.metadata = metadataWithAuth;
-        const authContext = await authenticateRequest(strategies, request, metadataWithAuth);
-        if (!authContext && requiresAuth) {
-            await safeInvokeHook("onAuthFailure", hooks.onAuthFailure, {
-                requestId,
-                queryKey: endpoint.key,
-                metadata: metadataWithAuth,
-                request,
-                auth: context.auth,
-                reason: "MISSING",
-            });
-            return createErrorResponse(401, "UNAUTHORIZED", "Authentication required", {
-                reason: "missing_credentials",
-                strategies_attempted: strategies.length,
-                endpoint: endpoint.metadata.path,
-            });
-        }
-        // After the auth check above, if requiresAuth is true, authContext is guaranteed to be non-null
-        context.auth = authContext;
-        const hydratedContext = await resolveContext(contextFactory, request, authContext);
-        Object.assign(context, hydratedContext, additionalContext);
-        // Tenant isolation: Extract and validate tenant ID if configured
-        // Use endpoint-specific config, or fall back to global config
-        const tenantConfig = endpoint.tenant ?? globalTenantConfig;
-        if (tenantConfig) {
-            const tenantRequired = tenantConfig.required !== false; // Default to true
-            const tenantId = authContext ? tenantConfig.extract(authContext) : null;
-            if (!tenantId && tenantRequired) {
-                const errorMessage = tenantConfig.errorMessage ??
-                    "Tenant context is required but could not be determined from authentication";
-                await safeInvokeHook("onError", hooks.onError, {
-                    requestId,
-                    queryKey: endpoint.key,
-                    metadata: metadataWithAuth,
-                    request,
-                    auth: context.auth,
-                    durationMs: Date.now() - startedAt,
-                    error: new Error(errorMessage),
-                });
-                return createErrorResponse(403, "UNAUTHORIZED", errorMessage, {
-                    reason: "missing_tenant_context",
-                    tenant_required: true,
-                });
-            }
-            if (tenantId) {
-                context.tenantId = tenantId;
-                // Auto-inject tenant filtering if configured
-                const mode = tenantConfig.mode ?? 'manual'; // Default to manual for backward compatibility
-                const column = tenantConfig.column;
-                if (mode === 'auto-inject' && column) {
-                    // Wrap all query builders in the context to auto-inject tenant filters
-                    const contextValues = context;
-                    for (const key of Object.keys(contextValues)) {
-                        const value = contextValues[key];
-                        // Check if it looks like a query builder (has a table method)
-                        if (value && typeof value === 'object' && 'table' in value && typeof value.table === 'function') {
-                            contextValues[key] = createTenantScope(value, { tenantId, column });
-                        }
-                    }
-                }
-                else if (mode === 'manual') {
-                    // Warn developers in manual mode to ensure they manually filter
-                    warnTenantMisconfiguration({
-                        queryKey: endpoint.key,
-                        hasTenantConfig: true,
-                        hasTenantId: true,
-                        mode: 'manual',
-                    });
-                }
-            }
-            else if (tenantConfig && !tenantRequired) {
-                // Optional tenant mode - warn if no tenant config when accessing user data
-                warnTenantMisconfiguration({
-                    queryKey: endpoint.key,
-                    hasTenantConfig: true,
-                    hasTenantId: false,
-                    mode: tenantConfig.mode,
-                });
-            }
-        }
-        const validationResult = validateInput(endpoint.inputSchema, context.input);
-        if (!validationResult.success) {
-            await safeInvokeHook("onError", hooks.onError, {
-                requestId,
-                queryKey: endpoint.key,
-                metadata: metadataWithAuth,
-                request,
-                auth: context.auth,
-                durationMs: Date.now() - startedAt,
-                error: validationResult.error,
-            });
-            return createErrorResponse(400, "VALIDATION_ERROR", "Request validation failed", {
-                issues: validationResult.error.issues,
-            });
-        }
-        context.input = validationResult.data;
-        const pipeline = [
-            ...globalMiddlewares,
-            ...endpoint.middlewares,
-        ];
-        const result = await runMiddlewares(pipeline, context, () => endpoint.handler(context));
-        const headers = { ...(endpoint.defaultHeaders ?? {}) };
-        if (typeof cacheTtlMs === "number") {
-            headers["cache-control"] = cacheTtlMs > 0 ? `public, max-age=${Math.floor(cacheTtlMs / 1000)}` : "no-store";
-        }
-        const durationMs = Date.now() - startedAt;
-        await safeInvokeHook("onRequestEnd", hooks.onRequestEnd, {
-            requestId,
-            queryKey: endpoint.key,
-            metadata: metadataWithAuth,
-            request,
-            auth: context.auth,
-            durationMs,
-            result,
-        });
-        return {
-            status: 200,
-            headers,
-            body: result,
-        };
-    }
-    catch (error) {
-        await safeInvokeHook("onError", hooks.onError, {
-            requestId,
-            queryKey: endpoint.key,
-            metadata: context.metadata,
-            request,
-            auth: context.auth,
-            durationMs: Date.now() - startedAt,
-            error,
-        });
-        const message = error instanceof Error ? error.message : "Unexpected error";
-        return createErrorResponse(500, "INTERNAL_SERVER_ERROR", message);
-    }
-};
+import { createProcedureBuilder } from "./builder.js";
+import { ensureArray, mergeTags } from "./utils.js";
+import { createDocsEndpoint, createOpenApiEndpoint, createServeHandler, executeEndpoint, } from "./pipeline.js";
 export const defineServe = (config) => {
-    const basePath = config.basePath ?? "";
+    const basePath = config.basePath ?? "/api/analytics";
     const router = new ServeRouter(basePath);
     const globalMiddlewares = [
         ...(config.middlewares ?? []),
@@ -414,23 +32,14 @@ export const defineServe = (config) => {
     for (const key of Object.keys(configuredQueries)) {
         registerQuery(key, configuredQueries[key]);
     }
-    const handler = async (request) => {
-        const requestId = getRequestId(request);
-        const endpoint = router.match(request.method, request.path);
-        if (!endpoint) {
-            return createErrorResponse(404, "NOT_FOUND", `No endpoint registered for ${request.method} ${request.path}`);
-        }
-        return executeEndpoint({
-            endpoint,
-            request,
-            requestId,
-            authStrategies,
-            contextFactory,
-            globalMiddlewares,
-            globalTenantConfig,
-            hooks,
-        });
-    };
+    const handler = createServeHandler({
+        router,
+        globalMiddlewares,
+        authStrategies,
+        tenantConfig: globalTenantConfig,
+        contextFactory,
+        hooks,
+    });
     // Track route configuration for client config extraction
     const routeConfig = {};
     const executeQuery = async (key, options) => {
@@ -446,15 +55,13 @@ export const defineServe = (config) => {
             body: options?.input ?? options?.request?.body,
             raw: options?.request?.raw,
         };
-        const requestId = getRequestId(request);
         const response = await executeEndpoint({
             endpoint,
             request,
-            requestId,
             authStrategies,
             contextFactory,
             globalMiddlewares,
-            globalTenantConfig,
+            tenantConfig: globalTenantConfig,
             hooks,
             additionalContext: options?.context,
         });

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const ensureArray: <T>(value: T | T[] | undefined | null) => T[];
+export declare const mergeTags: (existing: string[], next?: string[]) => string[];
+export declare const generateRequestId: () => string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,KAAG,CAAC,EAKnE,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,EAAE,EAAE,OAAO,MAAM,EAAE,aAG5D,CAAC;AAEF,eAAO,MAAM,iBAAiB,QAAO,MAKpC,CAAC"}

package/dist/utils.js

@@ -0,0 +1,16 @@
+export const ensureArray = (value) => {
+    if (!value) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+};
+export const mergeTags = (existing, next) => {
+    const merged = [...existing, ...(next ?? [])];
+    return Array.from(new Set(merged.filter(Boolean)));
+};
+export const generateRequestId = () => {
+    if (typeof globalThis.crypto?.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypequery/serve",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "Declarative HTTP server for exposing hypequery analytics endpoints",
   "license": "Apache-2.0",
   "type": "module",
@@ -47,4 +47,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/dist/queries.d.ts

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

package/dist/queries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,aAAa,GACxB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,KAAK,CAAC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAE1F,SAAS,QAAQ,KAChB,QAAmB,CAAC"}

package/dist/queries.js

@@ -1 +0,0 @@
-export const defineQueries = (queries) => queries;

package/dist/query.d.ts

@@ -1,4 +0,0 @@
-import type { ZodTypeAny } from "zod";
-import type { AuthContext, SchemaOutput, ServeQueryConfig } from "./types.js";
-export declare const defineQuery: <TInputSchema extends ZodTypeAny | undefined = undefined, TOutputSchema extends ZodTypeAny = ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext, TResult = SchemaOutput<TOutputSchema>>(definition: ServeQueryConfig<TInputSchema, TOutputSchema, TContext, TAuth, TResult>) => ServeQueryConfig<TInputSchema, TOutputSchema, TContext, TAuth, TResult>;
-//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9E,eAAO,MAAM,WAAW,GACtB,YAAY,SAAS,UAAU,GAAG,SAAS,GAAG,SAAS,EACvD,aAAa,SAAS,UAAU,GAAG,UAAU,EAC7C,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,OAAO,GAAG,YAAY,CAAC,aAAa,CAAC,EAErC,YAAY,gBAAgB,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,KAClF,gBAAgB,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAe,CAAC"}

package/dist/query.js

@@ -1 +0,0 @@
-export const defineQuery = (definition) => definition;

package/dist/sdk-generator.d.ts

@@ -1,7 +0,0 @@
-export interface GenerateSdkOptions {
-    input: string;
-    output: string;
-    clientName?: string;
-}
-export declare const generateSdkClient: (options: GenerateSdkOptions) => Promise<void>;
-//# sourceMappingURL=sdk-generator.d.ts.map

package/dist/sdk-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdk-generator.d.ts","sourceRoot":"","sources":["../src/sdk-generator.ts"],"names":[],"mappings":"AAuHA,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD,eAAO,MAAM,iBAAiB,GAAU,SAAS,kBAAkB,kBAalE,CAAC"}

package/dist/sdk-generator.js

@@ -1,143 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import openapiTS, { astToString } from "openapi-typescript";
-const TEMPLATE_CLIENT = (clientName) => [
-    'import type { paths } from "./types";',
-    '',
-    'type FetchImpl = typeof fetch;',
-    '',
-    'type ExtractJsonResponse<T> = T extends { responses: infer Responses }',
-    '  ? Responses extends Record<string, any>',
-    '    ? Responses[200] extends { content: { "application/json": infer R } }',
-    '      ? R',
-    '      : Responses[201] extends { content: { "application/json": infer R } }',
-    '        ? R',
-    '        : unknown',
-    '    : unknown',
-    '  : unknown;',
-    '',
-    'type ExtractBody<T> = T extends { requestBody: { content: { "application/json": infer Body } } }',
-    '  ? Body',
-    '  : undefined;',
-    '',
-    'type ExtractQuery<T> = T extends { parameters: { query: infer Params } }',
-    '  ? Params',
-    '  : undefined;',
-    '',
-    'type RequestOptions<Path extends keyof paths, Method extends keyof paths[Path]> = {',
-    '  path: Path;',
-    '  method: Method;',
-    '  query?: ExtractQuery<paths[Path][Method]>;',
-    '  body?: ExtractBody<paths[Path][Method]>;',
-    '  headers?: Record<string, string>;',
-    '  fetch?: FetchImpl;',
-    '} & Omit<RequestInit, "body" | "method">;',
-    '',
-    'interface ClientConfig {',
-    '  baseUrl: string;',
-    '  headers?: Record<string, string>;',
-    '  fetch?: FetchImpl;',
-    '}',
-    '',
-    'const encodeQueryValue = (value: unknown) =>',
-    '  Array.isArray(value)',
-    '    ? value.map((v) => encodeURIComponent(String(v))).join(",")',
-    '    : encodeURIComponent(String(value));',
-    '',
-    'const buildUrl = (baseUrl: string, path: string, query?: Record<string, unknown>) => {',
-    '  const url = new URL(path, baseUrl);',
-    '',
-    '  if (query) {',
-    '    Object.entries(query).forEach(([key, value]) => {',
-    '      if (value === undefined || value === null) {',
-    '        return;',
-    '      }',
-    '',
-    '      if (Array.isArray(value)) {',
-    '        value.forEach((entry) => url.searchParams.append(key, String(entry)));',
-    '      } else if (typeof value === "object") {',
-    '        url.searchParams.append(key, encodeQueryValue(JSON.stringify(value)));',
-    '      } else {',
-    '        url.searchParams.append(key, encodeQueryValue(value));',
-    '      }',
-    '    });',
-    '  }',
-    '',
-    '  return url;',
-    '};',
-    '',
-    `export class ${clientName} {`,
-    '  constructor(private readonly config: ClientConfig) {}',
-    '',
-    '  async request<Path extends keyof paths, Method extends keyof paths[Path]>(',
-    '    options: RequestOptions<Path, Method>',
-    '  ): Promise<ExtractJsonResponse<paths[Path][Method]>> {',
-    '    const target = buildUrl(this.config.baseUrl, options.path as string, options.query);',
-    '    const fetchImpl = options.fetch ?? this.config.fetch ?? globalThis.fetch;',
-    '',
-    '    if (!fetchImpl) {',
-    '      throw new Error("No fetch implementation available. Provide one via config.fetch.");',
-    '    }',
-    '',
-    '    const headers = {',
-    '      "content-type": "application/json",',
-    '      ...(this.config.headers ?? {}),',
-    '      ...(options.headers ?? {}),',
-    '    };',
-    '',
-    '    const response = await fetchImpl(target.toString(), {',
-    '      ...options,',
-    '      method: options.method as string,',
-    '      headers,',
-    '      body: options.body !== undefined ? JSON.stringify(options.body) : undefined,',
-    '    });',
-    '',
-    '    if (!response.ok) {',
-    '      const errorText = await response.text();',
-    '      throw new Error(`Request failed with status ${response.status}: ${errorText}`);',
-    '    }',
-    '',
-    '    const text = await response.text();',
-    '    if (!text) {',
-    '      return undefined as ExtractJsonResponse<paths[Path][Method]>;',
-    '    }',
-    '',
-    '    return JSON.parse(text);',
-    '  }',
-    '}',
-    '',
-    `export const createClient = (config: ClientConfig) => new ${clientName}(config);`,
-    '',
-].join("\n");
-const TEMPLATE_INDEX = `export * from "./client";
-export * from "./types";
-`;
-const isHttpUrl = (value) => /^https?:\/\//i.test(value);
-const loadDocument = async (input) => {
-    if (isHttpUrl(input)) {
-        const response = await fetch(input);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch OpenAPI spec from ${input}: ${response.status}`);
-        }
-        return response.json();
-    }
-    const absolutePath = isAbsolute(input) ? input : resolve(process.cwd(), input);
-    const contents = await readFile(absolutePath, "utf8");
-    return JSON.parse(contents);
-};
-const writeFileSafe = async (filePath, contents) => {
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, contents, "utf8");
-};
-export const generateSdkClient = async (options) => {
-    const document = await loadDocument(options.input);
-    const typesAst = await openapiTS(document, {
-        exportType: true,
-    });
-    const types = astToString(typesAst);
-    const outputDir = isAbsolute(options.output) ? options.output : resolve(process.cwd(), options.output);
-    const clientName = options.clientName ?? "HypeQueryClient";
-    await writeFileSafe(join(outputDir, "types.ts"), types);
-    await writeFileSafe(join(outputDir, "client.ts"), TEMPLATE_CLIENT(clientName));
-    await writeFileSafe(join(outputDir, "index.ts"), TEMPLATE_INDEX);
-};