@autofleet/shtinker 0.0.1 → 0.0.3

package/dist/audit-logger.d.ts

@@ -0,0 +1,9 @@
+import { AuditLoggerOptions, AuditLogContext } from './types';
+declare class AuditLogger {
+    private rabbit;
+    private sequelize;
+    constructor(options: AuditLoggerOptions);
+    addModelHooks(): void;
+    sendAuditLog(context: AuditLogContext): Promise<void>;
+}
+export default AuditLogger;

package/dist/audit-logger.js

@@ -0,0 +1,51 @@
+"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 });
+const zehut_1 = require("@autofleet/zehut");
+const const_1 = require("./const");
+const getAuditContext = () => {
+    var _a;
+    const currentTrace = (0, zehut_1.getCurrentPayload)();
+    const auditContext = (_a = currentTrace === null || currentTrace === void 0 ? void 0 : currentTrace.context) === null || _a === void 0 ? void 0 : _a.get(const_1.AUDIT_LOG_CONTEXT_KEY);
+    return auditContext;
+};
+class AuditLogger {
+    constructor(options) {
+        this.rabbit = options.rabbit;
+        this.sequelize = options.sequelize;
+    }
+    addModelHooks() {
+        Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
+            modelType.addHook('afterSave', (instance) => __awaiter(this, void 0, void 0, function* () {
+                const auditContext = getAuditContext();
+                if (auditContext) {
+                    const changedProperties = instance.changed();
+                    const payload = {
+                        entityType: modelName,
+                        entityId: instance.id,
+                        rows: changedProperties.map((property) => ({
+                            property,
+                            previousValue: instance.previousValue(property),
+                            newValue: instance.get(property),
+                        })),
+                    };
+                    yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_ROWS_QUEUE, payload);
+                }
+            }));
+        });
+    }
+    sendAuditLog(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_CONTEXT_QUEUE, context);
+        });
+    }
+}
+exports.default = AuditLogger;

package/dist/index.d.ts

@@ -1,9 +1,5 @@
+import AuditLogger from './audit-logger';
 import { AuditLoggerOptions } from './types';
-declare class AuditLogger {
-    private rabbit;
-    private sequelize;
-    constructor(options: AuditLoggerOptions);
-    enableAuditLogging(): void;
-    setAuditingContext: (entityType: string, entityId: string, action: string) => (req: any, res: any, next: any) => Promise<void>;
-}
+export declare const enableAuditing: (options: AuditLoggerOptions) => void;
+export declare const setAuditContext: (entityType: string, entityId: string, action: string) => (req: any, res: any, next: any) => Promise<any>;
 export default AuditLogger;

package/dist/index.js

@@ -8,56 +8,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.setAuditContext = exports.enableAuditing = void 0;
 const zehut_1 = require("@autofleet/zehut");
+const audit_logger_1 = __importDefault(require("./audit-logger"));
 const const_1 = require("./const");
-const getAuditingContext = () => {
-    var _a;
-    const currentTrace = (0, zehut_1.getCurrentPayload)();
-    const auditingContext = (_a = currentTrace === null || currentTrace === void 0 ? void 0 : currentTrace.context) === null || _a === void 0 ? void 0 : _a.get(const_1.AUDIT_LOG_CONTEXT_KEY);
-    return auditingContext;
+let auditLogger;
+const enableAuditing = (options) => {
+    auditLogger = new audit_logger_1.default(options);
+    auditLogger.addModelHooks();
 };
-class AuditLogger {
-    constructor(options) {
-        this.setAuditingContext = (entityType, entityId, action) => (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            const currentTrace = (0, zehut_1.getCurrentPayload)();
-            if (currentTrace) {
-                const user = currentTrace.context.get('userObject');
-                const auditLogContext = {
-                    entityType,
-                    entityId,
-                    action,
-                    endpoint: req.url,
-                    method: req.method,
-                    performedBy: user.id,
-                };
-                currentTrace.context.set(const_1.AUDIT_LOG_CONTEXT_KEY, auditLogContext);
-                yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_CONTEXT_QUEUE, auditLogContext);
-                next();
-            }
-        });
-        this.rabbit = options.rabbit;
-        this.sequelize = options.sequelize;
-    }
-    enableAuditLogging() {
-        Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
-            modelType.addHook('afterSave', (instance) => __awaiter(this, void 0, void 0, function* () {
-                const auditingContext = getAuditingContext();
-                if (auditingContext) {
-                    const changedProperties = instance.changed();
-                    const payload = {
-                        entityType: modelName,
-                        entityId: instance.id,
-                        rows: changedProperties.map((property) => ({
-                            property,
-                            previousValue: instance.previousValue(property),
-                            newValue: instance.get(property),
-                        })),
-                    };
-                    yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_ROWS_QUEUE, payload);
-                }
-            }));
-        });
+exports.enableAuditing = enableAuditing;
+const setAuditContext = (entityType, entityId, action) => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const currentTrace = (0, zehut_1.getCurrentPayload)();
+    if (currentTrace) {
+        const user = currentTrace.context.get('userObject');
+        const auditLogContext = {
+            entityType,
+            entityId,
+            action,
+            endpoint: req.url,
+            method: req.method,
+            performedBy: user.id,
+        };
+        currentTrace.context.set(const_1.AUDIT_LOG_CONTEXT_KEY, auditLogContext);
+        yield auditLogger.sendAuditLog(auditLogContext);
     }
