@supacloud/elysia 0.17.0 → 0.18.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { Elysia } from "elysia";
+import type { CommandRuntimeAudit, CommandRuntimeAuthorizer, CommandRuntimeGovernance, CommandRuntimeInvocation, CommandRuntimeMiddleware } from "@supacloud/app";
 import { type CommandPreview } from "@supacloud/contracts";
 import { type ExecutionObserver } from "./execution";
 import { type ApplicationDocumentationOptions } from "./documentation";
@@ -116,19 +117,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 +139,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 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 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 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.

package/dist/index.js

@@ -1291,6 +1291,42 @@ function descriptorPipeline(descriptor, boundary, observer) {
     ...executionTrace(context.requestContext)
   }, run) : undefined);
 }
+function createCommandAuthorizationAdapter(options) {
+  return async (invocation) => {
+    const permission = invocation.command.permission;
+    if (!permission || !/^[a-z][a-z0-9._-]*:[a-z][a-z0-9._-]*$/.test(permission)) {
+      throw new ApplicationError("Command permission must use resource:action syntax", {
+        status: 500,
+        code: "COMMAND_PERMISSION_INVALID"
+      });
+    }
+    const context = invocation.requestContext;
+    const identity = isRecord(context) && isTrustedIdentity(context.identity) ? context.identity : undefined;
+    if (!isAuthenticatedTrustedIdentity(identity)) {
+      throw new ApplicationError("Authentication required", { status: 401, code: "AUTHENTICATION_REQUIRED" });
+    }
+    const request = {
+      principal: { kind: "user", issuer: options.issuer, subject: identity.subject },
+      applicationId: options.applicationId,
+      domain: options.domain(invocation)
+    };
+    let resolved;
+    try {
+      resolved = await options.resolve(request);
+    } catch {
+      throw new ApplicationError("Authorization is unavailable", { status: 503, code: "AUTHORIZATION_UNAVAILABLE" });
+    }
+    if (!isRecord(resolved) || !Array.isArray(resolved.permissions) || !resolved.permissions.every((value) => typeof value === "string") || resolved.permissionCatalogVersion !== undefined && typeof resolved.permissionCatalogVersion !== "string" || resolved.permissionCatalogDigest !== undefined && typeof resolved.permissionCatalogDigest !== "string" || resolved.applicationId !== options.applicationId || options.catalog !== undefined && (resolved.permissionCatalogVersion !== options.catalog.version || options.catalog.digest !== undefined && resolved.permissionCatalogDigest !== options.catalog.digest)) {
+      throw new ApplicationError("Authorization context is not bound to this application", {
+        status: 503,
+        code: "AUTHORIZATION_CONTEXT_INVALID"
+      });
+    }
+    if (!resolved.permissions.includes(permission)) {
+      throw new ApplicationError("Permission denied", { status: 403, code: "PERMISSION_DENIED" });
+    }
+  };
+}
 function composeCommandExecutors(...executors) {
   const active = executors.filter((e) => typeof e === "function");
   if (active.length === 0)
@@ -1585,6 +1621,67 @@ function requireIdempotencyKey(invocation) {
   }
   return key;
 }
