@ductape/sdk 0.1.11 → 0.1.12

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

@@ -156,6 +156,7 @@ export default class ProductsBuilderService implements IProductsBuilderService {
     private isQuotaFallbackInput;
     private redisClient?;
     private queues;
+    private env_type;
     /** In-memory cache for the current product run (cleared on init) to avoid repeated API calls in workflows */
     private brokerCache;
     private envCache;

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

@@ -21,6 +21,10 @@ const userApi_service_1 = require("../../api/services/userApi.service");
 const inputs_service_1 = __importDefault(require("../../inputs/inputs.service"));
 const inputs_utils_create_1 = require("../../inputs/utils/inputs.utils.create");
 const enums_1 = require("../../types/enums");
+const cloudApi_service_1 = require("../../api/services/cloudApi.service");
+const storage_cloud_link_util_1 = require("../../storage/storage-cloud-link.util");
+const cloud_broker_link_util_1 = require("../../cloud/cloud-broker-link.util");
+const cloud_database_link_util_1 = require("../../cloud/cloud-database-link.util");
 const productsBuilder_types_1 = require("../../types/productsBuilder.types");
 const validators_1 = require("../validators");
 const objects_utils_1 = require("../utils/objects.utils");
@@ -59,6 +63,7 @@ class ProductsBuilderService {
         this.token = token;
         this.access_key = access_key || null;
         this.workspace_private_key = workspace_private_key !== null && workspace_private_key !== void 0 ? workspace_private_key : null;
+        this.env_type = env_type;
         this.userApi = new userApi_service_1.UserApiService(env_type, redis_client);
         this.productApi = new productsApi_service_1.ProductsApiService(env_type, redis_client);
         this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(env_type, redis_client);
@@ -1347,6 +1352,19 @@ class ProductsBuilderService {
         const existingBroker = await this.fetchMessageBroker(data.tag);
         if (!existingBroker) {
             console.log(`${logPrefix} Broker ${data.tag} does not exist, proceeding with creation`);
+            const auth = this.getUserAccess();
+            const cloudApi = new cloudApi_service_1.CloudApiService(this.env_type);
+            const productTag = this.product.tag;
+            const materializedEnvs = [];
+            for (const env of data.envs || []) {
+                materializedEnvs.push(await (0, cloud_broker_link_util_1.materializeCloudLinkedBrokerEnv)(env, {
+                    cloudApi,
+                    auth,
+                    productTag,
+                    brokerTag: data.tag,
+                }));
+            }
+            data.envs = materializedEnvs;
             console.log(`${logPrefix} Validating schema...`);
             await validators_1.CreateMessageBrokerSchema.validateAsync(data);
             console.log(`${logPrefix} Schema validation passed`);
@@ -1407,6 +1425,17 @@ class ProductsBuilderService {
             console.log(`${logPrefix} Existing broker found with ${((_b = messageBroker.envs) === null || _b === void 0 ? void 0 : _b.length) || 0} environments`);
             const { _id, envs } = messageBroker;
             console.log(`${logPrefix} Broker ID: ${_id}`);
+            if (data.envs && data.envs.length > 0) {
+                const auth = this.getUserAccess();
+                const cloudApi = new cloudApi_service_1.CloudApiService(this.env_type);
+                const productTag = this.product.tag;
+                data.envs = await Promise.all(data.envs.map(async (env) => (0, cloud_broker_link_util_1.materializeCloudLinkedBrokerEnv)(env, {
+                    cloudApi,
+                    auth,
+                    productTag,
+                    brokerTag: data.tag || tag,
+                })));
+            }
             console.log(`${logPrefix} Validating update schema...`);
             await validators_1.UpdateMessageBrokerSchema.validateAsync(data);
             console.log(`${logPrefix} Schema validation passed`);
@@ -1415,7 +1444,7 @@ class ProductsBuilderService {
                 throw new Error(`tag ${tag} is in use`);
             }
             const processedEnvs = [];
-            for (const env of data.envs) {
+            for (const env of data.envs || []) {
                 console.log(`${logPrefix} Processing env: ${env.slug} (type: ${env.type})`);
                 const exists = await this.fetchEnv(env.slug);
                 if (!exists) {
@@ -1570,6 +1599,19 @@ class ProductsBuilderService {
     }
     async createStorage(data, throwErrorIfExists = false) {
         if (!(await this.fetchStorage(data.tag))) {
+            const auth = this.getUserAccess();
+            const cloudApi = new cloudApi_service_1.CloudApiService(this.env_type);
+            const productTag = this.product.tag;
+            const materializedEnvs = [];
+            for (const env of data.envs || []) {
+                materializedEnvs.push(await (0, storage_cloud_link_util_1.materializeCloudLinkedStorageEnv)(env, {
+                    cloudApi,
+                    auth,
+                    productTag,
+                    storageTag: data.tag,
+                }));
+            }
+            data.envs = materializedEnvs;
             await create_productStorage_validator_1.CreateProductStorageSchema.validateAsync(data);
             const processedEnvs = [];
             for (const env of data.envs) {
@@ -1608,11 +1650,22 @@ class ProductsBuilderService {
                 throw new Error(`Storage ${tag} not found`);
             }
             const { _id, envs } = storage;
-            await create_productStorage_validator_1.UpdateProductStorageSchema.validateAsync(data); // Change to update;
             if (data.tag && await this.fetchStorage(data.tag)) {
                 throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
             }
             // Only process envs if they are provided in the update
+            if (data.envs && data.envs.length > 0) {
+                const auth = this.getUserAccess();
+                const cloudApi = new cloudApi_service_1.CloudApiService(this.env_type);
+                const productTag = this.product.tag;
+                data.envs = await Promise.all(data.envs.map(async (env) => (0, storage_cloud_link_util_1.materializeCloudLinkedStorageEnv)(env, {
+                    cloudApi,
+                    auth,
+                    productTag,
+                    storageTag: data.tag || tag,
+                })));
+            }
+            await create_productStorage_validator_1.UpdateProductStorageSchema.validateAsync(data);
             if (data.envs && data.envs.length > 0) {
                 data.envs = await Promise.all(data.envs.map(async (env) => {
                     const exists = await this.fetchEnv(env.slug);
@@ -4107,8 +4160,20 @@ class ProductsBuilderService {
     }
     async createDatabase(data, throwErrorIfExists = false) {
         try {
-            // TODO: figure out a way to check if this has run before, halt if it has
             if (!(await this.fetchDatabase(data.tag))) {
+                const auth = this.getUserAccess();
+                const cloudApi = new cloudApi_service_1.CloudApiService(this.env_type);
+                const productTag = this.product.tag;
+                const materializedEnvs = [];
+                for (const env of data.envs || []) {
+                    materializedEnvs.push(await (0, cloud_database_link_util_1.materializeCloudLinkedDatabaseEnv)(env, {
+                        cloudApi,
+                        auth,
+                        productTag,
+                        databaseTag: data.tag,
+                    }));
+                }
+                data.envs = materializedEnvs;
                 await validators_1.CreateProductDatabaseSchema.validateAsync(data);
                 const processedEnvs = [];
                 for (const env of data.envs) {
@@ -4145,20 +4210,36 @@ class ProductsBuilderService {
                 throw new Error(`Database  ${tag} not found`);
             }
             const { _id, envs } = db;
-            await validators_1.UpdateProductDatabaseSchema.validateAsync(data); // Change to update;
             if (data.tag && this.fetchDatabase(data.tag)) {
                 throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
             }
-            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;
-            }));
+            if (data.envs && data.envs.length > 0) {
+                const auth = this.getUserAccess();
+                const cloudApi = new cloudApi_service_1.CloudApiService(this.env_type);
+                const productTag = this.product.tag;
+                data.envs = await Promise.all(data.envs.map(async (env) => (0, cloud_database_link_util_1.materializeCloudLinkedDatabaseEnv)(env, {
+                    cloudApi,
+                    auth,
+                    productTag,
+                    databaseTag: data.tag || tag,
+                })));
+            }
+            await validators_1.UpdateProductDatabaseSchema.validateAsync(data);
+            if (data.envs && data.envs.length > 0) {
+                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;
+                }));
+            }
+            if (!data.envs) {
+                data.envs = [];
+            }
             const overwrite = [];
             const newEnvs = [];
             data.envs.map((dataEnv) => {