@ptkl/sdk 0.2.0 → 0.2.2

package/dist/index.umd.js

@@ -1,16 +1,80 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('axios')) :
-    typeof define === 'function' && define.amd ? define(['axios'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ProtokolSDK = factory(global.axios));
-})(this, (function (axios) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('axios')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'axios'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ProtokolSDK = {}, global.axios));
+})(this, (function (exports, axios) { 'use strict';
 
     class BaseClient {
         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");
         }
@@ -20,9 +84,21 @@
         async update(uuid, update) {
             return await this.client.patch(`/v1/system/function/${uuid}`, update);
         }
-        async run(id, input, query) {
-            const { data } = await this.client.post(`/v1/system/function/run/${id}`, input, {
-                params: query || {},
+        /**
+         * Run platform function
+         *
+         * @param id - Function ID
+         * @param input - Input data
+         * @param query - Query parameters
+         * @returns - Function result
+         *
+         * @example
+         * const result = await platform.function().run("myFunction", { foo: "bar" }, { queryParam: "value" })
+         */
+        async run(id, d) {
+            const { data } = await this.client.post(`/v1/system/function/run/${id}`, d.input, {
+                params: d.query,
+                headers: d.headers
             });
             return data.data;
         }
@@ -31,7 +107,7 @@
         }
     }
 
-    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))
@@ -55,11 +131,15 @@
         }
     }
 
-    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) {
@@ -79,7 +159,7 @@
         }
     }
 
