@punks/backend-entity-manager 0.0.470 → 0.0.472

package/dist/cjs/types/abstractions/pipelines.d.ts

@@ -8,3 +8,4 @@ export interface IPipelinesController {
 export interface IPipelineOperationExecutor<TPipelineInput, TPipelineOutput, TContext> {
     execute(input: TPipelineInput, context: TContext): Promise<PipelineOperationResult<TPipelineInput, TPipelineOutput>>;
 }
+export type PipelineConcurrency = "exclusive" | "sequential";

package/dist/cjs/types/platforms/nest/decorators/pipelines.d.ts

@@ -1,4 +1,13 @@
+import { PipelineConcurrency } from "../../../abstractions/pipelines";
+export type PipelineTemplateOptions = {
+    logging?: {
+        enabled?: boolean;
+        ignoreMeta?: boolean;
+    };
+};
 export type PipelineTemplateProps = {
     name: string;
+    concurrency?: PipelineConcurrency;
+    options?: PipelineTemplateOptions;
 };
 export declare const WpPipeline: (name: string, props?: Omit<PipelineTemplateProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

package/dist/cjs/types/platforms/nest/pipelines/template/template.d.ts

@@ -2,9 +2,12 @@ import { PipelineDefinition, PipelineResult } from "../../../../types";
 import { IPipelineTemplateBuilder } from "../builder/types";
 import { PipelineUtils } from "./utils";
 import { PipelineTemplateProps } from "../../decorators";
-export type PipelineConcurrency = "exclusive" | "sequential";
+import { PipelineConcurrency } from "../../../../abstractions/pipelines";
 export type PipelineTemplateOptions = {
     concurrency?: PipelineConcurrency;
+    logging?: {
+        ignoreMeta?: boolean;
+    };
 };
 export declare abstract class NestPipelineTemplate<TPipelineInput, TPipelineOutput, TContext> {
     private readonly options?;
@@ -21,9 +24,11 @@ export declare abstract class NestPipelineTemplate<TPipelineInput, TPipelineOutp
         context: TContext;
     }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
     private pipelineExecute;
+    private processLogMetadata;
     private getDefinition;
     private buildDefinition;
     private getContext;
+    private get concurrency();
     private get operationsLockService();
     private get controller();
     private get registry();

package/dist/cjs/types/platforms/nest/plugins/jobs/aws-batch/manager/index.d.ts

@@ -12,6 +12,7 @@ export declare class AwsBatchService {
     private getActiveJobDefinitions;
     private ensureQueue;
     private createQueue;
+    private updateQueue;
     private getQueue;
     private client;
     private get awsSettings();

package/dist/cjs/types/platforms/nest/plugins/jobs/aws-batch/manager/types.d.ts

@@ -9,6 +9,7 @@ export type BathJobDefinition = {
 };
 export type BatchJobOverrides = {
     command?: string[];
+    batchComputeEnvironment?: string;
 };
 export type SubmitBatchJobInput = {
     overrides?: BatchJobOverrides;
@@ -24,3 +25,6 @@ export type AwsJobDefinition = {
     infrastructureParams: AwsBatchInfrastructureParams;
     invocationParams: AwsBatchInvocationParams;
 };
+export type AwsBatchCreateQueueOptions = {
+    batchComputeEnvironment: string;
+};

package/dist/cjs/types/platforms/nest/plugins/jobs/aws-batch/models/index.d.ts

@@ -14,6 +14,7 @@ export type AwsBatchInfrastructureParams = {
     assignPublicIp?: boolean;
     logGroupName?: string;
     privileged?: boolean;
+    batchComputeEnvironment?: string;
 };
 export type AwsBatchInvocationParams = {
     startCommand: string[];

package/dist/cjs/types/platforms/nest/plugins/jobs/aws-batch/settings/index.d.ts

@@ -3,7 +3,8 @@ export type AwsBatchSettings = {
     awsAccessKeyId?: string;
     awsSecretAccessKey?: string;
     region?: string;
-    batchComputeEnvironment: string;
+    defaultFargateBatchComputeEnvironment: string;
+    defaultEc2BatchComputeEnvironment?: string;
     batchExecutionRole: string;
     batchResourcesPrefix: string;
 };

package/dist/esm/index.js

@@ -20,7 +20,7 @@ import { ListObjectsCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCom
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
 import { MailService } from '@sendgrid/mail';
-import { BatchClient, CancelJobCommand, ListJobsCommand, SubmitJobCommand, DeregisterJobDefinitionCommand, RegisterJobDefinitionCommand, JobDefinitionType, PlatformCapability, ResourceType, AssignPublicIp, DescribeJobDefinitionsCommand, CreateJobQueueCommand, DescribeJobQueuesCommand, JobStatus as JobStatus$1 } from '@aws-sdk/client-batch';
+import { BatchClient, CancelJobCommand, ListJobsCommand, PlatformCapability, SubmitJobCommand, DeregisterJobDefinitionCommand, RegisterJobDefinitionCommand, JobDefinitionType, ResourceType, AssignPublicIp, DescribeJobDefinitionsCommand, CreateJobQueueCommand, UpdateJobQueueCommand, DescribeJobQueuesCommand, JobStatus as JobStatus$1 } from '@aws-sdk/client-batch';
 import { CloudWatchLogsClient, DescribeLogGroupsCommand, CreateLogGroupCommand } from '@aws-sdk/client-cloudwatch-logs';
 import require$$1$1 from 'http';
 import require$$2 from 'https';
@@ -35581,7 +35581,7 @@ class NestPipelineTemplate {
         return result.output;
     }
     async execute(data) {
-        if (this.options?.concurrency === "sequential") {
+        if (this.concurrency === "sequential") {
             return await this.operationsLockService.executeSequential({
                 lockUid: this.getConcurrencyKey(data.input),
                 operation: async () => {
@@ -35589,7 +35589,7 @@ class NestPipelineTemplate {
                 },
             });
         }
-        if (this.options?.concurrency === "exclusive") {
+        if (this.concurrency === "exclusive") {
             const result = await this.operationsLockService.executeExclusive({
                 lockUid: this.getConcurrencyKey(data.input),
                 operation: async () => {
@@ -35607,9 +35607,9 @@ class NestPipelineTemplate {
             context: data.context,
             instanceId,
         };
-        this.logger.debug(`[START] | ${this.metadata.name}`, logMetadata);
+        this.logger.debug(`[START] | ${this.metadata.name}`, this.processLogMetadata(logMetadata));
         if (!this.isAuthorized(data.context)) {
-            this.logger.debug(`[ERROR] | ${this.metadata.name} -> Unauthorized`, logMetadata);
+            this.logger.debug(`[ERROR] | ${this.metadata.name} -> Unauthorized`, this.processLogMetadata(logMetadata));
             return {
                 type: "error",
                 errorType: PipelineErrorType.Unauthorized,
@@ -35622,19 +35622,25 @@ class NestPipelineTemplate {
         if (result.type === "error") {
             this.logger.error(`[ERROR] | ${this.metadata.name} -> ${result.exception
                 ? `exception: ${result.exception.name}\n${result.exception.stack}`
-                : ""}`, {
+                : ""}`, this.processLogMetadata({
                 ...logMetadata,
                 result,
-            });
+            }));
         }
         else {
-            this.logger.debug(`[COMPLETED] | ${this.metadata.name}`, {
+            this.logger.debug(`[COMPLETED] | ${this.metadata.name}`, this.processLogMetadata({
                 ...logMetadata,
                 result,
-            });
+            }));
         }
         return result;
     }
+    processLogMetadata(meta) {
+        if (this.metadata.options?.logging?.ignoreMeta) {
+            return undefined;
+        }
+        return meta;
+    }
     getDefinition() {
         if (!this.cachedDefinition) {
             this.cachedDefinition = this.buildDefinition();
@@ -35651,6 +35657,9 @@ class NestPipelineTemplate {
             .resolveAuthenticationContextProvider();
         return (await contextService?.getContext());
     }
+    get concurrency() {
+        return this.options?.concurrency ?? this.metadata.concurrency;
+    }
     get operationsLockService() {
         return this.registry
             .getContainer()
@@ -41539,9 +41548,25 @@ 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 === 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,
@@ -41668,18 +41693,32 @@ 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}`);
+            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 sleep(10000);
@@ -41689,8 +41728,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 CreateJobQueueCommand({
@@ -41698,7 +41738,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 UpdateJobQueueCommand({
+            jobQueue: queueName,
+            priority: 0,
+            computeEnvironmentOrder: [
+                {
+                    computeEnvironment: options?.batchComputeEnvironment ||
+                        this.awsSettings.defaultFargateBatchComputeEnvironment,
                     order: 0,
                 },
             ],
@@ -41743,11 +41801,13 @@ 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,
             },
         });
     }