@vortenixinnovations/flagra-common-module 1.0.56 → 1.0.60

package/build/events/account/account-created-event.d.ts

@@ -0,0 +1,11 @@
+import { Subjects } from "../base/subjects.js";
+export interface AccountCreatedEvent {
+    subject: Subjects.AccountCreated;
+    data: {
+        id: string;
+        fullname: string;
+        role: string;
+        email: string;
+        password: string;
+    };
+}

package/build/events/account/account-created-event.js

@@ -0,0 +1 @@
+export {};

package/build/events/account/account-verify-event.d.ts

@@ -0,0 +1,10 @@
+import { Subjects } from "../base/subjects.js";
+export interface AccountVerifyEvent {
+    subject: Subjects.AccountVerify;
+    data: {
+        id: string;
+        first: string;
+        email: string;
+        otp: number;
+    };
+}

package/build/events/account/account-verify-event.js

@@ -0,0 +1 @@
+export {};

package/build/events/base/base-event.d.ts

@@ -0,0 +1,5 @@
+import { Subjects } from "./subjects.js";
+export interface Event {
+    subject: Subjects;
+    data: any;
+}

package/build/events/base/base-event.js

@@ -0,0 +1 @@
+export {};

package/build/events/base/base-listener.d.ts

@@ -0,0 +1,21 @@
+import { JetStreamClient, JetStreamManager, JsMsg, NatsConnection, ConsumerConfig } from "nats";
+import { Subjects } from "./subjects.js";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Listener<T extends Event> {
+    protected nc: NatsConnection;
+    abstract subject: T["subject"];
+    abstract queueGroupName: string;
+    abstract onMessage(data: T["data"], msg: JsMsg): void;
+    protected client: JetStreamClient;
+    protected manager: JetStreamManager;
+    protected ackWait: number;
+    constructor(nc: NatsConnection);
+    init(): Promise<void>;
+    subscriptionOptions(): Partial<ConsumerConfig>;
+    listen(): Promise<void>;
+    private parseMessage;
+}
+export {};

package/build/events/base/base-listener.js

