@hypequery/serve 0.0.7 → 0.0.9

package/dist/auth.js

@@ -0,0 +1,221 @@
+export const createApiKeyStrategy = (options) => {
+    const headerName = options.header ?? "authorization";
+    const queryParam = options.queryParam;
+    return async ({ request }) => {
+        let key;
+        if (queryParam && typeof request.query[queryParam] === "string") {
+            key = request.query[queryParam];
+        }
+        if (!key) {
+            const headerValue = request.headers[headerName] ?? request.headers[headerName.toLowerCase()];
+            if (typeof headerValue === "string") {
+                key = headerValue.startsWith("Bearer ")
+                    ? headerValue.slice("Bearer ".length)
+                    : headerValue;
+            }
+        }
+        if (!key) {
+            return null;
+        }
+        return options.validate(key, request);
+    };
+};
+export const createBearerTokenStrategy = (options) => {
+    const headerName = options.header ?? "authorization";
+    const prefix = options.prefix ?? "Bearer ";
+    return async ({ request }) => {
+        const raw = request.headers[headerName] ?? request.headers[headerName.toLowerCase()];
+        if (typeof raw !== "string" || !raw.startsWith(prefix)) {
+            return null;
+        }
+        const token = raw.slice(prefix.length).trim();
+        if (!token) {
+            return null;
+        }
+        return options.validate(token, request);
+    };
+};
+/**
+ * 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 const checkRoleAuthorization = (auth, requiredRoles) => {
+    if (!requiredRoles || requiredRoles.length === 0) {
+        return { ok: true };
+    }
+    const userRoles = auth?.roles ?? [];
+    const hasRole = requiredRoles.some((role) => userRoles.includes(role));
+    // Note: We return ALL required roles in missing[], not just the ones the user lacks.
+    // This matches the original behavior for error reporting consistency.
+    return hasRole
+        ? { ok: true }
+        : { ok: false, missing: requiredRoles, reason: 'MISSING_ROLE' };
+};
+/**
+ * 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 const checkScopeAuthorization = (auth, requiredScopes) => {
+    if (!requiredScopes || requiredScopes.length === 0) {
+        return { ok: true };
+    }
+    const userScopes = auth?.scopes ?? [];
+    const hasAllScopes = requiredScopes.every((scope) => userScopes.includes(scope));
+    // Note: We return ALL required scopes in missing[], not just the ones the user lacks.
+    // This matches the original behavior for error reporting consistency.
+    return hasAllScopes
+        ? { ok: true }
+        : { ok: false, missing: requiredScopes, reason: 'MISSING_SCOPE' };
+};
+/**
+ * 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 const requireAuthMiddleware = () => async (ctx, next) => {
+    if (!ctx.auth) {
+        throw Object.assign(new Error("Authentication required"), {
+            status: 401,
+            type: "UNAUTHORIZED",
+        });
+    }
+    return next();
+};
+/**
+ * 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 const requireRoleMiddleware = (...roles) => async (ctx, next) => {
+    const result = checkRoleAuthorization(ctx.auth, roles);
+    if (!result.ok) {
+        throw Object.assign(new Error(`Missing required role. Required one of: ${roles.join(", ")}`), { status: 403, type: "FORBIDDEN" });
+    }
+    return next();
+};
+/**
+ * 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 const requireScopeMiddleware = (...scopes) => async (ctx, next) => {
+    const result = checkScopeAuthorization(ctx.auth, scopes);
+    if (!result.ok) {
+        throw Object.assign(new Error(`Missing required scopes: ${result.missing.join(", ")}`), { status: 403, type: "FORBIDDEN" });
+    }
+    return next();
+};
+/**
+ * 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 const createAuthSystem = (options = {}) => {
+    return {
+        /**
+         * 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: (strategy) => strategy,
+        /**
+         * The combined typed auth context type.
+         * Use this to type your defineServe generic parameter.
+         *
+         * @example
+         * ```ts
+         * type AppAuth = typeof TypedAuth;
+         * ```
+         */
+        TypedAuth: null,
+    };
+};

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;AA0BpB,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,SAAS,WAAW,OACtB,qBAAqB,CAAC,QAAQ,EAAE,KAAK,CA4DzC,CAAC"}

package/dist/builder.js

