@hypequery/serve 0.0.7 → 0.0.9

package/dist/server/builder.js

@@ -0,0 +1,73 @@
+import { mergeTags } from "../utils.js";
+import { normalizeRoutePath } from "../router.js";
+import { mapEndpointToToolkit } from "./mapper.js";
+export const createBuilderMethods = (queryEntries, queryLogger, routeConfig, router, authStrategies, globalMiddlewares, executeQuery, handler, basePath) => {
+    const builder = {
+        queries: queryEntries,
+        queryLogger,
+        _routeConfig: routeConfig,
+        route: (path, endpoint, options = {}) => {
+            if (!endpoint) {
+                throw new Error("Endpoint definition is required when registering a route");
+            }
+            const method = options?.method ?? endpoint.method;
+            // Find the query key for this endpoint
+            const queryKey = Object.entries(queryEntries).find(([_, e]) => e === endpoint)?.[0];
+            if (queryKey) {
+                routeConfig[queryKey] = { method };
+            }
+            const normalizedPath = normalizeRoutePath(path);
+            const fallbackRequiresAuth = endpoint.auth
+                ? true
+                : authStrategies.length > 0
+                    ? true
+                    : undefined;
+            const requiresAuth = options?.requiresAuth ?? endpoint.metadata.requiresAuth ?? fallbackRequiresAuth;
+            const visibility = options?.visibility ?? endpoint.metadata.visibility ?? "public";
+            const metadata = {
+                ...endpoint.metadata,
+                path: normalizedPath,
+                method,
+                name: options?.name ?? endpoint.metadata.name ?? endpoint.key,
+                summary: options?.summary ?? endpoint.metadata.summary,
+                description: options?.description ?? endpoint.metadata.description,
+                tags: mergeTags(endpoint.metadata.tags, options?.tags),
+                requiresAuth,
+                visibility,
+            };
+            const middlewares = [...endpoint.middlewares, ...(options?.middlewares ?? [])];
+            const registeredEndpoint = {
+                ...endpoint,
+                method,
+                metadata,
+                middlewares,
+            };
+            router.register(registeredEndpoint);
+            return builder;
+        },
+        use: (middleware) => {
+            globalMiddlewares.push(middleware);
+            return builder;
+        },
+        useAuth: (strategy) => {
+            authStrategies.push(strategy);
+            router.markRoutesRequireAuth();
+            return builder;
+        },
+        execute: executeQuery,
+        run: executeQuery,
+        describe: () => {
+            const description = {
+                basePath: basePath || undefined,
+                queries: router.list().map(mapEndpointToToolkit),
+            };
+            return description;
+        },
+        handler,
+        start: async (options = {}) => {
+            const { startNodeServer } = require("../adapters/node.js");
+            return startNodeServer(handler, options);
+        },
+    };
+    return builder;
+};

package/dist/server/define-serve.d.ts

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

package/dist/server/define-serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-serve.d.ts","sourceRoot":"","sources":["../../src/server/define-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAGX,YAAY,EACZ,WAAW,EAGX,gBAAgB,EAIhB,eAAe,EAChB,MAAM,aAAa,CAAC;AAUrB,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,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAEpF,QAAQ,WAAW,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,KAC7C,YAAY,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CAiH3E,CAAC"}

package/dist/server/define-serve.js

