@ductape/sdk 0.0.4-v46 → 0.0.4-v49

package/dist/products/services/products.service.d.ts

@@ -1,6 +1,6 @@
 import { IApp, IAppAccess, IAppAction, IAppWebhook, ISample, IVersion } from '../../types/appBuilder.types';
 import { IBuilderInit } from '../../types/index.types';
-import { IActionDataParserInput, IActionRequest, ICreateProductsBuilder, IFeatureEvent, IFeatureInput, IFeatureSequence, IProduct, IProductApp, IProductCache, IProductDatabase, IProductDatabaseAction, IProductEnv, IProductFeature, IProductFunction, IProductJobs, IParseActionEventInput, IParseInputStringInput, IParseInputStringMetaData, IProductStorage, IDbActionRequest, INotificationRequest, IProductQuota, IProductFallback, IProductDatabaseMigration, IQuotaOptions, IFallbackOptions, IProductSession, IFetchFilesPayload, IFetchUsersPayload, IProductAppHealth } from '../../types/productsBuilder.types';
+import { IActionDataParserInput, IActionRequest, ICreateProductsBuilder, IFeatureEvent, IFeatureInput, IFeatureSequence, IProduct, IProductApp, IProductCache, IProductDatabase, IProductDatabaseAction, IProductEnv, IProductFeature, IProductFunction, IProductJobs, IParseActionEventInput, IParseInputStringInput, IParseInputStringMetaData, IProductStorage, IDbActionRequest, INotificationRequest, IProductQuota, IProductFallback, IProductDatabaseMigration, IProductGraph, IProductGraphAction, IQuotaOptions, IFallbackOptions, IProductSession, IFetchFilesPayload, IFetchUsersPayload, IProductAppHealth } from '../../types/productsBuilder.types';
 import { KeyValuePair } from '../../imports/imports.types';
 import { IProductNotification, INotificationEnv, IProductNotificationTemplate, IProductMessageBroker, IProductMessageBrokerTopic, IFileURLPayload } from '../../types/processor.types';
 import { IParsedSample } from '../../types/inputs.types';