@@ -0,0 +1,56 @@
+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 }),
+        requireAuth: () => build({ ...state, requiresAuth: true }),
+        requireRole: (...roles) => build({
+            ...state,
+            requiresAuth: true,
+            requiredRoles: [...(state.requiredRoles ?? []), ...roles],
+        }),
+        requireScope: (...scopes) => build({
+            ...state,
+            requiresAuth: true,
+            requiredScopes: [...(state.requiredScopes ?? []), ...scopes],
+        }),
+        public: () => build({ ...state, requiresAuth: false }),
+        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,
+                requiresAuth: state.requiresAuth,
+                tenant: state.tenant,
+                requiredRoles: state.requiredRoles,
+                requiredScopes: state.requiredScopes,
+                custom: state.custom,
+                middlewares: state.middlewares,
+                query: executable,
+            };
+            return config;
+        },
+    });
+    return build(defaultState());
+};

package/dist/client-config.d.ts

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

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

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

package/dist/client-config.js

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

package/dist/dev.d.ts

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

package/dist/dev.d.ts.map

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

package/dist/dev.js

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

package/dist/docs-ui.d.ts

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

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

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

package/dist/docs-ui.js

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

package/dist/endpoint.d.ts

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

package/dist/endpoint.d.ts.map

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

package/dist/endpoint.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+const fallbackSchema = z.any();
+const resolveQueryRunner = (query) => {
+    if (!query) {
+        return null;
+    }
+    const fn = typeof query === "function"
+        ? query
+        : typeof query === "object" && typeof query.run === "function"
+            ? query.run.bind(query)
+            : null;
+    if (!fn) {
+        return null;
+    }
+    return async (args) => {
+        return fn(args);
+    };
+};
+export const createEndpoint = (key, definition) => {
+    const method = definition.method ?? "GET";
+    const hasRolesOrScopes = (definition.requiredRoles?.length ?? 0) > 0
+        || (definition.requiredScopes?.length ?? 0) > 0;
+    const metadata = {
+        path: "",
+        method: method,
+        name: definition.name ?? definition.summary ?? key,
+        summary: definition.summary,
+        description: definition.description,
+        tags: definition.tags ?? [],
+        requiresAuth: definition.requiresAuth ?? (definition.auth ? true : hasRolesOrScopes ? true : undefined),
+        requiredRoles: definition.requiredRoles,
+        requiredScopes: definition.requiredScopes,
+        deprecated: undefined,
+        visibility: "public",
+        custom: definition.custom,
+    };
+    const runner = resolveQueryRunner(definition.query);
+    const handler = async (ctx) => {
+        if (!runner) {
+            throw new Error(`Endpoint "${key}" is missing an executable query`);
+        }
+        return runner({
+            input: ctx.input,
+            ctx: ctx,
+        });
+    };
+    const outputSchema = (definition.outputSchema ?? fallbackSchema);
+    const inputSchema = definition.inputSchema;
+    return {
+        key,
+        method,
+        inputSchema,
+        outputSchema,
+        handler,
+        query: definition.query,
+        middlewares: definition.middlewares ?? [],
+        auth: definition.auth ?? null,
+        tenant: definition.tenant,
+        metadata,
+        cacheTtlMs: definition.cacheTtlMs ?? null,
+        defaultHeaders: undefined,
+        requiredRoles: definition.requiredRoles,
+        requiredScopes: definition.requiredScopes,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./types.js";
+export * from "./query-logger.js";
+export * from "./server/index.js";
+export * from "./router.js";
+export * from "./endpoint.js";
+export * from "./openapi.js";
+export * from "./docs-ui.js";
+export * from "./auth.js";
+export * from "./client-config.js";
+export * from "./adapters/node.js";
+export * from "./adapters/fetch.js";
+export * from "./adapters/vercel.js";
+export * from "./dev.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from "./types.js";
+export * from "./query-logger.js";
+export * from "./server/index.js";
+export * from "./router.js";
+export * from "./endpoint.js";
+export * from "./openapi.js";
+export * from "./docs-ui.js";
+export * from "./auth.js";
+export * from "./client-config.js";
+export * from "./adapters/node.js";
+export * from "./adapters/fetch.js";
+export * from "./adapters/vercel.js";
+export * from "./dev.js";

package/dist/openapi.d.ts

@@ -0,0 +1,3 @@
+import type { OpenApiDocument, OpenApiOptions, ServeEndpoint } from "./types.js";
+export declare const buildOpenApiDocument: (endpoints: ServeEndpoint<any, any, any, any>[], options?: OpenApiOptions) => OpenApiDocument;
+//# sourceMappingURL=openapi.d.ts.map

package/dist/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../src/openapi.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAuMjF,eAAO,MAAM,oBAAoB,GAC/B,WAAW,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAC9C,UAAU,cAAc,KACvB,eAyCF,CAAC"}