@skillstew/common 1.0.13 → 1.0.15

package/build/errors/MessageQueueErrors.d.ts

@@ -0,0 +1,18 @@
+import { EventName } from "../events/EventMap";
+import { InfrastructureError } from "./AppError";
+export declare class InvalidEventPayloadError extends InfrastructureError {
+    constructor(eventName: EventName, errorString: string);
+    toJSON(): object;
+}
+export declare class UnknownEventError extends InfrastructureError {
+    constructor(eventName: string);
+    toJSON(): object;
+}
+export declare class ConsumerUsedBeforeInitializationError extends InfrastructureError {
+    constructor();
+    toJSON(): object;
+}
+export declare class ProducerUsedBeforeInitializationError extends InfrastructureError {
+    constructor();
+    toJSON(): object;
+}

package/build/errors/MessageQueueErrors.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProducerUsedBeforeInitializationError = exports.ConsumerUsedBeforeInitializationError = exports.UnknownEventError = exports.InvalidEventPayloadError = void 0;
+const AppError_1 = require("./AppError");
+const MessageQueueErrorCodes_1 = require("./codes/MessageQueueErrorCodes");
+class InvalidEventPayloadError extends AppError_1.InfrastructureError {
+    constructor(eventName, errorString) {
+        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + `for ${eventName}`, "INVALID_EVENT_PAYLOAD", { zodErrorString: errorString });
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            code: this.code,
+            error: this.context.zodErrorStrings,
+        };
+    }
+}
+exports.InvalidEventPayloadError = InvalidEventPayloadError;
+class UnknownEventError extends AppError_1.InfrastructureError {
+    constructor(eventName) {
+        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.UNKNOWN_EVENT + eventName, "UNKNOWN_EVENT");
+    }
+    toJSON() {
+        return { message: this.message, code: this.code };
+    }
+}
+exports.UnknownEventError = UnknownEventError;
+class ConsumerUsedBeforeInitializationError extends AppError_1.InfrastructureError {
+    constructor() {
+        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.CONSUMER_USED_BEFORE_INITIALIZATION, "CONSUMER_USED_BEFORE_INITIALIZATION");
+    }
+    toJSON() {
+        return { message: this.message, code: this.code };
+    }
+}
+exports.ConsumerUsedBeforeInitializationError = ConsumerUsedBeforeInitializationError;
+class ProducerUsedBeforeInitializationError extends AppError_1.InfrastructureError {
+    constructor() {
+        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.PRODUCER_USED_BEFORE_INITIALIZATION, "PRODUCER_USED_BEFORE_INITIALIZATION");
+    }
+    toJSON() {
+        return { message: this.message, code: this.code };
+    }
+}
+exports.ProducerUsedBeforeInitializationError = ProducerUsedBeforeInitializationError;

package/build/errors/codes/MessageQueueErrorCodes.d.ts

@@ -0,0 +1,6 @@
+export declare const MessageQueueErrorCodes: {
+    readonly PRODUCER_USED_BEFORE_INITIALIZATION: "Producer used before initialization!";
+    readonly CONSUMER_USED_BEFORE_INITIALIZATION: "Consumer used before initialization!";
+    readonly UNKNOWN_EVENT: "Unknown event type";
+    readonly INVALID_EVENT_PAYLOAD: "Invalid payload";
+};

package/build/errors/codes/MessageQueueErrorCodes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueueErrorCodes = void 0;
+exports.MessageQueueErrorCodes = {
+    PRODUCER_USED_BEFORE_INITIALIZATION: "Producer used before initialization!",
+    CONSUMER_USED_BEFORE_INITIALIZATION: "Consumer used before initialization!",
+    UNKNOWN_EVENT: "Unknown event type",
+    INVALID_EVENT_PAYLOAD: "Invalid payload",
+};

package/build/events/Consumer.d.ts

@@ -0,0 +1,18 @@
+import { Channel } from "amqplib";
+import { EventName } from "./EventMap";
+import { AppEvent } from "./AppEvent";
+export declare class Consumer {
+    private _channel;
+    private _exchange;
+    private _initialized;
+    private _handlers;
+    constructor();
+    init: (channel: Channel, exchange: string, serviceName: string, interestedEvents: (string | EventName)[]) => Promise<void>;
+    private handleEvent;
+    registerHandler: <T extends EventName>(eventName: T, handler: (event: AppEvent<T>) => Promise<HandlerResult>) => void;
+}
+interface HandlerResult {
+    success: boolean;
+    retryable?: boolean;
+}
+export {};

