@zero-server/fetch 0.9.2 → 0.9.5

package/types/index.d.ts

@@ -0,0 +1,384 @@
+// Type definitions for zero-server
+// Project: https://github.com/tonywied17/zero-server
+// Definitions by: zero-server contributors
+
+/// <reference types="node" />
+
+// --- Re-exports from individual type modules ---------------------
+
+export { App, ListenOptions } from './app';
+export { RouterInstance, RouteChain, RouteEntry, RouteInfo, RouteOptions, RouteHandler } from './router';
+export { Request, RangeResult } from './request';
+export { Response, SendFileOptions, CookieOptions, PushOptions } from './response';
+export { SSEOptions, SSEStream } from './sse';
+export { LifecycleManager, LifecycleState, LIFECYCLE_STATE } from './lifecycle';
+export { ClusterManager, ClusterOptions, cluster } from './cluster';
+export {
+    Logger, LoggerOptions, LogEntry, StructuredLoggerOptions, structuredLogger,
+    Counter, CounterOptions, Gauge, GaugeOptions, Histogram, HistogramOptions,
+    MetricsRegistry, MetricsRegistryOptions, DEFAULT_BUCKETS, DefaultMetrics,
+    createDefaultMetrics, MetricsMiddlewareOptions, metricsMiddleware, metricsEndpoint,
+    Span, Tracer, TracerOptions, TracingMiddlewareOptions,
+    parseTraceparent, formatTraceparent, tracingMiddleware, instrumentFetch,
+    HealthCheckResult, HealthCheckOptions, healthCheck,
+    CreateHealthHandlersOptions, createHealthHandlers,
+    memoryCheck, eventLoopCheck, diskSpaceCheck,
+} from './observe';
+export {
+    JwtHeader, JwtPayload, JwtDecoded, JwtSignOptions, JwtVerifyOptions, JwtVerifyResult,
+    JwtMiddlewareOptions, jwt, jwtSign, jwtVerify, jwtDecode,
+    JwksGetKey, JwksOptions, jwks,
+    TokenPairConfig, TokenPairInstance, tokenPair, createRefreshToken, SUPPORTED_ALGORITHMS,
+    Session, SessionData, SessionCookieOptions, SessionStore, MemoryStoreOptions, MemoryStore, SessionOptions, session,
+    OAuthProviderPreset, OAuthOptions, OAuthAuthorizeResult, OAuthTokens, OAuthClient,
+    oauth, generatePKCE, generateState, OAUTH_PROVIDERS,
+    authorize, can, canAny, Policy, gate, attachUserHelpers,
+    TwoFactor, twoFactor,
+    InMemoryReplayStore, ReplayStore, Verify2FAOptions,
+    WebAuthn, webauthn, WebAuthnRegistrationOptions, WebAuthnRegistrationResult,
+    WebAuthnVerifyRegistrationOptions, WebAuthnAuthenticationOptions,
+    WebAuthnAuthenticationResult, WebAuthnVerifyAuthenticationOptions,
+    TrustedDevice, trustedDevice, TrustedDeviceIssueOptions,
+    TrustedDeviceVerifyOptions, TrustedDeviceRevokeOptions,
+    EnrollmentFlow, EnrollmentOptions, enrollment,
+} from './auth';
+export {
+    NextFunction, MiddlewareFunction, ErrorHandlerFunction,
+    CorsOptions, cors,
+    BodyParserOptions, JsonParserOptions, UrlencodedParserOptions, TextParserOptions,
+    MultipartOptions, MultipartFile,
+    json, urlencoded, text, raw, multipart,
+    RateLimitOptions, rateLimit,
+    LoggerOptions, logger,
+    CompressOptions, compress,
+    HelmetOptions, helmet,
+    TimeoutOptions, timeout,
+    RequestIdOptions, requestId,
+    CookieParserStatic, cookieParser,
+    StaticOptions,
+    CsrfOptions, csrf,
+    ValidationRule, ValidatorSchema, ValidatorOptions, ValidateFunction, validate,
+} from './middleware';
+export { static } from './middleware';
+export {
+    FetchOptions, FetchResponse, FetchHeaders, fetch,
+} from './fetch';
+export { Env, EnvFieldDef, EnvSchema, EnvLoadOptions, env } from './env';
+export {
+    TYPES, SchemaColumnDef, validateValue, validateFKAction, validateCheck,
+    Query, Model, ModelHooks, ModelObserver, FindOrCreateResult, PaginatedResult,
+    Database, AdapterType, RetryOptions,
+    DatabaseView, DatabaseViewOptions,
+    FullTextSearch, FullTextSearchOptions, SearchOptions, SuggestOptions,
+    GeoQuery, GeoQueryOptions, NearOptions, WithinBounds,
+    GeoJSONPoint, GeoJSONFeature, GeoJSONFeatureCollection,
+    EARTH_RADIUS_KM, EARTH_RADIUS_MI,
+    Migrator, MigrationDefinition, MigrateResult, RollbackResult, MigrationStatus, defineMigration,
+    QueryCache, QueryCacheOptions, CacheStats,
+    Seeder, SeederRunner, Factory, Fake,
+    QueryProfiler, QueryProfilerOptions, ProfiledQuery, N1Detection, ProfilerMetrics,
+    ReplicaManager, ReplicaManagerOptions, HealthCheckResult,
+    // Phase 4
+    TenantManager, TenantManagerOptions, TenantMiddlewareOptions,
+    AuditLog, AuditLogOptions, AuditEntry, AuditTrailOptions, AuditMiddlewareOptions,
+    PluginManager, PluginDefinition, PluginInfo,
+    StoredProcedure, StoredProcedureOptions, ProcedureParam,
+    StoredFunction, StoredFunctionOptions,
+    TriggerManager, TriggerDefinition,
+    CLI, runCLI,
+} from './orm';
+// Re-export validate from orm as schemaValidate to avoid collision with middleware validate
+export { validate as schemaValidate } from './orm';
+export {
+    GrpcStatus, STATUS_NAMES, grpcToHttp, statusName as grpcStatusName,
+    Metadata as GrpcMetadata,
+    Writer as ProtoWriter, Reader as ProtoReader, encode as protoEncode, decode as protoDecode,
+    WIRE_TYPE, TYPE_INFO,
+    parseProto, parseProtoFile, tokenize,
+    frameEncode, FrameParser,
+    BaseCall, UnaryCall, ServerStreamCall, ClientStreamCall, BidiStreamCall,
+    GrpcServiceRegistry, GrpcServiceOptions, GrpcInterceptor, GrpcHandler,
+    GrpcClient, GrpcClientOptions, GrpcCallOptions, GrpcClientMultiAddressOptions,
+    ProtoSchema, MessageDescriptor, EnumDescriptor, ServiceDescriptor, MethodDescriptor, FieldDescriptor,
+    HealthService, ServingStatus,
+    ReflectionService, buildFileDescriptorProto,
+    LoadBalancer, Subchannel, SubchannelState, RoundRobinPicker,
+    ChannelCredentials, CredentialType, createRotatingCredentials,
+    watchProto, WatchProtoOptions,
+} from './grpc';
+export {
+    HttpError, HttpErrorOptions,
+    BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError,
+    MethodNotAllowedError, ConflictError, GoneError, PayloadTooLargeError,
+    UnprocessableEntityError, ValidationError, TooManyRequestsError,
+    InternalError, NotImplementedError, BadGatewayError, ServiceUnavailableError,
+    DatabaseError, DatabaseErrorOptions,
+    ConfigurationError, ConfigurationErrorOptions,
+    MiddlewareError, MiddlewareErrorOptions,
+    RoutingError, RoutingErrorOptions,
+    TimeoutError, TimeoutErrorOptions,
+    ConnectionError, ConnectionErrorOptions,
+    MigrationError, MigrationErrorOptions,
+    TransactionError, TransactionErrorOptions,
+    QueryError, QueryErrorOptions,
+    AdapterError, AdapterErrorOptions,
+    CacheError, CacheErrorOptions,
+    TenancyError, TenancyErrorOptions,
+    AuditError, AuditErrorOptions,
+    PluginError, PluginErrorOptions,
+    ProcedureError, ProcedureErrorOptions,
+    createError, isHttpError,
+    ErrorHandlerOptions, errorHandler,
+    Debug, DebugLogger, DebugLevels, debug,
+} from './errors';
+
+// --- Module Exports ----------------------------------------------
+
+import { App } from './app';
+import { RouterInstance } from './router';
+import { WebSocketConnection, WebSocketPool } from './websocket';
+import { SSEStream } from './sse';
+import {
+    cors, json, urlencoded, text, raw, multipart,
+    rateLimit, logger, compress, helmet, timeout, requestId,
+    CookieParserStatic, csrf, ValidateFunction,
+} from './middleware';
+import { fetch } from './fetch';
+import { Env } from './env';
+import { Database, Model, Query } from './orm';
+import { TYPES, validateFKAction, validateCheck } from './orm';
+import { Migrator, QueryCache, Seeder, SeederRunner, Factory, Fake, defineMigration } from './orm';
+import { QueryProfiler, ReplicaManager } from './orm';
+import { TenantManager, AuditLog, PluginManager, StoredProcedure, StoredFunction, TriggerManager, CLI, runCLI } from './orm';
+import { LifecycleManager, LIFECYCLE_STATE } from './lifecycle';
+import { ClusterManager, cluster as clusterize } from './cluster';
+import {
+    Logger, structuredLogger,
+    Counter, Gauge, Histogram, MetricsRegistry, DEFAULT_BUCKETS,
+    createDefaultMetrics, metricsMiddleware, metricsEndpoint as metricsEndpointHandler,
+    Span, Tracer, parseTraceparent, formatTraceparent, tracingMiddleware, instrumentFetch,
+    healthCheck, createHealthHandlers, memoryCheck, eventLoopCheck, diskSpaceCheck,
+} from './observe';
+import {
+    jwt, jwtSign, jwtVerify, jwtDecode, jwks, tokenPair, createRefreshToken, SUPPORTED_ALGORITHMS,
+    session, Session, MemoryStore,
+    oauth, generatePKCE, generateState, OAUTH_PROVIDERS,
+    authorize, can, canAny, Policy, gate, attachUserHelpers,
+    twoFactor,
+    webauthn,
+    trustedDevice,
+    enrollment,
+} from './auth';
+import {
+    GrpcStatus, grpcToHttp, statusName as grpcStatusName, STATUS_NAMES as GRPC_STATUS_NAMES,
+    GrpcMetadata, ProtoWriter, ProtoReader, protoEncode, protoDecode,
+    WIRE_TYPE, TYPE_INFO,
+    parseProto, parseProtoFile,
+    frameEncode, FrameParser,
+    GrpcServiceRegistry, GrpcClient,
+    ProtoSchema, GrpcServiceOptions, GrpcInterceptor, GrpcHandler,
+    HealthService as GrpcHealthService, ServingStatus as GrpcServingStatus,
+    ReflectionService as GrpcReflectionService,
+    LoadBalancer as GrpcLoadBalancer, Subchannel as GrpcSubchannel, SubchannelState as GrpcSubchannelState,
+    ChannelCredentials, createRotatingCredentials,
+    watchProto,
+} from './grpc';
+import {
+    HttpError, BadRequestError, UnauthorizedError, ForbiddenError,
+    NotFoundError, MethodNotAllowedError, ConflictError, GoneError,
+    PayloadTooLargeError, UnprocessableEntityError, ValidationError,
+    TooManyRequestsError, InternalError, NotImplementedError,
+    BadGatewayError, ServiceUnavailableError,
+    DatabaseError, ConfigurationError, MiddlewareError, RoutingError, TimeoutError,
+    ConnectionError, MigrationError, TransactionError, QueryError, AdapterError, CacheError,
+    TenancyError, AuditError, PluginError, ProcedureError,
+    createError, isHttpError, errorHandler, debug,
+} from './errors';
+
+declare function serveStatic(root: string, options?: import('./middleware').StaticOptions): import('./middleware').MiddlewareFunction;
+
+declare const zeroServer: {
+    createApp(): App;
+    Router(): RouterInstance;
+    cors: typeof cors;
+    fetch: typeof fetch;
+    json: typeof json;
+    urlencoded: typeof urlencoded;
+    text: typeof text;
+    raw: typeof raw;
+    multipart: typeof multipart;
+    static: typeof serveStatic;
+    rateLimit: typeof rateLimit;
+    logger: typeof logger;
+    compress: typeof compress;
+    helmet: typeof helmet;
+    timeout: typeof timeout;
+    requestId: typeof requestId;
+    cookieParser: CookieParserStatic;
+    csrf: typeof csrf;
+    validate: ValidateFunction;
+    env: Env;
+    Database: typeof Database;
+    Model: typeof Model;
+    TYPES: typeof TYPES;
+    Query: typeof Query;
+    validateFKAction: typeof validateFKAction;
+    validateCheck: typeof validateCheck;
+    // Error handling & debugging
+    HttpError: typeof HttpError;
+    BadRequestError: typeof BadRequestError;
+    UnauthorizedError: typeof UnauthorizedError;
+    ForbiddenError: typeof ForbiddenError;
+    NotFoundError: typeof NotFoundError;
+    MethodNotAllowedError: typeof MethodNotAllowedError;
+    ConflictError: typeof ConflictError;
+    GoneError: typeof GoneError;
+    PayloadTooLargeError: typeof PayloadTooLargeError;
+    UnprocessableEntityError: typeof UnprocessableEntityError;
+    ValidationError: typeof ValidationError;
+    TooManyRequestsError: typeof TooManyRequestsError;
+    InternalError: typeof InternalError;
+    NotImplementedError: typeof NotImplementedError;
+    BadGatewayError: typeof BadGatewayError;
+    ServiceUnavailableError: typeof ServiceUnavailableError;
+    // Framework-specific errors
+    DatabaseError: typeof DatabaseError;
+    ConfigurationError: typeof ConfigurationError;
+    MiddlewareError: typeof MiddlewareError;
+    RoutingError: typeof RoutingError;
+    TimeoutError: typeof TimeoutError;
+    // ORM-specific errors
+    ConnectionError: typeof ConnectionError;
+    MigrationError: typeof MigrationError;
+    TransactionError: typeof TransactionError;
+    QueryError: typeof QueryError;
+    AdapterError: typeof AdapterError;
+    CacheError: typeof CacheError;
+    // Phase 4 errors
+    TenancyError: typeof TenancyError;
+    AuditError: typeof AuditError;
+    PluginError: typeof PluginError;
+    ProcedureError: typeof ProcedureError;
+    createError: typeof createError;
+    isHttpError: typeof isHttpError;
+    errorHandler: typeof errorHandler;
+    debug: typeof debug;
+    // ORM Extended 0.6.0 features
+    Migrator: typeof Migrator;
+    defineMigration: typeof defineMigration;
+    QueryCache: typeof QueryCache;
+    Seeder: typeof Seeder;
+    SeederRunner: typeof SeederRunner;
+    Factory: typeof Factory;
+    Fake: typeof Fake;
+    QueryProfiler: typeof QueryProfiler;
+    ReplicaManager: typeof ReplicaManager;
+    // ORM Enterprise (Phase 4)
+    TenantManager: typeof TenantManager;
+    AuditLog: typeof AuditLog;
+    PluginManager: typeof PluginManager;
+    StoredProcedure: typeof StoredProcedure;
+    StoredFunction: typeof StoredFunction;
+    TriggerManager: typeof TriggerManager;
+    // CLI tooling
+    CLI: typeof CLI;
+    runCLI: typeof runCLI;
+    // classes
+    WebSocketConnection: WebSocketConnection;
+    WebSocketPool: {
+        new(): WebSocketPool;
+    };
+    SSEStream: SSEStream;
+    // Lifecycle & Clustering
+    LifecycleManager: typeof LifecycleManager;
+    LIFECYCLE_STATE: typeof LIFECYCLE_STATE;
+    ClusterManager: typeof ClusterManager;
+    cluster: typeof clusterize;
+    // Observability — Structured Logging
+    Logger: typeof Logger;
+    structuredLogger: typeof structuredLogger;
+    // Observability — Metrics
+    Counter: typeof Counter;
+    Gauge: typeof Gauge;
+    Histogram: typeof Histogram;
+    MetricsRegistry: typeof MetricsRegistry;
+    DEFAULT_BUCKETS: typeof DEFAULT_BUCKETS;
+    createDefaultMetrics: typeof createDefaultMetrics;
+    metricsMiddleware: typeof metricsMiddleware;
+    metricsEndpoint: typeof metricsEndpointHandler;
+    // Observability — Tracing
+    Span: typeof Span;
+    Tracer: typeof Tracer;
+    parseTraceparent: typeof parseTraceparent;
+    formatTraceparent: typeof formatTraceparent;
+    tracingMiddleware: typeof tracingMiddleware;
+    instrumentFetch: typeof instrumentFetch;
+    // Observability — Health Checks
+    healthCheck: typeof healthCheck;
+    createHealthHandlers: typeof createHealthHandlers;
+    memoryCheck: typeof memoryCheck;
+    eventLoopCheck: typeof eventLoopCheck;
+    diskSpaceCheck: typeof diskSpaceCheck;
+    // Authentication & Sessions (Phase 3)
+    jwt: typeof jwt;
+    jwtSign: typeof jwtSign;
+    jwtVerify: typeof jwtVerify;
+    jwtDecode: typeof jwtDecode;
+    jwks: typeof jwks;
+    tokenPair: typeof tokenPair;
+    createRefreshToken: typeof createRefreshToken;
+    SUPPORTED_ALGORITHMS: typeof SUPPORTED_ALGORITHMS;
+    session: typeof session;
+    Session: typeof Session;
+    MemoryStore: typeof MemoryStore;
+    oauth: typeof oauth;
+    generatePKCE: typeof generatePKCE;
+    generateState: typeof generateState;
+    OAUTH_PROVIDERS: typeof OAUTH_PROVIDERS;
+    authorize: typeof authorize;
+    can: typeof can;
+    canAny: typeof canAny;
+    Policy: typeof Policy;
+    gate: typeof gate;
+    attachUserHelpers: typeof attachUserHelpers;
+    twoFactor: typeof twoFactor;
+    webauthn: typeof webauthn;
+    trustedDevice: typeof trustedDevice;
+    enrollment: typeof enrollment;
+    // gRPC
+    GrpcStatus: typeof GrpcStatus;
+    grpcToHttp: typeof grpcToHttp;
+    grpcStatusName: typeof grpcStatusName;
+    GRPC_STATUS_NAMES: typeof GRPC_STATUS_NAMES;
+    GrpcMetadata: typeof GrpcMetadata;
+    ProtoWriter: typeof ProtoWriter;
+    ProtoReader: typeof ProtoReader;
+    protoEncode: typeof protoEncode;
+    protoDecode: typeof protoDecode;
+    WIRE_TYPE: typeof WIRE_TYPE;
+    TYPE_INFO: typeof TYPE_INFO;
+    parseProto: typeof parseProto;
+    parseProtoFile: typeof parseProtoFile;
+    frameEncode: typeof frameEncode;
+    FrameParser: typeof FrameParser;
+    GrpcServiceRegistry: typeof GrpcServiceRegistry;
+    GrpcClient: typeof GrpcClient;
+    // gRPC: Health check
+    GrpcHealthService: typeof GrpcHealthService;
+    GrpcServingStatus: typeof GrpcServingStatus;
+    // gRPC: Server reflection
+    GrpcReflectionService: typeof GrpcReflectionService;
+    // gRPC: Load balancing
+    GrpcLoadBalancer: typeof GrpcLoadBalancer;
+    GrpcSubchannel: typeof GrpcSubchannel;
+    GrpcSubchannelState: typeof GrpcSubchannelState;
+    // gRPC: Channel credentials
+    ChannelCredentials: typeof ChannelCredentials;
+    createRotatingCredentials: typeof createRotatingCredentials;
+    // gRPC: Proto hot-reload
+    watchProto: typeof watchProto;
+    /** Package version string */
+    version: string;
+};
+
+export default zeroServer;