@@ -0,0 +1,75 @@
+import { AckPolicy, StorageType, DeliverPolicy, } from "nats";
+import { logger } from "../../util/logger/index.js";
+export class Listener {
+    nc;
+    client;
+    manager;
+    ackWait = 30_000_000_000; // 30 seconds in nanoseconds
+    constructor(nc) {
+        this.nc = nc;
+        this.client = nc.jetstream();
+    }
+    async init() {
+        this.manager = await this.nc.jetstreamManager();
+    }
+    subscriptionOptions() {
+        return {
+            durable_name: this.queueGroupName,
+            ack_policy: AckPolicy.Explicit,
+            deliver_policy: DeliverPolicy.All,
+            ack_wait: this.ackWait,
+            max_ack_pending: 100,
+            max_deliver: 5,
+        };
+    }
+    async listen() {
+        if (!this.manager)
+            await this.init();
+        const streamName = `STREAM_${this.subject}`;
+        const durableName = this.queueGroupName;
+        // Ensure the stream exists
+        try {
+            await this.manager.streams.info(streamName);
+        }
+        catch {
+            logger.info(`Creating stream: ${streamName}`);
+            await this.manager.streams.add({
+                name: streamName,
+                subjects: [this.subject],
+                storage: StorageType.File,
+            });
+        }
+        // Ensure the consumer (durable queue group) exists
+        try {
+            await this.manager.consumers.info(streamName, durableName);
+        }
+        catch {
+            logger.info(`Creating durable consumer: ${durableName}`);
+            await this.manager.consumers.add(streamName, this.subscriptionOptions());
+        }
+        logger.info(`Listening for subject "${this.subject}" with queue group "${durableName}"`);
+        const consumer = await this.client.consumers.get(streamName, durableName);
+        // Use next() in a loop - simplest and works reliably
+        while (true) {
+            try {
+                const msg = await consumer.next({ expires: 30000 });
+                if (msg) {
+                    const parsedData = this.parseMessage(msg);
+                    this.onMessage(parsedData, msg);
+                }
+            }
+            catch (err) {
+                // Handle timeout or other errors
+                if (err.code !== "408") {
+                    // 408 is timeout, which is normal
+                    logger.info("Error getting message:", err);
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+            }
+        }
+    }
+    parseMessage(msg) {
+        const data = msg.data;
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+}

package/build/events/base/base-publisher.d.ts

@@ -0,0 +1,9 @@
+import { NatsConnection } from "nats";
+import { Event } from "./base-event.js";
+export declare abstract class Publisher<T extends Event> {
+    abstract subject: T["subject"];
+    protected client: NatsConnection;
+    private sc;
+    constructor(client: NatsConnection);
+    publish(data: T["data"]): Promise<void>;
+}

package/build/events/base/base-publisher.js

@@ -0,0 +1,15 @@
+import { StringCodec } from "nats";
+import { logger } from "../../util/logger/index.js";
+export class Publisher {
+    client;
+    sc = StringCodec();
+    constructor(client) {
+        this.client = client;
+    }
+    async publish(data) {
+        const encoded = this.sc.encode(JSON.stringify(data));
+        this.client.publish(this.subject, encoded);
+        await this.client.flush();
+        logger.info(`Event published to [${this.subject}]: ${JSON.stringify(data)}`);
+    }
+}

package/build/events/base/base-request-listener.d.ts

@@ -0,0 +1,11 @@
+import { NatsConnection } from "nats";
+import { RequestEvent } from "./request-event.js";
+export declare abstract class RequestListener<T extends RequestEvent> {
+    abstract subject: T["subject"];
+    abstract queueGroupName: string;
+    protected client: NatsConnection;
+    private sc;
+    constructor(client: NatsConnection);
+    abstract onRequest(data: T["request"]): Promise<T["response"]>;
+    listen(): Promise<void>;
+}

package/build/events/base/base-request-listener.js

@@ -0,0 +1,25 @@
+import { StringCodec } from "nats";
+import { logger } from "../../util/logger/index.js";
+export class RequestListener {
+    client;
+    sc = StringCodec();
+    constructor(client) {
+        this.client = client;
+    }
+    async listen() {
+        const opts = { queue: this.queueGroupName };
+        const sub = this.client.subscribe(this.subject, opts);
+        logger.info(`Listening for RPC requests on subject [${this.subject}] in queue [${this.queueGroupName}]`);
+        for await (const msg of sub) {
+            try {
+                const data = JSON.parse(this.sc.decode(msg.data));
+                const response = await this.onRequest(data);
+                msg.respond(this.sc.encode(JSON.stringify(response)));
+            }
+            catch (err) {
+                logger.error(`Failed to process RPC [${this.subject}]: ${err.message}`);
+                msg.respond(this.sc.encode(JSON.stringify({ error: err.message })));
+            }
+        }
+    }
+}

package/build/events/base/base-request-publisher.d.ts

@@ -0,0 +1,9 @@
+import { NatsConnection } from "nats";
+import { RequestEvent } from "./request-event.js";
+export declare abstract class RequestPublisher<T extends RequestEvent> {
+    abstract subject: T["subject"];
+    protected client: NatsConnection;
+    private sc;
+    constructor(client: NatsConnection);
+    send(data: T["request"], timeout?: number): Promise<T["response"]>;
+}

package/build/events/base/base-request-publisher.js

@@ -0,0 +1,22 @@
+import { StringCodec } from "nats";
+import { logger } from "../../util/logger/index.js";
+export class RequestPublisher {
+    client;
+    sc = StringCodec();
+    constructor(client) {
+        this.client = client;
+    }
+    async send(data, timeout = 5000) {
+        const encoded = this.sc.encode(JSON.stringify(data));
+        try {
+            const msg = await this.client.request(this.subject, encoded, { timeout });
+            const response = JSON.parse(this.sc.decode(msg.data));
+            logger.info(`RPC response received for [${this.subject}]`);
+            return response;
+        }
+        catch (err) {
+            logger.error(`RPC request to [${this.subject}] failed: ${err.message}`);
+            throw err;
+        }
+    }
+}

package/build/events/base/request-event.d.ts

@@ -0,0 +1,6 @@
+import { Subjects } from "./subjects.js";
+export interface RequestEvent {
+    subject: Subjects;
+    request: any;
+    response: any;
+}

package/build/events/base/request-event.js

@@ -0,0 +1 @@
+export {};

package/build/events/base/subjects.d.ts

@@ -0,0 +1,4 @@
+export declare enum Subjects {
+    AccountVerify = "account:verify",
+    AccountCreated = "account:created"
+}

package/build/events/base/subjects.js

@@ -0,0 +1,5 @@
+export var Subjects;
+(function (Subjects) {
+    Subjects["AccountVerify"] = "account:verify";
+    Subjects["AccountCreated"] = "account:created";
+})(Subjects || (Subjects = {}));

package/build/index.d.ts

@@ -1 +1,9 @@
 export * from "./util/index.js";
+export * from "./events/base/base-event.js";
+export * from "./events/base/base-listener.js";
+export * from "./events/base/base-publisher.js";
+export * from "./events/base/subjects.js";
+export * from "./events/account/account-created-event.js";
+export * from "./events/base/request-event.js";
+export * from "./events/base/base-request-publisher.js";
+export * from "./events/base/base-request-listener.js";

package/build/index.js

@@ -1 +1,9 @@
 export * from "./util/index.js";
+export * from "./events/base/base-event.js";
+export * from "./events/base/base-listener.js";
+export * from "./events/base/base-publisher.js";
+export * from "./events/base/subjects.js";
+export * from "./events/account/account-created-event.js";
+export * from "./events/base/request-event.js";
+export * from "./events/base/base-request-publisher.js";
+export * from "./events/base/base-request-listener.js";

package/build/util/index.d.ts

@@ -1,4 +1 @@
-export * from "./logger/index.js";
-export * from "./error/index.js";
 export * from "./global/index.js";
-export * from "./validator.js";

package/build/util/index.js

@@ -1,4 +1 @@
-export * from "./logger/index.js";
-export * from "./error/index.js";
 export * from "./global/index.js";
-export * from "./validator.js";

package/package.json

@@ -1,47 +1,35 @@
 {
   "name": "@vortenixinnovations/flagra-common-module",
-  "version": "1.0.56",
-  "description": "common module of flagra",
+  "version": "1.0.60",
+  "description": "flagra.com common module",
+  "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
-    "/build/**/*"
+    "build/**/*"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "exports": {
-    ".": {
-      "types": "./build/index.d.ts",
-      "import": "./build/index.js",
-      "require": "./build/index.js",
-      "default": "./build/index.js"
-    },
-    "./package.json": "./package.json"
-  },
   "scripts": {
-    "clean": "del-cli ./build/*",
+    "clean": "del ./build/*",
     "build": "npm run clean && tsc",
     "release": "npm version patch && npm run build && npm publish"
   },
+  "keywords": [],
+  "author": "midhunx01",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "del-cli": "^5.1.0",
+    "typescript": "^5.6.2"
+  },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.41",
-    "ajv": "^8.17.1",
-    "ajv-errors": "^3.0.0",
-    "ajv-formats": "^3.0.1",
-    "class-validator": "^0.14.2",
+    "@types/express": "^5.0.5",
     "dotenv": "^17.2.3",
     "express": "^5.1.0",
-    "pino": "^10.0.0",
+    "nats": "^2.29.3",
+    "node": "^22.21.0",
+    "node-nats-streaming": "^0.3.2",
+    "pino": "^10.1.0",
     "pino-http": "^11.0.0",
-    "pino-pretty": "^13.0.0"
-  },
-  "devDependencies": {
-    "@types/express": "^5.0.3",
-    "@types/node": "^24.7.0",
-    "del-cli": "^7.0.0",
-    "typescript": "^5.9.3"
-  },
-  "author": "midhunx01",
-  "license": "ISC"
+    "pino-pretty": "^13.1.2"
+  }
 }