@@ -0,0 +1,88 @@
+import { createEndpoint } from "../endpoint.js";
+import { ServeRouter, applyBasePath } from "../router.js";
+import { ensureArray } from "../utils.js";
+import { ServeQueryLogger, formatQueryEvent, formatQueryEventJSON } from "../query-logger.js";
+import { createServeHandler } from "../pipeline.js";
+import { createDocsEndpoint, createOpenApiEndpoint } from "../pipeline.js";
+import { createExecuteQuery } from "./execute-query.js";
+import { createBuilderMethods } from "./builder.js";
+export const defineServe = (config) => {
+    const basePath = config.basePath ?? "/api/analytics";
+    const router = new ServeRouter(basePath);
+    const globalMiddlewares = [
+        ...(config.middlewares ?? []),
+    ];
+    const authStrategies = ensureArray(config.auth);
+    const globalTenantConfig = config.tenant;
+    const contextFactory = config.context;
+    const hooks = (config.hooks ?? {});
+    const queryLogger = new ServeQueryLogger();
+    // Wire up production query logging if configured
+    if (config.queryLogging) {
+        if (typeof config.queryLogging === 'function') {
+            queryLogger.on(config.queryLogging);
+        }
+        else if (config.queryLogging === 'json') {
+            queryLogger.on((event) => {
+                const line = formatQueryEventJSON(event);
+                if (line)
+                    console.log(line);
+            });
+        }
+        else {
+            queryLogger.on((event) => {
+                const line = formatQueryEvent(event);
+                if (line)
+                    console.log(line);
+            });
+        }
+    }
+    // Slow query warning
+    if (config.slowQueryThreshold != null) {
+        queryLogger.on((event) => {
+            if (event.status === 'completed' && event.durationMs && event.durationMs > config.slowQueryThreshold) {
+                console.warn(`[hypequery/slow-query] ${event.method} ${event.path} took ${event.durationMs}ms (threshold: ${config.slowQueryThreshold}ms)`);
+            }
+        });
+    }
+    const openapiConfig = {
+        enabled: config.openapi?.enabled ?? true,
+        path: config.openapi?.path ?? "/openapi.json",
+    };
+    const docsConfig = {
+        enabled: config.docs?.enabled ?? true,
+        path: config.docs?.path ?? "/docs",
+    };
+    const openapiPublicPath = applyBasePath(basePath, openapiConfig.path);
+    const configuredQueries = config.queries ?? {};
+    const queryEntries = {};
+    const registerQuery = (key, definition) => {
+        queryEntries[key] = createEndpoint(String(key), definition);
+    };
+    for (const key of Object.keys(configuredQueries)) {
+        registerQuery(key, configuredQueries[key]);
+    }
+    const handler = createServeHandler({
+        router,
+        globalMiddlewares,
+        authStrategies,
+        tenantConfig: globalTenantConfig,
+        contextFactory,
+        hooks,
+        queryLogger,
+        verboseAuthErrors: config.security?.verboseAuthErrors ?? false,
+    });
+    // Track route configuration for client config extraction
+    const routeConfig = {};
+    const executeQuery = createExecuteQuery(queryEntries, authStrategies, contextFactory, globalMiddlewares, globalTenantConfig, hooks, queryLogger, config.security?.verboseAuthErrors ?? false);
+    const builder = createBuilderMethods(queryEntries, queryLogger, routeConfig, router, authStrategies, globalMiddlewares, executeQuery, handler, basePath);
+    if (openapiConfig.enabled) {
+        const openapiEndpoint = createOpenApiEndpoint(openapiConfig.path, () => router.list(), config.openapi);
+        router.register(openapiEndpoint);
+    }
+    if (docsConfig.enabled) {
+        const docsEndpoint = createDocsEndpoint(docsConfig.path, openapiPublicPath, config.docs);
+        router.register(docsEndpoint);
+    }
+    return builder;
+};

package/dist/server/execute-query.d.ts

@@ -0,0 +1,8 @@
+import type { AuthContext, AuthStrategy, SchemaInput, ServeContextFactory, ServeEndpointMap, ServeEndpointResult, ServeLifecycleHooks, ServeMiddleware, ServeRequest, TenantConfig } from "../types.js";
+import { ServeQueryLogger } from "../query-logger.js";
+export declare const createExecuteQuery: <TContext extends Record<string, unknown>, TAuth extends AuthContext>(queryEntries: ServeEndpointMap<any, TContext, TAuth>, authStrategies: AuthStrategy<TAuth>[], contextFactory: ServeContextFactory<TContext, TAuth> | undefined, globalMiddlewares: ServeMiddleware<any, any, TContext, TAuth>[], tenantConfig: TenantConfig<TAuth> | undefined, hooks: ServeLifecycleHooks<TAuth>, queryLogger: ServeQueryLogger, verboseAuthErrors: boolean) => <TKey extends keyof typeof queryEntries>(key: TKey, options?: {
+    input?: SchemaInput<(typeof queryEntries)[TKey]["inputSchema"]>;
+    context?: Partial<TContext>;
+    request?: Partial<ServeRequest>;
+}) => Promise<ServeEndpointResult<(typeof queryEntries)[TKey]>>;
+//# sourceMappingURL=execute-query.d.ts.map

