@supacloud/elysia 0.18.0 → 0.20.0

package/dist/http-response-cache.d.ts

@@ -0,0 +1,14 @@
+import type { SupAuthRequestContext } from "./identity";
+import type { HttpPolicy } from "./http-policy";
+import type { HttpCacheStore } from "./http-policy-stores";
+interface CachePolicyOptions {
+    store: HttpCacheStore;
+    requireAccess(request: Request): SupAuthRequestContext;
+    ttlMs: number;
+    maxBodyBytes: number;
+    route: string;
+    namespace: string;
+    onWriteError(): void;
+}
+export declare function createCachePolicy(options: CachePolicyOptions): HttpPolicy;
+export {};

package/dist/http-telemetry.d.ts

@@ -0,0 +1,27 @@
+import { Elysia } from "elysia";
+export declare function httpRequestId(request: Request): string | undefined;
+export interface HttpTelemetryEvent {
+    requestId: string;
+    method: string;
+    /** Static route template only. Query strings and concrete paths are excluded. */
+    route: string;
+    status: number;
+    durationMs: number;
+}
+export type HttpTelemetryObserver = (event: Readonly<HttpTelemetryEvent>) => void | Promise<void>;
+/** Request tracing is best effort, not a durable business audit. */
+export declare function createHttpTelemetry(observe: HttpTelemetryObserver): Elysia<"", "local", {
+    decorator: {};
+    store: {};
+    derive: {};
+}, {
+    typebox: {};
+    error: [];
+}, {
+    schema: {};
+    schemas: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>;

package/dist/index.d.ts

@@ -1,19 +1,38 @@
-import { Elysia } from "elysia";
+import { Elysia, type AnyElysia, type Context, type StatusMap } from "elysia";
 import type { CommandRuntimeAudit, CommandRuntimeAuthorizer, CommandRuntimeGovernance, CommandRuntimeInvocation, CommandRuntimeMiddleware } from "@supacloud/app";
 import { type CommandPreview } from "@supacloud/contracts";
+import { type HttpPolicyRegistry } from "./http-policy";
+export { HttpPolicyConfigurationError } from "./http-policy";
+export type { HttpPolicy, HttpPolicyContext, HttpPolicyResponseContext, HttpPolicyDeclaration, HttpPolicyRegistry } from "./http-policy";
+export { createHttpPolicySuite } from "./http-policy-suite";
+export type { HttpPolicySuiteOptions, BuiltinHttpPolicyDeclaration } from "./http-policy-suite";
+export { createMemoryHttpRateLimitStore, createMemoryHttpCacheStore } from "./http-policy-stores";
+export type { HttpRateLimitStore, HttpRateLimitResult, HttpCacheStore, HttpCacheEntry } from "./http-policy-stores";
+export { createPostgresHttpPolicyStores, HTTP_POLICY_STORE_SQL } from "./http-policy-postgres";
+export type { HttpPolicyDatabase } from "./http-policy-postgres";
+export { createHttpTelemetry } from "./http-telemetry";
+export type { HttpTelemetryEvent, HttpTelemetryObserver } from "./http-telemetry";
 import { type ExecutionObserver } from "./execution";
 import { type ApplicationDocumentationOptions } from "./documentation";
 export type { ExecutionEvent, ExecutionObserver } from "./execution";
+export { bindCompiledCommand } from "./command-binding";
+export type { CompiledCommandBinding, CompiledCommandBindingOptions, CompiledCommandCallContext, } from "./command-binding";
 export { createSchemaDecoder, assertResponseStatusDeclared, defineElysiaRoute, defineJsonContract, defineRouteContract, registerElysiaRoute, responseSchemaForStatus, responseStatusDeclared, responseStatusOf, SchemaContractError, toElysiaRouteSchema, } from "./schema_contract";
 export type { ElysiaRouteContext, ElysiaRouteDefinition, ElysiaRouteHandler, ElysiaRouteSchema, ResponseMapSelector, RouteContractSchemas, SchemaDecoderOptions, SchemaNormalizeMode, } from "./schema_contract";
 export { createPersistentCommandAdapter, type PersistentCommandHandler } from "./persistent-command";
 export { createDocumentationPlugin } from "./documentation";
 export type { ApplicationDocumentationOptions, DocumentationSource, GraphqlDocumentationOptions, OpenApiDocumentationOptions, } from "./documentation";
 export interface CompiledRoute {
+    parse?: "none";
+    allowDeleteBody?: true;
+    /** Compiler-emitted route title, exposed as the OpenAPI operation summary. */
+    title?: string;
     method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
     path: string;
     /** Method name on the controller instance. */
     handler: string;
+    /** Static metadata preserved by the compiler; HTTP policies are adapter-owned. */
+    data?: Record<string, unknown>;
     /** TypeBox schema; validation is enabled only when the field is present. */
     body?: unknown;
     params?: unknown;
@@ -217,7 +236,13 @@ export interface ErrorContext {
     frameworkCode: string | number | undefined;
 }
 export type ErrorMapper = (error: unknown, context: ErrorContext) => Response | undefined | Promise<Response | undefined>;
-export interface ApplicationOptions {
+export type ApplicationHttpContext<Http extends AnyElysia = Elysia> = Omit<Context<{}, {
+    decorator: Http["~Singleton"]["decorator"];
+    store: Http["~Singleton"]["store"];
+    derive: Http["~Singleton"]["derive"] & Http["~Ephemeral"]["derive"];
+}>, "body" | "params" | "query" | "headers" | "cookie"> & Pick<HttpContext, "body" | "params" | "query" | "headers" | "cookie">;
+export type HttpRequestContextFactory<Http extends AnyElysia = Elysia, Value = unknown> = (request: Request, context: ApplicationHttpContext<Http>) => Value | Promise<Value>;
+export interface ApplicationOptions<Http extends AnyElysia = Elysia, RequestContext = unknown> {
     name?: string;
     /** false rejects extra schema properties instead of silently removing them. */
     normalize?: boolean;
@@ -225,8 +250,12 @@ export interface ApplicationOptions {
     modules?: CompiledModule[];
     /** Platform-level dependencies (db client etc.), passed to createServices. */
     deps?: Record<string, unknown>;
-    /** Builds the per-request context object. Defaults to { requestId, request }. */
-    requestContext?: RequestContextFactory;
+    /** Native plugin. Use scoped/global derive/resolve hooks to extend compiled routes. */
+    http?: Http;
+    /** Startup-compiled policies selected by route.data.httpPolicies, in declaration order. */
+    httpPolicies?: HttpPolicyRegistry<Http>;
+    /** Runs after validation and HTTP resolvers, with the validated native context. */
+    requestContext?: HttpRequestContextFactory<Http, RequestContext>;
     /** Enforces permission/audit/idempotency policy for command-bound routes. */
     commandGovernance?: CommandGovernance;
     /** Optional custom or composed executor. When provided alongside commandGovernance, it wraps or composes with governance. */
@@ -286,15 +315,47 @@ export declare function previewCompiledCommand<Input>(options: {
 }): Promise<CommandPreview>;
 export declare function requireTrustedIdentity(requestContext: unknown): Required<Pick<TrustedRequestIdentity, "subject" | "accessToken">> & TrustedRequestIdentity;
 export declare function requireIdempotencyKey(invocation: CommandInvocation): string;
+interface HttpContext {
+    body: unknown;
+    params: Record<string, unknown>;
+    query: Record<string, unknown>;
+    headers?: Record<string, unknown>;
+    cookie?: Record<string, unknown>;
+    request: Request;
+    set: {
+        status?: number | keyof StatusMap;
+    };
+    scope?: Record<string, unknown>;
+    requestContext?: unknown;
+}
 /**
  * Adapt a single compiled module into an Elysia plugin.
  *
- * The plugin decorates the context with `services`; when the module defines
- * `createRequestScope`, a fresh request scope is resolved per request and
- * exposed on the `scope` context key. Request-scoped controller instances are
- * looked up on `scope`, everything else on `services`.
+ * The plugin resolves module-local `services`; when the module defines
+ * `createRequestScope`, a fresh scope is created inside the governed handler
+ * and passed to the controller input as `scope`. Request-scoped controllers
+ * are looked up on that scope, everything else on `services`.
  */
-export declare function createModulePlugin(compiled: CompiledModule, services: Record<string, unknown>, ctxFactory?: RequestContextFactory, options?: Pick<ApplicationOptions, "commandGovernance" | "commandExecutor" | "errorMapper" | "onExecution" | "normalize">, imported?: Record<string, Record<string, unknown>>): Elysia;
+export declare function createModulePlugin<const Services extends Record<string, unknown>, const Http extends AnyElysia = Elysia>(compiled: CompiledModule, services: Services, ctxFactory?: HttpRequestContextFactory<Http>, options?: Pick<ApplicationOptions<Http>, "http" | "httpPolicies" | "commandGovernance" | "commandExecutor" | "errorMapper" | "onExecution" | "normalize">, imported?: Record<string, Record<string, unknown>>): import("elysia/types").LocalHookReturn<"", "local", {
+    decorator: {} & Http["~Singleton"]["decorator"];
+    store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
+    derive: {} & Http["~Singleton"]["derive"];
+}, {
+    typebox: {} & Http["~Definitions"]["typebox"];
+    error: [...Http["~Definitions"]["error"]];
+}, import("elysia").DefaultMetadata & Http["~Metadata"], import("elysia/types").ResolveRouteErrors<{}, [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]]> & Http["~Routes"], import("elysia").DefaultEphemeral, {
+    derive: {} & Http["~Ephemeral"]["derive"];
+    schema: {} & import("elysia/types").MergeSchema<{} & Http["~Ephemeral"]["schema"], {}, "", false>;
+    schemas: {} & Http["~Ephemeral"]["schemas"];
+    response: {} & Http["~Ephemeral"]["response"];
+    error: [...Http["~Ephemeral"]["error"]];
+}, import("elysia/types").ExtractErrorFromHandle<{
+    readonly services: Services;
+    readonly requestContext: unknown;
+}>, {
+    readonly services: Services;
+    readonly requestContext: unknown;
+}>;
 /**
  * Execute one compiler-emitted Job descriptor.
  *
@@ -311,9 +372,49 @@ export declare function defaultErrorResponse(error: unknown, frameworkCode?: str
  * `createServices` receives `deps` plus the services of all previously
  * created modules, keyed by module name.
  */
-export declare function createApplication(options: ApplicationOptions): Elysia;
+export declare function createApplication<const Http extends AnyElysia = Elysia>(options: ApplicationOptions<Http>): Elysia<"", "local", {
+    decorator: {} & Http["~Singleton"]["decorator"];
+    store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
+    derive: {} & Http["~Singleton"]["derive"] & Http["~Ephemeral"]["derive"];
+}, {
+    typebox: {} & Http["~Definitions"]["typebox"];
+    error: [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]];
+}, import("elysia").DefaultMetadata & {
+    schema: import("elysia/types").MergeSchema<import("elysia/types").MergeSchema<{} & Http["~Ephemeral"]["schema"], {}, "", false>, (import("elysia").DefaultMetadata & Http["~Metadata"])["schema"], "", false>;
+    schemas: (import("elysia").DefaultMetadata & Http["~Metadata"])["schemas"] & {} & Http["~Ephemeral"]["schemas"];
+    macro: (import("elysia").DefaultMetadata & Http["~Metadata"])["macro"];
+    macroFn: (import("elysia").DefaultMetadata & Http["~Metadata"])["macroFn"];
+    parser: (import("elysia").DefaultMetadata & Http["~Metadata"])["parser"];
+    response: import("elysia/types").UnionResponseStatus<(import("elysia").DefaultMetadata & Http["~Metadata"])["response"], import("elysia/types").UnionResponseStatus<{} & Http["~Ephemeral"]["response"], {}>>;
+}, import("elysia/types").ResolveRouteErrors<{}, [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]]> & Http["~Routes"], import("elysia").DefaultEphemeral, {
+    derive: {};
+    schema: {};
+    schemas: {};
+    response: {};
+    error: [];
+}>;
 /** Semantic alias of createApplication for readable tests. */
-export declare function createTestApp(options: ApplicationOptions): Elysia;
+export declare function createTestApp<const Http extends AnyElysia = Elysia>(options: ApplicationOptions<Http>): Elysia<"", "local", {
+    decorator: {} & Http["~Singleton"]["decorator"];
+    store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
+    derive: {} & Http["~Singleton"]["derive"] & Http["~Ephemeral"]["derive"];
+}, {
+    typebox: {} & Http["~Definitions"]["typebox"];
+    error: [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]];
+}, import("elysia").DefaultMetadata & {
+    schema: import("elysia/types").MergeSchema<import("elysia/types").MergeSchema<{} & Http["~Ephemeral"]["schema"], {}, "", false>, (import("elysia").DefaultMetadata & Http["~Metadata"])["schema"], "", false>;
+    schemas: (import("elysia").DefaultMetadata & Http["~Metadata"])["schemas"] & {} & Http["~Ephemeral"]["schemas"];
+    macro: (import("elysia").DefaultMetadata & Http["~Metadata"])["macro"];
+    macroFn: (import("elysia").DefaultMetadata & Http["~Metadata"])["macroFn"];
+    parser: (import("elysia").DefaultMetadata & Http["~Metadata"])["parser"];
+    response: import("elysia/types").UnionResponseStatus<(import("elysia").DefaultMetadata & Http["~Metadata"])["response"], import("elysia/types").UnionResponseStatus<{} & Http["~Ephemeral"]["response"], {}>>;
+}, import("elysia/types").ResolveRouteErrors<{}, [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]]> & Http["~Routes"], import("elysia").DefaultEphemeral, {
+    derive: {};
+    schema: {};
+    schemas: {};
+    response: {};
+    error: [];
+}>;
 export { createMemorySandbox, } from "./memory";
 export type { HandleLike as MemoryHandleLike, MemoryDatabase, MemorySandbox, MemorySandboxOptions, MemoryStorage, MemoryStorageObject, } from "./memory";
 export { createMemoryPolicy } from "./memory_policy";