package/build/events/Consumer.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = void 0;
+const EventMap_1 = require("./EventMap");
+const MessageQueueErrors_1 = require("../errors/MessageQueueErrors");
+const zod_1 = __importDefault(require("zod"));
+class Consumer {
+    constructor() {
+        this._initialized = false;
+        this._handlers = new Map();
+        this.init = (channel, exchange, serviceName, interestedEvents) => __awaiter(this, void 0, void 0, function* () {
+            this._channel = channel;
+            this._exchange = exchange;
+            yield this._channel.assertExchange(this._exchange, "topic", {
+                durable: true,
+            });
+            const queue = yield this._channel.assertQueue(`${serviceName}_queue`, {
+                durable: true,
+            });
+            yield Promise.all(interestedEvents.map((eventName) => this._channel.bindQueue(queue.queue, this._exchange, eventName)));
+            this._channel.consume(queue.queue, this.handleEvent, { noAck: true });
+            this._initialized = true;
+        });
+        this.handleEvent = (msg) => __awaiter(this, void 0, void 0, function* () {
+            if (!msg) {
+                return;
+            }
+            const event = JSON.parse(msg.content.toString());
+            const eventName = event.eventName;
+            // validate using schema
+            const schema = EventMap_1.EventSchemas[eventName];
+            if (!schema) {
+                throw new MessageQueueErrors_1.UnknownEventError(eventName);
+            }
+            const parseResult = schema.safeParse(event.data);
+            if (!parseResult.success) {
+                this._channel.nack(msg);
+                const error = zod_1.default.prettifyError(parseResult.error);
+                throw new MessageQueueErrors_1.InvalidEventPayloadError(eventName, error);
+            }
+            // create typed app event
+            const appEvent = Object.assign(Object.assign({}, event), { data: parseResult.data });
+            try {
+                const handler = this._handlers.get(eventName);
+                if (!handler) {
+                    this._channel.ack(msg); // ack if no handler
+                    return;
+                }
+                const result = yield handler(appEvent);
+                if (result.success) {
+                    this._channel.ack(msg);
+                }
+                else {
+                    const requeue = result.retryable;
+                    this._channel.nack(msg, false, requeue);
+                }
+            }
+            catch (err) {
+                console.log(err);
+                this._channel.nack(msg, false, false);
+            }
+        });
+        this.registerHandler = (eventName, handler) => {
+            if (!this._initialized) {
+                throw new MessageQueueErrors_1.ConsumerUsedBeforeInitializationError();
+            }
+            this._handlers.set(eventName, handler);
+        };
+    }
+}
+exports.Consumer = Consumer;

package/build/events/CreateEvent.d.ts

@@ -0,0 +1,3 @@
+import { AppEvent } from "./AppEvent";
+import { EventName, EventPayload } from "./EventMap";
+export declare function CreateEvent<T extends EventName>(eventName: T, data: EventPayload<T>, producer: string, traceId?: string): AppEvent<T>;

package/build/events/CreateEvent.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateEvent = CreateEvent;
+const crypto_1 = require("crypto");
+function CreateEvent(eventName, data, producer, traceId) {
+    return {
+        eventName,
+        eventId: (0, crypto_1.randomUUID)(),
+        data,
+        producer,
+        timestamp: new Date().toISOString(),
+        traceId,
+    };
+}

package/build/events/Producer.d.ts

@@ -0,0 +1,10 @@
+import { Channel } from "amqplib";
+import { AnyAppEvent } from "./AppEvent";
+export declare class Producer {
+    private _channel;
+    private _exchange;
+    private _initialized;
+    constructor();
+    init: (channel: Channel, exchange: string) => Promise<void>;
+    publish: (event: AnyAppEvent) => void;
+}