-}
-exports.default = AuditLogger;
+    return next();
+});
+exports.setAuditContext = setAuditContext;
+exports.default = audit_logger_1.default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/shtinker",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/audit-logger.ts

@@ -0,0 +1,47 @@
+import { getCurrentPayload as getCurrentTrace } from '@autofleet/zehut';
+import { AuditLogPayload, AuditLoggerOptions, AuditLogContext } from './types';
+import { AUDIT_LOG_CONTEXT_QUEUE, AUDIT_LOG_ROWS_QUEUE, AUDIT_LOG_CONTEXT_KEY } from './const';
+
+const getAuditContext = () => {
+  const currentTrace = getCurrentTrace();
+  const auditContext = currentTrace?.context?.get(AUDIT_LOG_CONTEXT_KEY);
+  return auditContext;
+};
+
+class AuditLogger {
+  private rabbit;
+
+  private sequelize;
+
+  constructor(options: AuditLoggerOptions) {
+    this.rabbit = options.rabbit;
+    this.sequelize = options.sequelize;
+  }
+
+  addModelHooks(): void {
+    Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
+      modelType.addHook('afterSave', async (instance: any) => {
+        const auditContext = getAuditContext();
+        if (auditContext) {
+          const changedProperties = instance.changed();
+          const payload: AuditLogPayload = {
+            entityType: modelName,
+            entityId: instance.id,
+            rows: changedProperties.map((property: string) => ({
+              property,
+              previousValue: instance.previousValue(property),
+              newValue: instance.get(property),
+            })),
+          };
+          await this.rabbit.sendToQueue(AUDIT_LOG_ROWS_QUEUE, payload);
+        }
+      });
+    });
+  }
+
+  async sendAuditLog(context: AuditLogContext): Promise<void> {
+    await this.rabbit.sendToQueue(AUDIT_LOG_CONTEXT_QUEUE, context);
+  }
+}
+
+export default AuditLogger;

package/src/index.ts

@@ -1,61 +1,35 @@
 import { getCurrentPayload as getCurrentTrace } from '@autofleet/zehut';
-import { AuditLogPayload, AuditLoggerOptions, AuditLogContext } from './types';
-import { AUDIT_LOG_CONTEXT_QUEUE, AUDIT_LOG_ROWS_QUEUE, AUDIT_LOG_CONTEXT_KEY } from './const';
+import AuditLogger from './audit-logger';
+import { AuditLogContext, AuditLoggerOptions } from './types';
+import { AUDIT_LOG_CONTEXT_KEY } from './const';
 
-const getAuditingContext = () => {
-  const currentTrace = getCurrentTrace();
-  const auditingContext = currentTrace?.context?.get(AUDIT_LOG_CONTEXT_KEY);
-  return auditingContext;
-};
-
-class AuditLogger {
-  private rabbit;
-
-  private sequelize;
-
-  constructor(options: AuditLoggerOptions) {
-    this.rabbit = options.rabbit;
-    this.sequelize = options.sequelize;
-  }
+let auditLogger: AuditLogger;
 
-  enableAuditLogging(): void {
-    Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
-      modelType.addHook('afterSave', async (instance: any) => {
-        const auditingContext = getAuditingContext();
-        if (auditingContext) {
-          const changedProperties = instance.changed();
-          const payload: AuditLogPayload = {
-            entityType: modelName,
-            entityId: instance.id,
-            rows: changedProperties.map((property: string) => ({
-              property,
-              previousValue: instance.previousValue(property),
-              newValue: instance.get(property),
-            })),
-          };
-          await this.rabbit.sendToQueue(AUDIT_LOG_ROWS_QUEUE, payload);
-        }
-      });
-    });
-  }
+export const enableAuditing = (options: AuditLoggerOptions) => {
+  auditLogger = new AuditLogger(options);
+  auditLogger.addModelHooks();
+};
 
-  setAuditingContext = (entityType: string, entityId: string, action: string) => async (req: any, res: any, next: any) => {
-    const currentTrace = getCurrentTrace();
-    if (currentTrace) {
-      const user = currentTrace.context.get('userObject');
-      const auditLogContext: AuditLogContext = {
-        entityType,
-        entityId,
-        action,
-        endpoint: req.url,
-        method: req.method,
-        performedBy: user.id,
-      };
-      currentTrace.context.set(AUDIT_LOG_CONTEXT_KEY, auditLogContext);
-      await this.rabbit.sendToQueue(AUDIT_LOG_CONTEXT_QUEUE, auditLogContext);
-      next();
-    }
+export const setAuditContext = (
+  entityType: string,
+  entityId: string,
+  action: string,
+) => async (req: any, res: any, next: any): Promise<any> => {
+  const currentTrace = getCurrentTrace();
+  if (currentTrace) {
+    const user = currentTrace.context.get('userObject');
+    const auditLogContext: AuditLogContext = {
+      entityType,
+      entityId,
+      action,
+      endpoint: req.url,
+      method: req.method,
+      performedBy: user.id,
+    };
+    currentTrace.context.set(AUDIT_LOG_CONTEXT_KEY, auditLogContext);
+    await auditLogger.sendAuditLog(auditLogContext);
   }
-}
+  return next();
+};
 
 export default AuditLogger;