@jaypie/fabric 0.1.0

package/dist/esm/express/types.d.ts

@@ -0,0 +1,51 @@
+import type { Request, RequestHandler, Response, Router } from "express";
+import type { AuthorizationConfig, CorsOption, FabricHttpService, HttpMethod } from "../http/types.js";
+/**
+ * Configuration for fabricExpress middleware
+ */
+export interface FabricExpressConfig<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown, TAuth = unknown> {
+    /** The fabric HTTP service to wrap */
+    service: FabricHttpService<TInput, TOutput, TAuth>;
+    /** Override path pattern (defaults to /${alias}) */
+    path?: string;
+    /** HTTP methods to handle (defaults to DEFAULT_HTTP_METHODS) */
+    methods?: HttpMethod[];
+}
+/**
+ * Express middleware returned by fabricExpress
+ */
+export interface FabricExpressMiddleware extends RequestHandler {
+    /** The wrapped fabric HTTP service */
+    service: FabricHttpService;
+    /** Path pattern for the middleware */
+    path: string;
+    /** HTTP methods handled */
+    methods: HttpMethod[];
+}
+/**
+ * Service entry for FabricRouter - either a service or a config object
+ */
+export type FabricRouterServiceEntry<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown, TAuth = unknown> = FabricHttpService<TInput, TOutput, TAuth> | FabricExpressConfig<TInput, TOutput, TAuth>;
+/**
+ * Configuration for FabricRouter
+ */
+export interface FabricRouterConfig {
+    /** Services to register in the router */
+    services: FabricRouterServiceEntry[];
+    /** Global authorization (applied to all services without their own) */
+    authorization?: AuthorizationConfig;
+    /** Global CORS configuration */
+    cors?: CorsOption;
+    /** Prefix for all routes (e.g., "/api" or "/v1") */
+    prefix?: string;
+}
+/**
+ * Extended Express Router with fabric metadata
+ */
+export interface FabricExpressRouter extends Router {
+    /** Registered services */
+    services: FabricHttpService[];
+    /** Route prefix */
+    prefix?: string;
+}
+export type { Request, Response, Router };

package/dist/esm/helpers/fallback.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Fallback Resolution Helper
+ *
+ * Resolves a field value with a fallback chain.
+ */
+/**
+ * Resolve a field value with fallbacks
+ *
+ * @param entity - The entity to read from
+ * @param field - The primary field name
+ * @param fallbacks - Fallback field names in priority order
+ * @returns First defined value, or undefined
+ *
+ * @example
+ * ```typescript
+ * const model = { title: undefined, name: "My Model", description: "A description" };
+ * resolveWithFallback(model, "title", ["name", "description"]);
+ * // Returns "My Model"
+ * ```
+ */
+export declare function resolveWithFallback(entity: Record<string, unknown>, field: string, fallbacks?: string[]): unknown;

package/dist/esm/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveWithFallback } from "./fallback.js";
+export { computeResolvedName } from "./resolvedName.js";
+export type { ResolvedNameModel } from "./resolvedName.js";

package/dist/esm/helpers/resolvedName.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Resolved Name Helper
+ *
+ * Computes a resolved name from model fields using a priority chain.
+ */
+/**
+ * Model with optional name fields
+ */
+export interface ResolvedNameModel {
+    abbreviation?: string;
+    alias?: string;
+    description?: string;
+    name?: string;
+}
+/**
+ * Compute resolved name from model fields
+ *
+ * Priority: name > alias > abbreviation > description
+ * Result is lowercase for consistent sorting/indexing
+ *
+ * @param model - The model to compute the resolved name from
+ * @returns The resolved name (lowercase) or undefined if no name fields exist
+ */
+export declare function computeResolvedName(model: ResolvedNameModel): string | undefined;

package/dist/esm/http/FabricHttpServer.d.ts

@@ -0,0 +1,31 @@
+import type { FabricHttpServer as FabricHttpServerType, FabricHttpServerConfig } from "./types.js";
+/**
+ * Create a standalone HTTP server for Lambda
+ *
+ * Routes multiple FabricHttpService instances without Express:
+ * - Parses API Gateway v1 and v2 events
+ * - Matches routes by path pattern and HTTP method
+ * - Handles CORS preflight and response headers
+ * - Returns JSON:API formatted responses
+ *
+ * @example
+ * ```typescript
+ * import { FabricHttpServer } from "@jaypie/fabric/http";
+ * import { lambdaHandler } from "@jaypie/lambda";
+ *
+ * const server = FabricHttpServer({
+ *   services: [
+ *     userService,
+ *     { service: productService, path: "/products/:id", methods: ["GET", "PUT"] },
+ *   ],
+ *   prefix: "/api",
+ * });
+ *
+ * export const handler = lambdaHandler(server);
+ * ```
+ */
+export declare function FabricHttpServer(config: FabricHttpServerConfig): FabricHttpServerType;
+/**
+ * Check if a value is a FabricHttpServer
+ */
+export declare function isFabricHttpServer(value: unknown): value is FabricHttpServerType;