package/build/events/Producer.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Producer = void 0;
+const MessageQueueErrors_1 = require("../errors/MessageQueueErrors");
+class Producer {
+    constructor() {
+        this._initialized = false;
+        this.init = (channel, exchange) => __awaiter(this, void 0, void 0, function* () {
+            this._channel = channel;
+            this._exchange = exchange;
+            yield this._channel.assertExchange(this._exchange, "topic", {
+                durable: true,
+            });
+            this._initialized = true;
+        });
+        this.publish = (event) => {
+            if (!this._initialized) {
+                throw new MessageQueueErrors_1.ProducerUsedBeforeInitializationError();
+            }
+            const routingKey = event.eventName;
+            const message = Buffer.from(JSON.stringify(event));
+            this._channel.publish(this._exchange, routingKey, message, {
+                persistent: true,
+            });
+        };
+    }
+}
+exports.Producer = Producer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillstew/common",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "scripts": {
@@ -15,9 +15,13 @@
   "dependencies": {
     "@types/express": "^5.0.3",
     "@types/jsonwebtoken": "^9.0.10",
+    "amqplib": "^0.10.8",
     "del-cli": "^6.0.0",
     "express": "^5.1.0",
     "jsonwebtoken": "^9.0.2",
     "zod": "^4.0.10"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.7"
   }
 }

package/publish.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Exit immediately on error
+set -e
+
+# Change to correct dir
+cd "/home/fahi/dev/brototype/skillStew/skill-stew-api/common/"
+
+# Step 1: Bump patch version
+npm version patch
+
+# Step 2: Build the package
+npm run build
+
+# Step 3: Stage all changes
+git add .
+
+# Step 4: Prompt for a commit message
+echo "Enter commit message:"
+read COMMIT_MESSAGE
+git commit -m "$COMMIT_MESSAGE"
+
+# Step 5: Push to GitHub
+echo "Enter remote branch to push to:"
+read REMOTE_BRANCH
+git push -u origin "$REMOTE_BRANCH"
+
+# Step 6: Publish to npm
+npm publish

package/src/errors/MessageQueueErrors.ts

@@ -0,0 +1,53 @@
+import { EventName } from "../events/EventMap";
+import { InfrastructureError } from "./AppError";
+import { MessageQueueErrorCodes } from "./codes/MessageQueueErrorCodes";
+
+export class InvalidEventPayloadError extends InfrastructureError {
+  constructor(eventName: EventName, errorString: string) {
+    super(
+      MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + `for ${eventName}`,
+      "INVALID_EVENT_PAYLOAD",
+      { zodErrorString: errorString },
+    );
+  }
+  toJSON(): object {
+    return {
+      message: this.message,
+      code: this.code,
+      error: this.context!.zodErrorStrings,
+    };
+  }
+}
+
+export class UnknownEventError extends InfrastructureError {
+  constructor(eventName: string) {
+    super(MessageQueueErrorCodes.UNKNOWN_EVENT + eventName, "UNKNOWN_EVENT");
+  }
+  toJSON(): object {
+    return { message: this.message, code: this.code };
+  }
+}
+
+export class ConsumerUsedBeforeInitializationError extends InfrastructureError {
+  constructor() {
+    super(
+      MessageQueueErrorCodes.CONSUMER_USED_BEFORE_INITIALIZATION,
+      "CONSUMER_USED_BEFORE_INITIALIZATION",
+    );
+  }
+  toJSON(): object {
+    return { message: this.message, code: this.code };
+  }
+}
+
+export class ProducerUsedBeforeInitializationError extends InfrastructureError {
+  constructor() {
+    super(
+      MessageQueueErrorCodes.PRODUCER_USED_BEFORE_INITIALIZATION,
+      "PRODUCER_USED_BEFORE_INITIALIZATION",
+    );
+  }
+  toJSON(): object {
+    return { message: this.message, code: this.code };
+  }
+}

package/src/errors/codes/MessageQueueErrorCodes.ts

@@ -0,0 +1,6 @@
+export const MessageQueueErrorCodes = {
+  PRODUCER_USED_BEFORE_INITIALIZATION: "Producer used before initialization!",
+  CONSUMER_USED_BEFORE_INITIALIZATION: "Consumer used before initialization!",
+  UNKNOWN_EVENT: "Unknown event type",
+  INVALID_EVENT_PAYLOAD: "Invalid payload",
+} as const;

package/src/events/Consumer.ts

