@punks/backend-entity-manager 0.0.471 → 0.0.473

package/dist/cjs/index.js

@@ -41521,6 +41521,27 @@ const ensureJobLogGroup = async (logGroupName, awsSettings) => {
     }
 };
 
+const replaceVariablesInValue = (value, variables) => {
+    // Example matches:
+    // Input: "Hello ${name} and $(user)!" with variables {name: "World", user: "John"}
+    // Output: "Hello World and John!"
+    //
+    // Input: "The ${animal} jumps over $(object)" with variables {animal: "fox", object: "fence"}
+    // Output: "The fox jumps over fence"
+    return value.replace(/[\$][\{\(]([^\}\)]+)[\}\)]/g, (match, p1) => variables[p1]);
+};
+const replaceVariable = (environmentValue, variables) => {
+    return {
+        name: environmentValue.name,
+        value: environmentValue.value
+            ? replaceVariablesInValue(environmentValue.value, variables)
+            : environmentValue.value,
+    };
+};
+const replaceVariables = (environment, variables) => {
+    return environment.map((e) => replaceVariable(e, variables));
+};
+
 var AwsBatchService_1;
 const jobDefinitionName = (jobUid) => `${awsBatchSettings.value.batchResourcesPrefix}-job-${jobUid}`;
 const jobInstanceName = (jobUid, instanceId) => `${awsBatchSettings.value.batchResourcesPrefix}-job-${jobUid}-${instanceId}`;
@@ -41563,22 +41584,42 @@ let AwsBatchService = AwsBatchService_1 = class AwsBatchService {
         this.logger.info(`AWS JOB -> submitting job triggered`, {
             input,
         });
-        const queue = await this.ensureQueue(jobQueueName(input.jobUid));
         const jobDefName = jobDefinitionName(input.jobUid);
         const jobDefinition = await this.getLatestJobDefinition(jobDefName);
+        if (!jobDefinition) {
+            throw new Error(`Job definition not found -> ${jobDefName}`);
+        }
+        const platformType = jobDefinition.platformCapabilities?.[0];
+        if (!platformType) {
+            throw new Error(`Platform type not found -> ${jobDefName}`);
+        }
+        const defaultComputeEnvironment = platformType === clientBatch.PlatformCapability.FARGATE
+            ? this.awsSettings.defaultFargateBatchComputeEnvironment
+            : this.awsSettings.defaultEc2BatchComputeEnvironment;
+        const batchComputeEnvironment = input.overrides?.batchComputeEnvironment ?? defaultComputeEnvironment;
+        if (!batchComputeEnvironment) {
+            throw new Error(`Compute environment not found -> ${jobDefName}`);
+        }
+        const queue = await this.ensureQueue(jobQueueName(input.jobUid), {
+            batchComputeEnvironment,
+        });
         const jobName = jobInstanceName(input.jobUid, input.instanceId);
         const submitJobRequest = {
             jobQueue: queue.jobQueueArn,
             jobDefinition: jobDefinition.jobDefinitionArn,
             jobName,
-            ...(input.overrides?.command || jobDefinition.containerProperties?.command
-                ? {
-                    containerOverrides: {
+            containerOverrides: {
+                ...(input.overrides?.command ||
+                    jobDefinition.containerProperties?.command
+                    ? {
                         command: input.overrides?.command ??
                             jobDefinition.containerProperties.command,
-                    },
-                }
-                : {}),
+                    }
+                    : {}),
+                environment: jobDefinition.containerProperties?.environment && input.variables
+                    ? replaceVariables(jobDefinition.containerProperties.environment, input.variables)
+                    : jobDefinition.containerProperties?.environment ?? [],
+            },
         };
         this.logger.info(`AWS JOB -> invoking job ${jobName} ${queue.jobQueueArn}`, {
             request: submitJobRequest,
@@ -41692,18 +41733,34 @@ let AwsBatchService = AwsBatchService_1 = class AwsBatchService {
         }));
         return result.jobDefinitions ?? [];
     }
