@hypequery/serve 0.0.5 → 0.0.7

package/dist/server.js

@@ -1,191 +0,0 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { startNodeServer } from "./adapters/node.js";
-import { createEndpoint } from "./endpoint.js";
-import { applyBasePath, normalizeRoutePath, ServeRouter } from "./router.js";
-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 ?? "/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 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,
-    });
-    // Track route configuration for client config extraction
-    const routeConfig = {};
-    const executeQuery = 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: globalTenantConfig,
-            hooks,
-            additionalContext: options?.context,
-        });
-        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;
-    };
-    const builder = {
-        queries: queryEntries,
-        _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) => startNodeServer(handler, options),
-    };
-    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;
-};
-const mapEndpointToToolkit = (endpoint) => {
-    // Use type assertion to avoid deep type instantiation issues with zodToJsonSchema
-    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,
-        inputSchema,
-        outputSchema,
-        custom: endpoint.metadata.custom,
-    };
-};
-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/tenant.d.ts

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,20 +0,0 @@
-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 }];