@aloma.io/integration-sdk 3.0.0-4 → 3.0.0-6

package/README.md

@@ -0,0 +1,9 @@
+# nodejs - Aloma Integration SDK
+
+## Prerequisites
+
+* You can find the `REGISTRATION_TOKEN` in your aloma workspace in the integration section.
+
+## Integration Examples
+
+See `examples` directory.

package/build/builder/index.d.mts

@@ -1,8 +1,6 @@
 import RuntimeContext from './runtime-context.mjs';
 export declare class Builder {
     private data;
-    id(what: string): Builder;
-    version(what: string): Builder;
     config(arg: any): Builder;
     options(arg: any): Builder;
     auth(arg: any): Builder;

package/build/builder/index.mjs

@@ -1,4 +1,4 @@
-import fs from 'fs';
+import fs from 'node:fs';
 import parseTypes from './transform/index.mjs';
 import RuntimeContext from './runtime-context.mjs';
 import { fileURLToPath } from 'node:url';
@@ -11,18 +11,11 @@ const notEmpty = (what, name) => {
 };
 export class Builder {
     data = { controller: './build/controller/.controller-for-types.mts' };
-    id(what) {
-        this.data.id = notEmpty(what, 'id');
-        return this;
-    }
-    version(what) {
-        this.data.version = notEmpty(what, 'version');
-        return this;
-    }
     config(arg) {
         return this;
     }
     options(arg) {
+        this.data.options = arg;
         return this;
     }
     auth(arg) {
@@ -30,13 +23,13 @@ export class Builder {
     }
     async build() {
         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);
+        const packageJson = JSON.parse(fs.readFileSync(__dirname + '/../../../../../package.json', { encoding: 'utf-8' }));
+        notEmpty(data.id = packageJson.connectorId, 'id');
+        notEmpty(data.version = packageJson.version, 'version');
         // @ts-ignore
         const Controller = (await import(__dirname + '/../../../../../build/controller/index.mjs')).default;
         return new RuntimeContext(new Controller(), this.data);

package/build/builder/runtime-context.mjs

@@ -1,3 +1,4 @@
+import { AbstractController } from '../controller/index.mjs';
 import { Connector } from '../internal/index.cjs';
 export default class RuntimeContext {
     controller;
@@ -8,13 +9,17 @@ export default class RuntimeContext {
     }
     async start() {
         const controller = this.controller;
+        if (!(controller instanceof AbstractController))
+            throw new Error('the controller needs to extend AbstractController');
+        const data = this.data;
         const connector = new Connector({
-            id: this.data.id,
-            version: this.data.version,
-            name: `${this.data.id}/${this.data.version}`,
+            id: data.id,
+            version: data.version,
+            name: `${data.id}/${data.version}`,
         });
+        const configuration = connector.configure();
         const resolvers = {};
-        const methods = [...this.data.methods, '__endpoint', '__configQuery', '__default'];
+        const methods = [...data.methods, '__endpoint', '__configQuery', '__default'];
         methods.forEach((method) => {
             resolvers[method] = async (args) => {
                 console.log('call', method, args);
@@ -23,12 +28,11 @@ export default class RuntimeContext {
                 return controller[method](args);
             };
         });
-        console.log(this.data.types);
-        connector
-            .configure()
-            .types(this.data.types)
-            .resolvers(resolvers)
-            .main(async ({ newTask, updateTask, config, oauth, getClient }) => {
+        configuration.types(data.types).resolvers(resolvers);
+        if (data.options?.endpoint) {
+            configuration.endpoint((arg) => controller.__endpoint(arg));
+        }
+        configuration.main(async ({ newTask, updateTask, config, oauth, getClient }) => {
             try {
                 await controller._doStop();
                 await controller._doStart(config, oauth, newTask, updateTask, getClient);

package/build/controller/index.mjs

@@ -22,7 +22,7 @@ export class AbstractController {
         throw new Error('not implemented');
     }
     async __endpoint(arg) {
-        return Promise.resolve(null);
+        return this.endpoint(arg);
     }
     async __configQuery(arg) {
         return this.configQuery(arg);

package/examples/hello-world/Containerfile

@@ -0,0 +1,17 @@
+FROM node:16-alpine3.18
+
+ENV NODE_ENV production
+
+WORKDIR /connector/
+
+COPY ./package.json ./
+COPY ./entrypoint.sh ./
+COPY ./src ./src
+
+RUN set -e; adduser -S -u 1111 connector
+
+RUN set -e; apk add --no-cache git; yarn config set --home enableTelemetry 0; chmod 755 /connector/entrypoint.sh; cd /connector/; yarn install; rm -rf package.json; rm -rf yarn.lock; 
+
+USER connector
+
+ENTRYPOINT ["/connector/entrypoint.sh"]

package/examples/hello-world/entrypoint.sh

@@ -0,0 +1,5 @@
+#!/bin/sh -e
+
+cd /connector/
+
+exec node src/index.js $@

package/examples/hello-world/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "hello-world",
+  "version": "1.0.0",
+  "description": "",
+  "author": "aloma.io",
+  "license": "Apache-2.0",
+  "scripts": {},
+  "dependencies": {
+    "@aloma.io/integration-sdk": "^3"
+  }
+}

package/examples/hello-world/src/controller/index.js

@@ -0,0 +1,14 @@
+class Controller
+{
+  setConfig({newTask, config})
+  {
+    // blank
+  }
+  
+  async hello(args)
+  {
+    return "world";
+  }
+}
+
+module.exports = {Controller}

package/examples/hello-world/src/index.js

@@ -0,0 +1,29 @@
+const {Connector}  = require('@aloma-io/integration-sdk');
+const {Controller} = require('./controller');
+
+const connector    = new Connector({id: 'TODO your connector id', version: '1.0.0'});
+const controller   = new Controller();
+
+connector.configure()
+  // types are the calls available in the step, these are typescript definitions
+  .types
+  (`
+    declare function hello(arg: {}): any;
+  `)
+  // resolvers hold the calls
+  .resolvers
+  ({
+    hello: async (args) => 
+    {
+      return controller.hello(args);
+    },
+  })
+  // main will be called once the connector is connected
+  .main(({newTask, config}) =>
+  {
+    // the config might have changed, so the connector should be able to deal with multiple setConfigs over it's lifetime
+    controller.setConfig({newTask, config});
+  });  
+
+// start the connector
+connector.run();

package/examples/kitchen-sink/01-hello-world.js

@@ -0,0 +1,26 @@
+const {Connector}  = require('@aloma-io/integration-sdk');
+
+const connector    = new Connector({id: 'TODO your connector id', version: '1.0.0'});
+
+connector.configure()
+  // types are the calls available in the step, these are typescript definitions
+  .types
+  (`
+    declare function hello(arg: {}): any;
+  `)
+  // resolvers hold the calls
+  .resolvers
+  ({
+    hello: async (args) => 
+    {
+      return "world";
+    },
+  })
+  // main will be called once the connector is connected
+  .main(({newTask, config}) =>
+  {
+    // the config might have changed, so the connector should be able to deal with multiple setConfigs over it's lifetime
+  });  
+
+// start the connector
+connector.run();

package/examples/kitchen-sink/02-config.js

@@ -0,0 +1,54 @@
+const {Connector}  = require('@aloma-io/integration-sdk');
+
+const connector    = new Connector({id: 'TODO your connector id', version: '1.0.0'});
+
+connector.configure()
+  // these config fields can be configured from the aloma ui. these require a private and a public key which the connector will generate on start
+  .config({fields: 
+  {
+    // this is then available from config.type
+    type: {
+      // name and placeholder for ui configuration
+      name: 'Database Type',
+      placeholder: 'e.g. mysql, pg, tedious',
+      // type
+      type: 'line',
+      // this is an unencrypted value, by default everything is encrypted
+      plain: true
+    },
+    user: {
+      name: 'User',
+      placeholder: 'e.g. john',
+      type: 'line',
+      plain: true,
+      // this is marked as optional in the ui, so does not have to be provided, everything else is mandatory
+      optional: true
+    },
+    // this is encrypted in the ui via public key, can only be decrypted by the connector having the private key
+    password: {
+      name: 'Password',
+      placeholder: 'e.g. x3gsadg',
+      type: 'line',
+      optional: true
+    },
+ 
+  }})
+  .types
+  (`
+    declare function hello(arg: {}): any;
+  `)
+  .resolvers
+  ({
+    hello: async (args) => 
+    {
+      return "world";
+    },
+  })
+  .main(({newTask, config}) =>
+  {
+    console.log(config.type)
+    console.log(config.password)
+    console.log(config.user)
+  });  
+
+connector.run();

package/examples/kitchen-sink/03-oauth.js

@@ -0,0 +1,36 @@
+const {Connector}  = require('@aloma-io/integration-sdk');
+
+const connector    = new Connector({id: 'TODO your connector id', version: '1.0.0'});
+
+connector.configure()
+  // these require a private and a public key which the connector will generate on start
+  // after a connector is added to a workspace it can be connected from the aloma ui
+  .oauth
+  ({
+    // the authorization url, the placeholders {{clientId}}, {{redirectURI}}, {{scope}} will be filled in by aloma
+    authorizationURL: 'https://github.com/login/oauth/authorize?client_id={{clientId}}&redirect_uri={{redirectURI}}&scope={{scope}}&allow_signup=false',
+    tokenURL: 'https://github.com/login/oauth/access_token',
+    clientId: 'clientId',
+    clientSecret: 'clientSecret',
+    scope: 'repo, user:email'
+  })
+  .types
+  (`
+    declare function hello(arg: {}): any;
+  `)
+  .resolvers
+  ({
+    hello: async (args) => 
+    {
+      return "world";
+    },
+  })
+  .main(({newTask, config, oauth}) =>
+  {
+    // one can access oauth.accessToken()
+    // one can get a fetch client: oauth.getClient()
+    // the client supports retries and will also do an automatic token refresh if a refresh_token is provided
+    // oauth.getClient().fetch({url, options = {method: 'POST', headers: {}, body: ''})
+  });  
+
+connector.run();

package/index.js

@@ -0,0 +1,3 @@
+const {Connector} = require('./src/')
+
+module.exports = {Connector}

package/package.json

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

package/src/builder/index.mts

@@ -1,4 +1,4 @@
-import fs from 'fs';
+import fs from 'node:fs';
 import parseTypes from './transform/index.mjs';
 import RuntimeContext from './runtime-context.mjs';
 import {fileURLToPath} from 'node:url';
@@ -15,23 +15,12 @@ const notEmpty = (what, name) => {
 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 {
+    this.data.options = arg;
     return this;
   }
 
@@ -42,16 +31,18 @@ export class Builder {
   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);
+
+    const packageJson = JSON.parse(fs.readFileSync(__dirname + '/../../../../../package.json', {encoding: 'utf-8'}));
+    
+    notEmpty(data.id = packageJson.connectorId, 'id');
+    notEmpty(data.version= packageJson.version, 'version');
+    
     // @ts-ignore
     const Controller = (await import(__dirname + '/../../../../../build/controller/index.mjs')).default;
 
@@ -64,7 +55,7 @@ export class Builder {
     const content = fs.readFileSync(this.data.controller);
     const {text, methods} = parseTypes(this.data.controller);
 
-    this.data.types = text;
+    this.data.types   = text;
     this.data.methods = methods;
   }
 }

package/src/builder/runtime-context.mts

@@ -6,15 +6,20 @@ export default class RuntimeContext {
 
   async start(): Promise<void> {
     const controller = this.controller;
-
+    
+    if (!(controller instanceof AbstractController)) throw new Error('the controller needs to extend AbstractController');
+    const data:any = this.data;
+    
     const connector = new Connector({
-      id: this.data.id,
-      version: this.data.version,
-      name: `${this.data.id}/${this.data.version}`,
+      id: data.id,
+      version: data.version,
+      name: `${data.id}/${data.version}`,
     });
 
+    const configuration = connector.configure();
+
     const resolvers: any = {};
-    const methods: string[] = [...this.data.methods, '__endpoint', '__configQuery', '__default'];
+    const methods: string[] = [...data.methods, '__endpoint', '__configQuery', '__default'];
 
     methods.forEach((method) => {
       resolvers[method] = async (args) => {
@@ -24,14 +29,15 @@ export default class RuntimeContext {
         return controller[method](args);
       };
     });
-
-    console.log(this.data.types);
-
-    connector
-      .configure()
-      .types(this.data.types)
-      .resolvers(resolvers)
-      .main(async ({newTask, updateTask, config, oauth, getClient}) => {
+    
+    configuration.types(data.types).resolvers(resolvers);    
+    
+    if (data.options?.endpoint)
+    {
+      configuration.endpoint((arg) => controller.__endpoint(arg));
+    }
+      
+      configuration.main(async ({newTask, updateTask, config, oauth, getClient}) => {
         try {
           await controller._doStop();
           await controller._doStart(config, oauth, newTask, updateTask, getClient);

package/src/controller/index.mts

@@ -31,7 +31,7 @@ export abstract class AbstractController {
   }
 
   async __endpoint(arg: any): Promise<any | null> {
-    return Promise.resolve(null);
+    return this.endpoint(arg);
   }
 
   async __configQuery(arg: any): Promise<any | null> {