package/build/util/error/errors.d.ts

@@ -1,19 +0,0 @@
-declare class BaseError extends Error {
-    readonly name: string;
-    readonly status: number;
-    readonly message: string;
-    constructor(name: string, status: number, description: string);
-}
-export declare class APIError extends BaseError {
-    constructor(description?: string);
-}
-export declare class ValidationError extends BaseError {
-    constructor(description?: string);
-}
-export declare class AuthorizeError extends BaseError {
-    constructor(description?: string);
-}
-export declare class NotFoundError extends BaseError {
-    constructor(description?: string);
-}
-export {};

package/build/util/error/errors.js

@@ -1,38 +0,0 @@
-import { STATUS_CODES } from "./status-codes.js";
-class BaseError extends Error {
-    name;
-    status;
-    message;
-    constructor(name, status, description) {
-        super(description);
-        this.name = name;
-        this.status = status;
-        this.message = description;
-        Object.setPrototypeOf(this, new.target.prototype);
-        Error.captureStackTrace(this);
-    }
-}
-// 500 Internal Error
-export class APIError extends BaseError {
-    constructor(description = "api error") {
-        super("api internal server error", STATUS_CODES.INTERNAL_ERROR, description);
-    }
-}
-// 400 Validation Error
-export class ValidationError extends BaseError {
-    constructor(description = "bad request") {
-        super("bad request", STATUS_CODES.BAD_REQUEST, description);
-    }
-}
-// 403 Authorize error
-export class AuthorizeError extends BaseError {
-    constructor(description = "access denied") {
-        super("access denied", STATUS_CODES.UN_AUTHORISED, description);
-    }
-}
-// 404 Not Found
-export class NotFoundError extends BaseError {
-    constructor(description = "not found") {
-        super(description, STATUS_CODES.NOT_FOUND, description);
-    }
-}

package/build/util/error/handler.d.ts

