@ductape/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,923 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const appApi_service_1 = require("./api/services/appApi.service");
+const userApi_service_1 = require("./api/services/userApi.service");
+const workspaceApi_service_1 = require("./api/services/workspaceApi.service");
+const app_service_1 = __importDefault(require("./apps/services/app.service"));
+const filePath = __importStar(require("path"));
+const products_service_1 = __importDefault(require("./products/services/products.service"));
+const fs_1 = require("fs");
+const index_types_1 = require("./types/index.types");
+const productsApi_service_1 = require("./api/services/productsApi.service");
+const imports_service_1 = __importDefault(require("./imports/imports.service"));
+const processor_service_1 = __importDefault(require("./processor/services/processor.service"));
+const logs_service_1 = __importDefault(require("./logs/logs.service"));
+const utils_1 = require("./utils");
+const redis_1 = require("redis");
+const mime = __importStar(require("mime-types"));
+class Ductape {
+    constructor({ workspace_id, private_key, user_id, env_type, redis_url }) {
+        this.product = {
+            create: async (data) => {
+                await this.initProduct();
+                return this.productBuilder.createProduct(data);
+            },
+            fetch: async (tag) => {
+                await this.initProduct();
+                await this.productBuilder.initializeProductByTag(tag);
+                this.productInit = false;
+                return this.productBuilder.fetchProduct();
+            },
+            update: async (tag, data) => {
+                await this.initProduct();
+                await this.productBuilder.initializeProductByTag(tag);
+                this.productInit = false;
+                return this.productBuilder.updateProduct(data);
+            },
+            init: async (productTag) => {
+                try {
+                    console.log(`Product initialized with tag: ${productTag}`);
+                    await this.initProduct();
+                    await this.productBuilder.initializeProductByTag(productTag);
+                    this.productInit = true;
+                }
+                catch (e) {
+                    console.error(e);
+                    throw e;
+                }
+            },
+            apps: {
+                connect: async (appTag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createAppAccessTag(appTag);
+                },
+                add: async (app) => {
+                    this.checkProductInit();
+                    return this.productBuilder.addApp(app);
+                },
+                fetchAll: async () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchApps();
+                },
+                fetch: async (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchApp(tag);
+                },
+                update: async (accessTag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateApp(accessTag, data);
+                },
+                webhooks: {
+                    fetchAll: async (accessTag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchAppWebhooks(accessTag);
+                    },
+                    enable: async (data) => {
+                        const processorService = await this.createNewProcessor();
+                        return processorService.registerWebhook(data);
+                    },
+                    generateLink: async (data) => {
+                        const processorService = await this.createNewProcessor();
+                        return processorService.generateWebhookLink(data);
+                    },
+                },
+            },
+            quota: {
+                create: async (data) => {
+                    await this.initProduct();
+                    return this.productBuilder.createQuota(data);
+                },
+                fetch: (tag) => { },
+                fetchAll: () => { },
+                update: async (slug, data) => { },
+            },
+            updateValidation: async (tag, update) => {
+                this.checkProductInit();
+                return this.productBuilder.updateDataValidation(tag, update);
+            },
+            environments: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createEnv(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchEnvs();
+                },
+                fetch: (slug) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchEnv(slug);
+                },
+                update: async (slug, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateEnv(slug, data);
+                },
+            },
+            storage: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createStorage(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchStorages();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchStorage(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateStorage(tag, data);
+                },
+            },
+            /*cloudFunctions: {
+              create: async (data: IProductFunction) => {
+                this.checkProductInit();
+                return this.productBuilder.createFunction(data);
+              },
+              fetchAll: () => {
+                this.checkProductInit();
+                return this.productBuilder.fetchFunctions();
+              },
+              fetch: (tag: string) => {
+                this.checkProductInit();
+                return this.productBuilder.fetchFunction(tag);
+              },
+              update: async (tag: string, data: Partial<IProductFunction>) => {
+                this.checkProductInit();
+                return this.productBuilder.updateFunction(tag, data);
+              },
+            },*/
+            messageBrokers: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createMessageBroker(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchMessageBrokers();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchMessageBroker(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateMessageBroker(tag, data);
+                },
+                topics: {
+                    create: async (data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.createMessageBrokerTopic(data);
+                    },
+                    fetchAll: (messageBrokerTag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchMessageBrokerTopics(messageBrokerTag);
+                    },
+                    fetch: (tag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchMessageBrokerTopic(tag);
+                    },
+                    update: (tag, data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.updateMessageBrokerTopic(Object.assign(Object.assign({}, data), { tag }));
+                    },
+                },
+            },
+            notifications: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createNotification(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchNotifications();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchNotification(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateNotification(tag, data);
+                },
+                messages: {
+                    create: async (data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.createNotificationMessage(data);
+                    },
+                    fetchAll: (notificationTag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchNotificationMessages(notificationTag);
+                    },
+                    fetch: (tag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchNotificationMessage(tag);
+                    },
+                    update: async (tag, data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.updateNotificationMessage(Object.assign(Object.assign({}, data), { tag }));
+                    },
+                },
+            },
+            databases: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createDatabase(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchDatabases();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchDatabase(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateDatabase(tag, data);
+                },
+                actions: {
+                    create: async (data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.createDatabaseAction(data);
+                    },
+                    fetchAll: (databaseTag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchDatabaseActions(databaseTag);
+                    },
+                    fetch: (tag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchDatabaseAction(tag);
+                    },
+                    update: async (tag, data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.updateDatabaseAction(Object.assign(Object.assign({}, data), { tag }));
+                    },
+                },
+                migrations: {
+                    create: (data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.createDatabaseMigration(data);
+                    },
+                    fetchAll: (databaseTag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchDatabaseMigrations(databaseTag);
+                    },
+                    fetch: (tag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchDatabaseMigration(tag);
+                    },
+                    update: (tag, data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.updateDatabaseMigration(Object.assign(Object.assign({}, data), { tag }));
+                    },
+                },
+            },
+            jobs: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createJob(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchJobs();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchJob(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateJob(tag, data);
+                },
+            },
+            caches: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createCache(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchCaches();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchCache(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateCache(tag, data);
+                },
+                values: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.fetchRemoteCaches(data);
+                },
+            },
+            features: {
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createFeature(data);
+                },
+                fetchAll: () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchFeatures();
+                },
+                fetch: (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchFeature(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateFeature(tag, data);
+                },
+            },
+        };
+        this.app = {
+            create: async (data) => {
+                await this.initApp();
+                return this.appBuilder.createApp(data);
+            },
+            fetch: async (tag) => {
+                await this.initApp();
+                await this.appBuilder.initializeAppByTag(tag);
+                this.appInit = false;
+                return this.appBuilder.fetchApp();
+            },
+            update: async (tag, data) => {
+                await this.initApp();
+                await this.appBuilder.initializeAppByTag(tag);
+                this.appInit = false;
+                return this.appBuilder.updateApp(data);
+            },
+            init: async (appTag) => {
+                console.log(`App initialized with tag: ${appTag}`);
+                await this.initApp();
+                await this.appBuilder.initializeAppByTag(appTag);
+                this.appInit = true;
+            },
+            variables: {
+                create: async (data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.createVariable(data);
+                },
+                fetchAll: () => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchVariables();
+                },
+                fetch: (tag) => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchVariable(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateVariable(tag, data);
+                },
+            },
+            constants: {
+                create: async (data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.createConstant(data);
+                },
+                fetchAll: () => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchConstants();
+                },
+                fetch: (tag) => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchConstant(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateConstant(tag, data);
+                },
+            },
+            actions: {
+                import: async ({ file, type, version, appTag, updateIfExists, }) => {
+                    var _a;
+                    if (!this.token)
+                        await this.initUserAuth();
+                    this.importService = this.createNewImporter();
+                    let app_id = null;
+                    if (appTag) {
+                        await this.initApp();
+                        await this.appBuilder.initializeAppByTag(appTag);
+                        const app = this.appBuilder.fetchApp();
+                        const latest = app.versions.find((version) => version.latest === true);
+                        if (!app) {
+                            throw new Error(`App ${appTag} not found`);
+                        }
+                        if (latest && ((_a = latest === null || latest === void 0 ? void 0 : latest.actions) === null || _a === void 0 ? void 0 : _a.length) && !updateIfExists) {
+                            console.log(`App ${appTag} version ${version} already has actions, please set updateIfExists to true to overwrite existing action`);
+                            return;
+                        }
+                        app_id = app._id;
+                    }
+                    return this.importService.importApp(file, type, version, updateIfExists, app_id);
+                },
+                update: async (tag, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateAction(tag, data);
+                },
+                fetchAll: () => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchActions();
+                },
+                fetch: (tag) => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchAction(tag);
+                },
+            },
+            auths: {
+                create: async (data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.createAuth(data);
+                },
+                fetchAll: () => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchAuths();
+                },
+                fetch: (tag) => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchAuth(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateAuth(tag, data);
+                },
+            },
+            webhooks: {
+                create: async (data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.createWebhook(data);
+                },
+                fetchAll: () => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchWebhooks();
+                },
+                fetch: (tag) => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchWebhook(tag);
+                },
+                update: async (tag, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateWebhook(tag, data);
+                },
+                events: {
+                    create: async (data) => {
+                        this.checkAppInit();
+                        return this.appBuilder.createWebhookEvent(data);
+                    },
+                    fetchAll: (webhookTag) => {
+                        this.checkAppInit();
+                        return this.appBuilder.fetchWebhookEvents(webhookTag);
+                    },
+                    fetch: (tag) => {
+                        this.checkAppInit();
+                        return this.appBuilder.fetchWebhookEvent(tag);
+                    },
+                    update: async (tag, data) => {
+                        this.checkAppInit();
+                        return this.appBuilder.updateWebhookEvent(Object.assign(Object.assign({}, data), { tag }));
+                    },
+                },
+            },
+            environments: {
+                create: async (data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.createEnv(data);
+                },
+                fetchAll: () => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchEnvs();
+                },
+                fetch: (slug) => {
+                    this.checkAppInit();
+                    return this.appBuilder.fetchEnv(slug);
+                },
+                update: async (slug, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateEnv(slug, data);
+                },
+            },
+            validation: (selector, update) => {
+                this.checkAppInit();
+                return this.appBuilder.updateDataValidation(selector, update);
+            },
+        };
+        this.processor = {
+            job: {
+                schedule: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    //return processorService.processJob()
+                },
+            },
+            action: {
+                run: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.processAction(data);
+                },
+            },
+            db: {
+                execute: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.processDBAction(data);
+                },
+                migration: {
+                    run: async ({ migration, env, product }) => {
+                        //this.checkProductInit();
+                        const processorService = await this.createNewProcessor();
+                        return processorService.runMigration(product, migration, env, 'up');
+                    },
+                    rollback: async ({ migration, env, product }) => {
+                        //this.checkProductInit();
+                        const processorService = await this.createNewProcessor();
+                        return processorService.runMigration(product, migration, env, 'down');
+                    },
+                },
+            },
+            feature: {
+                run: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return await processorService.processFeature(data);
+                },
+                output: async (process_id) => {
+                    const processorService = await this.createNewProcessor();
+                    return await processorService.generateOutput(process_id);
+                },
+                replay: async (process_id) => {
+                    const processorService = await this.createNewProcessor();
+                    return await processorService.replayProcess(process_id);
+                },
+                resume: async (process_id) => {
+                    const processorService = await this.createNewProcessor();
+                    return await processorService.resumeProcess(process_id);
+                },
+            },
+            quota: {
+                run: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    //return processorService.processQuota(data)
+                },
+            },
+            notification: {
+                send: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.processNotification(data);
+                },
+            },
+            storage: {
+                readFile: async (path) => {
+                    try {
+                        const buffer = await fs_1.promises.readFile(path);
+                        const mimeType = mime.lookup(path) || ''; // Get MIME type or fallback to empty string
+                        return { buffer: buffer.toString('base64'), fileName: filePath.basename(path), mimeType };
+                    }
+                    catch (error) {
+                        console.error('Error reading file:', error);
+                        throw error;
+                    }
+                },
+                save: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.processStorage(data);
+                },
+            },
+            /*cloudFunction: {
+              invoke: async (data: IFunctionProcessorInput) => {
+                const processorService = this.createNewProcessor();
+                return processorService.processFunction(data);
+              },
+            },*/
+            messageBroker: {
+                publish: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.processMessageBrokerPublish(data);
+                },
+                subcribe: async (data) => {
+                    const processorService = await this.createNewProcessor();
+                    return processorService.processMessageBrokerSubscribe(data);
+                },
+            },
+        };
+        this.logs = {
+            init: async (productTag, appTag) => {
+                if (!productTag && !appTag) {
+                    throw new Error('At least one of productTag or appTag must be provided');
+                }
+                if (productTag) {
+                    await this.initProduct();
+                    await this.productBuilder.initializeProductByTag(productTag);
+                    this.productInit = true;
+                }
+                if (appTag) {
+                    await this.initApp();
+                    await this.appBuilder.initializeAppByTag(appTag);
+                    this.appInit = true;
+                }
+                this.loggerService = this.createNewLogger(productTag ? this.productBuilder.fetchProduct()._id : null, appTag ? this.appBuilder.fetchApp()._id : null);
+            },
+            add: async () => { },
+            /**
+             * Fetches logs based on provded query parameters.
+             *
+             * @param params.component - Required. Specifies the component type ('app' or 'product')
+             * @param params.type - Optional. Type of analysis ('apps', 'process', 'feature', 'integrations', etc.)
+             * @param params.groupBy - Optional. Time period for grouping ('day', 'week', 'month', 'year')
+             * @param params.search - Optional. Search term for filtering logs
+             * @param params.page - Optional. Page number for pagination (≥ 1)
+             * @param params.limit - Optional. Number of items per page (≥ 1)
+             * @param params.status - Optional. Filter by status ('success', 'processing', 'fail')
+             *
+             * For component='app':
+             * @param params.tag - Optional. Tag identifier (only valid when type='actions')
+             * @param params.env - Optional. Environment filter
+             * @param params.name - Optional. Name filter
+             * @param params.action - Optional. Specific action filter
+             *
+             * For component='product':
+             * @param params.env - Optional. Environment filter
+             * @param params.name - Optional. Name filter
+             * @param params.action - Optional. Specific action filter
+             *
+             * @throws {Error} If logger service is not initialized
+             * @throws {Error} If required parameters are missing or invalid
+             * @throws {Error} If API request fails
+             *
+             * @returns {Promise<any>} The fetched log data
+             *
+             * @example
+             * // Fetch app logs
+             * const appLogs = await logs.fetch({
+             *   component: 'app',
+             *   type: 'actions',
+             *   groupBy: 'day',
+             *   limit: 20
+             * });
+             *
+             * // Fetch product logs
+             * const productLogs = await logs.fetch({
+             *   component: 'product',
+             *   type: 'database',
+             *   status: 'success'
+             * });
+             */
+            fetch: async (params) => {
+                if (!this.loggerService) {
+                    throw new Error('Logger service not initialized. Call logs.init() first');
+                }
+                try {
+                    return await this.loggerService.fetch(params);
+                }
+                catch (e) {
+                    const error = e.response ? e.response.data.errors : e.toString();
+                    throw error;
+                }
+            },
+            publish: async () => { },
+        };
+        this.workspace_id = workspace_id;
+        this.private_key = private_key;
+        this.user_id = user_id;
+        this.environment = env_type || index_types_1.EnvType.PRODUCTION;
+        this.userApi = new userApi_service_1.UserApiService(this.environment);
+        this.appApi = new appApi_service_1.AppApiService(this.environment);
+        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(this.environment);
+        this.productsApi = new productsApi_service_1.ProductsApiService(this.environment);
+        if (redis_url) {
+            this.redisClient = (0, redis_1.createClient)({ url: redis_url });
+        }
+        return (0, utils_1.createDeepProxy)(this, this.environment);
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    setPublicKey(public_key) {
+        this.public_key = public_key;
+    }
+    async initProduct() {
+        if (!this.token)
+            await this.initUserAuth();
+        if (!this.productBuilder)
+            this.productBuilder = this.createNewProductBuilder();
+    }
+    async initApp() {
+        if (!this.token)
+            await this.initUserAuth();
+        if (!this.appBuilder)
+            this.appBuilder = this.createNewAppBuilder();
+    }
+    checkProductInit() {
+        if (!this.productBuilder || !this.token || !this.productInit) {
+            throw new Error(`product init required`);
+        }
+    }
+    checkAppInit() {
+        if (!this.appBuilder || !this.token || !this.appInit) {
+            throw new Error(`app init required`);
+        }
+    }
+    async initUserAuth(subCheck = true) {
+        this.token = null;
+        this.public_key = null;
+        this.session = null;
+        await this.fetchSession();
+        if (!this.session) {
+            await this.refreshUserAccessToken();
+            await this.createNewAppBuilderSession();
+        }
+        try {
+            await this.validateWorkspace(subCheck);
+        }
+        catch (e) {
+            const error = e.response ? e.response.data.errors : e.toString();
+            throw error;
+        }
+    }
+    createNewLogger(product_id, app_id) {
+        return new logs_service_1.default({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            product_id,
+            env_type: this.environment,
+            app_id,
+        });
+    }
+    createNewProductBuilder() {
+        return new products_service_1.default({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+        });
+    }
+    async createNewProcessor() {
+        const subCheck = false;
+        await this.initUserAuth(subCheck);
+        return new processor_service_1.default({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+        });
+    }
+    createNewImporter() {
+        return new imports_service_1.default({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+        });
+    }
+    createNewAppBuilder() {
+        return new app_service_1.default({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+        });
+    }
+    async fetchSession() {
+        try {
+            if (!this.public_key && this.private_key)
+                await this.refreshUserAccessToken();
+            if (!this.public_key && !this.private_key)
+                throw new Error('No user private/public keys');
+            this.session = await this.appApi.fetchAppBuilderSession({
+                public_key: this.public_key,
+                user_id: this.user_id,
+                workspace_id: this.workspace_id,
+            });
+            /*this.token = this.session.token;
+            this.public_key = this.session.public_key;*/
+        }
+        catch (e) {
+            console.log(e);
+            console.log('No Existing session, should try to create a new one');
+        }
+    }
+    async validateWorkspace(subCheck = true) {
+        try {
+            const workspace = await this.workspaceApi.fetchWorkspaceById({
+                token: this.token,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                workspace_id: this.workspace_id,
+            }, subCheck);
+            if (!workspace)
+                throw new Error(`Workspace does not exist`);
+        }
+        catch (e) {
+            const error = e.response ? e.response.data.errors : e.toString();
+            throw error;
+        }
+    }
+    async createNewAppBuilderSession() {
+        try {
+            this.session = await this.appApi.createAppBuilderSession({
+                token: this.token,
+                workspace_id: this.workspace_id,
+                user_id: this.user_id,
+                public_key: this.public_key,
+            });
+        }
+        catch (e) {
+            const error = e.response ? e.response.data.errors : e.toString();
+            throw error;
+        }
+    }
+    async refreshUserAccessToken() {
+        try {
+            const validUser = await this.userApi.fetchUserByPrivateKey({
+                private_key: this.private_key,
+                workspace_id: this.workspace_id,
+                user_id: this.user_id,
+            });
+            this.token = validUser.auth_token;
+            this.public_key = validUser.public_key;
+        }
+        catch (e) {
+            const error = e.response ? e.response.data.errors : e.toString();
+            throw error;
+        }
+    }
+    async fetchWorkspaceApps(status) {
+        try {
+            if (!this.public_key || !this.token)
+                throw new Error('User session not initiated');
+            this.apps = await this.appApi.fetchWorkspaceApps(status, {
+                token: this.token,
+                workspace_id: this.workspace_id,
+                user_id: this.user_id,
+                public_key: this.public_key,
+            });
+            return this.apps;
+        }
+        catch (e) {
+            const error = e.response ? e.response.data.errors : e.toString();
+            throw error;
+        }
+    }
+    async fetchWorkspaceProjects(status) {
+        try {
+            if (!this.public_key || !this.token)
+                throw new Error('User session not initiated');
+            this.products = await this.productsApi.fetchWorkspaceProducts(status, {
+                token: this.token,
+                workspace_id: this.workspace_id,
+                user_id: this.user_id,
+                public_key: this.public_key,
+            });
+            return this.products;
+        }
+        catch (e) {
+            const error = e.response ? e.response.data.errors : e.toString();
+            throw error;
+        }
+    }
+}
+exports.default = Ductape;
+//# sourceMappingURL=index.js.map