package/dist/server/execute-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-query.d.ts","sourceRoot":"","sources":["../../src/server/execute-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EAEZ,WAAW,EACX,mBAAmB,EAEnB,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,EAEf,YAAY,EACZ,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,EAEzB,cAAc,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EACpD,gBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,EACrC,gBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,SAAS,EAChE,mBAAmB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,EAC/D,cAAc,YAAY,CAAC,KAAK,CAAC,GAAG,SAAS,EAC7C,OAAO,mBAAmB,CAAC,KAAK,CAAC,EACjC,aAAa,gBAAgB,EAC7B,mBAAmB,OAAO,MAEZ,IAAI,SAAS,MAAM,OAAO,YAAY,EAClD,KAAK,IAAI,EACT,UAAU;IACR,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,YAAY,EAAE,IAAI,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAChE,OAAO,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;CACjC,KACA,OAAO,CAAC,mBAAmB,CAAC,CAAC,OAAO,YAAY,EAAE,IAAI,CAAC,CAAC,CAwC5D,CAAC"}

package/dist/server/execute-query.js

@@ -0,0 +1,39 @@
+import { executeEndpoint } from "../pipeline.js";
+export const createExecuteQuery = (queryEntries, authStrategies, contextFactory, globalMiddlewares, tenantConfig, hooks, queryLogger, verboseAuthErrors) => {
+    return async (key, options) => {
+        const endpoint = queryEntries[key];
+        if (!endpoint) {
+            throw new Error(`No query registered for key ${String(key)}`);
+        }
+        const request = {
+            method: endpoint.method,
+            path: options?.request?.path ?? endpoint.metadata.path ?? `/__execute/${String(key)}`,
+            query: options?.request?.query ?? {},
+            headers: options?.request?.headers ?? {},
+            body: options?.input ?? options?.request?.body,
+            raw: options?.request?.raw,
+        };
+        const response = await executeEndpoint({
+            endpoint,
+            request,
+            authStrategies,
+            contextFactory,
+            globalMiddlewares,
+            tenantConfig,
+            hooks,
+            queryLogger,
+            additionalContext: options?.context,
+            verboseAuthErrors,
+        });
+        if (response.status !== 200) {
+            const errorBody = response.body;
+            const error = new Error(errorBody.error.message);
+            error.type = errorBody.error.type;
+            if (errorBody.error.details) {
+                error.details = errorBody.error.details;
+            }
+            throw error;
+        }
+        return response.body;
+    };
+};

package/dist/server/index.d.ts

@@ -0,0 +1,6 @@
+export { defineServe } from "./define-serve.js";
+export { initServe } from "./init-serve.js";
+export { createExecuteQuery } from "./execute-query.js";
+export { createBuilderMethods } from "./builder.js";
+export { mapEndpointToToolkit } from "./mapper.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,5 @@
+export { defineServe } from "./define-serve.js";
+export { initServe } from "./init-serve.js";
+export { createExecuteQuery } from "./execute-query.js";
+export { createBuilderMethods } from "./builder.js";
+export { mapEndpointToToolkit } from "./mapper.js";

package/dist/server/init-serve.d.ts