package/dist/esm/http/authorization.d.ts

@@ -0,0 +1,30 @@
+import type { AuthorizationConfig } from "./types.js";
+/**
+ * Extract token from Authorization header
+ * Removes "Bearer " prefix (case insensitive) and strips whitespace
+ *
+ * Examples:
+ * - "Bearer eyJhbGc..." → "eyJhbGc..."
+ * - "bearer eyJhbGc..." → "eyJhbGc..."
+ * - "BEARER eyJhbGc..." → "eyJhbGc..."
+ * - "eyJhbGc..." → "eyJhbGc..."
+ * - "  eyJhbGc...  " → "eyJhbGc..."
+ */
+export declare function extractToken(authHeader: string | null | undefined): string;
+/**
+ * Get authorization header from Headers object
+ */
+export declare function getAuthHeader(headers: Headers): string | null;
+/**
+ * Validate authorization and return auth context
+ *
+ * @param headers - Request headers
+ * @param config - Authorization configuration (function or false)
+ * @returns Auth context from the authorization function, or undefined if public
+ * @throws UnauthorizedError if authorization fails
+ */
+export declare function validateAuthorization<TAuth = unknown>(headers: Headers, config: AuthorizationConfig<TAuth>): Promise<TAuth | undefined>;
+/**
+ * Check if authorization is required
+ */
+export declare function isAuthorizationRequired(config: AuthorizationConfig<unknown>): boolean;

package/dist/esm/http/cors.d.ts

@@ -0,0 +1,40 @@
+import type { CorsConfig, CorsHeaders, CorsOption, HttpMethod } from "./types.js";
+/**
+ * Default CORS configuration
+ */
+export declare const DEFAULT_CORS_CONFIG: CorsConfig;
+/**
+ * Default allowed methods for CORS
+ */
+export declare const DEFAULT_CORS_METHODS: HttpMethod[];
+/**
+ * Normalize CORS option to CorsConfig
+ * - true → default config
+ * - false → disabled (returns undefined)
+ * - CorsConfig → merged with defaults
+ */
+export declare function normalizeCorsConfig(option: CorsOption | undefined): CorsConfig | undefined;
+/**
+ * Get the allowed origin for a request
+ * @param config - CORS configuration
+ * @param requestOrigin - Origin header from request
+ * @returns The origin to allow, or undefined if not allowed
+ */
+export declare function getAllowedOrigin(config: CorsConfig, requestOrigin: string | null): string | undefined;
+/**
+ * Build CORS headers for a response
+ * @param config - CORS configuration
+ * @param requestOrigin - Origin header from request
+ * @param methods - Allowed HTTP methods
+ * @returns Object with CORS headers, or empty object if CORS is disabled
+ */
+export declare function buildCorsHeaders(config: CorsConfig | undefined, requestOrigin: string | null, methods?: HttpMethod[]): CorsHeaders;
+/**
+ * Check if request is a CORS preflight request
+ */
+export declare function isPreflightRequest(method: string, headers: Headers): boolean;
+/**
+ * Build preflight response headers
+ * Includes all CORS headers needed for preflight response
+ */
+export declare function buildPreflightHeaders(config: CorsConfig | undefined, requestOrigin: string | null, requestMethod: string | null, requestHeaders: string | null, methods?: HttpMethod[]): CorsHeaders;

package/dist/esm/http/fabricHttp.d.ts

@@ -0,0 +1,28 @@
+import type { ServiceContext } from "../types.js";
+import type { FabricHttpConfig, FabricHttpService, HttpContext } from "./types.js";
+/**
+ * Extended service context with auth information
+ */
+export interface HttpServiceContext<TAuth = unknown> extends ServiceContext {
+    /** Authorization result (returned from authorization function) */
+    auth?: TAuth;
+    /** HTTP context for advanced use cases */
+    http?: HttpContext;
+}
+/**
+ * Create an HTTP-aware fabric service
+ *
+ * Extends fabricService with:
+ * - HTTP context transformation (body, headers, method, path, query, params)
+ * - Authorization handling (token extraction from Authorization header)
+ * - CORS configuration (enabled by default)
+ *
+ * Accepts either:
+ * - Inline service definition (with `service` function)
+ * - Pre-built `fabricService` instance (via `service` property)
+ */
+export declare function fabricHttp<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown, TAuth = unknown>(config: FabricHttpConfig<TInput, TOutput, TAuth>): FabricHttpService<TInput, TOutput, TAuth>;
+/**
+ * Check if a service is an HTTP service (has http, authorization, cors properties)
+ */
+export declare function isFabricHttpService<TInput extends Record<string, unknown>, TOutput, TAuth>(value: unknown): value is FabricHttpService<TInput, TOutput, TAuth>;

