@aloma.io/integration-sdk 3.3.92 → 3.4.0

package/build/builder/runtime-context.mjs

@@ -50,10 +50,10 @@ export default class RuntimeContext {
         if (data.auth?.oauth) {
             configuration.oauth(data.auth?.oauth);
         }
-        configuration.main(async ({ newTask, updateTask, config, oauth, getClient }) => {
+        configuration.main(async ({ newTask, updateTask, config, oauth, getClient, getBlob, getBlobContent, putBlob, }) => {
             try {
                 await controller._doStop();
-                await controller._doStart(config, oauth, newTask, updateTask, getClient);
+                await controller._doStart(config, oauth, newTask, updateTask, getClient, getBlob, getBlobContent, putBlob);
             }
             catch (e) {
                 console.log(e);

package/build/controller/index.d.mts

@@ -7,15 +7,31 @@ export declare abstract class AbstractController {
     protected fallback(arg: any): Promise<any>;
     protected endpoint(arg: any): Promise<any>;
     protected newTask(name: string, data: any): Promise<string>;
-    protected getClient({ baseUrl, onResponse, customize }: {
+    protected getClient({ baseUrl, onResponse, customize, }: {
         baseUrl: string;
         onResponse?: (response: any) => void;
         customize?: (request: any) => void;
     }): Promise<any>;
     protected updateTask(name: string, data: any): Promise<string>;
+    protected newBlob({ content, name, size, mimetype, meta, taskId, }: {
+        content: string;
+        name?: string;
+        size?: number;
+        mimetype?: string;
+        meta?: any;
+        taskId?: string;
+    }): Promise<string>;
+    protected getBlob(id: string): Promise<{
+        name?: string;
+        id: any;
+        size?: number;
+        mimetype?: string;
+        meta?: any;
+    }>;
+    protected getBlobContent(id: string): Promise<string>;
     __endpoint(arg: any): Promise<any | null>;
     __configQuery(arg: any): Promise<any | null>;
     __default(arg: any): Promise<any | null>;
-    _doStart(config: any, client: any, newTask: any, updateTask: any, getClient: any): Promise<void>;
+    _doStart(config: any, client: any, newTask: any, updateTask: any, getBlob: any, getBlobContent: any, putBlob: any, getClient: any): Promise<void>;
     _doStop(isShutdown?: boolean): Promise<void>;
 }

package/build/controller/index.mjs

@@ -15,12 +15,21 @@ export class AbstractController {
     async newTask(name, data) {
         throw new Error("not implemented");
     }
-    getClient({ baseUrl, onResponse, customize }) {
+    getClient({ baseUrl, onResponse, customize, }) {
         throw new Error("not implemented");
     }
     async updateTask(name, data) {
         throw new Error("not implemented");
     }
+    async newBlob({ content, name, size, mimetype, meta, taskId, }) {
+        throw new Error("not implemented");
+    }
+    async getBlob(id) {
+        throw new Error("not implemented");
+    }
+    async getBlobContent(id) {
+        throw new Error("not implemented");
+    }
     async __endpoint(arg) {
         return this.endpoint(arg);
     }
@@ -30,12 +39,15 @@ export class AbstractController {
     async __default(arg) {
         return this.fallback(arg);
     }
-    async _doStart(config, client, newTask, updateTask, getClient) {
+    async _doStart(config, client, newTask, updateTask, getBlob, getBlobContent, putBlob, getClient) {
         this.config = config;
         this.client = client;
         this.newTask = newTask;
         this.updateTask = updateTask;
         this.getClient = getClient;
+        this.newBlob = putBlob;
+        this.getBlob = getBlob;
+        this.getBlobContent = getBlobContent;
         await this.start();
     }
     async _doStop(isShutdown = false) {

package/build/internal/index.mjs

@@ -77,7 +77,7 @@ class Fetcher {
             options.url = url;
             await local.customize(options, args);
             url = options.url;
-            delete (options.url);
+            delete options.url;
             theURL = `${baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"}${url}`.replace(/\/\/+/gi, "/");
             if (!options?.headers || !options?.headers?.Accept) {
                 options.headers = {
@@ -117,7 +117,7 @@ class Fetcher {
             }
             // bad request
             if (e.status === 400 || e.status === 422) {
-                throw (e);
+                throw e;
             }
             --retries;
             console.log(theURL, e);
@@ -508,9 +508,40 @@ ${text}
                             }, 4 * 60 * 60 * 15000);
                         }
                     }
+                    const getBlob = (id) => {
+                        return new Promise((resolve, reject) => {
+                            const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                            packet.method("connector.blob.get");
+                            packet.args({
+                                id,
+                            });
+                            transport.send(packet);
+                        });
+                    };
+                    const getBlobContent = (id) => {
+                        return new Promise((resolve, reject) => {
+                            const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                            packet.method("connector.blob.get-content");
+                            packet.args({
+                                id,
+                            });
+                            transport.send(packet);
+                        });
+                    };
+                    const putBlob = (args = {}) => {
+                        return new Promise((resolve, reject) => {
+                            const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                            packet.method("connector.blob.put");
+                            packet.args(args);
+                            transport.send(packet);
+                        });
+                    };
                     start({
                         config: decrypted,
                         oauth: theOAuth,
+                        getBlob,
+                        getBlobContent,
+                        putBlob,
                         getClient: (arg) => theOAuth ? theOAuth.getClient(arg) : new Fetcher(arg),
                         newTask: (name, data) => {
                             return new Promise((resolve, reject) => {

package/package.json

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

package/src/builder/runtime-context.mts

@@ -64,7 +64,16 @@ export default class RuntimeContext {
     }
 
     configuration.main(
-      async ({ newTask, updateTask, config, oauth, getClient }) => {
+      async ({
+        newTask,
+        updateTask,
+        config,
+        oauth,
+        getClient,
+        getBlob,
+        getBlobContent,
+        putBlob,
+      }) => {
         try {
           await controller._doStop();
           await controller._doStart(
@@ -73,6 +82,9 @@ export default class RuntimeContext {
             newTask,
             updateTask,
             getClient,
+            getBlob,
+            getBlobContent,
+            putBlob,
           );
         } catch (e) {
           console.log(e);

package/src/controller/index.mts

@@ -25,7 +25,7 @@ export abstract class AbstractController {
   protected getClient({
     baseUrl,
     onResponse,
-    customize
+    customize,
   }: {
     baseUrl: string;
     onResponse?: (response: any) => void;
@@ -38,6 +38,38 @@ export abstract class AbstractController {
     throw new Error("not implemented");
   }
 
+  protected async newBlob({
+    content,
+    name,
+    size,
+    mimetype,
+    meta,
+    taskId,
+  }: {
+    content: string;
+    name?: string;
+    size?: number;
+    mimetype?: string;
+    meta?: any;
+    taskId?: string;
+  }): Promise<string> {
+    throw new Error("not implemented");
+  }
+
+  protected async getBlob(id: string): Promise<{
+    name?: string;
+    id;
+    size?: number;
+    mimetype?: string;
+    meta?: any;
+  }> {
+    throw new Error("not implemented");
+  }
+
+  protected async getBlobContent(id: string): Promise<string> {
+    throw new Error("not implemented");
+  }
+
   async __endpoint(arg: any): Promise<any | null> {
     return this.endpoint(arg);
   }
@@ -55,6 +87,9 @@ export abstract class AbstractController {
     client: any,
     newTask: any,
     updateTask: any,
+    getBlob: any,
+    getBlobContent: any,
+    putBlob: any,
     getClient: any,
   ): Promise<void> {
     this.config = config;
@@ -62,6 +97,9 @@ export abstract class AbstractController {
     this.newTask = newTask;
     this.updateTask = updateTask;
     this.getClient = getClient;
+    this.newBlob = putBlob;
+    this.getBlob = getBlob;
+    this.getBlobContent = getBlobContent;
 
     await this.start();
   }

package/src/internal/index.mjs

@@ -33,15 +33,16 @@ const reply = (arg, packet, transport) => {
 
 const unwrap0 = (ret, body, options) => {
   if (options?.bodyOnly === false) {
-    return {status: ret.status, headers: ret.headers, body};
+    return { status: ret.status, headers: ret.headers, body };
   } else {
-    return body;    
+    return body;
   }
-}
+};
 
 const unwrap = async (ret, options) => {
   if (options?.text) return unwrap0(ret, await ret.text(), options);
-  if (options?.base64) return unwrap0(ret, (await ret.buffer()).toString("base64"), options);
+  if (options?.base64)
+    return unwrap0(ret, (await ret.buffer()).toString("base64"), options);
 
   const text = await ret.text();
 
@@ -52,7 +53,6 @@ const unwrap = async (ret, options) => {
   }
 };
 
-
 class Fetcher {
   constructor({ retry = 5, baseUrl, onResponse, customize }) {
     this.retry = retry;
@@ -95,9 +95,9 @@ class Fetcher {
     try {
       options.url = url;
       await local.customize(options, args);
-      
+
       url = options.url;
-      delete(options.url);
+      delete options.url;
 
       theURL = `${
         baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"
@@ -147,10 +147,10 @@ class Fetcher {
       if (e.status === 429) {
         return local.onError(e, url, options, retries, args, true);
       }
-      
+
       // bad request
       if (e.status === 400 || e.status === 422) {
-        throw(e);
+        throw e;
       }
 
       --retries;
@@ -165,7 +165,7 @@ class Fetcher {
 }
 
 class OAuthFetcher extends Fetcher {
-  constructor({ oauth, retry = 5, getToken, baseUrl, onResponse, customize}) {
+  constructor({ oauth, retry = 5, getToken, baseUrl, onResponse, customize }) {
     super({ retry, baseUrl, onResponse, customize });
 
     this.oauth = oauth;
@@ -235,9 +235,9 @@ class OAuthFetcher extends Fetcher {
 
   async customize(options, args = {}) {
     const local = this;
-    
+
     if (this.customize0) await this.customize0(options, args);
-    
+
     const token = await local.getToken(args.forceTokenRefresh);
 
     options.headers = {
@@ -293,7 +293,6 @@ class OAuth {
   async invalidate(err) {
     if (true) return;
     //if (this._data.access_token === "invalid") return;
-
   }
 
   getClient(arg = {}) {
@@ -638,9 +637,61 @@ ${text}
             }
           }
 
+          const getBlob = (id) => {
+            return new Promise((resolve, reject) => {
+              const packet = transport.newPacket(
+                {},
+                (ret) => (ret?.error ? reject(ret.error) : resolve(ret)),
+                `_req-${cuid()}`,
+              );
+
+              packet.method("connector.blob.get");
+              packet.args({
+                id,
+              });
+
+              transport.send(packet);
+            });
+          };
+
+          const getBlobContent = (id) => {
+            return new Promise((resolve, reject) => {
+              const packet = transport.newPacket(
+                {},
+                (ret) => (ret?.error ? reject(ret.error) : resolve(ret)),
+                `_req-${cuid()}`,
+              );
+
+              packet.method("connector.blob.get-content");
+              packet.args({
+                id,
+              });
+
+              transport.send(packet);
+            });
+          };
+
+          const putBlob = (args = {}) => {
+            return new Promise((resolve, reject) => {
+              const packet = transport.newPacket(
+                {},
+                (ret) => (ret?.error ? reject(ret.error) : resolve(ret)),
+                `_req-${cuid()}`,
+              );
+
+              packet.method("connector.blob.put");
+              packet.args(args);
+
+              transport.send(packet);
+            });
+          };
+
           start({
             config: decrypted,
             oauth: theOAuth,
+            getBlob,
+            getBlobContent,
+            putBlob,
             getClient: (arg) =>
               theOAuth ? theOAuth.getClient(arg) : new Fetcher(arg),
             newTask: (name, data) => {