@aloma.io/integration-sdk 3.0.0-4

package/src/builder/index.mts

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import parseTypes from './transform/index.mjs';
+import RuntimeContext from './runtime-context.mjs';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const notEmpty = (what, name) => {
+  if (!what?.trim()) throw new Error(`${name} cannot be empty`);
+
+  return what;
+};
+
+export class Builder {
+  private data: any = {controller: './build/controller/.controller-for-types.mts'};
+
+  id(what: string): Builder {
+    this.data.id = notEmpty(what, 'id');
+
+    return this;
+  }
+
+  version(what: string): Builder {
+    this.data.version = notEmpty(what, 'version');
+
+    return this;
+  }
+
+  config(arg: any): Builder {
+    return this;
+  }
+
+  options(arg: any): Builder {
+    return this;
+  }
+
+  auth(arg: any): Builder {
+    return this;
+  }
+
+  async build(): Promise<RuntimeContext> {
+    const data = this.data;
+
+    notEmpty(data.id, 'id');
+    notEmpty(data.version, 'version');
+
+    await this.discoverTypes();
+
+    // validate config
+    // validate options
+    // validate auth
+
+    console.log('dirname', __dirname);
+    // @ts-ignore
+    const Controller = (await import(__dirname + '/../../../../../build/controller/index.mjs')).default;
+
+    return new RuntimeContext(new Controller(), this.data);
+  }
+
+  private async discoverTypes() {
+    notEmpty(this.data.controller, 'controller');
+
+    const content = fs.readFileSync(this.data.controller);
+    const {text, methods} = parseTypes(this.data.controller);
+
+    this.data.types = text;
+    this.data.methods = methods;
+  }
+}

package/src/builder/runtime-context.mts

@@ -0,0 +1,45 @@
+import {AbstractController} from '../controller/index.mjs';
+import {Connector} from '../internal/index.cjs';
+
+export default class RuntimeContext {
+  constructor(private controller: AbstractController, private data: any) {}
+
+  async start(): Promise<void> {
+    const controller = this.controller;
+
+    const connector = new Connector({
+      id: this.data.id,
+      version: this.data.version,
+      name: `${this.data.id}/${this.data.version}`,
+    });
+
+    const resolvers: any = {};
+    const methods: string[] = [...this.data.methods, '__endpoint', '__configQuery', '__default'];
+
+    methods.forEach((method) => {
+      resolvers[method] = async (args) => {
+        console.log('call', method, args);
+        if (!methods.includes(method)) throw new Error(`${method} not found`);
+
+        return controller[method](args);
+      };
+    });
+
+    console.log(this.data.types);
+
+    connector
+      .configure()
+      .types(this.data.types)
+      .resolvers(resolvers)
+      .main(async ({newTask, updateTask, config, oauth, getClient}) => {
+        try {
+          await controller._doStop();
+          await controller._doStart(config, oauth, newTask, updateTask, getClient);
+        } catch (e) {
+          console.log(e);
+        }
+      });
+
+    connector.run();
+  }
+}

package/src/builder/transform/index.mts