package/dist/esm/http/httpTransform.d.ts

@@ -0,0 +1,36 @@
+import type { HttpContext, HttpTransformFunction } from "./types.js";
+/**
+ * Default HTTP transformation function
+ * Merges query parameters with body (body takes precedence)
+ */
+export declare const defaultHttpTransform: HttpTransformFunction;
+/**
+ * Parse query string into URLSearchParams
+ */
+export declare function parseQueryString(queryString: string): URLSearchParams;
+/**
+ * Parse path parameters from a URL path using a route pattern
+ * @param path - The actual URL path (e.g., "/users/123")
+ * @param pattern - The route pattern (e.g., "/users/:id")
+ * @returns Object with extracted parameters
+ */
+export declare function parsePathParams(path: string, pattern: string): Record<string, string>;
+/**
+ * Parse request body from string or return as-is if already parsed
+ */
+export declare function parseBody(body: unknown): unknown;
+/**
+ * Create HTTP context from raw request data
+ */
+export declare function createHttpContext(options: {
+    body?: unknown;
+    headers?: Headers | Record<string, string>;
+    method?: string;
+    path?: string;
+    queryString?: string;
+    params?: Record<string, string>;
+}): HttpContext;
+/**
+ * Apply HTTP transformation to get service input
+ */
+export declare function transformHttpToInput<TInput = Record<string, unknown>>(context: HttpContext, transform?: HttpTransformFunction<TInput>): Promise<TInput>;

package/dist/esm/http/index.d.ts

@@ -0,0 +1,10 @@
+export { fabricHttp, isFabricHttpService } from "./fabricHttp.js";
+export type { HttpServiceContext } from "./fabricHttp.js";
+export { FabricHttpServer, isFabricHttpServer } from "./FabricHttpServer.js";
+export { extractToken, getAuthHeader, isAuthorizationRequired, validateAuthorization, } from "./authorization.js";
+export { buildCorsHeaders, buildPreflightHeaders, DEFAULT_CORS_CONFIG, DEFAULT_CORS_METHODS, getAllowedOrigin, isPreflightRequest, normalizeCorsConfig, } from "./cors.js";
+export { createHttpContext, defaultHttpTransform, parseBody, parsePathParams, parseQueryString, transformHttpToInput, } from "./httpTransform.js";
+export { collectStreamEvents, createCompleteEvent, createDataEvent, createErrorEvent, createMessageEvent, createNoopEvent, createStreamContext, createTextEvent, createToolCallEvent, createToolResultEvent, DEFAULT_STREAM_CONFIG, formatNdjsonEvent, formatSseEvent, formatStreamEvent, getStreamContentType, isAsyncIterable, isStreamingEnabled, llmChunkToHttpEvent, normalizeStreamConfig, pipeLlmStream, pipeLlmStreamToWriter, wrapServiceForStreaming, } from "./stream.js";
+export type { HttpStreamContext, LlmStreamChunk, PipeLlmStreamOptions, StreamWriter, } from "./stream.js";
+export type { ApiGatewayEvent, ApiGatewayResponse, ApiGatewayV1Event, ApiGatewayV2Event, AuthorizationConfig, AuthorizationFunction, CorsConfig, CorsHeaders, CorsOption, DataResponse, ErrorObject, ErrorResponse, FabricHttpConfig, FabricHttpServer as FabricHttpServerInterface, FabricHttpServerConfig, FabricHttpServerHandler, FabricHttpServerRoute, FabricHttpServerServiceEntry, FabricHttpService, HttpContext, HttpMethod, HttpStreamEvent, HttpStreamEventBase, HttpStreamEventComplete, HttpStreamEventData, HttpStreamEventError, HttpStreamEventMessage, HttpStreamEventNoop, HttpStreamEventText, HttpStreamEventToolCall, HttpStreamEventToolResult, HttpTransformFunction, RegisteredRoute, RouteMatch, StreamConfig, StreamingServiceFunction, StreamOption, } from "./types.js";
+export { DEFAULT_HTTP_METHODS, HttpStreamEventType } from "./types.js";