@aloma.io/integration-sdk 3.8.0 → 3.8.1

package/build/builder/index.d.mts

@@ -1,12 +1,60 @@
-import RuntimeContext from "./runtime-context.mjs";
 import "dotenv/config";
+import RuntimeContext from "./runtime-context.mjs";
 export declare const TARGET_DIR: string;
+export type ConfigField = {
+    name: string;
+    description?: string;
+    placeholder?: string;
+    type: "multiline" | "text" | "number" | "boolean";
+    optional?: boolean;
+    plain?: boolean;
+} | undefined;
+declare type Config = {
+    summary?: string;
+    description?: string;
+    fields?: {
+        authorizationURL: ConfigField;
+        tokenURL?: ConfigField;
+        scope?: ConfigField;
+        clientId?: ConfigField;
+        clientSecret?: ConfigField;
+        [key: string]: ConfigField;
+    };
+};
+declare type Options = {
+    endpoint?: {
+        enabled: boolean;
+        required?: boolean;
+    };
+};
+declare type Auth = {
+    /**
+     * preferred via process.env.OAUTH_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * preferred via process.env.OAUTH_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * @example https://example.com/oauth2/v2/auth?client_id={{clientId}}&redirect_uri={{redirectURI}}&scope={{scope}}&response_type=code
+     */
+    authorizationURL?: string;
+    tokenURL?: string;
+    scope?: string;
+    tokenRefreshPeriod?: number;
+    useAuthHeader?: boolean;
+    additionalTokenArgs?: {
+        grant_type?: string;
+    };
+};
 export declare class Builder {
     private data;
-    config(arg: any): Builder;
-    options(arg: any): Builder;
-    auth(arg: any): Builder;
+    config(arg: Config): Builder;
+    options(arg: Options): Builder;
+    auth(arg: Auth): Builder;
     build(): Promise<RuntimeContext>;
     private checkIcon;
     private loadDescriptor;
 }
+export {};

package/build/builder/index.mjs

@@ -1,9 +1,9 @@
+import "dotenv/config";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { notEmpty } from "../internal/util/index.mjs";
 import RuntimeContext from "./runtime-context.mjs";
-import "dotenv/config";
 const DIR_OFFSET = "/../../../../../";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const TARGET_DIR = `${__dirname}${DIR_OFFSET}`;

package/build/internal/connector/config.d.mts

@@ -1,5 +1,5 @@
 import { Config } from "../websocket/config.mjs";
-export declare const makeConfig: ({ id, version, name, introspect, configSchema, icon }: {
+export declare const makeConfig: ({ id, version, name, introspect, configSchema, icon, }: {
     id: any;
     version: any;
     name: any;

package/build/internal/connector/config.mjs

@@ -1,6 +1,6 @@
 import JWE from "../util/jwe/index.mjs";
 import { Config } from "../websocket/config.mjs";
-export const makeConfig = async ({ id, version, name, introspect, configSchema, icon }) => {
+export const makeConfig = async ({ id, version, name, introspect, configSchema, icon, }) => {
     const config = new Config({
         id: id,
         version: version,
@@ -43,7 +43,7 @@ ${text}
                     resolve(null);
                 }, 2 * 60 * 1000);
             });
-            throw new Error('could not start');
+            throw new Error("could not start");
         }
     }
     return config;

package/build/internal/connector/index.mjs

@@ -33,7 +33,13 @@ export class Connector {
             name: this.name,
             version: this.version,
         });
-        const server = await makeServer({ config, configSchema, start, processPacket, dispatcher: this.dispatcher });
+        const server = await makeServer({
+            config,
+            configSchema,
+            start,
+            processPacket,
+            dispatcher: this.dispatcher,
+        });
         await server.start();
     }
 }

package/build/internal/connector/server/index.d.mts

@@ -1,7 +1,7 @@
 import Dispatcher from "../../dispatcher/index.mjs";
 import { Config } from "../../websocket/config.mjs";
 import { WebsocketConnector } from "../../websocket/index.mjs";
