@ptkl/sdk 0.2.1 → 0.2.2

package/dist/index.umd.js

@@ -8,9 +8,73 @@
         constructor(client) {
             this.client = client;
         }
+        setClient(client) {
+            this.client = client;
+            return this;
+        }
     }
 
-    class Functions extends BaseClient {
+    typeof process !== "undefined" &&
+        process.versions != null &&
+        process.versions.node != null;
+    const isBrowser = typeof window !== "undefined" &&
+        typeof document !== "undefined";
+
+    /**
+     * Base client for the platform API
+     * Classes that extend PlatformBaseClient have intentins of only working in platform context
+     *
+     *
+     * @class PlatformBaseClient
+     * @extends BaseClient
+     * @constructor
+     * @param {AxiosInstance} [client] - The axios instance to use for the client
+     *
+     * @example
+     * // if sdk is used in the forge app that is running in the platform context
+     * const utils = new ComponentUtils()
+     * // this won't work outside of platform context because client needs authtorization to communicate with the API.
+     *
+     */
+    class PlatformBaseClient extends BaseClient {
+        constructor(options) {
+            var _a, _b;
+            let { env = null, token, host, } = options !== null && options !== undefined ? options : {};
+            let headers = {};
+            if (isBrowser) {
+                if (localStorage.getItem('protokol_context') == "forge") {
+                    headers['X-Project-Env'] = (_a = localStorage.getItem('forge_app_env')) !== null && _a !== undefined ? _a : "dev";
+                }
+                else {
+                    // this potentially means that it is running as dev server in local
+                    headers['X-Project-Env'] = "dev";
+                }
+                // @ts-ignore
+                const __global_env__ = window === null || window === undefined ? undefined : window.__ENV_VARIABLES__;
+                host = (_b = __global_env__ === null || __global_env__ === undefined ? undefined : __global_env__.API_HOST) !== null && _b !== undefined ? _b : host;
+            }
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            if (env) {
+                headers['X-Project-Env'] = env;
+            }
+            const client = axios.create({
+                baseURL: host !== null && host !== undefined ? host : "https://lemon.protokol.io",
+                timeout: 15000,
+                headers: {
+                    ...headers,
+                },
+                withCredentials: true,
+            });
+            super(client);
+            this.env = null;
+            this.token = null;
+            this.host = null;
+        }
+    }
+
+    class Functions extends PlatformBaseClient {
         async list() {
             return await this.client.get("/v1/system/function");
         }
@@ -43,12 +107,7 @@
         }
     }
 
-    var functions = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Functions
-    });
-
-    class Roles extends BaseClient {
+    class Roles extends PlatformBaseClient {
         async create(role) {
             const res = await this.client.post("/v1/user/role/create", role);
             //    writeFileSync(`.role.create.json`,JSON.stringify(res))
@@ -72,16 +131,15 @@
         }
     }
 
-    var roles = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Roles
-    });
-
-    class APIUser extends BaseClient {
-        async apiAuth(username, password) {
+    class APIUser extends PlatformBaseClient {
+        async auth(username, password, project) {
             return this.client.post("/v1/user/api/auth", {
                 username,
                 password
+            }, {
+                headers: {
+                    "X-Project-Uuid": project
+                }
             });
         }
         async newSecret(uuid) {
@@ -101,12 +159,7 @@
         }
     }
 
-    var apiUser = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: APIUser
-    });
-
-    class Users extends BaseClient {
+    class Users extends PlatformBaseClient {
         async invite(email, roles) {
             return await this.client.post("/v1/project/invite", {
                 email,
@@ -118,14 +171,9 @@
         }
     }
 
-    var users = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Users
-    });
-
-    class Apps extends BaseClient {
-        constructor(client, appType) {
-            super(client);
+    class Apps extends PlatformBaseClient {
+        constructor(appType) {
+            super();
             this.appType = appType;
         }
         async updateSettings(updateValues, ref) {
@@ -142,19 +190,10 @@
         }
     }
 
-    var apps = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Apps
-    });
-
-    class Component extends BaseClient {
-        constructor(adapter, ref) {
-            super(adapter);
-            this.ref = ref;
-        }
-        new(ref) {
+    class Component extends PlatformBaseClient {
+        constructor(ref = null) {
+            super();
             this.ref = ref;
-            return this;
         }
         /**
          * Find method to search for models
@@ -265,14 +304,9 @@
          * @param uuid string - The uuid of the model
          * @returns (Promise<Model>)
          */
-        get(uuid) {
-            return new Promise((resolve, reject) => {
-                this.client.get(`/v3/system/component/${this.ref}/model/${uuid}`).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
-            });
+        async get(uuid) {
+            const { data } = await this.client.get(`/v3/system/component/${this.ref}/model/${uuid}`);
+            return data;
         }
         /**
          * Update model by uuid
@@ -281,73 +315,62 @@
          * @param data
          * @returns
          */
-        update(uuid, data) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
-                    data,
-                }).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
+        async update(uuid, data, options) {
+            const { data: responseData } = await this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
+                data,
+                options,
             });
+            return responseData;
         }
-        concurrentUpdate(uuid, version, data) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
-                    version: version,
-                    data,
-                }).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
+        /**
+         * Update many models
+         *
+         * @param data
+         * @param options
+         * @returns
+         */
+        async updateMany(data, options) {
+            const { data: responseData } = await this.client.post(`/v3/system/component/${this.ref}/models/bulk`, {
+                data,
+                options,
             });
+            return responseData;
         }
