@autofleet/shtinker 0.0.7 → 0.0.9-beta-1

package/dist/jest.config.d.ts

@@ -0,0 +1,12 @@
+export const testEnvironment: string;
+export const roots: string[];
+export const transform: {
+    '^.+\\.tsx?$': string;
+};
+export const testRegex: string;
+export const moduleFileExtensions: string[];
+export namespace coverageThreshold {
+    namespace global {
+        const lines: number;
+    }
+}

package/dist/src/audit-api.d.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+declare const _default: ({ router, entiyScopedModelMap, }: {
+    router: Router;
+    entiyScopedModelMap: Array<any>;
+}) => Promise<void>;
+export default _default;

package/dist/src/audit-api.js

@@ -0,0 +1,38 @@
+"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 });
+const errors_1 = require("@autofleet/errors");
+const logger_1 = __importDefault(require("./logger"));
+const audit_ms_1 = __importDefault(require("./audit-ms"));
+exports.default = ({ router, entiyScopedModelMap, }) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.default.info('*** SEPHI got here', { entiyScopedModelMap });
+    if (entiyScopedModelMap) {
+        Object.entries(entiyScopedModelMap).forEach(([entity, ScopedModel]) => {
+            router.get(`${entity}/:id/audit`, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+                try {
+                    const { id } = req.params;
+                    const entityData = yield ScopedModel.findByPk(id);
+                    if (!entityData) {
+                        return (0, errors_1.handleError)(new errors_1.ResourceNotFoundError(), res);
+                    }
+                    const auditData = audit_ms_1.default.getByEntityId(id);
+                    return res.json(auditData);
+                }
+                catch (err) {
+                    return (0, errors_1.handleError)(new errors_1.UnexpectedError(err), res);
+                }
+            }));
+        });
+    }
+});

package/dist/src/audit-logger.d.ts

@@ -0,0 +1,11 @@
+import { AuditLogPayload, AuditLoggerOptions, AuditLogContext } from './types';
+declare class AuditLogger {
+    private rabbit;
+    private sequelize;
+    private logger;
+    constructor(options: AuditLoggerOptions);
+    registerHooks(): void;
+    sendAuditLogContext(context: AuditLogContext): Promise<void>;
+    sendAuditLogRows(payload: AuditLogPayload): Promise<void>;
+}
+export default AuditLogger;

package/dist/{audit-logger.js → src/audit-logger.js}

@@ -8,25 +8,33 @@ 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 });
 const zehut_1 = require("@autofleet/zehut");
 const const_1 = require("./const");
+const logger_1 = __importDefault(require("./logger"));
 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);
+    logger_1.default.info('*** SEPHI getAuditContext', { currentTrace, auditContext });
     return auditContext;
 };
 class AuditLogger {
     constructor(options) {
         this.rabbit = options.rabbit;
         this.sequelize = options.sequelize;
+        this.logger = options.logger;
     }
-    addModelHooks() {
+    registerHooks() {
         Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
             modelType.addHook('afterSave', (instance) => __awaiter(this, void 0, void 0, function* () {
                 const auditContext = getAuditContext();
+                logger_1.default.info('*** SEPHI after save', { instance, auditContext });
                 if (auditContext) {
+                    logger_1.default.info('*** SEPHI after save got context', { instance, auditContext });
                     const changedProperties = instance.changed();
                     const payload = {
                         entityType: modelName,
@@ -37,14 +45,32 @@ class AuditLogger {
                             newValue: instance.get(property),
                         })),
                     };
-                    yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_ROWS_QUEUE, payload);
+                    logger_1.default.info('*** SEPHI after save got context payload', { payload, changedProperties });
+                    this.sendAuditLogRows(payload);
                 }
             }));
         });
     }
-    sendAuditLog(context) {
+    sendAuditLogContext(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info('*** SEPHI sendAuditLogContext', { context });
+            try {
+                yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_CONTEXT_QUEUE, context);
+            }
+            catch (err) {
+                logger_1.default.error('Failed to send audit log context', err);
+            }
+        });
+    }
+    sendAuditLogRows(payload) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_CONTEXT_QUEUE, context);
+            logger_1.default.info('*** SEPHI sendAuditLogRows', { payload });
+            try {
+                yield this.rabbit.sendToQueue(const_1.AUDIT_LOG_ROWS_QUEUE, payload);
+            }
+            catch (err) {
+                logger_1.default.error('Failed to send audit log rows', err);
+            }
         });
     }
 }

package/dist/src/audit-ms.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    getByEntityId: (entityId: string) => any;
+};
+export default _default;