-    class Users extends BaseClient {
+    class Users extends PlatformBaseClient {
         async invite(email, roles) {
             return await this.client.post("/v1/project/invite", {
                 email,
@@ -91,9 +171,9 @@
         }
     }
 
-    class Apps extends BaseClient {
-        constructor(client, appType) {
-            super(client);
+    class Apps extends PlatformBaseClient {
+        constructor(appType) {
+            super();
             this.appType = appType;
         }
         async updateSettings(updateValues, ref) {
@@ -104,21 +184,40 @@
             return await this.client.post(`/v3/system/gateway/app-service/${this.appType}/download`, { version, uuid: ref }, { responseType: "arraybuffer" });
         }
         async upload(formData) {
-            return await this.client.post(`/v3/system/gateway/app-service/${this.appType}/upload`, formData);
+            return await this.client.post(`/v3/system/gateway/app-service/${this.appType}/upload`, formData, {
+                timeout: 60000
+            });
         }
     }
 
-    class Component extends BaseClient {
-        constructor(adapter, ref) {
-            super(adapter);
+    class Component extends PlatformBaseClient {
+        constructor(ref = null) {
+            super();
             this.ref = ref;
         }
-        new(ref) {
-            this.ref = ref;
-            return this;
-        }
+        /**
+         * Find method to search for models
+         *
+         * @param {FindParams} filters - The filters to apply to the search
+         * @param {FindOptions} opts - The options to apply to the search
+         *
+         * @returns {Promise<FindResponse>} - The result of the search
+         *
+         * @example
+         * platform.component(name).find({
+         *     currentPage: 1,
+         *     perPage: 10,
+         * })
+         *
+         * // advanced search
+         * platform.component(name).find({
+         *     $adv: {
+         *         name: "John Doe",
+         *     }
+         * )
+         **/
         find(filters, opts) {
-            const { cache = false, buildttl = -1, locale = "en_US" } = opts !== null && opts !== undefined ? opts : {};
+            const { cache = false, buildttl = -1, locale = "en_US", } = opts !== null && opts !== undefined ? opts : {};
             return new Promise((resolve, reject) => {
                 let payload = {
                     context: filters,
@@ -146,7 +245,6 @@
                     sortDesc: sortDesc,
                     filter: ctx.filter,
                     filterOn: ctx.filterOn.join(","),
-                    disabled: ctx.disabled,
                     limit: limit,
                     dateFrom: ctx.dateFrom,
                     dateTo: ctx.dateTo,
@@ -158,9 +256,11 @@
                 if (ctx.$aggregate && ctx.$aggregate.length > 0) {
                     params.$aggregate = JSON.stringify(ctx.$aggregate);
                 }
-                Object.keys(opts || {}).forEach(k => {
-                    params[`_opt_${k}`] = opts[k];
-                });
+                if (opts) {
+                    Object.keys(opts).forEach(k => {
+                        params[`_opt_${k}`] = opts ? opts[k] : null;
+                    });
+                }
                 this.client.get(`/v3/system/component/${this.ref}/models`, {
                     params: params,
                     headers: {
@@ -176,6 +276,19 @@
                 });
             });
         }
+        /**
+         * FindOne method to search for a single model
+         *
+         * @param {FindAdvancedParams} filter - The filters to apply to the search
+         * @param {FindOptions} opts - The options to apply to the search
+         *
+         * @returns {Promise<?Model>} - The result of the search
+         *
+         * @example
+         * platform.component(name).findOne({
+         *     name: "John Doe",
+         * })
+         **/
         async findOne(filter, opts) {
             const { items } = await this.find({
                 $adv: filter
@@ -185,82 +298,79 @@
             }
             return null;
         }
-        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);
-                });
-            });
-        }
-        update(uuid, model) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
-                    data: model
-                }).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
-            });
+        /**
+         * Get model by uuid
+         *
+         * @param uuid string - The uuid of the model
+         * @returns (Promise<Model>)
+         */
+        async get(uuid) {
+            const { data } = await this.client.get(`/v3/system/component/${this.ref}/model/${uuid}`);
+            return data;
         }
-        concurrentUpdate(uuid, version, model) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
-                    version: version,
-                    data: model
-                }).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
+        /**
+         * Update model by uuid
+         *
+         * @param uuid string - The uuid of the model
+         * @param data
+         * @returns
+         */
+        async update(uuid, data, options) {
+            const { data: responseData } = await this.client.post(`/v3/system/component/${this.ref}/model/${uuid}`, {
+                data,
+                options,
+            });
+            return responseData;
+        }
+        /**
+         * 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;
+        }
+        /**
+         * 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;
         }
-        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);
-                });
-            });
+        async create(model) {
+            const { data } = await this.client.post(`/v3/system/component/${this.ref}/model`, model);
+            return data;
         }
-        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 delete(uuid) {
+            const { data } = await this.client.delete(`/v3/system/component/${this.ref}/model/${uuid}`);
+            return data;
         }
-        aggregate(payload) {
-            return new Promise((resolve, reject) => {
-                this.client.post(`/v3/system/component/${this.ref}/aggregate`, payload).then((resp) => {
-                    resolve(resp.data);
-                }).catch((error) => {
-                    reject(error);
-                });
-            });
+        async aggregate(pipeline) {
+            const { data } = await this.client.post(`/v3/system/component/${this.ref}/aggregate`, pipeline);
+            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 settings() {
+            const { data } = await this.client.get(`/v3/system/component/settings/${this.ref}`);
+            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 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}`, {
@@ -273,24 +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);
+        }
+    }
+
+    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`);
+        }
+    }
+
+    // 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 BaseClient {
+    class Invoicing extends PlatformBaseClient {
         async getSalesInvoices(provider, page) {
             return await this.request("GET", `/invoices/${provider}/sales`, {
                 params: {
@@ -309,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 });
         }
@@ -425,7 +682,7 @@
         }
     }
 
-    class SerbiaUtil extends BaseClient {
+    class SerbiaUtil extends IntegrationsBaseClient {
         async nsbSearch(params) {
             return await this.services("GET", "nbs/search", { params });
         }
@@ -452,7 +709,7 @@
         }
     }
 
-    class VPFR extends BaseClient {
+    class VPFR extends IntegrationsBaseClient {
         async request(method, endpoint, params) {
             return await this.client.request({
                 method: method,
@@ -462,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() {
@@ -498,152 +756,20 @@
         }
     }
 
-    class Ratchet extends BaseClient {
-        async query(name, params) {
-            let res = await this.client.post('/v1/ratchet/query', {
-                name: name,
-                params: params
-            });
-            return res.data;
-        }
-    }
-
-    class Sandbox extends BaseClient {
-        async spark(name, data) {
-            return await this.client.post(`/v1/project/sandbox/spark/exec/${name}`, data);
-        }
-    }
-
-    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;
-        }
-    }
-
-    class Workflow extends BaseClient {
-        async trigger(id, event, data) {
-            return await this.client.post(`/v1/project/workflow/workflow/${id}/event/${event}`, data);
-        }
-    }
-
-    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 { project = null, 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";
-                    // here we don't know actual project so we need a way to determine it
-                }
-            }
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
-            if (env) {
-                headers['X-Project-Env'] = env;
-            }
-            if (project) {
-                headers['X-Project-Uuid'] = project;
-            }
-            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.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;
 
-    return Platform;
+    Object.defineProperty(exports, '__esModule', { value: true });
 
 }));