@ptkl/sdk 0.1.0

package/dist/index.umd.js

@@ -0,0 +1,649 @@
+(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';
+
+    class BaseClient {
+        constructor(client) {
+            this.client = client;
+        }
+    }
+
+    class Functions extends BaseClient {
+        async list() {
+            return await this.client.get("/v1/system/function");
+        }
+        async get(ref) {
+            return await this.client.get(`/v1/system/function/${ref}`);
+        }
+        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 || {},
+            });
+            return data.data;
+        }
+        async generateSignature(ref, env) {
+            return await this.client.get(`/v1/system/function/signature/${env}/${ref}`);
+        }
+    }
+
+    class Roles extends BaseClient {
+        async create(role) {
+            const res = await this.client.post("/v1/user/role/create", role);
+            //    writeFileSync(`.role.create.json`,JSON.stringify(res))
+            return res.data;
+        }
+        async delete(uuid) {
+            const { data } = await this.client.delete(`/v1/user/role/delete/${uuid}`);
+            return data;
+        }
+        async list() {
+            const { data } = await this.client.get(`/v1/user/role/list`);
+            return data;
+        }
+        async listPermissions() {
+            const { data } = await this.client.get(`/v1/user/permissions/list`);
+            return data;
+        }
+        async edit(permissions, workspaces, level, uuid) {
+            const { data } = await this.client.post(`/v1/user/role/edit/${uuid}`, { permissions, workspaces, level });
+            return data;
+        }
+    }
+
+    class APIUser extends BaseClient {
+        async apiAuth(username, password) {
+            return this.client.post("/v1/user/api/auth", {
+                username,
+                password
+            });
+        }
+        async newSecret(uuid) {
+            return await this.client.post(`/v1/user/api-user/secret/${uuid}`, {});
+        }
+        async revokeSecret(uuid) {
+            return await this.client.delete(`/v1/user/api-user/secret/${uuid}`);
+        }
+        async edit(uuid, roles) {
+            return await this.client.patch(`/v1/user/api-user/${uuid}`, { roles });
+        }
+        async list() {
+            return await this.client.get(`/v1/user/api-user`);
+        }
+        async get(uuid) {
+            return await this.client.get(`/v1/user/api-user/${uuid}`);
+        }
+    }
+
+    class Users extends BaseClient {
+        async invite(email, roles) {
+            return await this.client.post("/v1/project/invite", {
+                email,
+                roles,
+            });
+        }
+        async delete(uuid) {
+            return await this.client.delete(`/v1/project/user/${uuid}`);
+        }
+    }
+
+    class Apps extends BaseClient {
+        constructor(client, appType) {
+            super(client);
+            this.appType = appType;
+        }
+        async updateSettings(updateValues, ref) {
+            const payload = { ...updateValues };
+            return await this.client.put(`/v3/system/gateway/app-service/${this.appType}/${ref}/settings`, payload);
+        }
+        async download(ref, version) {
+            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);
+        }
+    }
+
+    class Component extends BaseClient {
+        constructor(adapter, ref) {
+            super(adapter);
+            this.ref = ref;
+        }
+        new(ref) {
+            this.ref = ref;
+            return this;
+        }
+        find(filters, opts) {
+            const { cache = false, buildttl = -1, locale = "en_US" } = opts !== null && opts !== undefined ? opts : {};
+            return new Promise((resolve, reject) => {
+                let payload = {
+                    context: filters,
+                    ref: this.ref,
+                };
+                let ctx = payload.context;
+                let offset = ctx.currentPage;
+                if (offset == undefined) {
+                    offset = 0;
+                }
+                let limit = ctx.perPage;
+                if (limit == undefined || limit == -1) {
+                    limit = 10;
+                }
+                let sortDesc = 1;
+                if (ctx.sortDesc) {
+                    sortDesc = -1;
+                }
+                if (ctx.filterOn === undefined) {
+                    ctx.filterOn = [];
+                }
+                let params = {
+                    offset: offset,
+                    sortBy: ctx.sortBy,
+                    sortDesc: sortDesc,
+                    filter: ctx.filter,
+                    filterOn: ctx.filterOn.join(","),
+                    disabled: ctx.disabled,
+                    limit: limit,
+                    dateFrom: ctx.dateFrom,
+                    dateTo: ctx.dateTo,
+                    dateField: ctx.dateField,
+                };
+                if (Object.keys(ctx.$adv || []).length > 0) {
+                    params.$adv = JSON.stringify([ctx.$adv]);
+                }
+                if (ctx.$aggregate && ctx.$aggregate.length > 0) {
+                    params.$aggregate = JSON.stringify(ctx.$aggregate);
+                }
+                Object.keys(opts || {}).forEach(k => {
+                    params[`_opt_${k}`] = opts[k];
+                });
+                this.client.get(`/v3/system/component/${this.ref}/models`, {
+                    params: params,
+                    headers: {
+                        'X-Cache': cache,
+                        'X-Build-Ttl': buildttl,
+                        'Accept-Language': locale
+                    }
+                }).then((resp) => {
+                    let { data = [] } = resp || {};
+                    resolve(data);
+                }).catch((err) => {
+                    reject(err);
+                });
+            });
+        }
+        async findOne(filter, opts) {
+            const { items } = await this.find({
+                $adv: filter
+            }, opts);
+            if (items && items.length > 0) {
+                return items[0];
+            }
+            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);
+                });
+            });
+        }
+        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);
+                });
+            });
+        }
+        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);
+                });
+            });
+        }
+        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);
+                });
+            });
+        }
+        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);
+                });
+            });
+        }
+        settings() {
+            return new Promise((resolve, reject) => {
+                this.client.get(`/v3/system/component/settings/${this.ref}`).then((resp) => {
+                    resolve(resp.data);
+                }).catch(err => {
+                    reject(err);
+                });
+            });
+        }
+        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 saveTemplatesDist(version, sdkVersion, engine, dist) {
+            const { data } = await this.client.post(`/v3/system/component/templates/${this.ref}/${version}`, {
+                templates_dist: {
+                    sdk_version: sdkVersion,
+                    sdk_engine: engine,
+                    dist,
+                }
+            });
+            return data;
+        }
+        async workflow(event, input) {
+            return await this.client.post("/v1/system/component/" + this.ref + "/workflow/event", {
+                event,
+                input
+            });
+        }
+        async function(name, input) {
+            return await this.client.post(`/v3/system/component/${this.ref}/function/${name}`, input);
+        }
+        async all() {
+            const { data } = await this.client.get("/v1/system/components");
+            return data;
+        }
+        async setup(data) {
+            return await this.client.post("/v3/system/component/create", data);
+        }
+    }
+
+    class Invoicing extends BaseClient {
+        async getSalesInvoices(provider, page) {
+            return await this.request("GET", `/invoices/${provider}/sales`, {
+                params: {
+                    page: page || 1
+                }
+            });
+        }
+        async acceptPurchaseInvoice(provider, id, comment) {
+            return await this.request('POST', `/invoices/${provider}/purchase/acceptReject/${id}`, {
+                data: {
+                    accepted: true,
+                    comment: comment
+                }
+            });
+        }
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/karadjordje/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class Media extends BaseClient {
+        async list(data) {
+            return this.request('POST', 'list', { data });
+        }
+        async libraries() {
+            return await this.requestv1("GET", "library/list");
+        }
+        async upload(payload) {
+            let files = payload.files;
+            let formData = new FormData();
+            let count = 0;
+            files.forEach((file, index) => {
+                let rename = file.rename || file.name;
+                let orgExt = file.name.split('.');
+                rename = `${rename}.${orgExt[orgExt.length - 1]}`;
+                formData.append('file', file, rename);
+                count++;
+            });
+            if (count == files.length) {
+                formData.append('path', payload.uploadDir);
+                formData.append('ref', payload.uuid);
+                if (payload.public) {
+                    formData.append('is_public', "true");
+                }
+                if (payload.expiresAt)
+                    formData.append('expiresAt', new Date(payload.expiresAt).toISOString());
+                if (Object.keys(payload.metadata).length > 0)
+                    formData.append('metadata', JSON.stringify(payload.metadata));
+                return await this.request("POST", "", {
+                    data: formData,
+                    headers: {
+                        'Content-Type': 'multipart/form-data'
+                    }
+                });
+            }
+        }
+        async delete(data) {
+            return this.request('POST', 'delete', data);
+        }
+        async uploadBase64(data) {
+            return this.request('POST', ``, {
+                data,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        async getMedia(lib, key, encoding) {
+            return this.request('GET', `library/${lib}/get/${key}`, {
+                params: {
+                    encoding
+                },
+                responseType: (!encoding) ? 'blob' : null
+            });
+        }
+        async download(lib, key) {
+            return this.request('POST', `library/${lib}/download`, {
+                data: {
+                    key
+                },
+                responseType: 'blob'
+            });
+        }
+        async getExifData(lib, key) {
+            return this.request('GET', `library/${lib}/exif/${key}`);
+        }
+        async html2pdf(lib, data) {
+            const { output_pdf = false, input_path, input_html, output_path, output_file_name, data: templateData } = data;
+            const type = output_pdf ? 'arraybuffer' : 'json';
+            const contentType = output_pdf ? 'application/pdf' : 'application/json';
+            return this.request('POST', `library/${lib}/html2pdf`, {
+                data: {
+                    output_pdf,
+                    input_path,
+                    output_path,
+                    input_html,
+                    output_file_name,
+                    data: templateData
+                },
+                headers: {
+                    'Content-Type': contentType
+                },
+                responseType: type
+            });
+        }
+        async createDir(lib, path) {
+            return this.request('POST', `library/${lib}/dir`, { data: { path } });
+        }
+        async deleteDir(lib, path) {
+            return this.request('POST', `library/${lib}/delete/dir`, { data: { path } });
+        }
+        async dirs(lib, data) {
+            return await this.request("POST", `library/${lib}/dirs`, { data });
+        }
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v2/media/${endpoint}`,
+                ...params
+            });
+        }
+        async requestv1(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/media/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class SerbiaUtil extends BaseClient {
+        async nsbSearch(params) {
+            return await this.services("GET", "nbs/search", { params });
+        }
+        async getReceiptFromUrl(url, source) {
+            return await this.services("POST", "receipt/crawl", {
+                data: {
+                    url,
+                    source
+                }
+            });
+        }
+        async getContoList() {
+            return await this.services("GET", "conto");
+        }
+        async services(method, endpoint, params) {
+            return this.request(method, `services/${endpoint}`, params);
+        }
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/karadjordje/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class VPFR extends BaseClient {
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/karadjordje/vpfr/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class Integrations extends BaseClient {
+        constructor(adapter) {
+            super(adapter);
+            this.integrations = {
+                'protokol-invoicing': new Invoicing(adapter),
+                'protokol-vpfr': new VPFR(adapter),
+                'protokol-media': new Media(adapter),
+                'serbia-utilities': new SerbiaUtil(adapter)
+            };
+        }
+        getSerbiaUtilities() {
+            return this.getInterfaceOf('serbia-utilities');
+        }
+        getMedia() {
+            return this.getInterfaceOf('protokol-media');
+        }
+        getVPFR() {
+            return this.getInterfaceOf('protokol-vpfr');
+        }
+        getInvoicing() {
+            return this.getInterfaceOf('protokol-invoicing');
+        }
+        async isInstalled(id) {
+            const { data } = await this.client.get("/v1/integrations");
+            return data.find((i) => i.id == id) !== undefined;
+        }
+        getInterfaceOf(id) {
+            try {
+                return this.integrations[id];
+            }
+            catch {
+                throw new Error(`Interface ${id} not provided`);
+            }
+        }
+    }
+
+    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);
+        }
+    }
+
+    return Platform;
+
+}));

package/dist/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "protokol-sdk",
+  "version": "0.8.0",
+  "scripts": {
+    "build": "rollup -c"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/types/index.d.ts",
+  "author": "protokol.io",
+  "license": "ISC",
+  "type": "module",
+  "description": "",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/babel__standalone": "^7.1.9",
+    "@types/lodash": "^4.17.13",
+    "@types/node": "^22.9.0",
+    "rollup": "^4.30.1",
+    "rollup-plugin-polyfill-node": "^0.13.0",
+    "typescript": "^5.6.3",
+    "rollup-plugin-copy": "^3.5.0"
+  },
+  "dependencies": {
+    "@rollup/plugin-replace": "^6.0.2",
+    "axios": "^1.7.7",
+    "dom-parser": "^1.1.5",
+    "lodash": "^4.17.21"
+  }
+}

package/dist/types/api/apiUser.d.ts

@@ -0,0 +1,9 @@
+import BaseClient from "./baseClient";
+export default class APIUser extends BaseClient {
+    apiAuth(username: string, password: string): Promise<import("axios").AxiosResponse<any, any>>;
+    newSecret(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+    revokeSecret(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+    edit(uuid: string, roles: string[]): Promise<import("axios").AxiosResponse<any, any>>;
+    list(): Promise<any>;
+    get(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+}