package/dist/src/audit-ms.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Network = __importStar(require("@autofleet/network"));
+const auditMs = new Network({ serviceName: 'AUDIT_MS', timeout: 1000 * 60 });
+const getByEntityId = (entityId) => {
+    const { data } = auditMs.get(`api/v1/audit-logs/${entityId}`);
+    return data;
+};
+exports.default = {
+    getByEntityId,
+};

package/dist/{const.d.ts → src/const.d.ts}

@@ -1,3 +1,4 @@
 export declare const AUDIT_LOG_CONTEXT_QUEUE = "audit-log-context";
 export declare const AUDIT_LOG_ROWS_QUEUE = "audit-log-rows";
 export declare const AUDIT_LOG_CONTEXT_KEY = "auditLogContext";
+export declare const USER_CONTEXT_KEY = "userObject";

package/dist/{const.js → src/const.js}

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUDIT_LOG_CONTEXT_KEY = exports.AUDIT_LOG_ROWS_QUEUE = exports.AUDIT_LOG_CONTEXT_QUEUE = void 0;
+exports.USER_CONTEXT_KEY = exports.AUDIT_LOG_CONTEXT_KEY = exports.AUDIT_LOG_ROWS_QUEUE = exports.AUDIT_LOG_CONTEXT_QUEUE = void 0;
 exports.AUDIT_LOG_CONTEXT_QUEUE = 'audit-log-context';
 exports.AUDIT_LOG_ROWS_QUEUE = 'audit-log-rows';
 exports.AUDIT_LOG_CONTEXT_KEY = 'auditLogContext';
+exports.USER_CONTEXT_KEY = 'userObject';

package/dist/{index.d.ts → src/index.d.ts}

@@ -1,7 +1,7 @@
 import AuditLogger from './audit-logger';
 import { AuditLoggerOptions } from './types';
 export declare const enableAuditing: (options: AuditLoggerOptions) => void;
-export declare const setAuditContext: (entityType: string, entityIdFetcher: (req: any) => any, action: string) => (req: any, res: any, next: any) => Promise<any>;
+export declare const setAuditContext: (entityType: string, entityId: string, action: string) => (req: any, res: any, next: any) => Promise<any>;
 export * from './types';
 export * from './const';
 export default AuditLogger;

package/dist/{index.js → src/index.js}

@@ -30,26 +30,40 @@ 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 audit_api_1 = __importDefault(require("./audit-api"));
+const logger_1 = __importDefault(require("./logger"));
 let auditLogger;
+// export let getCurrentTrace: () => any;
 const enableAuditing = (options) => {
     auditLogger = new audit_logger_1.default(options);
-    auditLogger.addModelHooks();
+    // getCurrentTrace = options.getCurrentTrace;
+    (0, audit_api_1.default)(options);
+    auditLogger.registerHooks();
 };
 exports.enableAuditing = enableAuditing;
-const setAuditContext = (entityType, entityIdFetcher, action) => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+const setAuditContext = (entityType, entityId, action) => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     const currentTrace = (0, zehut_1.getCurrentPayload)();
+    logger_1.default.info('*** SEPHI current trace', { currentTrace });
     if (currentTrace) {
-        const user = currentTrace.context.get('userObject');
-        const auditLogContext = {
-            entityType,
-            entityId: entityIdFetcher(req),
-            action,
-            endpoint: req.url,
-            method: req.method,
-            performedBy: user.id,
-        };
-        currentTrace.context.set(const_1.AUDIT_LOG_CONTEXT_KEY, auditLogContext);
-        yield auditLogger.sendAuditLog(auditLogContext);
+        try {
+            logger_1.default.info('*** SEPHI entered if');
+            const user = currentTrace.context.get(const_1.USER_CONTEXT_KEY);
+            logger_1.default.info('*** SEPHI user', { user });
+            const auditLogContext = {
+                entityType,
+                entityId,
+                action,
+                endpoint: req.url,
+                method: req.method,
+                performedBy: user.id,
+            };
+            logger_1.default.info('*** SEPHI auditLogContext', { auditLogContext });
+            currentTrace.context.set(const_1.AUDIT_LOG_CONTEXT_KEY, auditLogContext);
+            yield auditLogger.sendAuditLogContext(auditLogContext);
+        }
+        catch (err) {
+            logger_1.default.error('*** SEPHI something wrong with trace', err);
+        }
     }
     return next();
 });

package/dist/src/logger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("winston").Logger;
+export default _default;

package/dist/src/logger.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@autofleet/logger"));
+exports.default = (0, logger_1.default)(null);

package/dist/{types.d.ts → src/types.d.ts}