+function assertCommandGovernanceReady(compiled, governance, executor) {
+  if ((compiled.commands ?? []).length === 0)
+    return;
+  if (executor !== undefined && typeof executor !== "function") {
+    throw new ApplicationError(`Module "${compiled.name}" has no callable command executor`, {
+      code: "COMMAND_EXECUTOR_UNCONFIGURED"
+    });
+  }
+  if (!governance && !executor) {
+    throw new ApplicationError(`Module "${compiled.name}" has commands but no command governance`, {
+      code: "COMMAND_GOVERNANCE_UNCONFIGURED"
+    });
+  }
+  if (!governance)
+    return;
+  if (typeof governance.authorize !== "function") {
+    throw new ApplicationError(`Module "${compiled.name}" has no authorization adapter`, {
+      code: "COMMAND_AUTHORIZATION_UNCONFIGURED"
+    });
+  }
+  for (const command of compiled.commands ?? []) {
+    if (command.audit && command.rpc === undefined && (typeof governance.audit?.succeeded !== "function" || typeof governance.audit?.failed !== "function")) {
+      throw new ApplicationError(`Command "${command.name}" has no audit adapter`, {
+        code: "COMMAND_AUDIT_UNCONFIGURED"
+      });
+    }
+    if (command.idempotency === "required" && typeof governance.idempotency !== "function" && command.rpc === undefined) {
+      throw new ApplicationError(`Command "${command.name}" has no idempotency adapter`, {
+        code: "COMMAND_IDEMPOTENCY_UNCONFIGURED"
+      });
+    }
+    if (command.transaction === "required" && typeof governance.transaction !== "function" && command.rpc === undefined) {
+      throw new ApplicationError(`Command "${command.name}" has no transaction adapter`, {
+        code: "COMMAND_TRANSACTION_UNCONFIGURED"
+      });
+    }
+    if (command.rpc !== undefined) {
+      const adapter = Object.hasOwn(governance.rpc ?? {}, command.rpc) ? governance.rpc?.[command.rpc] : undefined;
+      if (!adapter || typeof adapter.execute !== "function" || !isRecord(adapter.capabilities)) {
+        throw new ApplicationError(`Command "${command.name}" has no RPC governance adapter`, {
+          code: "COMMAND_RPC_UNCONFIGURED"
+        });
+      }
+      if (command.audit && adapter.capabilities.audit !== true) {
+        throw new ApplicationError(`Command "${command.name}" RPC adapter has no audit capability`, {
+          code: "COMMAND_AUDIT_UNCONFIGURED"
+        });
+      }
+      if (command.idempotency === "required" && adapter.capabilities.idempotency !== true) {
+        throw new ApplicationError(`Command "${command.name}" RPC adapter has no idempotency capability`, {
+          code: "COMMAND_IDEMPOTENCY_UNCONFIGURED"
+        });
+      }
+      if (command.transaction === "required" && adapter.capabilities.transaction !== true) {
+        throw new ApplicationError(`Command "${command.name}" RPC adapter has no transaction capability`, {
+          code: "COMMAND_TRANSACTION_UNCONFIGURED"
+        });
+      }
+    }
+  }
+}
 function joinPaths(prefix, path) {
   const joined = `${prefix}/${path}`.replace(/\/{2,}/g, "/");
   return joined.length > 1 ? joined.replace(/\/+$/, "") : joined;
@@ -1654,6 +1751,7 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
   if (hasCommandRoutes && !options.commandGovernance && !options.commandExecutor) {
     throw new ApplicationError(`Module "${compiled.name}" has command routes but no commandGovernance`, { code: "COMMAND_GOVERNANCE_UNCONFIGURED" });
   }
+  assertCommandGovernanceReady(compiled, options.commandGovernance, options.commandExecutor);
   const commandsByClassName = new Map((compiled.commands ?? []).map((command) => [command.className, command]));
   for (const controller of compiled.controllers) {
     for (const route of controller.routes) {
@@ -1953,6 +2051,7 @@ export {
   composeAspects,
   composeCommandExecutors,
   createApplication,
+  createCommandAuthorizationAdapter,
   createCommandExecutor,
   createDocumentationPlugin,
   createMemoryPolicy,

package/dist/webhook-migration-example.d.ts

@@ -1,7 +1,16 @@
-import type { CommandAuthorization, CommandIdentity } from "@supacloud/contracts";
+import { type CommandAuthorization, type CommandIdentity } from "@supacloud/contracts";
 import { type CommandDatabase, type CommandTransaction } from "@supacloud/db";
+import { type CommandExecutor } from "./index";
 export { decodeWebhookInput } from "./fixtures/webhook/contracts";
 export declare const WEBHOOK_EXAMPLE_SQL = "CREATE TABLE IF NOT EXISTS public.webhook_module_example (\n  tenant_id text NOT NULL, id text NOT NULL, enabled boolean NOT NULL,\n  writes integer NOT NULL DEFAULT 0, PRIMARY KEY (tenant_id,id)\n);";
+/**
+ * Register the existing native command boundary, not a pass-through executor.
+ * Controllers still call their generated UpdateWebhook service directly. Any
+ * explicit command invocation delegates to that same service, which owns
+ * authorization, durable receipts, transactions and audit. Never run a second
+ * route continuation or construct another command runtime here.
+ */
+export declare const executeWebhookCommand: CommandExecutor;
 /** Composition only; the compiler generates factories and routes from the real module. */
 export declare function createWebhookMigrationExample(options: {
     database: CommandDatabase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/elysia",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Elysia runtime adapter for SupaCloud compiled modules: application/request scopes, route registration and validation",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,7 +46,7 @@
     "directory": "packages/elysia"
   },
   "dependencies": {
-    "@supacloud/app": "0.14.0",
+    "@supacloud/app": "0.15.0",
     "@supacloud/contracts": "0.4.0",
     "jose": "^6.2.11"
   },
@@ -58,7 +58,7 @@
     "elysia": "^1.4.30"
   },
   "devDependencies": {
-    "@supacloud/compiler": "0.22.0",
+    "@supacloud/compiler": "0.23.0",
     "@supacloud/commands": "0.5.0",
     "@supacloud/db": "0.8.0",
     "@types/bun": "^1.4.2",