-export declare const makeServer: ({ config, configSchema, start, processPacket, dispatcher }: {
+export declare const makeServer: ({ config, configSchema, start, processPacket, dispatcher, }: {
     config: Config;
     configSchema: any;
     start: any;

package/build/internal/connector/server/index.mjs

@@ -1,11 +1,11 @@
 import { WebsocketConnector } from "../../websocket/index.mjs";
 import { onConnect } from "./on-connect/index.mjs";
 import { onMessage } from "./on-message.mjs";
-export const makeServer = async ({ config, configSchema, start, processPacket, dispatcher }) => {
+export const makeServer = async ({ config, configSchema, start, processPacket, dispatcher, }) => {
     const server = new WebsocketConnector({
         config,
         onConnect: onConnect({ config, configSchema, dispatcher, start }),
-        onMessage: onMessage(processPacket)
+        onMessage: onMessage(processPacket),
     });
     const term = async () => {
         await server.leaving();

package/build/internal/connector/server/on-connect/finish-oauth.d.mts

@@ -1,7 +1,7 @@
 import Dispatcher from "../../../dispatcher/index.mjs";
 import { Config } from "../../../websocket/config.mjs";
 import { WebsocketConnector } from "../../../websocket/index.mjs";
-export declare const patchFinishOAuth: ({ dispatcher, decrypted, config, transport }: {
+export declare const patchFinishOAuth: ({ dispatcher, decrypted, config, transport, }: {
     dispatcher: Dispatcher;
     decrypted: any;
     config: Config;

package/build/internal/connector/server/on-connect/finish-oauth.mjs

@@ -1,4 +1,4 @@
-export const patchFinishOAuth = async ({ dispatcher, decrypted, config, transport }) => {
+export const patchFinishOAuth = async ({ dispatcher, decrypted, config, transport, }) => {
     dispatcher.finishOAuth = async function (arg) {
         const tokenURL = process.env.OAUTH_TOKEN_URL ||
             decrypted.tokenURL ||

package/build/internal/connector/server/on-connect/index.d.mts

@@ -1,6 +1,6 @@
 import Dispatcher from "../../../dispatcher/index.mjs";
 import { Config } from "../../../websocket/config.mjs";
-export declare const onConnect: ({ dispatcher, configSchema, config, start }: {
+export declare const onConnect: ({ dispatcher, configSchema, config, start, }: {
     config: Config;
     configSchema: any;
     start: any;

package/build/internal/connector/server/on-connect/index.mjs

@@ -5,13 +5,22 @@ import { patchFinishOAuth } from "./finish-oauth.mjs";
 import { makeOAuth } from "./make-oauth.mjs";
 import { patchStartOAuth } from "./start-oauth.mjs";
 const cuid = init({ length: 32 });
-export const onConnect = ({ dispatcher, configSchema, config, start }) => {
+export const onConnect = ({ dispatcher, configSchema, config, start, }) => {
     return async (transport) => {
         dispatcher.onConfig = async function (secrets) {
-            const decrypted = await decryptConfig({ configSchema, secrets, config });
+            const decrypted = await decryptConfig({
+                configSchema,
+                secrets,
+                config,
+            });
             await patchStartOAuth({ dispatcher, decrypted });
             await patchFinishOAuth({ dispatcher, decrypted, config, transport });
-            const theOAuth = await makeOAuth({ config, transport, decrypted, dispatcher });
+            const theOAuth = await makeOAuth({
+                config,
+                transport,
+                decrypted,
+                dispatcher,
+            });
             const getBlob = (id) => {
                 return new Promise((resolve, reject) => {
                     const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
@@ -24,7 +33,7 @@ export const onConnect = ({ dispatcher, configSchema, config, start }) => {
             };
             const getBlobContent = (id) => {
                 return new Promise((resolve, reject) => {
-                    const packet = transport.newPacket({}, (ret) => ret?.error ? reject(ret.error) : resolve(ret?.content), `_req-${cuid()}`);
+                    const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret?.content)), `_req-${cuid()}`);
                     packet.method("connector.blob.get-content");
                     packet.args({
                         id,
@@ -64,9 +73,7 @@ export const onConnect = ({ dispatcher, configSchema, config, start }) => {
                     packet.args(result);
                     transport.send(packet);
                 },
-                getClient: (arg) => theOAuth
-                    ? (oauthClient = theOAuth.getClient(arg))
-                    : new Fetcher(arg),
+                getClient: (arg) => theOAuth ? (oauthClient = theOAuth.getClient(arg)) : new Fetcher(arg),
                 newTask: (name, data) => {
                     return new Promise((resolve, reject) => {
                         const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);

package/build/internal/connector/server/on-connect/make-oauth.d.mts

@@ -1,7 +1,7 @@
 import Dispatcher from "../../../dispatcher/index.mjs";
 import { OAuth } from "../../../fetcher/oauth-fetcher.mjs";
 import { Config } from "../../../websocket/config.mjs";
-export declare const makeOAuth: ({ config, transport, decrypted, dispatcher }: {
+export declare const makeOAuth: ({ config, transport, decrypted, dispatcher, }: {
     config: Config;
     transport: any;
     decrypted: any;

package/build/internal/connector/server/on-connect/make-oauth.mjs

@@ -1,5 +1,5 @@
 import { OAuth } from "../../../fetcher/oauth-fetcher.mjs";
-export const makeOAuth = async ({ config, transport, decrypted, dispatcher }) => {
+export const makeOAuth = async ({ config, transport, decrypted, dispatcher, }) => {
     const saveOAuthResult = async (what) => {
         const jwe = await config.validateKeys("RSA-OAEP-256");
         const value = await jwe.encrypt(what, "none", config.id());

package/build/internal/index.d.mts

@@ -1,2 +1,2 @@
-import { Connector } from './connector/index.mjs';
+import { Connector } from "./connector/index.mjs";
 export { Connector };

package/build/internal/index.mjs

@@ -1,2 +1,2 @@
-import { Connector } from './connector/index.mjs';
+import { Connector } from "./connector/index.mjs";
 export { Connector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aloma.io/integration-sdk",
-  "version": "3.8.0",
+  "version": "3.8.1",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",

package/src/builder/index.mts

@@ -1,9 +1,9 @@
+import "dotenv/config";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { notEmpty } from "../internal/util/index.mjs";
 import RuntimeContext from "./runtime-context.mjs";
-import "dotenv/config";
 
 const DIR_OFFSET = "/../../../../../";
 
@@ -11,24 +11,71 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 export const TARGET_DIR = `${__dirname}${DIR_OFFSET}`;
 
+export type ConfigField = {
+  name: string;
+  description?: string;
+  placeholder?: string;
+  type: "multiline" | "text" | "number" | "boolean";
+  optional?: boolean;
+  plain?: boolean;
+} | undefined;
+
+declare type Config = {
+  summary?: string;
+  description?: string;
+  fields?: {
+    authorizationURL: ConfigField;
+    tokenURL?: ConfigField;
+    scope?: ConfigField;
+    clientId?: ConfigField;
+    clientSecret?: ConfigField;
+    [key: string]: ConfigField
+  };
+};
+
+declare type Options = {
+  endpoint?: {enabled: boolean, required?: boolean};
+};
+
+declare type Auth = {
+  /**
+   * preferred via process.env.OAUTH_CLIENT_ID
+   */
+  clientId?: string;
+  /**
+   * preferred via process.env.OAUTH_CLIENT_SECRET
+   */
+  clientSecret?: string;
+
+  /**
+   * @example https://example.com/oauth2/v2/auth?client_id={{clientId}}&redirect_uri={{redirectURI}}&scope={{scope}}&response_type=code
+   */
+  authorizationURL?: string;
+  tokenURL?: string;
+  scope?: string;
+  tokenRefreshPeriod?: number;
+  useAuthHeader?: boolean;
+  additionalTokenArgs?: {grant_type?: string}
+};
+
 export class Builder {
   private data: any = {
     controller: "./build/.controller.json",
   };
 
-  config(arg: any): Builder {
+  config(arg: Config): Builder {
     this.data.config = arg;
 
     return this;
   }
 
-  options(arg: any): Builder {
+  options(arg: Options): Builder {
     this.data.options = arg;
 
     return this;
   }
 
-  auth(arg: any): Builder {
+  auth(arg: Auth): Builder {
     this.data.auth = arg;
     return this;
   }

package/src/internal/connector/config.mts

@@ -1,7 +1,14 @@
 import JWE from "../util/jwe/index.mjs";
 import { Config } from "../websocket/config.mjs";
 
-export const makeConfig = async ({id, version, name, introspect, configSchema, icon}): Promise<Config> => {
+export const makeConfig = async ({
+  id,
+  version,
+  name,
+  introspect,
+  configSchema,
+  icon,
+}): Promise<Config> => {
   const config = new Config({
     id: id,
     version: version,
@@ -44,14 +51,17 @@ ${text}
       `);
 
       await new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(null);
-        }, 2 * 60 * 1000);
+        setTimeout(
+          () => {
+            resolve(null);
+          },
+          2 * 60 * 1000,
+        );
       });
 
-      throw new Error('could not start');
+      throw new Error("could not start");
     }
   }
 
   return config;
-}
+};

package/src/internal/connector/index.mts

@@ -23,7 +23,8 @@ export class Connector {
   async run() {
     console.log(`Running ${this.name}`);
 
-    const { processPacket, start, introspect, configSchema } = this.dispatcher!.build();
+    const { processPacket, start, introspect, configSchema } =
+      this.dispatcher!.build();
 
     const config = await makeConfig({
       id: this.id,
@@ -40,9 +41,14 @@ export class Connector {
       version: this.version,
     });
 
-    const server = await makeServer({config, configSchema, start, processPacket, dispatcher: this.dispatcher!})
+    const server = await makeServer({
+      config,
+      configSchema,
+      start,
+      processPacket,
+      dispatcher: this.dispatcher!,
+    });
 
     await server.start();
   }
 }
-

package/src/internal/connector/metrics.mts

@@ -1,7 +1,7 @@
 import express from "express";
 import PromClient from "prom-client";
 
-export const makeMetrics = async ({id, name, version}): Promise<void> => {
+export const makeMetrics = async ({ id, name, version }): Promise<void> => {
   const newMetrics = () => {
     const metrics = PromClient;
 
@@ -31,5 +31,4 @@ export const makeMetrics = async ({id, name, version}): Promise<void> => {
   };
 
   makeMetricsServer(newMetrics()).listen(4050, "0.0.0.0");
-
-}
+};

package/src/internal/connector/server/index.mts

@@ -4,11 +4,23 @@ import { WebsocketConnector } from "../../websocket/index.mjs";
 import { onConnect } from "./on-connect/index.mjs";
 import { onMessage } from "./on-message.mjs";
 
-export const makeServer = async ({config, configSchema, start, processPacket, dispatcher}: {config: Config, configSchema: any, start: any, processPacket: any, dispatcher: Dispatcher}): Promise<WebsocketConnector> => {
+export const makeServer = async ({
+  config,
+  configSchema,
+  start,
+  processPacket,
+  dispatcher,
+}: {
+  config: Config;
+  configSchema: any;
+  start: any;
+  processPacket: any;
+  dispatcher: Dispatcher;
+}): Promise<WebsocketConnector> => {
   const server = new WebsocketConnector({
     config,
-    onConnect: onConnect({config, configSchema, dispatcher, start}),
-    onMessage: onMessage(processPacket)
+    onConnect: onConnect({ config, configSchema, dispatcher, start }),
+    onMessage: onMessage(processPacket),
   });
 
   const term = async () => {
@@ -36,4 +48,4 @@ export const makeServer = async ({config, configSchema, start, processPacket, di
   process.on("SIGINT", term);
 
   return server;
-}
+};

package/src/internal/connector/server/on-connect/decrypt-config.mts

@@ -1,5 +1,4 @@
-
-export const decryptConfig = async ({configSchema, config, secrets}) => {
+export const decryptConfig = async ({ configSchema, config, secrets }) => {
   const decrypted: any = {};
 
   const fields = configSchema().fields;
@@ -24,4 +23,4 @@ export const decryptConfig = async ({configSchema, config, secrets}) => {
   }
 
   return decrypted;
-}
+};

package/src/internal/connector/server/on-connect/finish-oauth.mts

@@ -2,8 +2,22 @@ import Dispatcher from "../../../dispatcher/index.mjs";
 import { Config } from "../../../websocket/config.mjs";
 import { WebsocketConnector } from "../../../websocket/index.mjs";
 
-export const patchFinishOAuth = async ({dispatcher, decrypted, config, transport}: {dispatcher: Dispatcher, decrypted: any, config: Config, transport: WebsocketConnector}) => {
-  dispatcher.finishOAuth = async function (arg: {code: string, redirectURI: string, codeVerifier?: string}): Promise<{value: string}>{
+export const patchFinishOAuth = async ({
+  dispatcher,
+  decrypted,
+  config,
+  transport,
+}: {
+  dispatcher: Dispatcher;
+  decrypted: any;
+  config: Config;
+  transport: WebsocketConnector;
+}) => {
+  dispatcher.finishOAuth = async function (arg: {
+    code: string;
+    redirectURI: string;
+    codeVerifier?: string;
+  }): Promise<{ value: string }> {
     const tokenURL =
       process.env.OAUTH_TOKEN_URL ||
       decrypted.tokenURL ||
@@ -48,8 +62,7 @@ export const patchFinishOAuth = async ({dispatcher, decrypted, config, transport
       }
 
       let headers: any = {
-        "Content-Type":
-          "application/x-www-form-urlencoded;charset=UTF-8",
+        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
         Accept: "application/json",
       };
 
@@ -85,9 +98,7 @@ export const patchFinishOAuth = async ({dispatcher, decrypted, config, transport
         } else if (ret.access_token) {
           return { ...ret };
         } else {
-          throw new Error(
-            status + " response has no access_token - " + text,
-          );
+          throw new Error(status + " response has no access_token - " + text);
         }
       } else {
         throw new Error(status + " " + text);
@@ -108,4 +119,4 @@ export const patchFinishOAuth = async ({dispatcher, decrypted, config, transport
 
     return { value: await jwe.encrypt(data, "none", config.id()) };
   };
-}
+};

package/src/internal/connector/server/on-connect/index.mts

@@ -9,15 +9,34 @@ import { patchStartOAuth } from "./start-oauth.mjs";
 
 const cuid = init({ length: 32 });
 
-export const onConnect = ({dispatcher, configSchema, config, start}:  {config: Config, configSchema: any, start: any, dispatcher: Dispatcher}) => {
+export const onConnect = ({
+  dispatcher,
+  configSchema,
+  config,
+  start,
+}: {
+  config: Config;
+  configSchema: any;
+  start: any;
+  dispatcher: Dispatcher;
+}) => {
   return async (transport) => {
     dispatcher.onConfig = async function (secrets) {
-      const decrypted: any = await decryptConfig({configSchema, secrets, config});
+      const decrypted: any = await decryptConfig({
+        configSchema,
+        secrets,
+        config,
+      });
 
-      await patchStartOAuth({dispatcher, decrypted});
-      await patchFinishOAuth({dispatcher, decrypted, config, transport});
+      await patchStartOAuth({ dispatcher, decrypted });
+      await patchFinishOAuth({ dispatcher, decrypted, config, transport });
 
-      const theOAuth = await makeOAuth({config, transport, decrypted, dispatcher});
+      const theOAuth = await makeOAuth({
+        config,
+        transport,
+        decrypted,
+        dispatcher,
+      });
 
       const getBlob = (id) => {
         return new Promise((resolve, reject) => {
@@ -40,8 +59,7 @@ export const onConnect = ({dispatcher, configSchema, config, start}:  {config: C
         return new Promise((resolve, reject) => {
           const packet = transport.newPacket(
             {},
-            (ret) =>
-              ret?.error ? reject(ret.error) : resolve(ret?.content),
+            (ret) => (ret?.error ? reject(ret.error) : resolve(ret?.content)),
             `_req-${cuid()}`,
           );
 
@@ -99,9 +117,7 @@ export const onConnect = ({dispatcher, configSchema, config, start}:  {config: C
           transport.send(packet);
         },
         getClient: (arg) =>
-          theOAuth
-            ? (oauthClient = theOAuth.getClient(arg))
-            : new Fetcher(arg),
+          theOAuth ? (oauthClient = theOAuth.getClient(arg)) : new Fetcher(arg),
         newTask: (name, data) => {
           return new Promise((resolve, reject) => {
             const packet = transport.newPacket(
@@ -138,5 +154,5 @@ export const onConnect = ({dispatcher, configSchema, config, start}:  {config: C
         },
       });
     };
-  }
-};
+  };
+};

package/src/internal/connector/server/on-connect/make-oauth.mts

@@ -2,7 +2,17 @@ import Dispatcher from "../../../dispatcher/index.mjs";
 import { OAuth } from "../../../fetcher/oauth-fetcher.mjs";
 import { Config } from "../../../websocket/config.mjs";
 
-export const makeOAuth = async ({config, transport, decrypted, dispatcher}: {config: Config, transport: any, decrypted: any, dispatcher: Dispatcher}) => {
+export const makeOAuth = async ({
+  config,
+  transport,
+  decrypted,
+  dispatcher,
+}: {
+  config: Config;
+  transport: any;
+  decrypted: any;
+  dispatcher: Dispatcher;
+}) => {
   const saveOAuthResult = async (what) => {
     const jwe = await config.validateKeys("RSA-OAEP-256");
     const value = await jwe.encrypt(what, "none", config.id());
@@ -55,8 +65,7 @@ export const makeOAuth = async ({config, transport, decrypted, dispatcher}: {con
         client_secret: clientSecret,
       }),
       headers: {
-        "Content-Type":
-          "application/x-www-form-urlencoded;charset=UTF-8",
+        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
         Accept: "application/json",
         ...headers,
       },
@@ -69,33 +78,31 @@ export const makeOAuth = async ({config, transport, decrypted, dispatcher}: {con
     if (status === 200) {
       return JSON.parse(text);
     } else {
-      throw new Error(
-        "could not get refresh token " + status + " " + text,
-      );
+      throw new Error("could not get refresh token " + status + " " + text);
     }
   };
 
-  const theOAuth =  dispatcher._oauth
+  const theOAuth = dispatcher._oauth
     ? new OAuth(decrypted.oauthResult, saveOAuthResult, getRefreshToken)
     : null;
 
-    if (theOAuth) {
-      clearInterval(dispatcher._refreshOAuthToken);
-
-      if (!(dispatcher._oauth.noPeriodicTokenRefresh === false)) {
-        dispatcher._refreshOAuthToken = setInterval(
-          async () => {
-            try {
-              console.log("refreshing oauth token");
-              await theOAuth.periodicRefresh();
-            } catch (e) {
-              console.log("periodic refresh", e);
-            }
-          },
-          dispatcher._oauth.tokenRefreshPeriod || 4 * 60 * 60 * 15000,
-        );
-      }
+  if (theOAuth) {
+    clearInterval(dispatcher._refreshOAuthToken);
+
+    if (!(dispatcher._oauth.noPeriodicTokenRefresh === false)) {
+      dispatcher._refreshOAuthToken = setInterval(
+        async () => {
+          try {
+            console.log("refreshing oauth token");
+            await theOAuth.periodicRefresh();
+          } catch (e) {
+            console.log("periodic refresh", e);
+          }
+        },
+        dispatcher._oauth.tokenRefreshPeriod || 4 * 60 * 60 * 15000,
+      );
     }
+  }
 
-    return theOAuth
-}
+  return theOAuth;
+};

package/src/internal/connector/server/on-connect/start-oauth.mts

@@ -1,5 +1,4 @@
-
-export const patchStartOAuth = async ({dispatcher, decrypted}) => {
+export const patchStartOAuth = async ({ dispatcher, decrypted }) => {
   dispatcher.startOAuth = async function () {
     if (!dispatcher._oauth) throw new Error("oauth not configured");
 
@@ -8,8 +7,7 @@ export const patchStartOAuth = async ({dispatcher, decrypted}) => {
       decrypted.authorizationURL ||
       dispatcher._oauth.authorizationURL;
 
-    if (!authorizationURL)
-      throw new Error("authorizationURL not configured");
+    if (!authorizationURL) throw new Error("authorizationURL not configured");
 
     const clientId =
       decrypted.clientId ||
@@ -32,4 +30,4 @@ export const patchStartOAuth = async ({dispatcher, decrypted}) => {
       useCodeChallenge,
     };
   };
-}
+};

package/src/internal/connector/server/on-message.mts

@@ -1,11 +1,13 @@
 import { handlePacketError, reply } from "../../util/index.mjs";
 
-export const onMessage = (processPacket: any) => { return async (packet, transport) => {
-  try {
-    const ret = await processPacket(packet);
-    if (ret) reply(ret, packet, transport);
-  } catch (e) {
-    console.log(e);
-    handlePacketError(packet, e, transport);
-  }
-}};
+export const onMessage = (processPacket: any) => {
+  return async (packet, transport) => {
+    try {
+      const ret = await processPacket(packet);
+      if (ret) reply(ret, packet, transport);
+    } catch (e) {
+      console.log(e);
+      handlePacketError(packet, e, transport);
+    }
+  };
+};

package/src/internal/dispatcher/index.mts

@@ -131,13 +131,17 @@ ${arg.configurableClientScope}
   }
 
   async startOAuth(): Promise<{
-    url: string,
-    useCodeChallenge: boolean,
+    url: string;
+    useCodeChallenge: boolean;
   }> {
     throw new Error("oauth not configured");
   }
 
-  async finishOAuth(arg: {code: string, redirectURI: string, codeVerifier?: string}): Promise<{value: string}> {
+  async finishOAuth(arg: {
+    code: string;
+    redirectURI: string;
+    codeVerifier?: string;
+  }): Promise<{ value: string }> {
     throw new Error("oauth not configured");
   }
 

package/src/internal/index.mts

@@ -1,3 +1,3 @@
-import { Connector } from './connector/index.mjs';
+import { Connector } from "./connector/index.mjs";
 
 export { Connector };