@@ -0,0 +1,89 @@
+import {parseFromFiles} from '@ts-ast-parser/core';
+
+const transform = (meta: any) => {
+  if (!meta?.length) throw new Error('metadata is empty');
+  meta = meta[0];
+
+  if (meta.getDeclarations()?.length !== 1) {
+    throw new Error('connector file needs to export default class');
+  }
+
+  const methods = {};
+  const decl = meta.getDeclarations()[0];
+
+  // todo validate getConstructors
+
+  const members = decl.getMethods().filter((member: any) => {
+    return !(
+      member.isStatic() ||
+      member.isInherited() ||
+      member.getKind() !== 'Method' ||
+      member.getModifier() !== 'public' ||
+      member.getName().startsWith('_')
+    );
+  });
+
+  const text = members
+    .map((member: any) => {
+      methods[member.getName()] = true;
+
+      return member
+        .getSignatures()
+        .map((sig: any) => {
+          const docs = sig.getJSDoc().serialize() || [];
+          const desc = docs.find((what: any) => what.kind === 'description')?.value;
+
+          const paramDocs =
+            docs
+              .filter((what: any) => what.kind === 'param')
+              .map((what: any) => {
+                return ` * @param {${what.value.type}} ${what.value.name} - ${what.value.description || ''}`;
+              })
+              .join('\n') || ' *';
+
+          const params = sig
+            .getParameters()
+            .map((param: any) => {
+              const serialized = param.serialize();
+
+              switch (!!param.isNamed()) {
+                case true:
+                  const tmp = param
+                    .getNamedElements()
+                    .map((p) => {
+                      const defaultVal = p.default != null ? ' = ' + p.default : '';
+
+                      return `${p.name}${defaultVal}`;
+                    })
+                    .join('; ');
+                  return `{${tmp}}: ${param.getType().text}`;
+                case false:
+                  return `${param.getName()}: ${param.getType().text}`;
+              }
+            })
+            .join(', ');
+
+          const retVal = sig
+            .getReturnType()
+            .type.text.replace(/^Promise</, '')
+            .replace(/>$/, '');
+
+          return `
+/**
+ * ${desc || ''}
+ *
+${paramDocs}
+ **/    
+declare function ${member.getName()}(${params}): ${retVal};
+      `;
+        })
+        .join('\n');
+    })
+    .join('');
+
+  return {text, methods: Object.keys(methods)};
+};
+
+export default (path: string) => {
+  return transform(parseFromFiles([path]));
+};

package/src/controller/index.mts

@@ -0,0 +1,58 @@
+export abstract class AbstractController {
+  protected config;
+  protected client;
+
+  protected async start(): Promise<void> {}
+
+  protected async stop(): Promise<void> {}
+
+  protected configQuery(arg: any): Promise<any> {
+    return Promise.resolve({});
+  }
+
+  protected fallback(arg: any): Promise<any> {
+    throw new Error('method not found');
+  }
+
+  protected endpoint(arg: any): Promise<any> {
+    throw new Error('method not found');
+  }
+
+  protected async newTask(name: string, data: any): Promise<string> {
+    throw new Error('not implemented');
+  }
+
+  protected getClient({baseUrl}: {baseUrl: string}): Promise<any> {
+    throw new Error('not implemented');
+  }
+
+  protected async updateTask(name: string, data: any): Promise<string> {
+    throw new Error('not implemented');
+  }
+
+  async __endpoint(arg: any): Promise<any | null> {
+    return Promise.resolve(null);
+  }
+
+  async __configQuery(arg: any): Promise<any | null> {
+    return this.configQuery(arg);
+  }
+
+  async __default(arg: any): Promise<any | null> {
+    return this.fallback(arg);
+  }
+
+  async _doStart(config: any, client: any, newTask: any, updateTask: any, getClient: any): Promise<void> {
+    this.config = config;
+    this.client = client;
+    this.newTask = newTask;
+    this.updateTask = updateTask;
+    this.getClient = getClient;
+
+    await this.start();
+  }
+
+  async _doStop(): Promise<void> {
+    await this.stop();
+  }
+}

package/src/index.mts

@@ -0,0 +1,2 @@
+export * from './builder/index.mjs';
+export * from './controller/index.mjs';

package/src/internal/dispatcher/index.cjs

