@supacloud/elysia 0.20.2 → 0.21.0

package/dist/examples/framework-catalog.d.ts

@@ -0,0 +1,77 @@
+import { type CompiledModule } from "../index";
+export interface CatalogIdentity {
+    tenantId: string;
+    subject: string;
+}
+export interface CatalogItem {
+    id: string;
+    name: string;
+}
+export interface CatalogPorts {
+    /** Resolve credentials using a trusted verifier, never a tenant header alone. */
+    authenticate(request: Request): Promise<CatalogIdentity>;
+    /** The repository must apply this verified identity to its authorization. */
+    read(identity: CatalogIdentity, id: string): Promise<CatalogItem>;
+}
+/**
+ * A handwritten adapter fixture, not compiler output or a new module format.
+ * Real applications can supply the existing compiler's createCompiledModules().
+ */
+export declare function createCatalogModule(ports: CatalogPorts): CompiledModule;
+export declare function createCatalogApplication(ports: CatalogPorts): import("elysia/types").AddRoute<"", "local", {
+    decorator: {
+        clock: () => number;
+    };
+    store: {};
+    derive: {};
+}, {
+    typebox: {};
+    error: [];
+}, import("elysia").DefaultMetadata & {
+    schema: {};
+    schemas: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, import("elysia").DefaultEphemeral, {
+    derive: {};
+    schema: {};
+    schemas: {};
+    response: {};
+    error: [];
+}, "get", "/health", import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, "/health">, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, ({ clock }: {
+    body: unknown;
+    query: Record<string, string | undefined>;
+    params: {};
+    headers: Record<string, string | undefined>;
+    cookie: Record<string, import("elysia").Cookie<unknown>>;
+    server: import("elysia").Server | null;
+    redirect: import("elysia").redirect;
+    set: {
+        headers: import("elysia").HTTPHeaders;
+        status?: number | keyof import("elysia").StatusMap;
+        cookie?: Record<string, import("elysia").BaseCookie>;
+        redirect?: never;
+    };
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = import("elysia").StatusResponse<Code>>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, import("elysia").NumericStatus<Code>>;
+    problem: typeof import("elysia").problem;
+    defer: (fn: import("elysia/types").AfterResponseHandler<NoInfer<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, "/health">, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>>, NoInfer<{
+        decorator: {
+            clock: () => number;
+        };
+        store: {};
+        derive: {};
+    } & {
+        derive: {};
+    }>>) => import("elysia/types").MaybePromise<void>;
+    readonly path: string;
+    route?: string | undefined;
+    rid?: string | undefined;
+    request: Request;
+    store: {};
+    clock: () => number;
+}) => {
+    ok: boolean;
+    time: number;
+}>;

package/dist/execution.d.ts

@@ -1,13 +1,2 @@
-export interface ExecutionEvent {
-    kind: "route" | "command" | "job";
-    operation: string;
-    stage: string;
-    phase: "started" | "succeeded" | "failed";
-    requestId?: string;
-    durationMs?: number;
-}
-/** Metadata only: never receives request bodies, credentials, results or errors. */
-export type ExecutionObserver = (event: Readonly<ExecutionEvent>) => void | Promise<void>;
-export declare function observeExecution<T>(observer: ExecutionObserver | undefined, event: Pick<ExecutionEvent, "kind" | "operation" | "stage" | "requestId">, next: () => T | Promise<T>): Promise<T>;
-export declare function executionRequestId(context: unknown): string | undefined;
-export declare function executionTrace(context: unknown): Pick<ExecutionEvent, "requestId">;
+export { executionRequestId, executionTrace, observeExecution, } from "@supacloud/app/execution";
+export type { ExecutionEvent, ExecutionObserver } from "@supacloud/app/execution";

package/dist/framework.d.ts

@@ -0,0 +1,39 @@
+import type { AnyElysia, Elysia } from "elysia";
+import { type ApplicationOptions, type CompiledModule } from "./index";
+/**
+ * Experimental profile for evaluating SupaCloud application composition.
+ *
+ * This intentionally remains a thin profile over createApplication. It owns
+ * SupaCloud defaults without wrapping or reimplementing Elysia's API.
+ */
+export interface SupaCloudFrameworkOptions<Http extends AnyElysia = Elysia, RequestContext = unknown> extends Omit<ApplicationOptions<Http, RequestContext>, "name" | "normalize" | "modules"> {
+    /** Application modules in compiler-emitted topological order. */
+    modules?: CompiledModule[];
+    /** Public application name used in diagnostics and Elysia plugin identity. */
+    name: string;
+    /**
+     * Reject extra properties rather than silently removing them.
+     */
+    normalize?: false;
+}
+export declare function createSupaCloudFramework<const Http extends AnyElysia = Elysia, RequestContext = unknown>(options: SupaCloudFrameworkOptions<Http, RequestContext>): 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: [];
+}>;

package/dist/index.d.ts