@@ -0,0 +1,8 @@
+import type { AuthContext, ServeContextFactory, ServeInitializer, ServeQueriesMap, ServeConfig } from "../types.js";
+type InferInitializerContext<TFactory, TAuth extends AuthContext> = TFactory extends ServeContextFactory<infer TContext, TAuth> ? TContext : never;
+type ServeInitializerOptions<TFactory extends ServeContextFactory<any, TAuth>, TAuth extends AuthContext> = Omit<ServeConfig<InferInitializerContext<TFactory, TAuth>, TAuth, ServeQueriesMap<InferInitializerContext<TFactory, TAuth>, TAuth>>, "queries" | "context"> & {
+    context: TFactory;
+};
+export declare const initServe: <TFactory extends ServeContextFactory<any, TAuth>, TAuth extends AuthContext = AuthContext>(options: ServeInitializerOptions<TFactory, TAuth>) => ServeInitializer<InferInitializerContext<TFactory, TAuth>, TAuth>;
+export {};
+//# sourceMappingURL=init-serve.d.ts.map

package/dist/server/init-serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-serve.d.ts","sourceRoot":"","sources":["../../src/server/init-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,WAAW,EACZ,MAAM,aAAa,CAAC;AAIrB,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/init-serve.js

@@ -0,0 +1,18 @@
+import { createProcedureBuilder } from "../builder.js";
+import { defineServe } from "./define-serve.js";
+export const initServe = (options) => {
+    const { context, ...staticOptions } = options;
+    const procedure = createProcedureBuilder();
+    return {
+        procedure,
+        query: procedure,
+        queries: (definitions) => definitions,
+        define: (config) => {
+            return defineServe({
+                ...staticOptions,
+                ...config,
+                context: (context ?? {}),
+            });
+        },
+    };
+};

package/dist/server/mapper.d.ts

@@ -0,0 +1,3 @@
+import type { ServeEndpoint, ToolkitQueryDescription } from "../types.js";
+export declare const mapEndpointToToolkit: (endpoint: ServeEndpoint<any, any, any, any>) => ToolkitQueryDescription;
+//# sourceMappingURL=mapper.d.ts.map

package/dist/server/mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../../src/server/mapper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,oBAAoB,GAC/B,UAAU,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,KAC1C,uBA6BF,CAAC"}

package/dist/server/mapper.js

@@ -0,0 +1,30 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+export const mapEndpointToToolkit = (endpoint) => {
+    // Type assertions (as any) are necessary below for external library compatibility:
+    // - zod-to-json-schema doesn't export types that properly constrain Zod schema inputs
+    // - Using 'unknown' for the result type is safer than 'any' for the output
+    // - This is a known limitation of the zod-to-json-schema library
+    const inputSchema = endpoint.inputSchema
+        ? zodToJsonSchema(endpoint.inputSchema, { target: "openApi3" })
+        : undefined;
+    const outputSchema = endpoint.outputSchema
+        ? zodToJsonSchema(endpoint.outputSchema, { target: "openApi3" })
+        : undefined;
+    return {
+        key: endpoint.key,
+        path: endpoint.metadata.path,
+        method: endpoint.method,
+        name: endpoint.metadata.name ?? endpoint.key,
+        summary: endpoint.metadata.summary,
+        description: endpoint.metadata.description,
+        tags: endpoint.metadata.tags,
+        visibility: endpoint.metadata.visibility,
+        requiresAuth: Boolean(endpoint.metadata.requiresAuth),
+        requiresTenant: endpoint.tenant ? (endpoint.tenant.required !== false) : undefined,
+        requiredRoles: endpoint.requiredRoles,
+        requiredScopes: endpoint.requiredScopes,
+        inputSchema,
+        outputSchema,
+        custom: endpoint.metadata.custom,
+    };
+};

package/dist/tenant.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utilities for multi-tenant query isolation
+ */
+/**
+ * Creates a tenant-scoped query builder wrapper that automatically
+ * adds WHERE clauses to filter by tenant.
+ *
+ * @example
+ * ```typescript
+ * const api = defineServe({
+ *   context: ({ auth }) => ({
+ *     db: createTenantScope(myDb, {
+ *       tenantId: auth?.tenantId,
+ *       column: 'organization_id',
+ *     }),
+ *   }),
+ * });
+ * ```
+ */
+export declare function createTenantScope<TDb extends {
+    table: (name: string) => any;
+}>(db: TDb, options: {
+    tenantId: string | null | undefined;
+    column: string;
+}): TDb;
+/**
+ * Runtime warning when tenant isolation might be misconfigured
+ */
+export declare function warnTenantMisconfiguration(options: {
+    queryKey: string;
+    hasTenantConfig: boolean;
+    hasTenantId: boolean;
+    mode?: string;
+}): void;
+//# sourceMappingURL=tenant.d.ts.map