-        create(model) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/model`, model).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
+        /**
+         * Concurrent update model by uuid
+         *
+         * @param uuid string - The uuid of the model
+         * @param version number - The version of the model
+         * @param data
+         * @returns
+         */
+        async concurrentUpdate(uuid, version, data, options) {
+            const { data: responseData } = await this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
+                version: version,
+                data,
+                options,
             });
+            return responseData;
         }
-        delete(uuid) {
-            return new Promise((resolve, reject) => {
-                this.client.delete(`/v3/system/component/${this.ref}/model/${uuid}`).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
-            });
+        async create(model) {
+            const { data } = await this.client.post(`/v3/system/component/${this.ref}/model`, model);
+            return data;
         }
-        aggregate(pipeline) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/aggregate`, pipeline).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
-            });
+        async delete(uuid) {
+            const { data } = await this.client.delete(`/v3/system/component/${this.ref}/model/${uuid}`);
+            return data;
         }
-        settings() {
-            return new Promise((resolve, reject) => {
-                this.client.get(`/v3/system/component/settings/${this.ref}`).then((resp) => {
-                    resolve(resp.data);
-                }).catch(err => {
-                    reject(err);
-                });
-            });
+        async aggregate(pipeline) {
+            const { data } = await this.client.post(`/v3/system/component/${this.ref}/aggregate`, pipeline);
+            return data;
         }
-        saveSettings(settings) {
-            return new Promise((resolve, reject) => {
-                this.client.post("/v3/system/component/settings/" + settings.general.uuid + "/" + settings.settings.version, settings).then((resp) => {
-                    resolve(resp.data);
-                }).catch(err => {
-                    reject(err);
-                });
-            });
+        async settings() {
+            const { data } = await this.client.get(`/v3/system/component/settings/${this.ref}`);
+            return data;
+        }
+        async saveSettings(settings, version) {
+            const { data } = await this.client.post(`/v3/system/component/settings/${this.ref}/${version}`, settings);
+            return data;
         }
         async saveTemplatesDist(version, sdkVersion, engine, dist) {
             const { data } = await this.client.post(`/v3/system/component/templates/${this.ref}/${version}`, {
@@ -360,29 +383,136 @@
             return data;
         }
         async workflow(event, input) {
-            return await this.client.post(`/v1/system/component/${this.ref}/workflow/event`, {
+            const { data } = await this.client.post(`/v1/system/component/${this.ref}/workflow/event`, {
                 event,
                 input
             });
+            return data;
         }
         async function(name, input) {
-            return await this.client.post(`/v3/system/component/${this.ref}/function/${name}`, input);
+            const { data } = await this.client.post(`/v3/system/component/${this.ref}/function/${name}`, input);
+            return data;
         }
-        async all() {
+    }
+
+    class ComponentUtils extends PlatformBaseClient {
+        async list() {
             const { data } = await this.client.get("/v1/system/components");
             return data;
         }
-        async setup(data) {
-            return await this.client.post("/v3/system/component/create", data);
+        async create(data) {
+            const { data: responseData } = await this.client.post("/v3/system/component/create", data);
+            return responseData;
+        }
+    }
+
+    class Ratchet extends PlatformBaseClient {
+        async query(name, params) {
+            let res = await this.client.post('/v1/ratchet/query', {
+                name: name,
+                params: params
+            });
+            return res.data;
+        }
+    }
+
+    class Sandbox extends PlatformBaseClient {
+        /**
+         * Call the sandbox service to execute a serverless function
+         *
+         * @param name
+         * @param data
+         * @returns
+         *
+         * @example
+         * const result = await platform.sandbox().spark("myFunction", { foo: "bar" })
+         */
+        async spark(name, data) {
+            return await this.client.post(`/v1/project/sandbox/spark/exec/${name}`, data);
+        }
+    }
+
+    class System extends PlatformBaseClient {
+        async resourceResolver(ref, resourceName, format) {
+            const { data } = await this.client.post("/v3/system/resource-resolver", {
+                type: resourceName,
+                format,
+            });
+            if (format) {
+                return data.format;
+            }
+            return data;
+        }
+    }
+
+    class Workflow extends PlatformBaseClient {
+        async trigger(id, event, data) {
+            return await this.client.post(`/v1/project/workflow/workflow/${id}/event/${event}`, data);
         }
     }
 
-    var component = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Component
-    });
+    class Forge extends PlatformBaseClient {
+        async bundleUpload(buffer) {
+            return await this.client.post(`/v3/system/gateway/app-service/forge/upload`, buffer, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'Content-Length': buffer.length
+                }
+            });
+        }
+        async getWorkspaceApps() {
+            return await this.client.get(`/v3/system/gateway/app-service/forge/workspace`);
+        }
+    }
 
-    class Invoicing extends BaseClient {
+    // apis
+    class Platform extends PlatformBaseClient {
+        getPlatformClient() {
+            return this.client;
+        }
+        getPlatformBaseURL() {
+            var _a;
+            return (_a = this.client.defaults.baseURL) !== null && _a !== undefined ? _a : "";
+        }
+        apiUser() {
+            return (new APIUser()).setClient(this.client);
+        }
+        function() {
+            return (new Functions()).setClient(this.client);
+        }
+        role() {
+            return (new Roles()).setClient(this.client);
+        }
+        user() {
+            return (new Users()).setClient(this.client);
+        }
+        app(appType) {
+            return (new Apps(appType)).setClient(this.client);
+        }
+        forge() {
+            return (new Forge()).setClient(this.client);
+        }
+        component(ref) {
+            return (new Component(ref)).setClient(this.client);
+        }
+        componentUtils() {
+            return (new ComponentUtils()).setClient(this.client);
+        }
+        ratchet() {
+            return (new Ratchet()).setClient(this.client);
+        }
+        sandbox() {
+            return (new Sandbox()).setClient(this.client);
+        }
+        system() {
+            return (new System()).setClient(this.client);
+        }
+        workflow() {
+            return (new Workflow()).setClient(this.client);
+        }
+    }
+
+    class Invoicing extends PlatformBaseClient {
         async getSalesInvoices(provider, page) {
             return await this.request("GET", `/invoices/${provider}/sales`, {
                 params: {
@@ -401,13 +531,48 @@
         async request(method, endpoint, params) {
             return await this.client.request({
                 method: method,
-                url: `/v1/karadjordje/${endpoint}`,
+                url: `/v1/integrations/karadjordje/${endpoint}`,
                 ...params
             });
         }
     }
 
-    class Media extends BaseClient {
+    class IntegrationsBaseClient extends BaseClient {
+        constructor(options) {
+            var _a, _b;
+            let { env = null, token, host, } = options !== null && options !== undefined ? options : {};
+            let headers = {};
+            if (isBrowser) {
+                if (localStorage.getItem('protokol_context') == "forge") {
+                    headers['X-Project-Env'] = (_a = localStorage.getItem('forge_app_env')) !== null && _a !== undefined ? _a : "dev";
+                }
+                else {
+                    // this potentially means that it is running as dev server in local
+                    headers['X-Project-Env'] = "dev";
+                }
+                // @ts-ignore
+                const __global_env__ = window === null || window === undefined ? undefined : window.__ENV_VARIABLES__;
+                host = (_b = __global_env__.INTEGRATION_API) !== null && _b !== undefined ? _b : host;
+            }
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            if (env) {
+                headers['X-Project-Env'] = env;
+            }
+            const client = axios.create({
+                baseURL: host !== null && host !== undefined ? host : "https://orange.protokol.io",
+                timeout: 15000,
+                headers: {
+                    ...headers,
+                },
+                withCredentials: true,
+            });
+            super(client);
+        }
+    }
+
+    class Media extends IntegrationsBaseClient {
         async list(data) {
             return this.request('POST', 'list', { data });
         }
@@ -517,7 +682,7 @@
         }
     }
 
-    class SerbiaUtil extends BaseClient {
+    class SerbiaUtil extends IntegrationsBaseClient {
         async nsbSearch(params) {
             return await this.services("GET", "nbs/search", { params });
         }
@@ -544,7 +709,7 @@
         }
     }
 
-    class VPFR extends BaseClient {
+    class VPFR extends IntegrationsBaseClient {
         async request(method, endpoint, params) {
             return await this.client.request({
                 method: method,
@@ -554,14 +719,15 @@
         }
     }
 
-    class Integrations extends BaseClient {
-        constructor(adapter) {
-            super(adapter);
+    // import integrations
+    class Integrations extends IntegrationsBaseClient {
+        constructor(options) {
+            super(options);
             this.integrations = {
-                'protokol-invoicing': new Invoicing(adapter),
-                'protokol-vpfr': new VPFR(adapter),
-                'protokol-media': new Media(adapter),
-                'serbia-utilities': new SerbiaUtil(adapter)
+                'protokol-invoicing': new Invoicing().setClient(this.client),
+                'protokol-vpfr': new VPFR().setClient(this.client),
+                'protokol-media': new Media().setClient(this.client),
+                'serbia-utilities': new SerbiaUtil().setClient(this.client),
             };
         }
         getSerbiaUtilities() {
@@ -590,194 +756,18 @@
         }
     }
 
-    var integrations = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Integrations
-    });
-
-    class Ratchet extends BaseClient {
-        async query(name, params) {
-            let res = await this.client.post('/v1/ratchet/query', {
-                name: name,
-                params: params
-            });
-            return res.data;
-        }
-    }
-
-    var ratchet = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Ratchet
-    });
-
-    class Sandbox extends BaseClient {
-        /**
-         * Call the sandbox service to execute a serverless function
-         *
-         * @param name
-         * @param data
-         * @returns
-         *
-         * @example
-         * const result = await platform.sandbox().spark("myFunction", { foo: "bar" })
-         */
-        async spark(name, data) {
-            return await this.client.post(`/v1/project/sandbox/spark/exec/${name}`, data);
-        }
-    }
-
-    var sandbox = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Sandbox
-    });
-
-    class System extends BaseClient {
-        async resourceResolver(ref, resourceName, format) {
-            const { data } = await this.client.post("/v3/system/resource-resolver", {
-                type: resourceName,
-                format,
-            });
-            if (format) {
-                return data.format;
-            }
-            return data;
-        }
-    }
-
-    var system = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: System
-    });
-
-    class Workflow extends BaseClient {
-        async trigger(id, event, data) {
-            return await this.client.post(`/v1/project/workflow/workflow/${id}/event/${event}`, data);
-        }
-    }
-
-    var workflow = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        default: Workflow
-    });
-
-    class Forge extends BaseClient {
-        constructor(client) {
-            super(client);
-        }
-        async bundleUpload(buffer) {
-            return await this.client.post(`/v3/system/gateway/app-service/forge/upload`, buffer, {
-                headers: {
-                    'Content-Type': 'application/octet-stream',
-                    'Content-Length': buffer.length
-                }
-            });
-        }
-        async getWorkspaceApps() {
-            return await this.client.get(`/v3/system/gateway/app-service/forge/workspace`);
-        }
-    }
-
-    typeof process !== "undefined" &&
-        process.versions != null &&
-        process.versions.node != null;
-    const isBrowser = typeof window !== "undefined" &&
-        typeof document !== "undefined";
-
-    class Platform {
-        constructor(options) {
-            var _a;
-            let { env = null, token, host, integrationHost } = options !== null && options !== undefined ? options : {};
-            let headers = {};
-            if (isBrowser) {
-                if (localStorage.getItem('protokol_context') == "forge") {
-                    headers['X-Project-Env'] = (_a = localStorage.getItem('forge_app_env')) !== null && _a !== undefined ? _a : "dev";
-                }
-                else {
-                    // this potentially means that it is running as dev server in local
-                    headers['X-Project-Env'] = "dev";
-                }
-            }
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
-            if (env) {
-                headers['X-Project-Env'] = env;
-            }
-            this.platformClient = axios.create({
-                baseURL: host !== null && host !== undefined ? host : "https://lemon.protokol.io",
-                timeout: 15000,
-                headers: {
-                    ...headers,
-                },
-                withCredentials: true,
-            });
-            this.integrationsClient = axios.create({
-                baseURL: integrationHost !== null && integrationHost !== undefined ? integrationHost : "https://orange.protokol.io",
-                timeout: 15000,
-                headers: {
-                    ...headers,
-                }
-            });
-        }
-        setPlatformClient(client) {
-            this.platformClient = client;
-        }
-        getPlatformClient() {
-            return this.platformClient;
-        }
-        getPlatformBaseURL() {
-            var _a;
-            return (_a = this.platformClient.defaults.baseURL) !== null && _a !== undefined ? _a : "";
-        }
-        apiUser() {
-            return new APIUser(this.platformClient);
-        }
-        function() {
-            return new Functions(this.platformClient);
-        }
-        role() {
-            return new Roles(this.platformClient);
-        }
-        user() {
-            return new Users(this.platformClient);
-        }
-        app(appType) {
-            return new Apps(this.platformClient, appType);
-        }
-        forge() {
-            return new Forge(this.platformClient);
-        }
-        component(ref) {
-            return new Component(this.platformClient, ref);
-        }
-        integrations() {
-            return new Integrations(this.integrationsClient);
-        }
-        ratchet() {
-            return new Ratchet(this.platformClient);
-        }
-        sandbox() {
-            return new Sandbox(this.platformClient);
-        }
-        system() {
-            return new System(this.platformClient);
-        }
-        workflow() {
-            return new Workflow(this.platformClient);
-        }
-    }
-
-    exports.APIUser = apiUser;
-    exports.Apps = apps;
-    exports.Component = component;
-    exports.Functions = functions;
-    exports.Integration = integrations;
-    exports.Ratchet = ratchet;
-    exports.Roles = roles;
-    exports.Sandbox = sandbox;
-    exports.System = system;
-    exports.Users = users;
-    exports.Workflow = workflow;
+    exports.APIUser = APIUser;
+    exports.Apps = Apps;
+    exports.Component = Component;
+    exports.ComponentUtils = ComponentUtils;
+    exports.Functions = Functions;
+    exports.Integration = Integrations;
+    exports.Ratchet = Ratchet;
+    exports.Roles = Roles;
+    exports.Sandbox = Sandbox;
+    exports.System = System;
+    exports.Users = Users;
+    exports.Workflow = Workflow;
     exports.default = Platform;
 
     Object.defineProperty(exports, '__esModule', { value: true });