@aloma.io/integration-sdk 3.8.33 → 3.8.34

package/build/builder/runtime-context.d.mts

@@ -1,7 +1,13 @@
 import { AbstractController } from '../controller/index.mjs';
+/**
+ * Runtime context to manage the lifecycle of the connector
+ */
 export default class RuntimeContext {
     private controller;
     private data;
     constructor(controller: AbstractController, data: any);
+    /**
+     * start the connector
+     */
     start(): Promise<void>;
 }

package/build/builder/runtime-context.mjs

@@ -1,6 +1,9 @@
 import fs from 'node:fs';
 import { AbstractController } from '../controller/index.mjs';
 import { Connector } from '../internal/index.mjs';
+/**
+ * Runtime context to manage the lifecycle of the connector
+ */
 export default class RuntimeContext {
     controller;
     data;
@@ -8,6 +11,9 @@ export default class RuntimeContext {
         this.controller = controller;
         this.data = data;
     }
+    /**
+     * start the connector
+     */
     async start() {
         const controller = this.controller;
         if (!(controller instanceof AbstractController)) {

package/build/controller/index.d.mts

@@ -1,6 +1,10 @@
 import { ConfigField } from '../index.mjs';
 import Fetcher from '../internal/fetcher/fetcher.mjs';
 import { OAuth } from '../internal/fetcher/oauth-fetcher.mjs';
+/**
+ * Abstract controller class
+ * this needs to be used in a connector
+ */
 export declare abstract class AbstractController {
     /**
      * connector configuration
@@ -42,6 +46,11 @@ export declare abstract class AbstractController {
      * @param arg
      */
     protected fallback(arg: any): Promise<any>;
+    /**
+     * will be invoked, when the connector has an endpoint enabled
+     * will receive the data and can e.g. create a new task from it
+     * @param arg
+     */
     protected endpoint(arg: any): Promise<any>;
     /**
      * create a new task
@@ -49,6 +58,12 @@ export declare abstract class AbstractController {
      * @param data data of the task
      */
     protected newTask(name: string, data: any): Promise<string>;
+    /**
+     * get a client to make requests
+     * @param baseUrl base url of the client
+     * @param onResponse callback to be invoked on response
+     * @param customize callback to customize the request
+     */
     protected getClient({ baseUrl, onResponse, customize, }: {
         baseUrl?: string;
         onResponse?: (response: any) => void;
@@ -61,6 +76,15 @@ export declare abstract class AbstractController {
      * @returns taskId
      */
     protected updateTask(name: string, data: any): Promise<string>;
+    /**
+     * create a blob
+     * @param content content of the blob in base64
+     * @param name name of the blob
+     * @param size size of the blob
+     * @param mimetype mimetype of the blob
+     * @param meta meta data of the blob
+     * @param taskId id of the task
+     */
     protected createBlob({ content, name, size, mimetype, meta, taskId, }: {
         content: string;
         name?: string;
@@ -99,13 +123,34 @@ export declare abstract class AbstractController {
     protected configCheck(configSchema: {
         [key: string]: ConfigField;
     }): Promise<void>;
+    /**
+     * @ignore
+     **/
     __endpoint(arg: any): Promise<any | null>;
+    /**
+     * @ignore
+     **/
     __autocomplete(arg: any): Promise<any | null>;
+    /**
+     * @ignore
+     **/
     __default(arg: any): Promise<any | null>;
+    /**
+     * @ignore
+     **/
     __healthCheck(configSchema: () => {
         [key: string]: ConfigField;
     }): Promise<void>;
+    /**
+     * @ignore
+     **/
     private defaultConfigCheck;
+    /**
+     * @ignore
+     **/
     _doStart(config: any, oauth: any, newTask: any, updateTask: any, getClient: any, getBlob: any, getBlobContent: any, createBlob: any): Promise<void>;
+    /**
+     * @ignore
+     **/
     _doStop(isShutdown?: boolean): Promise<void>;
 }

package/build/controller/index.mjs

@@ -1,3 +1,7 @@
+/**
+ * Abstract controller class
+ * this needs to be used in a connector
+ */
 export class AbstractController {
     /**
      * connector configuration
@@ -41,6 +45,11 @@ export class AbstractController {
     fallback(arg) {
         throw new Error('method not found');
     }
+    /**
+     * will be invoked, when the connector has an endpoint enabled
+     * will receive the data and can e.g. create a new task from it
+     * @param arg
+     */
     async endpoint(arg) {
         throw new Error('method not found');
     }
@@ -52,6 +61,12 @@ export class AbstractController {
     async newTask(name, data) {
         throw new Error('not implemented');
     }
+    /**
+     * get a client to make requests
+     * @param baseUrl base url of the client
+     * @param onResponse callback to be invoked on response
+     * @param customize callback to customize the request
+     */
     getClient({ baseUrl, onResponse, customize, }) {
         throw new Error('not implemented');
     }
@@ -64,6 +79,15 @@ export class AbstractController {
     async updateTask(name, data) {
         throw new Error('not implemented');
     }
+    /**
+     * create a blob
+     * @param content content of the blob in base64
+     * @param name name of the blob
+     * @param size size of the blob
+     * @param mimetype mimetype of the blob
+     * @param meta meta data of the blob
+     * @param taskId id of the task
+     */
     async createBlob({ content, name, size, mimetype, meta, taskId, }) {
         throw new Error('not implemented');
     }
@@ -97,15 +121,27 @@ export class AbstractController {
     async configCheck(configSchema) {
         // blank, throw an error if the config is not valid
     }
+    /**
+     * @ignore
+     **/
     async __endpoint(arg) {
         return this.endpoint(arg);
     }
+    /**
+     * @ignore
+     **/
     async __autocomplete(arg) {
         return this.autocomplete(arg);
     }
+    /**
+     * @ignore
+     **/
     async __default(arg) {
         return this.fallback(arg);
     }
+    /**
+     * @ignore
+     **/
     async __healthCheck(configSchema) {
         const errors = [];
         const schema = configSchema();
@@ -132,6 +168,9 @@ export class AbstractController {
             throw new Error(errors.join('\n'));
         }
     }
+    /**
+     * @ignore
+     **/
     async defaultConfigCheck(configSchema) {
         const config = this.config;
         const missing = Object.entries(configSchema)
@@ -147,6 +186,9 @@ export class AbstractController {
             throw new Error(missing.join('\n'));
         }
     }
+    /**
+     * @ignore
+     **/
     async _doStart(config, oauth, newTask, updateTask, getClient, getBlob, getBlobContent, createBlob) {
         this.config = config;
         this.client = oauth;
@@ -159,6 +201,9 @@ export class AbstractController {
         this.getBlobContent = getBlobContent;
         await this.start();
     }
+    /**
+     * @ignore
+     **/
     async _doStop(isShutdown = false) {
         await this.stop(isShutdown);
     }

package/package.json

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

package/src/builder/runtime-context.mts

@@ -1,13 +1,19 @@
 import fs from 'node:fs';
-import {AbstractController} from '../controller/index.mjs';
-import {Connector} from '../internal/index.mjs';
+import { AbstractController } from '../controller/index.mjs';
+import { Connector } from '../internal/index.mjs';
 
+/**
+ * Runtime context to manage the lifecycle of the connector
+ */
 export default class RuntimeContext {
   constructor(
     private controller: AbstractController,
     private data: any
   ) {}
 
+  /**
+   * start the connector
+   */
   async start(): Promise<void> {
     const controller = this.controller;
 

package/src/controller/index.mts

@@ -2,6 +2,10 @@ import { ConfigField } from '../index.mjs';
 import Fetcher from '../internal/fetcher/fetcher.mjs';
 import { OAuth } from '../internal/fetcher/oauth-fetcher.mjs';
 
+/**
+ * Abstract controller class
+ * this needs to be used in a connector
+ */
 export abstract class AbstractController {
   /**
    * connector configuration
@@ -52,6 +56,11 @@ export abstract class AbstractController {
     throw new Error('method not found');
   }
 
+  /**
+   * will be invoked, when the connector has an endpoint enabled
+   * will receive the data and can e.g. create a new task from it
+   * @param arg
+   */
   protected async endpoint(arg: any): Promise<any> {
     throw new Error('method not found');
   }
@@ -65,6 +74,12 @@ export abstract class AbstractController {
     throw new Error('not implemented');
   }
 
+  /**
+   * get a client to make requests
+   * @param baseUrl base url of the client
+   * @param onResponse callback to be invoked on response
+   * @param customize callback to customize the request
+   */
   protected getClient({
     baseUrl,
     onResponse,
@@ -87,6 +102,15 @@ export abstract class AbstractController {
     throw new Error('not implemented');
   }
 
+  /**
+   * create a blob
+   * @param content content of the blob in base64
+   * @param name name of the blob
+   * @param size size of the blob
+   * @param mimetype mimetype of the blob
+   * @param meta meta data of the blob
+   * @param taskId id of the task
+   */
   protected async createBlob({
     content,
     name,
@@ -145,18 +169,30 @@ export abstract class AbstractController {
     // blank, throw an error if the config is not valid
   }
 
+  /**
+   * @ignore
+   **/
   async __endpoint(arg: any): Promise<any | null> {
     return this.endpoint(arg);
   }
 
+  /**
+   * @ignore
+   **/
   async __autocomplete(arg: any): Promise<any | null> {
     return this.autocomplete(arg);
   }
 
+  /**
+   * @ignore
+   **/
   async __default(arg: any): Promise<any | null> {
     return this.fallback(arg);
   }
 
+  /**
+   * @ignore
+   **/
   async __healthCheck(configSchema: () => {[key: string]: ConfigField}): Promise<void> {
     const errors: string[] = [];
     const schema = configSchema();
@@ -185,6 +221,9 @@ export abstract class AbstractController {
     }
   }
 
+  /**
+   * @ignore
+   **/
   private async defaultConfigCheck(configSchema: {[key: string]: ConfigField}): Promise<void> {
     const config = this.config;
 
@@ -203,6 +242,9 @@ export abstract class AbstractController {
     }
   }
 
+  /**
+   * @ignore
+   **/
   async _doStart(
     config: any,
     oauth: any,
@@ -226,6 +268,9 @@ export abstract class AbstractController {
     await this.start();
   }
 
+  /**
+   * @ignore
+   **/
   async _doStop(isShutdown: boolean = false): Promise<void> {
     await this.stop(isShutdown);
   }