package/dist/tenant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../src/tenant.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,SAAS;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;CAAE,EAC5E,EAAE,EAAE,GAAG,EACP,OAAO,EAAE;IACP,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;CAChB,GACA,GAAG,CAoBL;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,QAYA"}

package/dist/tenant.js

@@ -0,0 +1,49 @@
+/**
+ * Utilities for multi-tenant query isolation
+ */
+/**
+ * Creates a tenant-scoped query builder wrapper that automatically
+ * adds WHERE clauses to filter by tenant.
+ *
+ * @example
+ * ```typescript
+ * const api = defineServe({
+ *   context: ({ auth }) => ({
+ *     db: createTenantScope(myDb, {
+ *       tenantId: auth?.tenantId,
+ *       column: 'organization_id',
+ *     }),
+ *   }),
+ * });
+ * ```
+ */
+export function createTenantScope(db, options) {
+    if (!options.tenantId) {
+        return db;
+    }
+    const originalTable = db.table.bind(db);
+    return {
+        ...db,
+        table: (name) => {
+            const query = originalTable(name);
+            // Auto-inject tenant filter
+            if (query && typeof query.where === 'function') {
+                return query.where(options.column, 'eq', options.tenantId);
+            }
+            return query;
+        },
+    };
+}
+/**
+ * Runtime warning when tenant isolation might be misconfigured
+ */
+export function warnTenantMisconfiguration(options) {
+    if (!options.hasTenantConfig) {
+        console.warn(`[hypequery/serve] Query "${options.queryKey}" accesses user data but has no tenant configuration. ` +
+            `This may lead to data leaks. Add tenant config to defineServe or the query definition.`);
+    }
+    else if (options.hasTenantId && options.mode === 'manual') {
+        console.warn(`[hypequery/serve] Query "${options.queryKey}" uses manual tenant mode. ` +
+            `Ensure you manually filter queries by tenantId to prevent data leaks.`);
+    }
+}

package/dist/type-tests/builder.test-d.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const api: import("../types.js").ServeBuilder<import("../types.js").ServeEndpointMap<{
+    typedQuery: import("../types.js").ServeQueryConfig<z.ZodObject<{
+        plan: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        plan?: string | undefined;
+    }, {
+        plan?: string | undefined;
+    }>, z.ZodTypeAny, {}, import("../types.js").AuthContext, {
+        plan: string;
+    }[]>;
+}, {}, import("../types.js").AuthContext>, {}, import("../types.js").AuthContext>;
+//# sourceMappingURL=builder.test-d.d.ts.map

package/dist/type-tests/builder.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.test-d.d.ts","sourceRoot":"","sources":["../../src/type-tests/builder.test-d.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,GAAG;;;;;;;;;;iFAUd,CAAC"}

package/dist/type-tests/builder.test-d.js

@@ -0,0 +1,20 @@
+import { initServe } from '../index.js';
+import { z } from 'zod';
+const serve = initServe({
+    context: () => ({}),
+});
+const { query } = serve;
+export const api = serve.define({
+    queries: serve.queries({
+        typedQuery: query
+            .describe('builder infers input + output')
+            .input(z.object({ plan: z.string().optional() }))
+            .query(async ({ input }) => {
+            const plan = input.plan ?? 'starter';
+            return [{ plan }];
+        }),
+    }),
+});
+const _resultIsTyped = [{ plan: 'starter' }];
+// @ts-expect-error plan must be string
+const _resultRejectsNumber = [{ plan: 123 }];