@sn1006/common 1.0.24 → 1.0.25

package/build/errors/bad-request-error.d.ts

@@ -1,9 +1,9 @@
-import { NormalizedError } from './normalized-error';
-export declare class BadRequestError extends NormalizedError {
+import CustomError from './custom-error';
+export declare class BadRequestError extends CustomError {
     message: string;
     status: number;
     constructor(message: string);
-    serializeErrors(): {
+    serializeError(): {
         message: string;
     }[];
 }

package/build/errors/bad-request-error.js

@@ -1,15 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadRequestError = void 0;
-const normalized_error_1 = require("./normalized-error");
-class BadRequestError extends normalized_error_1.NormalizedError {
+const custom_error_1 = __importDefault(require("./custom-error"));
+class BadRequestError extends custom_error_1.default {
     constructor(message) {
         super(message);
         this.message = message;
         this.status = 400;
         Object.setPrototypeOf(this, BadRequestError.prototype);
     }
-    serializeErrors() {
+    serializeError() {
         return [{ message: this.message }];
     }
 }

package/build/errors/custom-error.d.ts

@@ -0,0 +1,9 @@
+declare abstract class CustomError extends Error {
+    abstract status: number;
+    constructor(message: string);
+    abstract serializeError(): {
+        message: string;
+        field?: string;
+    }[];
+}
+export default CustomError;

package/build/errors/custom-error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}
+exports.default = CustomError;

package/build/errors/db-error.d.ts

@@ -1,8 +1,8 @@
-import { NormalizedError } from './normalized-error';
-export default class DBError extends NormalizedError {
+import CustomError from './custom-error';
+export default class DBError extends CustomError {
     status: number;
     constructor();
-    serializeErrors(): {
+    serializeError(): {
         message: string;
         field?: string | undefined;
     }[];

package/build/errors/db-error.js

@@ -1,13 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const normalized_error_1 = require("./normalized-error");
-class DBError extends normalized_error_1.NormalizedError {
+const custom_error_1 = __importDefault(require("./custom-error"));
+class DBError extends custom_error_1.default {
     constructor() {
         super('Error connecting to DB');
         this.status = 500;
         Object.setPrototypeOf(this, DBError.prototype);
     }
-    serializeErrors() {
+    serializeError() {
         return [{ message: this.message }];
     }
 }

package/build/errors/not-authorized-error.d.ts

@@ -1,8 +1,8 @@
-import { NormalizedError } from './normalized-error';
-export declare class NotAuthorizedError extends NormalizedError {
+import CustomError from './custom-error';
+export declare class NotAuthorizedError extends CustomError {
     status: number;
     constructor();
-    serializeErrors(): {
+    serializeError(): {
         message: string;
     }[];
 }

package/build/errors/not-authorized-error.js

@@ -1,14 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotAuthorizedError = void 0;
-const normalized_error_1 = require("./normalized-error");
-class NotAuthorizedError extends normalized_error_1.NormalizedError {
+const custom_error_1 = __importDefault(require("./custom-error"));
+class NotAuthorizedError extends custom_error_1.default {
     constructor() {
         super('Not authorized');
         this.status = 401;
         Object.setPrototypeOf(this, NotAuthorizedError.prototype);
     }
-    serializeErrors() {
+    serializeError() {
         return [{ message: this.message }];
     }
 }

package/build/errors/not-found-error.d.ts

@@ -1,8 +1,8 @@
-import { NormalizedError } from './normalized-error';
-export declare class NotFoundError extends NormalizedError {
+import CustomError from './custom-error';
+export declare class NotFoundError extends CustomError {
     status: number;
     constructor();
-    serializeErrors(): {
+    serializeError(): {
         message: string;
     }[];
 }

package/build/errors/not-found-error.js

@@ -1,14 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotFoundError = void 0;
-const normalized_error_1 = require("./normalized-error");
-class NotFoundError extends normalized_error_1.NormalizedError {
+const custom_error_1 = __importDefault(require("./custom-error"));
+class NotFoundError extends custom_error_1.default {
     constructor() {
         super("Resource not found");
         this.status = 404;
         Object.setPrototypeOf(this, NotFoundError.prototype);
     }
-    serializeErrors() {
+    serializeError() {
         return [{ message: this.message }];
     }
 }

package/build/errors/validation-error.d.ts

@@ -1,15 +1,12 @@
-import { NormalizedError } from './normalized-error';
-interface NonSerializedValidationError {
-    message: string;
-    path: (string | number)[];
-}
-declare class CustomValidationError extends NormalizedError {
-    errors: NonSerializedValidationError[];
+import CustomError from './custom-error';
+import { ValidationError } from 'express-validator';
+declare class CustomValidationError extends CustomError {
+    errors: ValidationError[];
     status: number;
-    constructor(errors: NonSerializedValidationError[]);
-    serializeErrors(): {
-        message: string;
-        path: (string | number)[];
+    constructor(errors: ValidationError[]);
+    serializeError(): {
+        message: any;
+        field: string;
     }[];
 }
 export default CustomValidationError;

package/build/errors/validation-error.js

@@ -1,16 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const normalized_error_1 = require("./normalized-error");
-class CustomValidationError extends normalized_error_1.NormalizedError {
+const custom_error_1 = __importDefault(require("./custom-error"));
+class CustomValidationError extends custom_error_1.default {
     constructor(errors) {
-        super("Validaton error");
+        super("Invalid username or password");
         this.errors = errors;
         this.status = 400;
         Object.setPrototypeOf(this, CustomValidationError.prototype);
     }
-    serializeErrors() {
+    serializeError() {
         return this.errors.map(err => {
-            return { message: err.message, path: err.path };
+            const ferr = err;
+            return { message: ferr.msg, field: ferr.path };
         });
     }
 }

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

@@ -0,0 +1,18 @@
+import { Message, Stan } from "node-nats-streaming";
+import { Subjects } from "./subjects";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Listener<T extends Event> {
+    abstract subject: T['subject'];
+    abstract queueGroupName: string;
+    abstract onMessage(data: T['data'], msg: Message): void;
+    private client;
+    protected ackWait: number;
+    constructor(client: Stan);
+    subscriptionOptions(): import("node-nats-streaming").SubscriptionOptions;
+    listen(): void;
+    parseMessage(msg: Message): any;
+}
+export {};

package/build/events/base-listener.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+class Listener {
+    constructor(client) {
+        this.ackWait = 5 * 1000;
+        this.client = client;
+    }
+    subscriptionOptions() {
+        return this.client.subscriptionOptions()
+            .setDeliverAllAvailable()
+            .setManualAckMode(true)
+            .setAckWait(this.ackWait)
+            .setDurableName(this.queueGroupName);
+    }
+    listen() {
+        const subscription = this.client.subscribe(this.subject, this.queueGroupName, this.subscriptionOptions());
+        subscription.on('message', (msg) => {
+            console.log(`Message received ${this.subject} / ${this.queueGroupName}`);
+            const parsedData = this.parseMessage(msg);
+            this.onMessage(parsedData, msg);
+        });
+    }
+    parseMessage(msg) {
+        const data = msg.getData();
+        return typeof data === 'string'
+            ? JSON.parse(data)
+            : JSON.parse(data.toString('utf8'));
+    }
+}
+exports.Listener = Listener;

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

@@ -0,0 +1,13 @@
+import { Stan } from "node-nats-streaming";
+import { Subjects } from "./subjects";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Publisher<T extends Event> {
+    abstract subject: T['subject'];
+    private client;
+    constructor(client: Stan);
+    publish(data: T['data']): Promise<void>;
+}
+export {};

package/build/events/base-publisher.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publisher = void 0;
+class Publisher {
+    constructor(client) {
+        this.client = client;
+    }
+    publish(data) {
+        return new Promise((resolve, reject) => {
+            this.client.publish(this.subject, JSON.stringify(data), (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                console.log('Event published');
+                resolve();
+            });
+        });
+    }
+}
+exports.Publisher = Publisher;

package/build/events/subjects.d.ts

@@ -0,0 +1,4 @@
+export declare enum Subjects {
+    TicketCreated = "ticket:created",
+    TicketUpdated = "ticket:updated"
+}

package/build/events/subjects.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subjects = void 0;
+var Subjects;
+(function (Subjects) {
+    Subjects["TicketCreated"] = "ticket:created";
+    Subjects["TicketUpdated"] = "ticket:updated";
+})(Subjects || (exports.Subjects = Subjects = {}));

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

@@ -0,0 +1,10 @@
+import { Subjects } from "./subjects";
+export interface TicketCreatedEvent {
+    subject: Subjects.TicketCreated;
+    data: {
+        id: string;
+        title: string;
+        price: number;
+        userId: string;
+    };
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/events/ticket-updated-event.d.ts

@@ -0,0 +1,10 @@
+import { Subjects } from "./subjects";
+export interface TicketUpdatedEvent {
+    subject: Subjects.TicketUpdated;
+    data: {
+        id: string;
+        title: string;
+        price: number;
+        userId: string;
+    };
+}

package/build/events/ticket-updated-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/index.d.ts

@@ -1,5 +1,5 @@
 export * from './errors/bad-request-error';
-export * from './errors/normalized-error';
+export * from './errors/custom-error';
 export * from './errors/db-error';
 export * from './errors/validation-error';
 export * from './errors/not-authorized-error';
@@ -8,6 +8,8 @@ export * from './middlewares/current-user';
 export * from './middlewares/error-handler';
 export * from './middlewares/require-auth';
 export * from './middlewares/validate-request';
-export * from './middlewares/joi-validate-request';
-export * from './middlewares/zod-validate-request';
-export * from './middlewares/async-wrapper';
+export * from './events/base-listener';
+export * from './events/base-publisher';
+export * from './events/subjects';
+export * from './events/ticket-created-event';
+export * from './events/ticket-updated-event';

package/build/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./errors/bad-request-error"), exports);
-__exportStar(require("./errors/normalized-error"), exports);
+__exportStar(require("./errors/custom-error"), exports);
 __exportStar(require("./errors/db-error"), exports);
 __exportStar(require("./errors/validation-error"), exports);
 __exportStar(require("./errors/not-authorized-error"), exports);
@@ -24,6 +24,8 @@ __exportStar(require("./middlewares/current-user"), exports);
 __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/validate-request"), exports);
-__exportStar(require("./middlewares/joi-validate-request"), exports);
-__exportStar(require("./middlewares/zod-validate-request"), exports);
-__exportStar(require("./middlewares/async-wrapper"), exports);
+__exportStar(require("./events/base-listener"), exports);
+__exportStar(require("./events/base-publisher"), exports);
+__exportStar(require("./events/subjects"), exports);
+__exportStar(require("./events/ticket-created-event"), exports);
+__exportStar(require("./events/ticket-updated-event"), exports);

package/build/middlewares/error-handler.js

@@ -1,12 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
-const normalized_error_1 = require("../errors/normalized-error");
+const custom_error_1 = __importDefault(require("../errors/custom-error"));
 const errorHandler = (err, req, res, next) => {
-    console.log(err);
-    if (err instanceof normalized_error_1.NormalizedError) {
-        return res.status(err.status).send(err.serializeErrors());
+    if (err instanceof custom_error_1.default) {
+        return res.status(err.status).send(err.serializeError());
     }
+    console.error(err);
     return res.status(400).send('Something went wrong');
 };
 exports.errorHandler = errorHandler;

package/build/middlewares/validate-request.js

@@ -7,14 +7,9 @@ exports.validateRequest = void 0;
 const express_validator_1 = require("express-validator");
 const validation_error_1 = __importDefault(require("../errors/validation-error"));
 const validateRequest = (req, res, next) => {
-    const error = (0, express_validator_1.validationResult)(req);
-    if (!error.isEmpty()) {
-        const errors = error.array();
-        const cleanedErrors = errors.map((err) => ({
-            path: err.path.split("."),
-            message: err.msg
-        }));
-        return next(new validation_error_1.default(cleanedErrors));
+    const errors = (0, express_validator_1.validationResult)(req);
+    if (!errors.isEmpty()) {
+        return next(new validation_error_1.default(errors.array()));
     }
     next();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sn1006/common",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -26,8 +26,7 @@
     "cookie-session": "^2.0.0",
     "express": "^4.18.2",
     "express-validator": "^7.0.1",
-    "joi": "^17.12.1",
     "jsonwebtoken": "^9.0.1",
-    "zod": "^3.22.4"
+    "node-nats-streaming": "^0.3.2"
   }
 }

package/build/errors/normalized-error.d.ts

@@ -1,9 +0,0 @@
-export declare abstract class NormalizedError extends Error {
-    abstract status: number;
-    constructor(message: string);
-    abstract serializeErrors(): SerializedError[];
-}
-export interface SerializedError {
-    message: string;
-    path?: (string | number)[];
-}

package/build/errors/normalized-error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NormalizedError = void 0;
-// the purpose of this class is to "normalize" errors between services
-class NormalizedError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, NormalizedError.prototype);
-    }
-}
-exports.NormalizedError = NormalizedError;

package/build/middlewares/async-wrapper.d.ts

@@ -1,3 +0,0 @@
-import { NextFunction, Request, Response } from "express";
-declare const asyncWrapper: (asyncMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<any>) => (req: Request, res: Response, next: NextFunction) => Promise<any>;
-export { asyncWrapper };

package/build/middlewares/async-wrapper.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncWrapper = void 0;
-const asyncWrapper = (asyncMiddleware) => {
-    return (req, res, next) => asyncMiddleware(req, res, next).catch(err => next(err));
-};
-exports.asyncWrapper = asyncWrapper;

package/build/middlewares/joi-validate-request.d.ts

@@ -1,4 +0,0 @@
-import { NextFunction, Request, Response } from "express";
-import Joi from "joi";
-declare function joiValidateRequest(schema: Joi.AnySchema, options?: Joi.ValidationOptions): (req: Request, res: Response, next: NextFunction) => any;
-export { joiValidateRequest };

package/build/middlewares/joi-validate-request.js

@@ -1,24 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.joiValidateRequest = void 0;
-const validation_error_1 = __importDefault(require("../errors/validation-error"));
-function joiValidateRequest(schema, options) {
-    return (req, res, next) => {
-        const { error } = schema.validate(req, options);
-        if (error) {
-            // normalized the error to be similar to express-validator error
-            // const errors = error.details.map((err) => ({
-            //   ...err,
-            //   msg: err.message,
-            //   path: err.path.join("."),
-            // }));
-            const errors = error.details;
-            return next(new validation_error_1.default(errors));
-        }
-        return next();
-    };
-}
-exports.joiValidateRequest = joiValidateRequest;

package/build/middlewares/zod-validate-request.d.ts

@@ -1,4 +0,0 @@
-import { NextFunction, Request, Response } from "express";
-import { ZodSchema } from "zod";
-declare function zodValidateRequest(schema: ZodSchema): (req: Request, res: Response, next: NextFunction) => Promise<void>;
-export { zodValidateRequest };

package/build/middlewares/zod-validate-request.js

@@ -1,27 +0,0 @@
-"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.zodValidateRequest = void 0;
-const validation_error_1 = __importDefault(require("../errors/validation-error"));
-function zodValidateRequest(schema) {
-    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-        const result = schema.safeParse(req.body);
-        if (!result.success) {
-            const errors = result.error.issues;
-            return next(new validation_error_1.default(errors));
-        }
-        return next();
-    });
-}
-exports.zodValidateRequest = zodValidateRequest;