@resonatehq/supabase 0.1.5 → 0.1.6

package/.github/workflows/ci.yaml

@@ -27,13 +27,10 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up Bun
-        uses: oven-sh/setup-bun@v2
+      - name: Set up Deno
+        uses: denoland/setup-deno@v1
         with:
-          bun-version: 1.3.0
-
-      - name: install
-        run: bun install
+          deno-version: v1.x
 
       - name: check linting
-        run: bun run check
+        run: deno run check

package/dist/index.d.ts

@@ -1,13 +1,24 @@
-import { type Func } from "@resonatehq/sdk";
+import { Context, type Func } from "@resonatehq/sdk";
 import { type Encryptor } from "@resonatehq/sdk/dist/src/encryptor";
+type OnTerminateCallback = (result: {
+    status: "completed";
+    data?: any;
+} | {
+    status: "suspended";
+    result: string[];
+}) => Promise<void>;
+export { Context };
 export declare class Resonate {
     private registry;
     private dependencies;
     private verbose;
     private encryptor;
-    constructor({ verbose, encryptor, }?: {
+    private idPrefix;
+    private onTerminateFn?;
+    constructor({ verbose, encryptor, prefix, }?: {
         verbose?: boolean;
         encryptor?: Encryptor;
+        prefix?: string;
     });
     register<F extends Func>(name: string, func: F, options?: {
         version?: number;
@@ -16,6 +27,7 @@ export declare class Resonate {
         version?: number;
     }): void;
     setDependency(name: string, obj: any): void;
+    onTerminate(fn: OnTerminateCallback): void;
     handler(req: Request): Promise<Response>;
     httpHandler(): Deno.HttpServer;
 }

package/dist/index.js

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Resonate = void 0;
-const sdk_1 = require("@resonatehq/sdk");
-const encryptor_1 = require("@resonatehq/sdk/dist/src/encryptor");
-const options_1 = require("@resonatehq/sdk/dist/src/options");
-const tracer_1 = require("@resonatehq/sdk/dist/src/tracer");
-class Resonate {
-    constructor({ verbose = false, encryptor = undefined, } = {}) {
-        this.registry = new sdk_1.Registry();
+import { Handler, HttpNetwork, JsonEncoder, NoopHeartbeat, Registry, ResonateInner, WallClock, } from "@resonatehq/sdk";
+import { NoopEncryptor, } from "@resonatehq/sdk/dist/src/encryptor";
+import { OptionsBuilder } from "@resonatehq/sdk/dist/src/options";
+import { NoopTracer } from "@resonatehq/sdk/dist/src/tracer";
+export class Resonate {
+    constructor({ verbose = false, encryptor = undefined, prefix = undefined, } = {}) {
+        this.registry = new Registry();
         this.dependencies = new Map();
         this.verbose = verbose;
-        this.encryptor = encryptor ?? new encryptor_1.NoopEncryptor();
+        this.encryptor = encryptor ?? new NoopEncryptor();
+        this.idPrefix = prefix ? `${prefix}:` : "";
     }
     register(nameOrFunc, funcOrOptions, maybeOptions = {}) {
         const { version = 1 } = (typeof funcOrOptions === "object" ? funcOrOptions : maybeOptions) ?? {};
@@ -21,6 +19,9 @@ class Resonate {
     setDependency(name, obj) {
         this.dependencies.set(name, obj);
     }
+    onTerminate(fn) {
+        this.onTerminateFn = fn;
+    }
     async handler(req) {
         try {
             if (req.method !== "POST") {
@@ -46,34 +47,39 @@ class Resonate {
                     status: 400,
                 });
             }
-            const encoder = new sdk_1.JsonEncoder();
-            const clock = new sdk_1.WallClock();
-            const tracer = new tracer_1.NoopTracer();
-            const network = new sdk_1.HttpNetwork({
+            const encoder = new JsonEncoder();
+            const clock = new WallClock();
+            const tracer = new NoopTracer();
+            const network = new HttpNetwork({
                 headers: {},
                 timeout: 60 * 1000, // 60s
                 url: body.href.base,
                 verbose: this.verbose,
             });
-            const resonateInner = new sdk_1.ResonateInner({
+            const resonateInner = new ResonateInner({
                 unicast: url,
                 anycast: url,
                 pid: `pid-${Math.random().toString(36).substring(7)}`,
                 ttl: 30 * 1000,
                 clock,
                 network,
-                handler: new sdk_1.Handler(network, encoder, this.encryptor),
+                handler: new Handler(network, encoder, this.encryptor),
                 registry: this.registry,
-                heartbeat: new sdk_1.NoopHeartbeat(),
+                heartbeat: new NoopHeartbeat(),
                 dependencies: this.dependencies,
-                optsBuilder: new options_1.OptionsBuilder({
+                optsBuilder: new OptionsBuilder({
                     match: (_) => url,
+                    idPrefix: this.idPrefix,
                 }),
                 verbose: this.verbose,
                 tracer,
             });
             const task = { kind: "unclaimed", task: body.task };
-            const completion = new Promise((resolve) => {
+            const handleCallback = (data) => {
+                this.onTerminateFn?.(data);
+                return Promise.resolve();
+            };
+            return new Promise((resolve) => {
                 resonateInner.process(tracer.startSpan(task.task.rootPromiseId, clock.now()), task, (error, status) => {
                     if (error || !status) {
                         resolve(new Response(JSON.stringify({
@@ -85,27 +91,36 @@ class Resonate {
                         return;
                     }
                     if (status.kind === "completed") {
-                        resolve(new Response(JSON.stringify({
+                        handleCallback({
                             status: "completed",
-                            result: status.promise.value,
-                            requestUrl: url,
-                        }), {
-                            status: 200,
-                        }));
+                            data: encoder.decode(this.encryptor.decrypt(status.promise.value)),
+                        }).finally(() => {
+                            resolve(new Response(JSON.stringify({
+                                status: "completed",
+                                result: status.promise.value,
+                                requestUrl: url,
+                            }), {
+                                status: 200,
+                            }));
+                        });
                         return;
                     }
                     else if (status.kind === "suspended") {
-                        resolve(new Response(JSON.stringify({
+                        handleCallback({
                             status: "suspended",
-                            requestUrl: url,
-                        }), {
-                            status: 200,
-                        }));
+                            result: status.callbacks.map((callback) => callback.promiseId),
+                        }).finally(() => {
+                            resolve(new Response(JSON.stringify({
+                                status: "suspended",
+                                requestUrl: url,
+                            }), {
+                                status: 200,
+                            }));
+                        });
                         return;
                     }
                 });
             });
-            return completion;
         }
         catch (error) {
             return new Response(JSON.stringify({
@@ -119,7 +134,6 @@ class Resonate {
         });
     }
 }
-exports.Resonate = Resonate;
 function buildForwardedURL(req) {
     const headers = req.headers;
     const url = new URL(req.url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resonatehq/supabase",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Resonate FaaS handler for Supabase Edge Functions (TypeScript)",
   "repository": {
     "url": "https://github.com/resonatehq/resonate-faas-supabase-ts"
@@ -29,6 +29,6 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@resonatehq/sdk": "^0.9.3"
+    "@resonatehq/sdk": "^0.9.5"
   }
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 import {
+	Context,
 	type Func,
 	Handler,
 	HttpNetwork,
@@ -9,6 +10,7 @@ import {
 	type Task,
 	WallClock,
 } from "@resonatehq/sdk";
+
 import {
 	type Encryptor,
 	NoopEncryptor,
@@ -16,18 +18,29 @@ import {
 import { OptionsBuilder } from "@resonatehq/sdk/dist/src/options";
 import { NoopTracer } from "@resonatehq/sdk/dist/src/tracer";
 
+type OnTerminateCallback = (
+	result:
+		| { status: "completed"; data?: any }
+		| { status: "suspended"; result: string[] },
+) => Promise<void>;
+
+export { Context };
 export class Resonate {
 	private registry = new Registry();
 	private dependencies = new Map<string, any>();
 	private verbose: boolean;
 	private encryptor: Encryptor;
+	private idPrefix: string;
+	private onTerminateFn?: OnTerminateCallback;
 
 	constructor({
 		verbose = false,
 		encryptor = undefined,
-	}: { verbose?: boolean; encryptor?: Encryptor } = {}) {
+		prefix = undefined,
+	}: { verbose?: boolean; encryptor?: Encryptor; prefix?: string } = {}) {
 		this.verbose = verbose;
 		this.encryptor = encryptor ?? new NoopEncryptor();
+		this.idPrefix = prefix ? `${prefix}:` : "";
 	}
 
 	public register<F extends Func>(
@@ -66,6 +79,9 @@ export class Resonate {
 	public setDependency(name: string, obj: any): void {
 		this.dependencies.set(name, obj);
 	}
+	public onTerminate(fn: OnTerminateCallback): void {
+		this.onTerminateFn = fn;
+	}
 
 	public async handler(req: Request): Promise<Response> {
 		try {
@@ -131,6 +147,7 @@ export class Resonate {
 				dependencies: this.dependencies,
 				optsBuilder: new OptionsBuilder({
 					match: (_: string): string => url,
+					idPrefix: this.idPrefix,
 				}),
 				verbose: this.verbose,
 				tracer,
@@ -138,7 +155,16 @@ export class Resonate {
 
 			const task: Task = { kind: "unclaimed", task: body.task };
 
-			const completion: Promise<Response> = new Promise((resolve) => {
+			const handleCallback = (
+				data:
+					| { status: "completed"; data?: any }
+					| { status: "suspended"; result: string[] },
+			): Promise<void> => {
+				this.onTerminateFn?.(data);
+				return Promise.resolve();
+			};
+
+			return new Promise((resolve) => {
 				resonateInner.process(
 					tracer.startSpan(task.task.rootPromiseId, clock.now()),
 					task,
@@ -157,39 +183,49 @@ export class Resonate {
 							);
 							return;
 						}
-
 						if (status.kind === "completed") {
-							resolve(
-								new Response(
-									JSON.stringify({
-										status: "completed",
-										result: status.promise.value,
-										requestUrl: url,
-									}),
-									{
-										status: 200,
-									},
+							handleCallback({
+								status: "completed",
+								data: encoder.decode(
+									this.encryptor.decrypt(status.promise.value),
 								),
-							);
+							}).finally(() => {
+								resolve(
+									new Response(
+										JSON.stringify({
+											status: "completed",
+											result: status.promise.value,
+											requestUrl: url,
+										}),
+										{
+											status: 200,
+										},
+									),
+								);
+							});
 							return;
 						} else if (status.kind === "suspended") {
-							resolve(
-								new Response(
-									JSON.stringify({
-										status: "suspended",
-										requestUrl: url,
-									}),
-									{
-										status: 200,
-									},
-								),
-							);
+							handleCallback({
+								status: "suspended",
+								result: status.callbacks.map((callback) => callback.promiseId),
+							}).finally(() => {
+								resolve(
+									new Response(
+										JSON.stringify({
+											status: "suspended",
+											requestUrl: url,
+										}),
+										{
+											status: 200,
+										},
+									),
+								);
+							});
 							return;
 						}
 					},
 				);
 			});
-			return completion;
 		} catch (error) {
 			return new Response(
 				JSON.stringify({

package/tsconfig.json

@@ -1,8 +1,9 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",