@supacloud/elysia 0.17.0 → 0.19.0

package/dist/index.d.ts

@@ -1,18 +1,38 @@
-import { Elysia } from "elysia";
+import { Elysia, type AnyElysia, type InferContext, 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;
@@ -116,19 +136,8 @@ export interface SupaCloudRequestContext {
     identity: TrustedRequestIdentity;
     idempotencyKey?: string;
 }
-export interface CommandInvocation {
-    command: CompiledCommand;
-    input: {
-        body: unknown;
-        params: Record<string, unknown>;
-        query: Record<string, unknown>;
-    };
-    request: Request;
-    requestContext: unknown;
-    scope?: Record<string, unknown>;
-    services: Record<string, unknown>;
-}
-export type CommandExecutor = (invocation: CommandInvocation, next: () => unknown | Promise<unknown>) => unknown | Promise<unknown>;
+export type CommandInvocation = CommandRuntimeInvocation<CompiledCommand>;
+export type CommandExecutor = CommandRuntimeMiddleware<CommandInvocation>;
 export { assertFeatureTransition } from "./feature";
 export type { FeatureTransitionSpec } from "./feature";
 export interface ApplicationAspectContext {
@@ -149,28 +158,48 @@ export type ApplicationAspect = (context: ApplicationAspectContext, next: () =>
  */
 export declare function composeAspects(...aspects: (ApplicationAspect | undefined | null)[]): ApplicationAspect;
 export type ApplicationAspectPipeline = (context: ApplicationAspectContext, next: () => unknown | Promise<unknown>, observe?: (stage: string, run: () => unknown | Promise<unknown>) => unknown | Promise<unknown>) => unknown | Promise<unknown>;
-export type CommandAuthorizer = (invocation: CommandInvocation) => void | Promise<void>;
-export type CommandMiddleware = (invocation: CommandInvocation, next: () => unknown | Promise<unknown>) => unknown | Promise<unknown>;
-export interface CommandAudit {
-    succeeded(invocation: CommandInvocation, result: unknown): void | Promise<void>;
-    failed(invocation: CommandInvocation, error: unknown): void | Promise<void>;
+export type CommandAuthorizer = CommandRuntimeAuthorizer<CommandInvocation>;
+export type CommandMiddleware = CommandRuntimeMiddleware<CommandInvocation>;
+export type CommandAudit = CommandRuntimeAudit<CommandInvocation>;
+export type CommandGovernance = CommandRuntimeGovernance<CommandInvocation>;
+export interface CommandAuthorizationRequest {
+    readonly principal: {
+        readonly kind: "user" | "service";
+        readonly issuer: string;
+        readonly subject: string;
+    };
+    readonly applicationId: string;
+    readonly domain: {
+        readonly type: string;
+        readonly id: string;
+    };
 }
-export interface CommandGovernance {
-    /** Application-owned adapters: a single RPC owns all declared persistence. */
-    rpc?: Record<string, {
-        capabilities: {
-            audit?: boolean;
-            transaction?: boolean;
-            idempotency?: boolean;
-            boundary?: "database" | "external";
-        };
-        execute: CommandMiddleware;
-    }>;
-    authorize: CommandAuthorizer;
-    idempotency?: CommandMiddleware;
-    transaction?: CommandMiddleware;
-    audit?: CommandAudit;
+export interface CommandAuthorizationContext {
+    readonly applicationId: string;
+    readonly permissions: readonly string[];
+    readonly permissionCatalogVersion?: string;
+    readonly permissionCatalogDigest?: string;
 }
+export interface CommandAuthorizationCatalog {
+    readonly version: string;
+    readonly digest?: string;
+}
+export interface CommandAuthorizationAdapterOptions {
+    readonly applicationId: string;
+    readonly issuer: string;
+    readonly domain: (invocation: CommandInvocation) => {
+        readonly type: string;
+        readonly id: string;
+    };
+    readonly resolve: (request: CommandAuthorizationRequest) => Promise<CommandAuthorizationContext>;
+    readonly catalog?: CommandAuthorizationCatalog;
+}
+/**
+ * Adapt a SupAuth-style resolver to the standard command governance port.
+ * The resolver remains the authorization source of truth; this adapter only
+ * maps trusted request identity and normalizes public failure statuses.
+ */
+export declare function createCommandAuthorizationAdapter(options: CommandAuthorizationAdapterOptions): CommandAuthorizer;
 /**
  * Compose multiple CommandExecutors into a single onion-style pipeline.
  * Outer executors run first before calling `next()`, and complete last.
@@ -207,7 +236,73 @@ export interface ErrorContext {
     frameworkCode: string | number | undefined;
 }
 export type ErrorMapper = (error: unknown, context: ErrorContext) => Response | undefined | Promise<Response | undefined>;
-export interface ApplicationOptions {
+declare function mountHttp<const Http extends AnyElysia = Elysia>(http?: Http, name?: string, normalize?: boolean): Elysia<"", {
+    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"];
+    resolve: {} & Http["~Singleton"]["resolve"];
+}, {
+    typebox: {};
+    error: {};
+} & Http["~Definitions"], {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & Http["~Metadata"], {} & Http["~Routes"], {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["derive"];
+    resolve: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["resolve"];
+    schema: import("elysia").MergeSchema<({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["schema"], {}, "">;
+    standaloneSchema: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["standaloneSchema"] & {};
+    response: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["response"] & {};
+}>;
+export type ApplicationHttpContext<Http extends AnyElysia = Elysia> = Omit<InferContext<ReturnType<typeof mountHttp<Http>>>, "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;
@@ -215,8 +310,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. */
@@ -276,15 +375,91 @@ 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>>): Elysia<"", {
+    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"];
+    resolve: {} & Http["~Singleton"]["resolve"];
+}, {
+    typebox: {};
+    error: {};
+} & Http["~Definitions"], {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & Http["~Metadata"], {} & Http["~Routes"], {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["derive"];
+    resolve: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["resolve"] & {
+        readonly services: Services;
+        readonly requestContext: unknown;
+    };
+    schema: {} & import("elysia").MergeSchema<({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["schema"], {}, "">;
+    standaloneSchema: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["standaloneSchema"];
+    response: import("elysia/types").UnionResponseStatus<{} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["response"], import("elysia").ExtractErrorFromHandle<{
+        readonly services: Services;
+        readonly requestContext: unknown;
+    }>>;
+}>;
 /**
  * Execute one compiler-emitted Job descriptor.
  *
@@ -301,9 +476,135 @@ 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<"", {
+    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"];
+    resolve: {} & Http["~Singleton"]["resolve"];
+}, {
+    typebox: {};
+    error: {};
+} & Http["~Definitions"], {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & Http["~Metadata"], {} & Http["~Routes"], {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["derive"];
+    resolve: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["resolve"];
+    schema: import("elysia").MergeSchema<({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["schema"], {}, "">;
+    standaloneSchema: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["standaloneSchema"] & {};
+    response: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["response"] & {};
+}>;
 /** 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<"", {
+    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"];
+    resolve: {} & Http["~Singleton"]["resolve"];
+}, {
+    typebox: {};
+    error: {};
+} & Http["~Definitions"], {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & Http["~Metadata"], {} & Http["~Routes"], {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["derive"];
+    resolve: {} & ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["resolve"];
+    schema: import("elysia").MergeSchema<({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["schema"], {}, "">;
+    standaloneSchema: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["standaloneSchema"] & {};
+    response: ({
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & Http["~Ephemeral"])["response"] & {};
+}>;
 export { createMemorySandbox, } from "./memory";
 export type { HandleLike as MemoryHandleLike, MemoryDatabase, MemorySandbox, MemorySandboxOptions, MemoryStorage, MemoryStorageObject, } from "./memory";
 export { createMemoryPolicy } from "./memory_policy";