@@ -0,0 +1,108 @@
+import { Channel, ConsumeMessage } from "amqplib";
+import { EventName, EventSchemas } from "./EventMap";
+import { AnyAppEvent, AppEvent } from "./AppEvent";
+import {
+  ConsumerUsedBeforeInitializationError,
+  InvalidEventPayloadError,
+  UnknownEventError,
+} from "../errors/MessageQueueErrors";
+import z from "zod";
+
+export class Consumer {
+  private _channel!: Channel;
+  private _exchange!: string;
+  private _initialized: boolean = false;
+  private _handlers = new Map<
+    EventName,
+    (event: any) => Promise<HandlerResult>
+  >();
+  constructor() {}
+
+  init = async (
+    channel: Channel,
+    exchange: string,
+    serviceName: string,
+    interestedEvents: (string | EventName)[], // ex: user.#, payments.subscribed
+  ) => {
+    this._channel = channel;
+    this._exchange = exchange;
+    await this._channel.assertExchange(this._exchange, "topic", {
+      durable: true,
+    });
+
+    const queue = await this._channel.assertQueue(`${serviceName}_queue`, {
+      durable: true,
+    });
+
+    await Promise.all(
+      interestedEvents.map((eventName) =>
+        this._channel.bindQueue(queue.queue, this._exchange, eventName),
+      ),
+    );
+
+    this._channel.consume(queue.queue, this.handleEvent, { noAck: true });
+
+    this._initialized = true;
+  };
+
+  private handleEvent = async (msg: ConsumeMessage | null) => {
+    if (!msg) {
+      return;
+    }
+    const event = JSON.parse(msg.content.toString()) as AnyAppEvent;
+    const eventName = event.eventName;
+
+    // validate using schema
+    const schema = EventSchemas[eventName];
+    if (!schema) {
+      throw new UnknownEventError(eventName);
+    }
+    const parseResult = schema.safeParse(event.data);
+    if (!parseResult.success) {
+      this._channel.nack(msg);
+      const error = z.prettifyError(parseResult.error);
+      throw new InvalidEventPayloadError(eventName, error);
+    }
+
+    // create typed app event
+    const appEvent: AppEvent<typeof eventName> = {
+      ...event,
+      data: parseResult.data,
+    };
+
+    try {
+      const handler = this._handlers.get(eventName);
+      if (!handler) {
+        this._channel.ack(msg); // ack if no handler
+        return;
+      }
+
+      const result = await handler(appEvent);
+
+      if (result.success) {
+        this._channel.ack(msg);
+      } else {
+        const requeue = result.retryable;
+        this._channel.nack(msg, false, requeue);
+      }
+    } catch (err) {
+      console.log(err);
+      this._channel.nack(msg, false, false);
+    }
+  };
+
+  registerHandler = <T extends EventName>(
+    eventName: T,
+    handler: (event: AppEvent<T>) => Promise<HandlerResult>,
+  ) => {
+    if (!this._initialized) {
+      throw new ConsumerUsedBeforeInitializationError();
+    }
+    this._handlers.set(eventName, handler);
+  };
+}
+
+interface HandlerResult {
+  success: boolean;
+  retryable?: boolean;
+}

package/src/events/CreateEvent.ts

@@ -0,0 +1,19 @@
+import { AppEvent } from "./AppEvent";
+import { EventName, EventPayload } from "./EventMap";
+import { randomUUID } from "crypto";
+
+export function CreateEvent<T extends EventName>(
+  eventName: T,
+  data: EventPayload<T>,
+  producer: string,
+  traceId?: string,
+): AppEvent<T> {
+  return {
+    eventName,
+    eventId: randomUUID(),
+    data,
+    producer,
+    timestamp: new Date().toISOString(),
+    traceId,
+  };
+}

package/src/events/Producer.ts

@@ -0,0 +1,30 @@
+import { Channel } from "amqplib";
+import { AnyAppEvent } from "./AppEvent";
+import { ProducerUsedBeforeInitializationError } from "../errors/MessageQueueErrors";
+
+export class Producer {
+  private _channel!: Channel;
+  private _exchange!: string;
+  private _initialized: boolean = false;
+  constructor() {}
+
+  init = async (channel: Channel, exchange: string) => {
+    this._channel = channel;
+    this._exchange = exchange;
+    await this._channel.assertExchange(this._exchange, "topic", {
+      durable: true,
+    });
+    this._initialized = true;
+  };
+
+  publish = (event: AnyAppEvent) => {
+    if (!this._initialized) {
+      throw new ProducerUsedBeforeInitializationError();
+    }
+    const routingKey = event.eventName;
+    const message = Buffer.from(JSON.stringify(event));
+    this._channel.publish(this._exchange, routingKey, message, {
+      persistent: true,
+    });
+  };
+}