@resonatehq/supabase 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1,23 +1,12 @@
-import { Context, type Encryptor, type Func } from "@resonatehq/sdk";
-type OnTerminateCallback = (result: {
-    status: "completed";
-    data?: any;
-} | {
-    status: "suspended";
-    result: string[];
-}) => Promise<void>;
-export { Context };
+import { type Encryptor, type Func } from "@resonatehq/sdk";
 export declare class Resonate {
     private registry;
     private dependencies;
     private verbose;
     private encryptor;
-    private idPrefix;
-    private onTerminateFn?;
-    constructor({ verbose, encryptor, prefix, }?: {
+    constructor({ verbose, encryptor, }?: {
         verbose?: boolean;
         encryptor?: Encryptor;
-        prefix?: string;
     });
     register<F extends Func>(name: string, func: F, options?: {
         version?: number;
@@ -26,7 +15,6 @@ 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,11 +1,10 @@
 import { Handler, HttpNetwork, JsonEncoder, NoopEncryptor, NoopHeartbeat, NoopTracer, OptionsBuilder, Registry, ResonateInner, WallClock, } from "@resonatehq/sdk";
 export class Resonate {
-    constructor({ verbose = false, encryptor = undefined, prefix = undefined, } = {}) {
+    constructor({ verbose = false, encryptor = undefined, } = {}) {
         this.registry = new Registry();
         this.dependencies = new Map();
         this.verbose = verbose;
         this.encryptor = encryptor ?? new NoopEncryptor();
-        this.idPrefix = prefix ? `${prefix}:` : "";
     }
     register(nameOrFunc, funcOrOptions, maybeOptions = {}) {
         const { version = 1 } = (typeof funcOrOptions === "object" ? funcOrOptions : maybeOptions) ?? {};
@@ -16,9 +15,6 @@ export class Resonate {
     setDependency(name, obj) {
         this.dependencies.set(name, obj);
     }
-    onTerminate(fn) {
-        this.onTerminateFn = fn;
-    }
     async handler(req) {
         try {
             if (req.method !== "POST") {
@@ -66,17 +62,13 @@ export class Resonate {
                 dependencies: this.dependencies,
                 optsBuilder: new OptionsBuilder({
                     match: (_) => url,
-                    idPrefix: this.idPrefix,
+                    idPrefix: "",
                 }),
                 verbose: this.verbose,
                 tracer,
             });
             const task = { kind: "unclaimed", task: body.task };
-            const handleCallback = (data) => {
-                this.onTerminateFn?.(data);
-                return Promise.resolve();
-            };
-            return new Promise((resolve) => {
+            const completion = new Promise((resolve) => {
                 resonateInner.process(tracer.startSpan(task.task.rootPromiseId, clock.now()), task, (error, status) => {
                     if (error || !status) {
                         resolve(new Response(JSON.stringify({
@@ -88,36 +80,27 @@ export class Resonate {
                         return;
                     }
                     if (status.kind === "completed") {
-                        handleCallback({
+                        resolve(new Response(JSON.stringify({
                             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,
-                            }));
-                        });
+                            result: status.promise.value,
+                            requestUrl: url,
+                        }), {
+                            status: 200,
+                        }));
                         return;
                     }
                     else if (status.kind === "suspended") {
-                        handleCallback({
+                        resolve(new Response(JSON.stringify({
                             status: "suspended",
-                            result: status.callbacks.map((callback) => callback.promiseId),
-                        }).finally(() => {
-                            resolve(new Response(JSON.stringify({
-                                status: "suspended",
-                                requestUrl: url,
-                            }), {
-                                status: 200,
-                            }));
-                        });
+                            requestUrl: url,
+                        }), {
+                            status: 200,
+                        }));
                         return;
                     }
                 });
             });
+            return completion;
         }
         catch (error) {
             return new Response(JSON.stringify({

package/package.json

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

package/src/index.ts

@@ -1,5 +1,4 @@
 import {
-	Context,
 	type Encryptor,
 	type Func,
 	Handler,
@@ -15,29 +14,18 @@ import {
 	WallClock,
 } from "@resonatehq/sdk";
 
-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,
-		prefix = undefined,
-	}: { verbose?: boolean; encryptor?: Encryptor; prefix?: string } = {}) {
+	}: { verbose?: boolean; encryptor?: Encryptor } = {}) {
 		this.verbose = verbose;
 		this.encryptor = encryptor ?? new NoopEncryptor();
-		this.idPrefix = prefix ? `${prefix}:` : "";
 	}
 
 	public register<F extends Func>(
@@ -76,9 +64,6 @@ 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 {
@@ -144,7 +129,7 @@ export class Resonate {
 				dependencies: this.dependencies,
 				optsBuilder: new OptionsBuilder({
 					match: (_: string): string => url,
-					idPrefix: this.idPrefix,
+					idPrefix: "",
 				}),
 				verbose: this.verbose,
 				tracer,
@@ -152,16 +137,7 @@ export class Resonate {
 
 			const task: Task = { kind: "unclaimed", task: body.task };
 
-			const handleCallback = (
-				data:
-					| { status: "completed"; data?: any }
-					| { status: "suspended"; result: string[] },
-			): Promise<void> => {
-				this.onTerminateFn?.(data);
-				return Promise.resolve();
-			};
-
-			return new Promise((resolve) => {
+			const completion: Promise<Response> = new Promise((resolve) => {
 				resonateInner.process(
 					tracer.startSpan(task.task.rootPromiseId, clock.now()),
 					task,
@@ -180,49 +156,39 @@ export class Resonate {
 							);
 							return;
 						}
+
 						if (status.kind === "completed") {
-							handleCallback({
-								status: "completed",
-								data: encoder.decode(
-									this.encryptor.decrypt(status.promise.value),
+							resolve(
+								new Response(
+									JSON.stringify({
+										status: "completed",
+										result: status.promise.value,
+										requestUrl: url,
+									}),
+									{
+										status: 200,
+									},
 								),
-							}).finally(() => {
-								resolve(
-									new Response(
-										JSON.stringify({
-											status: "completed",
-											result: status.promise.value,
-											requestUrl: url,
-										}),
-										{
-											status: 200,
-										},
-									),
-								);
-							});
+							);
 							return;
 						} else if (status.kind === "suspended") {
-							handleCallback({
-								status: "suspended",
-								result: status.callbacks.map((callback) => callback.promiseId),
-							}).finally(() => {
-								resolve(
-									new Response(
-										JSON.stringify({
-											status: "suspended",
-											requestUrl: url,
-										}),
-										{
-											status: 200,
-										},
-									),
-								);
-							});
+							resolve(
+								new Response(
+									JSON.stringify({
+										status: "suspended",
+										requestUrl: url,
+									}),
+									{
+										status: 200,
+									},
+								),
+							);
 							return;
 						}
 					},
 				);
 			});
+			return completion;
 		} catch (error) {
 			return new Response(
 				JSON.stringify({