@forklaunch/interfaces-worker 1.0.3 → 1.0.4

package/lib/eject/domain/interfaces/decryptingWorker.consumer.ts

@@ -59,7 +59,9 @@ export function withDecryptionFailureHandler<T extends WorkerEventEntity>(
   handler: WorkerFailureHandler<T>,
   encryptor: EventEncryptor
 ): WorkerFailureHandler<EncryptedEventEnvelope> {
-  return async (results: WorkerProcessFailureResult<EncryptedEventEnvelope>[]) => {
+  return async (
+    results: WorkerProcessFailureResult<EncryptedEventEnvelope>[]
+  ) => {
     const decrypted = results.map((r) => ({
       ...r,
       value: decryptEvent<T>(r.value, encryptor)
@@ -72,8 +74,15 @@ function decryptEvent<T extends WorkerEventEntity>(
   envelope: EncryptedEventEnvelope,
   encryptor: EventEncryptor
 ): T {
-  const { id, tenantId, retryCount, processed, createdAt, updatedAt, encryptedPayload } =
-    envelope;
+  const {
+    id,
+    tenantId,
+    retryCount,
+    processed,
+    createdAt,
+    updatedAt,
+    encryptedPayload
+  } = envelope;
 
   const decrypted = encryptor.decrypt(encryptedPayload, tenantId);
   const payload = JSON.parse(decrypted!);

package/lib/eject/domain/interfaces/encryptingWorker.producer.ts

@@ -7,37 +7,41 @@ import type { WorkerProducer } from './worker.producer.interface';
 
 /**
  * Wraps any WorkerProducer to encrypt the entire event payload before enqueueing.
- * Base WorkerEventEntity fields (id, tenantId, retryCount, processed, createdAt,
- * updatedAt) are preserved in the clear for queue infrastructure. All remaining
- * fields are JSON-serialized and encrypted into a single `encryptedPayload` field.
+ * Base WorkerEventEntity fields (id, retryCount, processed, createdAt, updatedAt)
+ * are preserved in the clear for queue infrastructure. All remaining fields are
+ * JSON-serialized and encrypted into a single `encryptedPayload` field.
  *
- * The inner producer operates on EncryptedEventEnvelope, while the outer
- * interface accepts the full user-typed event T.
+ * tenantId is injected at construction (from request scope context) and stored
+ * on the envelope for key derivation during decryption.
  */
 export class EncryptingWorkerProducer<T extends WorkerEventEntity>
   implements WorkerProducer<T>
 {
   constructor(
     private readonly inner: WorkerProducer<EncryptedEventEnvelope>,
-    private readonly encryptor: EventEncryptor
+    private readonly encryptor: EventEncryptor,
+    private readonly tenantId: string
   ) {}
 
   async enqueueJob(job: T): Promise<void> {
-    await this.inner.enqueueJob(encryptEvent(job, this.encryptor));
+    await this.inner.enqueueJob(
+      encryptEvent(job, this.encryptor, this.tenantId)
+    );
   }
 
   async enqueueBatchJobs(jobs: T[]): Promise<void> {
     await this.inner.enqueueBatchJobs(
-      jobs.map((job) => encryptEvent(job, this.encryptor))
+      jobs.map((job) => encryptEvent(job, this.encryptor, this.tenantId))
     );
   }
 }
 
 function encryptEvent<T extends WorkerEventEntity>(
   event: T,
-  encryptor: EventEncryptor
+  encryptor: EventEncryptor,
+  tenantId: string
 ): EncryptedEventEnvelope {
-  const { id, tenantId, retryCount, processed, createdAt, updatedAt, ...payload } =
+  const { id, retryCount, processed, createdAt, updatedAt, ...payload } =
     event as WorkerEventEntity & Record<string, unknown>;
 
   return {

package/lib/eject/domain/types/eventEncryptor.types.ts

@@ -16,5 +16,6 @@ export interface EventEncryptor {
  * payload fields are serialized and encrypted into `encryptedPayload`.
  */
 export type EncryptedEventEnvelope = WorkerEventEntity & {
+  tenantId: string;
   encryptedPayload: string;
 };

package/lib/eject/domain/types/workerEventEntity.types.ts

@@ -1,6 +1,5 @@
 export type WorkerEventEntity = {
   id: string;
-  tenantId: string;
   retryCount: number;
   processed: boolean;
   createdAt: Date;

package/lib/interfaces/index.d.mts

@@ -12,17 +12,18 @@ interface WorkerProducer<T> {
 
 /**
  * Wraps any WorkerProducer to encrypt the entire event payload before enqueueing.
- * Base WorkerEventEntity fields (id, tenantId, retryCount, processed, createdAt,
- * updatedAt) are preserved in the clear for queue infrastructure. All remaining
- * fields are JSON-serialized and encrypted into a single `encryptedPayload` field.
+ * Base WorkerEventEntity fields (id, retryCount, processed, createdAt, updatedAt)
+ * are preserved in the clear for queue infrastructure. All remaining fields are
+ * JSON-serialized and encrypted into a single `encryptedPayload` field.
  *
- * The inner producer operates on EncryptedEventEnvelope, while the outer
- * interface accepts the full user-typed event T.
+ * tenantId is injected at construction (from request scope context) and stored
+ * on the envelope for key derivation during decryption.
  */
 declare class EncryptingWorkerProducer<T extends WorkerEventEntity> implements WorkerProducer<T> {
     private readonly inner;
     private readonly encryptor;
-    constructor(inner: WorkerProducer<EncryptedEventEnvelope>, encryptor: EventEncryptor);
+    private readonly tenantId;
+    constructor(inner: WorkerProducer<EncryptedEventEnvelope>, encryptor: EventEncryptor, tenantId: string);
     enqueueJob(job: T): Promise<void>;
     enqueueBatchJobs(jobs: T[]): Promise<void>;
 }

package/lib/interfaces/index.d.ts

@@ -12,17 +12,18 @@ interface WorkerProducer<T> {
 
 /**
  * Wraps any WorkerProducer to encrypt the entire event payload before enqueueing.
- * Base WorkerEventEntity fields (id, tenantId, retryCount, processed, createdAt,
- * updatedAt) are preserved in the clear for queue infrastructure. All remaining
- * fields are JSON-serialized and encrypted into a single `encryptedPayload` field.
+ * Base WorkerEventEntity fields (id, retryCount, processed, createdAt, updatedAt)
+ * are preserved in the clear for queue infrastructure. All remaining fields are
+ * JSON-serialized and encrypted into a single `encryptedPayload` field.
  *
- * The inner producer operates on EncryptedEventEnvelope, while the outer
- * interface accepts the full user-typed event T.
+ * tenantId is injected at construction (from request scope context) and stored
+ * on the envelope for key derivation during decryption.
  */
 declare class EncryptingWorkerProducer<T extends WorkerEventEntity> implements WorkerProducer<T> {
     private readonly inner;
     private readonly encryptor;
-    constructor(inner: WorkerProducer<EncryptedEventEnvelope>, encryptor: EventEncryptor);
+    private readonly tenantId;
+    constructor(inner: WorkerProducer<EncryptedEventEnvelope>, encryptor: EventEncryptor, tenantId: string);
     enqueueJob(job: T): Promise<void>;
     enqueueBatchJobs(jobs: T[]): Promise<void>;
 }

package/lib/interfaces/index.js

@@ -29,21 +29,24 @@ module.exports = __toCommonJS(interfaces_exports);
 
 // interfaces/encryptingWorker.producer.ts
 var EncryptingWorkerProducer = class {
-  constructor(inner, encryptor) {
+  constructor(inner, encryptor, tenantId) {
     this.inner = inner;
     this.encryptor = encryptor;
+    this.tenantId = tenantId;
   }
   async enqueueJob(job) {
-    await this.inner.enqueueJob(encryptEvent(job, this.encryptor));
+    await this.inner.enqueueJob(
+      encryptEvent(job, this.encryptor, this.tenantId)
+    );
   }
   async enqueueBatchJobs(jobs) {
     await this.inner.enqueueBatchJobs(
-      jobs.map((job) => encryptEvent(job, this.encryptor))
+      jobs.map((job) => encryptEvent(job, this.encryptor, this.tenantId))
     );
   }
 };
-function encryptEvent(event, encryptor) {
-  const { id, tenantId, retryCount, processed, createdAt, updatedAt, ...payload } = event;
+function encryptEvent(event, encryptor, tenantId) {
+  const { id, retryCount, processed, createdAt, updatedAt, ...payload } = event;
   return {
     id,
     tenantId,
@@ -89,7 +92,15 @@ function withDecryptionFailureHandler(handler, encryptor) {
   };
 }
 function decryptEvent(envelope, encryptor) {
-  const { id, tenantId, retryCount, processed, createdAt, updatedAt, encryptedPayload } = envelope;
+  const {
+    id,
+    tenantId,
+    retryCount,
+    processed,
+    createdAt,
+    updatedAt,
+    encryptedPayload
+  } = envelope;
   const decrypted = encryptor.decrypt(encryptedPayload, tenantId);
   const payload = JSON.parse(decrypted);
   return {

package/lib/interfaces/index.mjs

@@ -1,20 +1,23 @@
 // interfaces/encryptingWorker.producer.ts
 var EncryptingWorkerProducer = class {
-  constructor(inner, encryptor) {
+  constructor(inner, encryptor, tenantId) {
     this.inner = inner;
     this.encryptor = encryptor;
+    this.tenantId = tenantId;
   }
   async enqueueJob(job) {
-    await this.inner.enqueueJob(encryptEvent(job, this.encryptor));
+    await this.inner.enqueueJob(
+      encryptEvent(job, this.encryptor, this.tenantId)
+    );
   }
   async enqueueBatchJobs(jobs) {
     await this.inner.enqueueBatchJobs(
-      jobs.map((job) => encryptEvent(job, this.encryptor))
+      jobs.map((job) => encryptEvent(job, this.encryptor, this.tenantId))
     );
   }
 };
-function encryptEvent(event, encryptor) {
-  const { id, tenantId, retryCount, processed, createdAt, updatedAt, ...payload } = event;
+function encryptEvent(event, encryptor, tenantId) {
+  const { id, retryCount, processed, createdAt, updatedAt, ...payload } = event;
   return {
     id,
     tenantId,
@@ -60,7 +63,15 @@ function withDecryptionFailureHandler(handler, encryptor) {
   };
 }
 function decryptEvent(envelope, encryptor) {
-  const { id, tenantId, retryCount, processed, createdAt, updatedAt, encryptedPayload } = envelope;
+  const {
+    id,
+    tenantId,
+    retryCount,
+    processed,
+    createdAt,
+    updatedAt,
+    encryptedPayload
+  } = envelope;
   const decrypted = encryptor.decrypt(encryptedPayload, tenantId);
   const payload = JSON.parse(decrypted);
   return {

package/lib/types/index.d.mts

@@ -1,6 +1,5 @@
 type WorkerEventEntity = {
     id: string;
-    tenantId: string;
     retryCount: number;
     processed: boolean;
     createdAt: Date;
@@ -22,6 +21,7 @@ interface EventEncryptor {
  * payload fields are serialized and encrypted into `encryptedPayload`.
  */
 type EncryptedEventEnvelope = WorkerEventEntity & {
+    tenantId: string;
     encryptedPayload: string;
 };
 

package/lib/types/index.d.ts

@@ -1,6 +1,5 @@
 type WorkerEventEntity = {
     id: string;
-    tenantId: string;
     retryCount: number;
     processed: boolean;
     createdAt: Date;
@@ -22,6 +21,7 @@ interface EventEncryptor {
  * payload fields are serialized and encrypted into `encryptedPayload`.
  */
 type EncryptedEventEnvelope = WorkerEventEntity & {
+    tenantId: string;
     encryptedPayload: string;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/interfaces-worker",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Worker interfaces for forklaunch",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {