@autofleet/shtinker 1.1.7-beta2 → 1.1.7-beta4

package/dist/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/audit-api.js

@@ -0,0 +1,36 @@
+"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 audit_ms_1 = __importDefault(require("./audit-ms"));
+exports.default = ({ router, entiyScopedModelMap, }) => __awaiter(void 0, void 0, void 0, function* () {
+    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/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

@@ -0,0 +1,122 @@
+"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 zehut_1 = require("@autofleet/zehut");
+const const_1 = require("./const");
+const object_diff_1 = __importDefault(require("object-diff"));
+const logger_1 = __importDefault(require("./logger"));
+const CUSTOM_FIELDS_PROPERTY = 'customFields';
+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;
+};
+const isEmpty = (field) => {
+    if ([null, undefined].includes(field)) {
+        return true;
+    }
+    if (Array.isArray(field)) {
+        return field.length === 0;
+    }
+    if (typeof field === 'object' && !(field instanceof Date)) {
+        return Object.keys(field).length === 0;
+    }
+    return false;
+};
+const filterOutEmptyFields = (fields, instance) => fields.filter((field) => !isEmpty(instance.get(field)) || !isEmpty(instance.previous(field)));
+const getChangedFields = (instance, options) => {
+    // When bulk updating in sequelize using the "returning" option, the instance.changed() stops working.
+    // It's a known issut with sequelize.
+    const changedFields = options.returning ? options.fields : instance.changed();
+    //Filter customFields - we'll handle them later
+    const filteredChangedProperties = changedFields.filter(p => p !== CUSTOM_FIELDS_PROPERTY);
+    return filterOutEmptyFields(filteredChangedProperties, instance);
+};
+const getChangedFieldsRows = (instance, changedFields) => changedFields.map((property) => ({
+    property,
+    previousValue: instance.previous(property),
+    newValue: instance.get(property),
+}));
+const getChangedCustomFields = (instance) => {
+    const customFieldsChanged = instance.changed().includes(CUSTOM_FIELDS_PROPERTY);
+    if (!customFieldsChanged) {
+        return [];
+    }
+    const customFieldsValues = instance.get(CUSTOM_FIELDS_PROPERTY);
+    const previousCustomFieldsValues = instance.previous(CUSTOM_FIELDS_PROPERTY);
+    const diffObj = previousCustomFieldsValues && customFieldsValues ? (0, object_diff_1.default)(previousCustomFieldsValues, customFieldsValues) : customFieldsValues || previousCustomFieldsValues;
+    return Object.keys(diffObj).filter((field) => !isEmpty(customFieldsValues === null || customFieldsValues === void 0 ? void 0 : customFieldsValues[field]) || !isEmpty(previousCustomFieldsValues === null || previousCustomFieldsValues === void 0 ? void 0 : previousCustomFieldsValues[field]));
+};
+const getChangedCustomFieldsRows = (instance, changedCustomFields) => {
+    const customFieldsValues = instance.get(CUSTOM_FIELDS_PROPERTY);
+    const previousCustomFieldsValues = instance.previous(CUSTOM_FIELDS_PROPERTY);
+    return changedCustomFields.map((changedCustomField) => ({
+        property: `customFields.${changedCustomField}`,
+        previousValue: previousCustomFieldsValues === null || previousCustomFieldsValues === void 0 ? void 0 : previousCustomFieldsValues[changedCustomField],
+        newValue: customFieldsValues === null || customFieldsValues === void 0 ? void 0 : customFieldsValues[changedCustomField],
+    }));
+};
+class AuditLogger {
+    constructor(options) {
+        this.rabbit = options.rabbit;
+        this.sequelize = options.sequelize;
+        this.logger = options.logger;
+    }
+    registerHooks() {
+        Object.entries(this.sequelize.models).forEach(([modelName, modelType]) => {
+            modelType.addHook('afterSave', (instance, options) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const auditContext = getAuditContext();
+                    if (auditContext) {
+                        const changedFields = getChangedFields(instance, options);
+                        const changedFieldsRows = getChangedFieldsRows(instance, changedFields);
+                        const changedCustomFields = getChangedCustomFields(instance);
+                        const changedCustomFieldsRows = getChangedCustomFieldsRows(instance, changedCustomFields);
+                        const payload = {
+                            entityType: modelName,
+                            entityId: instance.id,
+                            rows: [...changedFieldsRows, ...changedCustomFieldsRows],
+                        };
+                        this.sendAuditLogRows(payload);
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error('Failed to send audit log rows', error);
+                }
+            }));
+        });
+    }
+    sendAuditLogContext(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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* () {
+            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);
+            }
+        });
+    }
+}
+exports.default = AuditLogger;

package/dist/audit-ms.d.ts

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

package/dist/audit-ms.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const network_1 = __importDefault(require("@autofleet/network"));
+const auditMs = new network_1.default({ 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

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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

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

package/dist/index.js

@@ -0,0 +1,83 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.setRabbitAuditContext = 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;
+const enableAuditing = (options) => {
+    auditLogger = new audit_logger_1.default(options);
+    (0, audit_api_1.default)(options);
+    auditLogger.registerHooks();
+};
+exports.enableAuditing = enableAuditing;
+const setAuditContext = (entityType, action) => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const currentTrace = (0, zehut_1.getCurrentPayload)();
+        if (currentTrace && currentTrace.context && currentTrace.context.get) {
+            const user = currentTrace.context.get(const_1.USER_CONTEXT_KEY);
+            const auditLogContext = {
+                entityType,
+                action,
+                endpoint: req.url,
+                method: req.method,
+                performedBy: user === null || user === void 0 ? void 0 : user.id,
+            };
+            currentTrace.context.set(const_1.AUDIT_LOG_CONTEXT_KEY, auditLogContext);
+            yield auditLogger.sendAuditLogContext(auditLogContext);
+        }
+    }
+    catch (err) {
+        logger_1.default.error('coudln\'t set audit context', err);
+    }
+    return next();
+});
+exports.setAuditContext = setAuditContext;
+const setRabbitAuditContext = (entityType, action) => (endpoint) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const currentTrace = (0, zehut_1.getCurrentPayload)();
+    if ((_a = currentTrace === null || currentTrace === void 0 ? void 0 : currentTrace.context) === null || _a === void 0 ? void 0 : _a.get) {
+        const user = currentTrace.context.get(const_1.USER_CONTEXT_KEY);
+        const auditLogContext = {
+            entityType,
+            action,
+            endpoint,
+            method: 'rabbit',
+            performedBy: user === null || user === void 0 ? void 0 : user.id,
+        };
+        currentTrace.context.set(const_1.AUDIT_LOG_CONTEXT_KEY, auditLogContext);
+        yield auditLogger.sendAuditLogContext(auditLogContext);
+    }
+});
+exports.setRabbitAuditContext = setRabbitAuditContext;
+__exportStar(require("./types"), exports);
+__exportStar(require("./const"), exports);
+exports.default = audit_logger_1.default;

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@autofleet/logger").LoggerInstanceManager;
+export default _default;

package/dist/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

@@ -0,0 +1,48 @@
+import { Sequelize } from 'sequelize-typescript';
+import RabbitMq from '@autofleet/rabbit';
+export type AuditLoggerOptions = {
+    rabbit: RabbitMq;
+    sequelize: Sequelize;
+    logger: any;
+};
+export interface AuditLogContext {
+    entityType: string;
+    action: string;
+    performedBy: string;
+    endpoint: string;
+    method: string;
+}
+export interface AuditLogRow {
+    property: string;
+    previousValue: any;
+    newValue: any;
+}
+export interface AuditLogPayload {
+    entityType: string;
+    entityId: string;
+    rows: AuditLogRow[];
+}
+export declare enum Action {
+    CREATE = "create",
+    BULK_CREATE = "bulk-create",
+    BULK_EDIT = "bulk-edit",
+    DELETE = "delete",
+    UPDATE = "update",
+    CANCEL = "cancel",
+    FAIL = "fail",
+    UNASSIGN = "unassign",
+    BULK_ASSIGN = "bulk-assign",
+    REASSIGN = "reassign",
+    DISPATCH = "dispatch",
+    BULK_DISPATCH = "bulk-dispatch",
+    BULK_UPSERT = "bulk-upsert",
+    UPSERT = "upsert",
+    JOIN = "join",
+    MOVE = "move"
+}
+export declare enum EntityType {
+    RIDE = "Ride",
+    VEHICLE = "Vehicle",
+    DRIVER = "Driver",
+    PRICE_CALCULATION = "PriceCalculation"
+}

package/dist/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = exports.Action = void 0;
+var Action;
+(function (Action) {
+    Action["CREATE"] = "create";
+    Action["BULK_CREATE"] = "bulk-create";
+    Action["BULK_EDIT"] = "bulk-edit";
+    Action["DELETE"] = "delete";
+    Action["UPDATE"] = "update";
+    Action["CANCEL"] = "cancel";
+    Action["FAIL"] = "fail";
+    Action["UNASSIGN"] = "unassign";
+    Action["BULK_ASSIGN"] = "bulk-assign";
+    Action["REASSIGN"] = "reassign";
+    Action["DISPATCH"] = "dispatch";
+    Action["BULK_DISPATCH"] = "bulk-dispatch";
+    Action["BULK_UPSERT"] = "bulk-upsert";
+    Action["UPSERT"] = "upsert";
+    Action["JOIN"] = "join";
+    Action["MOVE"] = "move";
+})(Action = exports.Action || (exports.Action = {}));
+var EntityType;
+(function (EntityType) {
+    EntityType["RIDE"] = "Ride";
+    EntityType["VEHICLE"] = "Vehicle";
+    EntityType["DRIVER"] = "Driver";
+    EntityType["PRICE_CALCULATION"] = "PriceCalculation";
+})(EntityType = exports.EntityType || (exports.EntityType = {}));

package/package.json

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

package/src/audit-logger.ts

@@ -52,7 +52,7 @@ const getChangedCustomFields = (instance) => {
   }
   const customFieldsValues = instance.get(CUSTOM_FIELDS_PROPERTY);
   const previousCustomFieldsValues = instance.previous(CUSTOM_FIELDS_PROPERTY);
-  const diffObj = diff(previousCustomFieldsValues, customFieldsValues);
+  const diffObj = previousCustomFieldsValues && customFieldsValues ? diff(previousCustomFieldsValues, customFieldsValues) : customFieldsValues || previousCustomFieldsValues;
   return Object.keys(diffObj).filter((field) => !isEmpty(customFieldsValues?.[field]) || !isEmpty(previousCustomFieldsValues?.[field]));
 };