@@ -0,0 +1,189 @@
+class Dispatcher {
+  constructor() {
+    this._config = {fields: {}};
+  }
+
+  main(what) {
+    this._main = what;
+
+    return this;
+  }
+
+  oauth(arg) {
+    if (arg.platformOAuth) {
+      this.config({
+        oauth: true,
+        fields: {
+          oauthResult: {
+            name: 'OAuth Result',
+            placeholder: 'will be set by finishing the oauth flow',
+            type: 'managed',
+          },
+        },
+      });
+
+      return this;
+    }
+
+    if (!arg.authorizationURL) throw new Error('need a authorizationURL');
+    if (!arg.tokenURL && !arg.finishOAuth) throw new Error('need a tokenURL or finishOAuth()');
+
+    this._oauth = {...arg};
+
+    this.config({
+      oauth: true,
+      fields: {
+        oauthResult: {
+          name: 'OAuth Result',
+          placeholder: 'will be set by finishing the oauth flow',
+          type: 'managed',
+        },
+      },
+    });
+
+    if (arg.configurableClient) {
+      this.config({
+        fields: {
+          clientId: {
+            name: 'OAuth Client ID',
+            placeholder: 'e.g. 1234',
+            type: 'line',
+          },
+          clientSecret: {
+            name: 'OAuth Client Secret',
+            placeholder: 'e.g. axd5xde',
+            type: 'line',
+          },
+        },
+      });
+    }
+
+    return this;
+  }
+
+  types(what) {
+    this._types = what;
+
+    return this;
+  }
+
+  config({fields, oauth}) {
+    this._config.oauth = this._config.oauth || oauth;
+    this._config.fields = {...fields, ...this._config.fields};
+
+    return this;
+  }
+
+  resolvers(what) {
+    this._resolvers = {...this._resolvers, ...what};
+
+    return this;
+  }
+
+  endpoint(what) {
+    this.config({
+      fields: {
+        _endpointToken: {
+          name: 'Endpoint Token (set to enable the endpoint)',
+          placeholder: 'e.g. 1234',
+          type: 'line',
+          plain: true,
+          optional: true,
+        },
+      },
+    });
+
+    this.resolvers({_endpoint: what});
+
+    return this;
+  }
+
+  startOAuth() {
+    throw new Error('oauth not configured');
+  }
+
+  finishOAuth() {
+    throw new Error('oauth not configured');
+  }
+
+  build() {
+    if (!this._types || !this._resolvers) throw new Error('missing types or resolvers');
+    var local = this;
+
+    const _resolvers = {...this._resolvers};
+
+    const main = this._main || (() => {});
+
+    const start = async (transport) => {
+      console.log('starting ...');
+      await main(transport);
+    };
+
+    const resolveMethod = (query) => {
+      let current = _resolvers;
+
+      while (query.length && current) {
+        current = current[query.shift()];
+      }
+
+      return current;
+    };
+
+    const execute = async ({query, variables}) => {
+      if (!Array.isArray(query)) query = [query];
+
+      query = query
+        .filter(
+          (what) => !!what?.trim() && !['constructor', '__proto__', 'toString', 'toSource', 'prototype'].includes(what)
+        )
+        .slice(0, 20);
+
+      const method = resolveMethod(query);
+      console.log('found method', query, method);
+      if (!method && !_resolvers.__default) throw new Error(`${query} not found`);
+
+      return method ? method(variables) : _resolvers.__default(variables ? {...variables, __method: query} : variables);
+    };
+
+    const introspect = () => local._types;
+    const configSchema = () => local._config;
+
+    const processPacket = async (packet) => {
+      switch (packet.method()) {
+        case 'connector.introspect':
+          const intro = await introspect({});
+
+          return {configSchema: local._config, introspect: intro};
+
+        case 'connector.start-oauth':
+          return await local.startOAuth(packet.args());
+
+        case 'connector.finish-oauth':
+          return await local.finishOAuth(packet.args());
+
+        case 'connector.query':
+          const ret = await execute(packet.args());
+
+          return typeof ret === 'object' && !Array.isArray(ret) ? ret : {[packet.args().query]: ret};
+
+        case 'connector.set-config':
+          await local.onConfig({...packet.args().secrets});
+
+          return;
+      }
+
+      console.dir(packet, {depth: null});
+      throw new Error('cannot handle packet');
+    };
+
+    return {
+      introspect,
+      configSchema,
+      execute,
+      processPacket,
+      start,
+    };
+  }
+}
+
+module.exports = {Dispatcher};