Maybe async refactor

packages/cli/src/cli.ts

@@ -2,13 +2,12 @@
 
 import * as Commands from "./commands";
 
-import { executeMaybeAsyncFunction } from "@polywrap/core-js";
 import { program } from "commander";
 
 export const run = async (argv: string[]): Promise<void> => {
   for (const command of Object.values(Commands)) {
     if ("setup" in command) {
-      await executeMaybeAsyncFunction(command.setup, program);
+      await command.setup(program);
     }
   }
 

packages/cli/src/commands/types.ts

@@ -1,7 +1,8 @@
+import { MaybeAsync } from "@polywrap/core-js";
 import { Command as Program, Argument } from "commander";
 
 export { Program, Argument };
 
 export interface Command {
-  setup: (program: Program) => void;
+  setup: (program: Program) => MaybeAsync<void>;
 }

packages/cli/src/lib/option-parsers/client-config.ts

@@ -3,7 +3,6 @@ import { intlMsg } from "../intl";
 import { importTypescriptModule } from "../system";
 import { getTestEnvClientConfig } from "../test-env";
 
-import { executeMaybeAsyncFunction } from "@polywrap/core-js";
 import { PolywrapClientConfig } from "@polywrap/client-js";
 import path from "path";
 
@@ -43,10 +42,7 @@ export async function parseClientConfigOption(
       process.exit(1);
     }
 
-    finalClientConfig = await executeMaybeAsyncFunction(
-      configModule.getClientConfig,
-      finalClientConfig
-    );
+    finalClientConfig = await configModule.getClientConfig(finalClientConfig);
 
     try {
       validateClientConfig(finalClientConfig);

packages/cli/src/lib/workflow/JobRunner.ts

@@ -1,7 +1,7 @@
 import { JobResult, JobStatus, Step } from "./types";
 
 import { PolywrapClient } from "@polywrap/client-js";
-import { executeMaybeAsyncFunction, MaybeAsync } from "@polywrap/core-js";
+import { MaybeAsync } from "@polywrap/core-js";
 import { WorkflowJobs } from "@polywrap/polywrap-manifest-types-js";
 import { ClientConfigBuilder } from "@polywrap/client-config-builder-js";
 
@@ -208,7 +208,7 @@ export class JobRunner {
       this.jobOutput.set(absId, result);
 
       if (this.onExecution) {
-        await executeMaybeAsyncFunction(this.onExecution, absId, result);
+        await this.onExecution(absId, result);
       }
     }
   }

packages/js/core/src/__tests__/MaybeAsync.spec.ts

@@ -1,40 +1,41 @@
-import {
-  MaybeAsync,
-  executeMaybeAsyncFunction,
-  isPromise,
-} from "..";
+import { MaybeAsync, isPromise } from "..";
 
-class ClassInstance {
+interface IClassInterface {
+  normalMethod(arg: string): MaybeAsync<string>;
+  asyncMethod(arg: string): MaybeAsync<string>;
+}
+
+class ClassInstance implements IClassInterface {
   constructor(private _prop: string) {}
 
   normalMethod(arg: string): string {
     return this._prop + arg;
   }
 
   async asyncMethod(arg: string): Promise<string> {
-    await new Promise((resolve) =>
-      setTimeout(resolve, 200)
-    );
+    await new Promise((resolve) => setTimeout(resolve, 200));
 
     return this._prop + arg;
   }
 }
 
 describe("MaybeAsync", () => {
-  const promise: MaybeAsync<string> =
-    new Promise<string>((resolve, reject) => { return "" });
-  const testFunction = (args: unknown[]) => { return "foo" };
-  const testFunctionReturnPromise = (args: unknown[]) => new Promise<string>((resolve) => { resolve("foo") });
+  const testFunction = (): MaybeAsync<string> => {
+    return "foo";
+  };
+  const testFunctionReturnPromise = (): MaybeAsync<string> =>
+    new Promise<string>((resolve) => {
+      resolve("foo");
+    });
 
   it("sanity", async () => {
-    expect(isPromise(promise)).toBe(true);
-    expect(await executeMaybeAsyncFunction(testFunction)).toBe("foo");
-    expect(await executeMaybeAsyncFunction(testFunctionReturnPromise)).toBe("foo");
+    expect(await testFunction()).toBe("foo");
+    expect(await testFunctionReturnPromise()).toBe("foo");
   });
 
   it("works with class instances", async () => {
-    const instance = new ClassInstance("bar");
-    expect(await executeMaybeAsyncFunction(instance.normalMethod.bind(instance, "foo"))).toBe("barfoo")
-    expect(await executeMaybeAsyncFunction(instance.asyncMethod.bind(instance, "foo"))).toBe("barfoo")
-  })
+    const instance: IClassInterface = new ClassInstance("bar");
+    expect(await instance.normalMethod("foo")).toBe("barfoo");
+    expect(await instance.asyncMethod("foo")).toBe("barfoo");
+  });
 });