@@ -3,6 +3,8 @@ import RabbitMq from '@autofleet/rabbit';
 export type AuditLoggerOptions = {
     rabbit: RabbitMq;
     sequelize: Sequelize;
+    getCurrentTrace: () => any;
+    logger: any;
 };
 export interface AuditLogContext {
     entityType: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/shtinker",
-  "version": "0.0.7",
+  "version": "0.0.9-beta-1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -12,14 +12,18 @@
     "dev": "nodemon"
   },
   "dependencies": {
+    "@autofleet/errors": "^1.2.2",
     "@autofleet/logger": "^2.0.5",
+    "@autofleet/network": "^1.4.7",
     "@autofleet/rabbit": "^2.4.1",
     "@autofleet/zehut": "^2.0.4",
     "sequelize-typescript": "^2.1.5"
   },
   "devDependencies": {
+    "@types/express": "^4.17.17",
     "@types/jest": "^27.0.9",
     "@types/node": "^18.11.19",
+    "@types/sequelize": "^4.28.14",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "eslint": "^7.13.0",
     "eslint-config-airbnb-typescript": "^12.0.0",

package/src/audit-api.ts

@@ -0,0 +1,32 @@
+import { Router } from 'express';
+import { handleError, ResourceNotFoundError, UnexpectedError } from '@autofleet/errors';
+import logger from './logger';
+
+import auditMs from './audit-ms';
+
+export default async ({
+  router,
+  entiyScopedModelMap,
+} : {
+  router: Router,
+  entiyScopedModelMap: Array<any>,
+}): Promise<void> => {
+  logger.info('*** SEPHI got here', { entiyScopedModelMap });
+  if (entiyScopedModelMap) {
+    Object.entries(entiyScopedModelMap).forEach(([entity, ScopedModel]) => {
+      router.get(`${entity}/:id/audit`, async (req, res) => {
+        try {
+          const { id } = req.params;
+          const entityData = await ScopedModel.findByPk(id);
+          if (!entityData) {
+            return handleError(new ResourceNotFoundError(), res);
+          }
+          const auditData = auditMs.getByEntityId(id);
+          return res.json(auditData);
+        } catch (err) {
+          return handleError(new UnexpectedError(err as Error), res);
+        }
+      });
+    });
+  }
+};

package/src/audit-logger.ts

@@ -1,10 +1,14 @@
 import { getCurrentPayload as getCurrentTrace } from '@autofleet/zehut';
+// import { getCurrentTrace } from './index';
 import { AuditLogPayload, AuditLoggerOptions, AuditLogContext } from './types';
 import { AUDIT_LOG_CONTEXT_QUEUE, AUDIT_LOG_ROWS_QUEUE, AUDIT_LOG_CONTEXT_KEY } from './const';
 
+import logger from './logger';
+
 const getAuditContext = () => {
   const currentTrace = getCurrentTrace();
   const auditContext = currentTrace?.context?.get(AUDIT_LOG_CONTEXT_KEY);
+  logger.info('*** SEPHI getAuditContext', { currentTrace, auditContext });
   return auditContext;
 };
 
@@ -13,16 +17,21 @@ class AuditLogger {
 
   private sequelize;
 
+  private logger;
+
   constructor(options: AuditLoggerOptions) {
     this.rabbit = options.rabbit;
     this.sequelize = options.sequelize;
+    this.logger = options.logger;
   }
 
-  addModelHooks(): void {
+  registerHooks(): void {
     Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
-      modelType.addHook('afterSave', async (instance: any) => {
+      (modelType as any).addHook('afterSave', async (instance: any) => {
         const auditContext = getAuditContext();
+        logger.info('*** SEPHI after save', { instance, auditContext });
         if (auditContext) {
+          logger.info('*** SEPHI after save got context', { instance, auditContext });
           const changedProperties = instance.changed();
           const payload: AuditLogPayload = {
             entityType: modelName,
@@ -33,14 +42,29 @@ class AuditLogger {
               newValue: instance.get(property),
             })),
           };
-          await this.rabbit.sendToQueue(AUDIT_LOG_ROWS_QUEUE, payload);
+          logger.info('*** SEPHI after save got context payload', { payload, changedProperties });
+          this.sendAuditLogRows(payload);
         }
       });
     });
   }
 
-  async sendAuditLog(context: AuditLogContext): Promise<void> {
-    await this.rabbit.sendToQueue(AUDIT_LOG_CONTEXT_QUEUE, context);
+  async sendAuditLogContext(context: AuditLogContext): Promise<void> {
+    logger.info('*** SEPHI sendAuditLogContext', { context });
+    try {
+      await this.rabbit.sendToQueue(AUDIT_LOG_CONTEXT_QUEUE, context);
+    } catch (err) {
+      logger.error('Failed to send audit log context', err);
+    }
+  }
+
+  async sendAuditLogRows(payload: AuditLogPayload): Promise<void> {
+    logger.info('*** SEPHI sendAuditLogRows', { payload });
+    try {
+      await this.rabbit.sendToQueue(AUDIT_LOG_ROWS_QUEUE, payload);
+    } catch (err) {
+      logger.error('Failed to send audit log rows', err);
+    }
   }
 }
 

package/src/audit-ms.ts

@@ -0,0 +1,12 @@
+import * as Network from '@autofleet/network';
+
+const auditMs = new Network({ serviceName: 'AUDIT_MS', timeout: 1000 * 60 });
+
+const getByEntityId = (entityId: string) => {
+  const { data } = auditMs.get(`api/v1/audit-logs/${entityId}`);
+  return data;
+};
+
+export default {
+  getByEntityId,
+};

package/src/const.ts

@@ -1,3 +1,4 @@
 export const AUDIT_LOG_CONTEXT_QUEUE = 'audit-log-context';
 export const AUDIT_LOG_ROWS_QUEUE = 'audit-log-rows';
 export const AUDIT_LOG_CONTEXT_KEY = 'auditLogContext';
+export const USER_CONTEXT_KEY = 'userObject';

package/src/index.ts

@@ -1,33 +1,48 @@
 import { getCurrentPayload as getCurrentTrace } from '@autofleet/zehut';
 import AuditLogger from './audit-logger';
 import { AuditLogContext, AuditLoggerOptions } from './types';
-import { AUDIT_LOG_CONTEXT_KEY } from './const';
+import { AUDIT_LOG_CONTEXT_KEY, USER_CONTEXT_KEY } from './const';
+import addAuditApi from './audit-api';
+
+import logger from './logger';
 
 let auditLogger: AuditLogger;
 
+// export let getCurrentTrace: () => any;
+
 export const enableAuditing = (options: AuditLoggerOptions) => {
   auditLogger = new AuditLogger(options);
-  auditLogger.addModelHooks();
+  // getCurrentTrace = options.getCurrentTrace;
+  addAuditApi(options as any);
+  auditLogger.registerHooks();
 };
 
 export const setAuditContext = (
   entityType: string,
-  entityIdFetcher: (req: any) => any,
+  entityId: string,
   action: string,
 ) => async (req: any, res: any, next: any): Promise<any> => {
   const currentTrace = getCurrentTrace();
+  logger.info('*** SEPHI current trace', { currentTrace });
   if (currentTrace) {
-    const user = currentTrace.context.get('userObject');
-    const auditLogContext: AuditLogContext = {
-      entityType,
-      entityId: entityIdFetcher(req),
-      action,
-      endpoint: req.url,
-      method: req.method,
-      performedBy: user.id,
-    };
-    currentTrace.context.set(AUDIT_LOG_CONTEXT_KEY, auditLogContext);
-    await auditLogger.sendAuditLog(auditLogContext);
+    try {
+      logger.info('*** SEPHI entered if');
+      const user = currentTrace.context.get(USER_CONTEXT_KEY);
+      logger.info('*** SEPHI user', { user });
+      const auditLogContext: AuditLogContext = {
+        entityType,
+        entityId,
+        action,
+        endpoint: req.url,
+        method: req.method,
+        performedBy: user.id,
+      };
+      logger.info('*** SEPHI auditLogContext', { auditLogContext });
+      currentTrace.context.set(AUDIT_LOG_CONTEXT_KEY, auditLogContext);
+      await auditLogger.sendAuditLogContext(auditLogContext);
+    } catch (err) {
+      logger.error('*** SEPHI something wrong with trace', err);
+    }
   }
   return next();
 };

package/src/logger.ts

@@ -0,0 +1,3 @@
+import Logger from '@autofleet/logger';
+
+export default Logger(null);

package/src/types.ts

@@ -1,9 +1,12 @@
 import { Sequelize } from 'sequelize-typescript';
 import RabbitMq from '@autofleet/rabbit';
+import { getCurrentTrace } from '@autofleet/zehut/lib/tracer';
 
 export type AuditLoggerOptions = {
   rabbit: RabbitMq;
   sequelize: Sequelize;
+  getCurrentTrace: () => any,
+  logger: any;
 };
 
 export interface AuditLogContext {
@@ -14,6 +17,7 @@ export interface AuditLogContext {
   endpoint: string;
   method: string;
 }
+
 export interface AuditLogRow {
   property: string;
   previousValue: any;

package/tsconfig.json

@@ -4,10 +4,16 @@
     "module": "commonjs",
     "declaration": true,
     "outDir": "./dist",
-    "strict": true,
     "esModuleInterop": true,
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "allowJs": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": [
+          "node_modules/*"
+      ]
+    }
   },
-  "exclude": ["node_modules", "**/*.test.ts"]
+  "exclude": ["node_modules", "**/*.test.ts", "dist"]
 }

package/dist/audit-logger.d.ts

@@ -1,9 +0,0 @@
-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;