@@ -1,3 +0,0 @@
-import type { Request, Response, NextFunction } from "express";
-export declare const HandleErrorWithLogger: (error: any, req: Request, res: Response, next: NextFunction) => void;
-export declare const HandleUnCaughtException: (error: Error) => Promise<never>;

package/build/util/error/handler.js

@@ -1,33 +0,0 @@
-import { AuthorizeError, NotFoundError, ValidationError } from "./errors.js";
-import { logger } from "../logger/index.js";
-export const HandleErrorWithLogger = (error, req, res, next) => {
-    let reportError = true;
-    let status = 500;
-    let data = error.message;
-    // convert express-jwt UnauthorizedError to your AuthorizeError
-    if (error.name === "UnauthorizedError") {
-        error = new AuthorizeError(error.message);
-    }
-    // skip known errors
-    [NotFoundError, ValidationError, AuthorizeError].forEach((typeOfError) => {
-        if (error instanceof typeOfError) {
-            reportError = false;
-            status = error.status || 400;
-            data = error.message;
-        }
-    });
-    if (reportError) {
-        logger.error(error);
-    }
-    else {
-        // future use third party error reporting tools
-        logger.warn(error);
-    }
-    res.status(status).json({ error: data });
-};
-export const HandleUnCaughtException = async (error) => {
-    // error report / monitoring tools
-    logger.error(error);
-    // recover
-    process.exit(1);
-};

package/build/util/error/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./errors.js";
-export * from "./status-codes.js";
-export * from "./handler.js";

package/build/util/error/index.js

@@ -1,3 +0,0 @@
-export * from "./errors.js";
-export * from "./status-codes.js";
-export * from "./handler.js";

package/build/util/error/status-codes.d.ts

@@ -1,7 +0,0 @@
-export declare const STATUS_CODES: {
-    OK: number;
-    BAD_REQUEST: number;
-    UN_AUTHORISED: number;
-    NOT_FOUND: number;
-    INTERNAL_ERROR: number;
-};

package/build/util/error/status-codes.js

@@ -1,7 +0,0 @@
-export const STATUS_CODES = {
-    OK: 200,
-    BAD_REQUEST: 400,
-    UN_AUTHORISED: 403,
-    NOT_FOUND: 404,
-    INTERNAL_ERROR: 500,
-};

package/build/util/error/validator.d.ts

@@ -1 +0,0 @@
-export declare const ValidateError: (input: any) => Promise<Record<string, any> | false>;

package/build/util/error/validator.js

@@ -1,14 +0,0 @@
-import { validate } from "class-validator";
-export const ValidateError = async (input) => {
-    const error = await validate(input, {
-        ValidationError: { target: true, property: true },
-    });
-    if (error.length) {
-        return error.map((err) => ({
-            field: err.property,
-            message: (err.constraints && Object.values(err.constraints)[0]) ||
-                "please provide input for this field",
-        }));
-    }
-    return false;
-};

package/build/util/validator.d.ts

@@ -1,9 +0,0 @@
-import type { Static, TSchema } from "@sinclair/typebox";
-export declare function sanitizeStrings<T>(input: T): T;
-export declare function ValidateRequest<T extends TSchema>(data: unknown, schema: T): {
-    valid: true;
-    data: Static<T>;
-} | {
-    valid: false;
-    error: string;
-};

package/build/util/validator.js

@@ -1,43 +0,0 @@
-import Ajv from "ajv";
-import ajvErrors from "ajv-errors";
-import addFormats from "ajv-formats";
-const ajv = new Ajv({ allErrors: true, strict: false, coerceTypes: true });
-ajvErrors(ajv);
-addFormats(ajv);
-export function sanitizeStrings(input) {
-    if (input === null || input === undefined) {
-        return input;
-    }
-    if (typeof input === "string") {
-        return input.trim();
-    }
-    // Handle arrays recursively
-    if (Array.isArray(input)) {
-        return input.map((item) => sanitizeStrings(item));
-    }
-    // Handle objects recursively
-    if (typeof input === "object") {
-        const result = {};
-        for (const key in input) {
-            if (Object.prototype.hasOwnProperty.call(input, key)) {
-                result[key] = sanitizeStrings(input[key]);
-            }
-        }
-        return result;
-    }
-    // Return non-string primitive values as-is
-    return input;
-}
-// Generic validator function using TypeBox schemas
-export function ValidateRequest(data, schema) {
-    const sanitizedData = sanitizeStrings(data);
-    const validate = ajv.compile(schema);
-    const isValid = validate(sanitizedData);
-    if (isValid)
-        return { valid: true, data: sanitizedData };
-    const errorMessages = validate.errors?.map((e) => e.message).filter(Boolean);
-    return {
-        valid: false,
-        error: errorMessages?.[0] || "Validation failed",
-    };
-}