-    async ensureQueue(queueName) {
+    async ensureQueue(queueName, options) {
         if (!queueName) {
             throw new Error(`Queue name not provided`);
         }
         this.logger.debug(`AWS JOB -> ensuring queue ${queueName}`);
         const queue = await this.getQueue(queueName);
         if (queue) {
-            this.logger.debug(`AWS JOB -> queue exists ${queueName}`);
-            return queue;
+            if (queue.computeEnvironmentOrder?.[0].computeEnvironment ===
+                options.batchComputeEnvironment) {
+                this.logger.debug(`AWS JOB -> queue exists ${queueName}`);
+                return queue;
+            }
+            this.logger.debug(`AWS JOB -> queue exists with different compute environment ${queueName}`, {
+                queue,
+                options,
+            });
+            await this.updateQueue(queueName, options);
+            this.logger.debug(`AWS JOB -> queue updated ${queueName}`);
+            // Wait for the queue to be active
+            await backendCore.sleep(10000);
+            const updatedQueue = await this.getQueue(queueName);
+            if (!updatedQueue) {
+                throw new Error(`Queue not updated -> ${queueName}`);
+            }
+            return updatedQueue;
         }
         this.logger.debug(`AWS JOB -> creating queue ${queueName}`);
-        await this.createQueue(queueName);
+        await this.createQueue(queueName, options);
         this.logger.debug(`AWS JOB -> queue created ${queueName}`);
         // Wait for the queue to be active
         await backendCore.sleep(10000);
@@ -41713,8 +41770,9 @@ let AwsBatchService = AwsBatchService_1 = class AwsBatchService {
         }
         return currentQueue;
     }
-    async createQueue(queueName) {
-        if (!this.awsSettings.batchComputeEnvironment) {
+    async createQueue(queueName, options) {
+        if (!this.awsSettings.defaultFargateBatchComputeEnvironment &&
+            !options?.batchComputeEnvironment) {
             throw new Error(`No compute environment defined`);
         }
         await this.client().send(new clientBatch.CreateJobQueueCommand({
@@ -41722,7 +41780,25 @@ let AwsBatchService = AwsBatchService_1 = class AwsBatchService {
             priority: 0,
             computeEnvironmentOrder: [
                 {
-                    computeEnvironment: this.awsSettings.batchComputeEnvironment,
+                    computeEnvironment: options?.batchComputeEnvironment ||
+                        this.awsSettings.defaultFargateBatchComputeEnvironment,
+                    order: 0,
+                },
+            ],
+        }));
+    }
+    async updateQueue(queueName, options) {
+        if (!this.awsSettings.defaultFargateBatchComputeEnvironment &&
+            !options?.batchComputeEnvironment) {
+            throw new Error(`No compute environment defined`);
+        }
+        await this.client().send(new clientBatch.UpdateJobQueueCommand({
+            jobQueue: queueName,
+            priority: 0,
+            computeEnvironmentOrder: [
+                {
+                    computeEnvironment: options?.batchComputeEnvironment ||
+                        this.awsSettings.defaultFargateBatchComputeEnvironment,
                     order: 0,
                 },
             ],
@@ -41767,12 +41843,15 @@ let AwsJobsProvider = class AwsJobsProvider {
         const { definition, schedule, instanceId, payload, commandPlaceholders } = input;
         const awsInvocationParams = schedule?.invocationOverrides ??
             definition.invocationParams;
+        const awsInfrastructureParams = definition.infrastructureParams;
         await this.awsBatchService.submitJob({
             instanceId,
             jobUid: definition.uid,
             overrides: {
                 command: awsInvocationParams.startCommand?.map((x) => replacePlaceholders(replacePayload(x, payload), commandPlaceholders)),
+                batchComputeEnvironment: awsInfrastructureParams.batchComputeEnvironment,
             },
+            variables: input.variables,
         });
     }
     async upsertJobDefinition(input) {