packages/js/core/src/types/MaybeAsync.ts

@@ -1,18 +1 @@
 export type MaybeAsync<T> = Promise<T> | T;
-
-export const isPromise = <T extends unknown>(
-  test?: MaybeAsync<T>
-): test is Promise<T> =>
-  !!test && typeof (test as Promise<T>).then === "function";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-export const executeMaybeAsyncFunction = async <T extends unknown>(
-  func: (...args: unknown[]) => Promise<T> | T,
-  ...args: unknown[]
-): Promise<T> => {
-  let result = func(...args);
-  if (isPromise(result)) {
-    result = await result;
-  }
-  return result;
-};

packages/js/core/src/types/Plugin.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { Client, MaybeAsync, executeMaybeAsyncFunction } from ".";
+import { Client, MaybeAsync } from ".";
 
 import { WrapManifest } from "@polywrap/wrap-manifest-types-js";
 import { Result, ResultErr, ResultOk } from "@polywrap/result";
@@ -60,9 +60,8 @@ export abstract class PluginModule<
       );
     }
 
-    const data = await executeMaybeAsyncFunction<TResult>(
-      fn.bind(this, args, client)
-    );
+    const data = await fn(args, client);
+
     return ResultOk(data);
   }
 
@@ -77,7 +76,7 @@ export abstract class PluginModule<
       PluginMethod<TArgs, TResult>
     >)[method];
 
-    return fn;
+    return fn.bind(this);
   }
 }
 

packages/js/uri-resolvers/src/cache/PackageToWrapperCacheResolver.ts

@@ -6,8 +6,6 @@ import {
   IUriResolver,
   Uri,
   Client,
-  executeMaybeAsyncFunction,
-  Wrapper,
   IUriResolutionContext,
   UriPackageOrWrapper,
   UriResolutionResult,
@@ -39,9 +37,7 @@ export class PackageToWrapperCacheResolver implements IUriResolver<Error> {
     client: Client,
     resolutionContext: IUriResolutionContext
   ): Promise<Result<UriPackageOrWrapper, Error>> {
-    const wrapper = await executeMaybeAsyncFunction<Wrapper | undefined>(
-      this.cache.get.bind(this.cache, uri)
-    );
+    const wrapper = await this.cache.get(uri);
 
     if (wrapper) {
       const result = UriResolutionResult.ok(uri, wrapper);
@@ -78,9 +74,7 @@ export class PackageToWrapperCacheResolver implements IUriResolver<Error> {
         const wrapper = createResult.value;
 
         for (const uri of resolutionPath) {
-          await executeMaybeAsyncFunction<Wrapper | undefined>(
-            this.cache.set.bind(this.cache, uri, wrapper)
-          );
+          await this.cache.set(uri, wrapper);
         }
 
         result = UriResolutionResult.ok(result.value.uri, wrapper);
@@ -89,9 +83,7 @@ export class PackageToWrapperCacheResolver implements IUriResolver<Error> {
         const resolutionPath: Uri[] = subContext.getResolutionPath();
 
         for (const uri of resolutionPath) {
-          await executeMaybeAsyncFunction<Wrapper | undefined>(
-            this.cache.set.bind(this.cache, uri, wrapper)
-          );
+          await this.cache.set(uri, wrapper);
         }
       }
     }