package/types/lifecycle.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+
+import { ServerResponse } from 'http';
+
+export type LifecycleState = 'running' | 'draining' | 'closed';
+
+export declare const LIFECYCLE_STATE: {
+    readonly RUNNING: 'running';
+    readonly DRAINING: 'draining';
+    readonly CLOSED: 'closed';
+};
+
+export declare class LifecycleManager {
+    constructor(app: import('./app').App);
+
+    /** Current lifecycle state. */
+    readonly state: LifecycleState;
+
+    /** Number of currently active HTTP requests. */
+    readonly activeRequests: number;
+
+    /** Whether the server is draining. */
+    readonly isDraining: boolean;
+
+    /** Whether the server has fully shut down. */
+    readonly isClosed: boolean;
+
+    /** Register a lifecycle event listener. */
+    on(event: 'beforeShutdown' | 'shutdown', fn: () => void | Promise<void>): LifecycleManager;
+
+    /** Remove a lifecycle event listener. */
+    off(event: 'beforeShutdown' | 'shutdown', fn: () => void | Promise<void>): LifecycleManager;
+
+    /** Track an active HTTP request. */
+    trackRequest(res: ServerResponse): void;
+
+    /** Register a WebSocket pool for graceful shutdown. */
+    registerPool(pool: import('./websocket').WebSocketPool): LifecycleManager;
+
+    /** Unregister a WebSocket pool. */
+    unregisterPool(pool: import('./websocket').WebSocketPool): LifecycleManager;
+
+    /** Track an SSE stream for graceful shutdown. */
+    trackSSE(stream: import('./sse').SSEStream): LifecycleManager;
+
+    /** Register an ORM Database for shutdown. */
+    registerDatabase(db: { close(): Promise<void> }): LifecycleManager;
+
+    /** Unregister an ORM Database. */
+    unregisterDatabase(db: { close(): Promise<void> }): LifecycleManager;
+
+    /** Install SIGTERM/SIGINT process signal handlers. */
+    installSignalHandlers(): void;
+
+    /** Remove installed signal handlers. */
+    removeSignalHandlers(): void;
+
+    /** Perform a full graceful shutdown. */
+    shutdown(opts?: { timeout?: number }): Promise<void>;
+}