@@ -22,6 +22,8 @@ export type { ElysiaRouteContext, ElysiaRouteDefinition, ElysiaRouteHandler, Ely
 export { createPersistentCommandAdapter, type PersistentCommandHandler } from "./persistent-command";
 export { createDocumentationPlugin } from "./documentation";
 export type { ApplicationDocumentationOptions, DocumentationSource, GraphqlDocumentationOptions, OpenApiDocumentationOptions, } from "./documentation";
+export { createSupaCloudFramework } from "./framework";
+export type { SupaCloudFrameworkOptions } from "./framework";
 export interface CompiledRoute {
     parse?: "none";
     allowDeleteBody?: true;

package/dist/index.js

@@ -662,39 +662,11 @@ function createPostgresHttpPolicyStores(database) {
   };
 }
 // src/execution.ts
-async function observeExecution(observer, event, next) {
-  const emit = (phase, durationMs) => {
-    if (!observer)
-      return;
-    try {
-      Promise.resolve(observer(Object.freeze({
-        ...event,
-        phase,
-        ...durationMs === undefined ? {} : { durationMs }
-      }))).catch(() => {});
-    } catch {}
-  };
-  const started = performance.now();
-  emit("started");
-  try {
-    const result = await next();
-    emit("succeeded", performance.now() - started);
-    return result;
-  } catch (error) {
-    emit("failed", performance.now() - started);
-    throw error;
-  }
-}
-function executionRequestId(context) {
-  if (!context || typeof context !== "object" || !("requestId" in context))
-    return;
-  const value = context.requestId;
-  return typeof value === "string" && /^[A-Za-z0-9._:-]{1,256}$/.test(value) ? value : undefined;
-}
-function executionTrace(context) {
-  const requestId = executionRequestId(context);
-  return requestId === undefined ? {} : { requestId };
-}
+import {
+  executionRequestId,
+  executionTrace,
+  observeExecution
+} from "@supacloud/app/execution";
 
 // src/schema_contract.ts
 import {
@@ -1099,6 +1071,14 @@ function createPersistentCommandAdapter(command, options) {
     }
   };
 }
+// src/framework.ts
+function createSupaCloudFramework(options) {
+  return createApplication({
+    ...options,
+    normalize: options.normalize ?? false,
+    modules: options.modules ?? []
+  });
+}
 // src/feature.ts
 function assertFeatureTransition(spec, state, event) {
   const transition = Object.hasOwn(spec.transitions, event) ? spec.transitions[event] : undefined;
@@ -2758,6 +2738,7 @@ export {
   createQueueWorkerTransport,
   createSchemaDecoder,
   createSupAuthRequestContext,
+  createSupaCloudFramework,
   createSupaCloudRequestContext,
   createTestApp,
   createWorker,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/elysia",
-  "version": "0.20.2",
+  "version": "0.21.0",
   "description": "Elysia runtime adapter for SupaCloud compiled modules: application/request scopes, route registration and validation",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,7 +28,7 @@
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build",
     "test": "bun test",
-    "test:conformance": "bun test src/conformance.test.ts",
+    "test:conformance": "bun test src/conformance.test.ts src/application-execution.test.ts ../app/src/execution.test.ts ../app/src/execution_bundle.test.ts",
     "test:runtime-safety": "SUPACLOUD_REQUIRE_RUNTIME_SAFETY=1 bun test src/runtime-safety.test.ts",
     "test:contract-upgrade": "bun test src/contract-upgrade.test.ts",
     "bench:http-policy": "bun bench/http-policy.ts",
@@ -49,25 +49,25 @@
     "directory": "packages/elysia"
   },
   "dependencies": {
-    "@supacloud/app": "0.18.1",
-    "@supacloud/contracts": "0.5.1",
+    "@supacloud/app": "0.19.0",
+    "@supacloud/contracts": "0.6.0",
     "exact-mirror": "1.2.6",
     "jose": "^6.2.11",
     "typebox": "1.3.34"
   },
   "overrides": {
-    "@supacloud/delivery": "0.2.1",
-    "@supacloud/contracts": "0.5.1",
-    "@supacloud/commands": "0.7.1"
+    "@supacloud/delivery": "0.3.0",
+    "@supacloud/contracts": "0.6.0",
+    "@supacloud/commands": "0.8.0"
   },
   "peerDependencies": {
     "elysia": "2.0.0-beta.19"
   },
   "devDependencies": {
-    "@supacloud/compiler": "0.27.4",
-    "@supacloud/delivery": "0.2.1",
-    "@supacloud/commands": "0.7.1",
-    "@supacloud/db": "0.9.1",
+    "@supacloud/compiler": "0.28.0",
+    "@supacloud/delivery": "0.3.0",
+    "@supacloud/commands": "0.8.0",
+    "@supacloud/db": "0.10.0",
     "@types/bun": "^1.4.2",
     "elysia": "2.0.0-beta.19",
     "typescript": "^7.0.2"