@resonatehq/supabase 0.1.10 → 0.1.11

package/dist/index.d.ts

@@ -1,10 +1,18 @@
 import { Context, type Encryptor, type Func } from "@resonatehq/sdk";
+type OnTerminateCallback = (result: {
+    status: "completed";
+    result?: any;
+} | {
+    status: "suspended";
+    waitingOn: string[];
+}) => Promise<void>;
 export { Context };
 export declare class Resonate {
     private registry;
     private dependencies;
     private verbose;
     private encryptor;
+    private encoder;
     constructor({ verbose, encryptor, }?: {
         verbose?: boolean;
         encryptor?: Encryptor;
@@ -16,6 +24,7 @@ export declare class Resonate {
         version?: number;
     }): void;
     setDependency(name: string, obj: any): void;
-    handler(req: Request): Promise<Response>;
-    httpHandler(): Deno.HttpServer;
+    handler(req: Request, onTerminate?: OnTerminateCallback): Promise<Response>;
+    private decrypt;
+    httpHandler(onTerminate?: OnTerminateCallback): Deno.HttpServer;
 }

package/dist/index.js

@@ -5,6 +5,7 @@ export class Resonate {
         this.dependencies = new Map();
         this.verbose = verbose;
         this.encryptor = encryptor ?? new NoopEncryptor();
+        this.encoder = new JsonEncoder();
     }
     register(nameOrFunc, funcOrOptions, maybeOptions = {}) {
         const { version = 1 } = (typeof funcOrOptions === "object" ? funcOrOptions : maybeOptions) ?? {};
@@ -15,7 +16,7 @@ export class Resonate {
     setDependency(name, obj) {
         this.dependencies.set(name, obj);
     }
-    async handler(req) {
+    async handler(req, onTerminate) {
         try {
             if (req.method !== "POST") {
                 return new Response(JSON.stringify({ error: "Method not allowed. Use POST." }), {
@@ -40,7 +41,6 @@ export class Resonate {
                     status: 400,
                 });
             }
-            const encoder = new JsonEncoder();
             const clock = new WallClock();
             const tracer = new NoopTracer();
             const network = new HttpNetwork({
@@ -56,7 +56,7 @@ export class Resonate {
                 ttl: 30 * 1000,
                 clock,
                 network,
-                handler: new Handler(network, encoder, this.encryptor),
+                handler: new Handler(network, this.encoder, this.encryptor),
                 registry: this.registry,
                 heartbeat: new NoopHeartbeat(),
                 dependencies: this.dependencies,
@@ -68,39 +68,39 @@ export class Resonate {
                 tracer,
             });
             const task = { kind: "unclaimed", task: body.task };
-            const completion = new Promise((resolve) => {
+            return new Promise((resolve, reject) => {
                 resonateInner.process(tracer.startSpan(task.task.rootPromiseId, clock.now()), task, (error, status) => {
                     if (error || !status) {
-                        resolve(new Response(JSON.stringify({
+                        return reject({
                             error: "Task processing failed",
                             details: { error, status },
-                        }), {
-                            status: 500,
-                        }));
-                        return;
-                    }
-                    if (status.kind === "completed") {
-                        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,
-                        }));
-                        return;
+                        });
                     }
+                    return resolve({
+                        ...(status.kind === "completed"
+                            ? { status: status.kind, result: status.promise.value }
+                            : {
+                                status: status.kind,
+                                waitingOn: status.callbacks.map((cb) => cb.promiseId),
+                            }),
+                    });
                 });
+            })
+                .then(async (res) => {
+                try {
+                    await onTerminate?.(this.decrypt(res));
+                }
+                catch (e) {
+                    console.error("onTerminate failed", e);
+                }
+                return new Response(JSON.stringify({
+                    ...res,
+                    requestUrl: url,
+                }), { status: 200 });
+            })
+                .catch((err) => {
+                return new Response(JSON.stringify(err), { status: 500 });
             });
-            return completion;
         }
         catch (error) {
             return new Response(JSON.stringify({
@@ -108,9 +108,17 @@ export class Resonate {
             }), { status: 500 });
         }
     }
-    httpHandler() {
+    decrypt(res) {
+        if (res.status !== "completed")
+            return res;
+        return {
+            ...res,
+            result: this.encoder.decode(this.encryptor.decrypt(res.result)),
+        };
+    }
+    httpHandler(onTerminate) {
         return Deno.serve(async (req) => {
-            return await this.handler(req);
+            return await this.handler(req, onTerminate);
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resonatehq/supabase",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Resonate FaaS handler for Supabase Edge Functions (TypeScript)",
   "repository": {
     "url": "https://github.com/resonatehq/resonate-faas-supabase-ts"

package/src/index.ts

@@ -15,6 +15,12 @@ import {
 	WallClock,
 } from "@resonatehq/sdk";
 
+type OnTerminateCallback = (
+	result:
+		| { status: "completed"; result?: any }
+		| { status: "suspended"; waitingOn: string[] },
+) => Promise<void>;
+
 export { Context };
 
 export class Resonate {
@@ -22,6 +28,7 @@ export class Resonate {
 	private dependencies = new Map<string, any>();
 	private verbose: boolean;
 	private encryptor: Encryptor;
+	private encoder: JsonEncoder;
 
 	constructor({
 		verbose = false,
@@ -29,6 +36,7 @@ export class Resonate {
 	}: { verbose?: boolean; encryptor?: Encryptor } = {}) {
 		this.verbose = verbose;
 		this.encryptor = encryptor ?? new NoopEncryptor();
+		this.encoder = new JsonEncoder();
 	}
 
 	public register<F extends Func>(
@@ -68,7 +76,10 @@ export class Resonate {
 		this.dependencies.set(name, obj);
 	}
 
-	public async handler(req: Request): Promise<Response> {
+	public async handler(
+		req: Request,
+		onTerminate?: OnTerminateCallback,
+	): Promise<Response> {
 		try {
 			if (req.method !== "POST") {
 				return new Response(
@@ -109,7 +120,6 @@ export class Resonate {
 				);
 			}
 
-			const encoder = new JsonEncoder();
 			const clock = new WallClock();
 			const tracer = new NoopTracer();
 			const network = new HttpNetwork({
@@ -126,7 +136,7 @@ export class Resonate {
 				ttl: 30 * 1000,
 				clock,
 				network,
-				handler: new Handler(network, encoder, this.encryptor),
+				handler: new Handler(network, this.encoder, this.encryptor),
 				registry: this.registry,
 				heartbeat: new NoopHeartbeat(),
 				dependencies: this.dependencies,
@@ -140,58 +150,49 @@ export class Resonate {
 
 			const task: Task = { kind: "unclaimed", task: body.task };
 
-			const completion: Promise<Response> = new Promise((resolve) => {
+			return new Promise<
+				| { status: "completed"; result?: any }
+				| { status: "suspended"; waitingOn: string[] }
+			>((resolve, reject) => {
 				resonateInner.process(
 					tracer.startSpan(task.task.rootPromiseId, clock.now()),
 					task,
 					(error, status) => {
 						if (error || !status) {
-							resolve(
-								new Response(
-									JSON.stringify({
-										error: "Task processing failed",
-										details: { error, status },
-									}),
-									{
-										status: 500,
-									},
-								),
-							);
-							return;
+							return reject({
+								error: "Task processing failed",
+								details: { error, status },
+							});
 						}
 
-						if (status.kind === "completed") {
-							resolve(
-								new Response(
-									JSON.stringify({
-										status: "completed",
-										result: status.promise.value,
-										requestUrl: url,
+						return resolve({
+							...(status.kind === "completed"
+								? { status: status.kind, result: status.promise.value }
+								: {
+										status: status.kind,
+										waitingOn: status.callbacks.map((cb) => cb.promiseId),
 									}),
-									{
-										status: 200,
-									},
-								),
-							);
-							return;
-						} else if (status.kind === "suspended") {
-							resolve(
-								new Response(
-									JSON.stringify({
-										status: "suspended",
-										requestUrl: url,
-									}),
-									{
-										status: 200,
-									},
-								),
-							);
-							return;
-						}
+						});
 					},
 				);
-			});
-			return completion;
+			})
+				.then(async (res) => {
+					try {
+						await onTerminate?.(this.decrypt(res));
+					} catch (e) {
+						console.error("onTerminate failed", e);
+					}
+					return new Response(
+						JSON.stringify({
+							...res,
+							requestUrl: url,
+						}),
+						{ status: 200 },
+					);
+				})
+				.catch((err) => {
+					return new Response(JSON.stringify(err), { status: 500 });
+				});
 		} catch (error) {
 			return new Response(
 				JSON.stringify({
@@ -202,9 +203,24 @@ export class Resonate {
 		}
 	}
 
-	public httpHandler(): Deno.HttpServer {
+	private decrypt(
+		res:
+			| { status: "completed"; result?: any }
+			| { status: "suspended"; waitingOn: string[] },
+	):
+		| { status: "completed"; result?: any }
+		| { status: "suspended"; waitingOn: string[] } {
+		if (res.status !== "completed") return res;
+
+		return {
+			...res,
+			result: this.encoder.decode(this.encryptor.decrypt(res.result)),
+		};
+	}
+
+	public httpHandler(onTerminate?: OnTerminateCallback): Deno.HttpServer {
 		return Deno.serve(async (req: Request) => {
-			return await this.handler(req);
+			return await this.handler(req, onTerminate);
 		});
 	}
 }