@@ -78,6 +78,14 @@ export interface IProductsBuilderService {
     updateDatabaseMigration(data: Partial<IProductDatabaseMigration>): Promise<void>;
     fetchDatabaseMigration(tag: string): Promise<IProductDatabaseMigration | null>;
     fetchDatabaseMigrations(databaseTag: string): Promise<Array<IProductDatabaseMigration>>;
+    createGraph(data: Partial<IProductGraph>, throwErrorIfExists?: boolean): Promise<void>;
+    updateGraph(tag: string, data: Partial<IProductGraph>): Promise<void>;
+    fetchGraph(tag: string): Promise<IProductGraph | null>;
+    fetchGraphs(): Promise<Array<IProductGraph>>;
+    createGraphAction(data: Partial<IProductGraphAction>, throwErrorIfExists?: boolean): Promise<void>;
+    updateGraphAction(data: Partial<IProductGraphAction>): Promise<void>;
+    fetchGraphAction(tag: string): Promise<IProductGraphAction | null>;
+    fetchGraphActions(graphTag: string): Promise<Array<IProductGraphAction>>;
     createJob(data: Partial<IProductJobs>, throwErrorIfExists?: boolean): Promise<void>;
     updateJob(tag: string, data: Partial<IProductJobs>): Promise<void>;
     fetchJob(tag: string): Promise<IProductJobs>;
@@ -246,6 +254,14 @@ export default class ProductsBuilderService implements IProductsBuilderService {
     updateDatabase(tag: string, data: Partial<IProductDatabase>): Promise<void>;
     fetchDatabases(): Promise<Array<IProductDatabase>>;
     fetchDatabase(tag: string): Promise<IProductDatabase | null>;
+    createGraph(data: Partial<IProductGraph>, throwErrorIfExists?: boolean): Promise<void>;
+    updateGraph(tag: string, data: Partial<IProductGraph>): Promise<void>;
+    fetchGraphs(): Promise<Array<IProductGraph>>;
+    fetchGraph(tag: string): Promise<IProductGraph | null>;
+    createGraphAction(data: Partial<IProductGraphAction>, throwErrorIfExists?: boolean): Promise<void>;
+    updateGraphAction(data: Partial<IProductGraphAction>): Promise<void>;
+    fetchGraphAction(tag: string, throwErrorIfNotExists?: boolean): Promise<IProductGraphAction | null>;
+    fetchGraphActions(graphTag: string): Promise<Array<IProductGraphAction>>;
     createDatabaseAction(data: Partial<IProductDatabaseAction>, throwErrorIfExists?: boolean): Promise<void>;
     fetchDatabaseAction(tag: string, throwErrorIfExists?: boolean): Promise<IProductDatabaseAction | null>;
     updateDatabaseAction(data: Partial<IProductDatabaseAction>): Promise<void>;

package/dist/products/services/products.service.js

@@ -24,8 +24,8 @@ const productsBuilder_types_1 = require("../../types/productsBuilder.types");
 const validators_1 = require("../validators");
 const objects_utils_1 = require("./utils/objects.utils");
 const processor_utils_1 = require("../../processor/utils/processor.utils");
-const create_productDatabaseAction_validator_1 = require("../validators/joi-validators/create.productDatabaseAction.validator");
-const update_productDatabaseAction_validator_1 = require("../validators/joi-validators/update.productDatabaseAction.validator");
+const create_productDatabaseAction_validator_1 = __importDefault(require("../validators/joi-validators/create.productDatabaseAction.validator"));
+const update_productDatabaseAction_validator_1 = __importDefault(require("../validators/joi-validators/update.productDatabaseAction.validator"));
 const create_productStorage_validator_1 = require("../validators/joi-validators/create.productStorage.validator");
 const inputs_types_1 = require("../../types/inputs.types");
 const string_utils_1 = require("./utils/string.utils");
@@ -36,6 +36,8 @@ const update_productDatabaseMigration_validator_1 = __importDefault(require("../
 const create_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/create.productNotificationMessage.validator"));
 const create_productMessageBrokerTopic_validator_1 = __importDefault(require("../validators/joi-validators/create.productMessageBrokerTopic.validator"));
 const update_productMessageBrokerTopic_validator_1 = __importDefault(require("../validators/joi-validators/update.productMessageBrokerTopic.validator"));
+const create_productGraphAction_validator_1 = __importDefault(require("../validators/joi-validators/create.productGraphAction.validator"));
+const update_productGraphAction_validator_1 = __importDefault(require("../validators/joi-validators/update.productGraphAction.validator"));
 const update_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/update.productNotificationMessage.validator"));
 const create_productNotification_validator_1 = require("../validators/joi-validators/create.productNotification.validator");
 const functions_utils_1 = require("./utils/functions.utils");
@@ -2948,6 +2950,217 @@ class ProductsBuilderService {
         });
         return database;
     }
+    // ==================== GRAPH DATABASE METHODS ====================
+    async createGraph(data, throwErrorIfExists = false) {
+        try {
+            if (!(await this.fetchGraph(data.tag))) {
+                await validators_1.CreateProductGraphSchema.validateAsync(data);
+                const processedEnvs = [];
+                for (const env of data.envs) {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
+                    processedEnvs.push(env);
+                }
+                data.envs = processedEnvs;
+                const envs = await this.fetchEnvs();
+                for (const env of envs) {
+                    const exists = data.envs.findIndex((graphEnv) => graphEnv.slug === env.slug);
+                    if (exists === -1) {
+                        throw new Error(`Product env ${env.slug} is not defined, please provide connection details`);
+                    }
+                }
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.GRAPH, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Graph ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateGraph(tag, data) {
+        try {
+            const graph = await this.fetchGraph(tag);
+            if (!graph) {
+                throw new Error(`Graph ${tag} not found`);
+            }
+            const { _id, envs } = graph;
+            await validators_1.UpdateProductGraphSchema.validateAsync(data);
+            if (data.tag && (await this.fetchGraph(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
+            }
+            if (data.envs) {
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    if (env.connection_url) {
+                        env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
+                    }
+                    return env;
+                }));
+                const overwrite = [];
+                const newEnvs = [];
+                data.envs.map((dataEnv) => {
+                    const existsIndex = envs.findIndex((env) => env.slug === dataEnv.slug);
+                    if (!(this.fetchEnv(dataEnv.slug))) {
+                        throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                    }
+                    if (existsIndex === -1) {
+                        if (!dataEnv.connection_url) {
+                            throw new Error(`connection_url is required for new env ${dataEnv.slug}`);
+                        }
+                        newEnvs.push(dataEnv);
+                    }
+                    else {
+                        overwrite.push(Object.assign(Object.assign({}, envs[existsIndex]), dataEnv));
+                    }
+                });
+                const unchanged = [];
+                envs.map((env) => {
+                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    if (!newEnv && !overwriteEnv) {
+                        unchanged.push(env);
+                    }
+                });
+                data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { tag, component: enums_1.ProductComponents.GRAPH, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchGraphs() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'graph', this.getUserAccess());
+        components.map((graph) => {
+            graph.envs.map((env) => {
+                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
+            });
+        });
+        return components;
+    }
+    async fetchGraph(tag) {
+        const graph = await this.productApi.fetchProductComponentByTag(this.product_id, 'graph', tag, this.getUserAccess());
+        if (graph && graph.envs) {
+            graph.envs.map((env) => {
+                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
+            });
+        }
+        return graph;
+    }
+    // ==================== GRAPH ACTION METHODS ====================
+    async createGraphAction(data, throwErrorIfExists = false) {
+        var _a;
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [graphTag, tag] = data.tag.split(':');
+            if (!graphTag || !tag) {
+                throw new Error('tag should be formatted as graph_tag:action_tag');
+            }
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph) {
+                throw new Error(`Graph ${graphTag} not found`);
+            }
+            const existingAction = (_a = graph.actions) === null || _a === void 0 ? void 0 : _a.find((action) => action.tag === tag);
+            if (existingAction) {
+                if (throwErrorIfExists) {
+                    throw new Error(`Graph action ${data.tag} already exists`);
+                }
+                return;
+            }
+            // Validate the action data
+            const validationData = Object.assign(Object.assign({}, data), { tag });
+            await create_productGraphAction_validator_1.default.validateAsync(validationData);
+            // Extract placeholders from template
+            const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+            const template = JSON.stringify(data.template);
+            // Process filter template if provided
+            let filterData, filterTemplate;
+            if (data.filterTemplate) {
+                filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                filterTemplate = JSON.stringify(data.filterTemplate);
+            }
+            const actionData = Object.assign(Object.assign({}, data), { tag, data: values, template,
+                filterData,
+                filterTemplate });
+            graph.actions = graph.actions || [];
+            graph.actions.push(actionData);
+            await this.updateGraph(graphTag, { actions: graph.actions });
+        }
+        catch (error) {
+            throw new Error(`Failed to create graph action: ${error.message}`);
+        }
+    }
+    async updateGraphAction(data) {
+        var _a;
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [graphTag, tag] = data.tag.split(':');
+            if (!graphTag || !tag) {
+                throw new Error('tag should be formatted as graph_tag:action_tag');
+            }
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph) {
+                throw new Error(`Graph ${graphTag} not found`);
+            }
+            const actionIndex = (_a = graph.actions) === null || _a === void 0 ? void 0 : _a.findIndex((action) => action.tag === tag);
+            if (actionIndex === undefined || actionIndex === -1) {
+                throw new Error(`Graph action ${data.tag} not found`);
+            }
+            // Validate the update data
+            const validationData = Object.assign(Object.assign({}, data), { tag });
+            await update_productGraphAction_validator_1.default.validateAsync(validationData);
+            // Process template if provided
+            const updateData = Object.assign(Object.assign({}, data), { tag });
+            if (data.template) {
+                updateData.data = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                updateData.template = JSON.stringify(data.template);
+            }
+            // Process filter template if provided
+            if (data.filterTemplate) {
+                updateData.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                updateData.filterTemplate = JSON.stringify(data.filterTemplate);
+            }
+            graph.actions[actionIndex] = Object.assign(Object.assign({}, graph.actions[actionIndex]), updateData);
+            await this.updateGraph(graphTag, { actions: graph.actions });
+        }
+        catch (error) {
+            throw new Error(`Failed to update graph action: ${error.message}`);
+        }
+    }
+    async fetchGraphAction(tag, throwErrorIfNotExists = false) {
+        var _a, _b;
+        const [graphTag, actionTag] = tag.split(':');
+        if (!graphTag || !actionTag) {
+            throw new Error('tag is expected to be defined as "graph_tag:action_tag"');
+        }
+        const graph = (_a = this.product.graphs) === null || _a === void 0 ? void 0 : _a.find((data) => data.tag === graphTag);
+        if (!graph)
+            throw new Error(`Graph ${graphTag} not found`);
+        const action = (_b = graph.actions) === null || _b === void 0 ? void 0 : _b.find((data) => data.tag === actionTag);
+        if (!action && throwErrorIfNotExists)
+            throw new Error(`Graph action ${tag} not found`);
+        return action || null;
+    }
+    async fetchGraphActions(graphTag) {
+        const graph = await this.fetchGraph(graphTag);
+        if (!graph) {
+            throw new Error(`Graph ${graphTag} not found`);
+        }
+        return graph.actions || [];
+    }
     async createDatabaseAction(data, throwErrorIfExists = false) {
         try {
             if (!data.tag) {
@@ -2960,27 +3173,18 @@ class ProductsBuilderService {
             const exists = await this.fetchDatabaseAction(data.tag);
             data.tag = tag;
             if (!exists) {
-                const database = await this.fetchDatabase(databaseTag);
-                let values, template;
-                if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
-                    await create_productDatabaseAction_validator_1.NOSQLDatabaseActionsSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                    template = JSON.stringify(data.template);
-                    if (data.type === productsBuilder_types_1.DatabaseActionTypes.UPDATE && !data.filterTemplate) {
-                        throw new Error(`filterTemplate is required for ${productsBuilder_types_1.DatabaseActionTypes.UPDATE} actions in ${productsBuilder_types_1.DatabaseTypes.MONGODB}`);
-                    }
-                    if (data.filterTemplate) {
-                        data.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
-                        data.filterTemplate = JSON.stringify(data.filterTemplate);
-                    }
-                }
-                else {
-                    create_productDatabaseAction_validator_1.SQLDatabaseActionSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(String(data.template));
-                    template = data.template;
-                    if (data.filterTemplate) {
-                        data.filterData = (0, string_utils_1.extractPlaceholders)(String(data.filterTemplate));
-                    }
+                // Verify database exists
+                await this.fetchDatabase(databaseTag);
+                // Validate the action data using the unified schema
+                const validationData = Object.assign(Object.assign({}, data), { tag });
+                await create_productDatabaseAction_validator_1.default.validateAsync(validationData);
+                // Extract placeholders from the structured template
+                const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                const template = JSON.stringify(data.template);
+                // Process filter template if provided (for UPDATE/DELETE actions)
+                if (data.filterTemplate) {
+                    data.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                    data.filterTemplate = JSON.stringify(data.filterTemplate);
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { data: values, template,
                     databaseTag, component: enums_1.ProductComponents.DATABASE_ACTION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
@@ -3020,32 +3224,27 @@ class ProductsBuilderService {
             if (!databaseTag || !tag) {
                 throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
             }
-            // Fetch required data
-            const database = await this.fetchDatabase(databaseTag);
+            // Fetch required data (also verifies database exists)
+            await this.fetchDatabase(databaseTag);
             const action = await this.fetchDatabaseAction(data.tag, true);
             // Construct payload
             const payload = Object.assign(Object.assign(Object.assign({}, action), data), { databaseTag, component: enums_1.ProductComponents.DATABASE_ACTION, action: enums_1.RequestAction.UPDATE });
             // Validate and process the template
             data.tag = tag;
+            // Validate using the unified schema
+            const validationData = Object.assign(Object.assign({}, data), { tag });
+            await update_productDatabaseAction_validator_1.default.validateAsync(validationData);
             if (data.template) {
-                let values, template;
-                if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
-                    await update_productDatabaseAction_validator_1.UpdateNOSQLDatabaseActionsSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                    template = JSON.stringify(data.template);
-                }
-                else {
-                    await update_productDatabaseAction_validator_1.UpdateSQLDatabaseActionSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(String(data.template));
-                    template = data.template;
-                }
+                // Extract placeholders from the structured template
+                const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                const template = JSON.stringify(data.template);
                 Object.assign(payload, { data: values, template });
             }
-            else if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
-                await update_productDatabaseAction_validator_1.UpdateNOSQLDatabaseActionsSchema.validateAsync(data);
-            }
-            else {
-                await update_productDatabaseAction_validator_1.UpdateSQLDatabaseActionSchema.validateAsync(data);
+            // Process filter template if provided
+            if (data.filterTemplate) {
+                const filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                const filterTemplate = JSON.stringify(data.filterTemplate);
+                Object.assign(payload, { filterData, filterTemplate });
             }
             // Update product and reinitialize
             await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());