@autofleet/matmon 2.0.1 → 2.0.4-beta-1

package/lib/index.d.ts

@@ -1,4 +1,4 @@
 import { getNewLRU, getWithCacheSupport } from './cache';
 import RedisCache from './redis';
-import { ORMCache } from './orm-cache';
-export { getNewLRU, getWithCacheSupport, RedisCache, ORMCache, };
+import { ORMCache, ORMTypes } from './orm-cache';
+export { getNewLRU, getWithCacheSupport, RedisCache, ORMCache, ORMTypes };

package/lib/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORMCache = exports.RedisCache = exports.getWithCacheSupport = exports.getNewLRU = void 0;
+exports.ORMTypes = exports.ORMCache = exports.RedisCache = exports.getWithCacheSupport = exports.getNewLRU = void 0;
 const cache_1 = require("./cache");
 Object.defineProperty(exports, "getNewLRU", { enumerable: true, get: function () { return cache_1.getNewLRU; } });
 Object.defineProperty(exports, "getWithCacheSupport", { enumerable: true, get: function () { return cache_1.getWithCacheSupport; } });
@@ -11,3 +11,4 @@ const redis_1 = __importDefault(require("./redis"));
 exports.RedisCache = redis_1.default;
 const orm_cache_1 = require("./orm-cache");
 Object.defineProperty(exports, "ORMCache", { enumerable: true, get: function () { return orm_cache_1.ORMCache; } });
+Object.defineProperty(exports, "ORMTypes", { enumerable: true, get: function () { return orm_cache_1.ORMTypes; } });

package/lib/orm-cache/adapter.d.ts

@@ -1,13 +1,13 @@
 import RedisCache from '../redis';
 export interface ModelOptions {
     name: string;
-    associations: AssociationOptions[];
+    associations?: AssociationOptions[];
 }
 export interface AssociationOptions {
     name: string;
     alias: string;
     accessKey?: string;
-    associations?: AssociationOptions[];
+    innerAssociation?: AssociationOptions;
 }
 export interface Adapter {
     ormInstance: any;

package/lib/orm-cache/index.d.ts

@@ -1,5 +1,5 @@
 import { ModelOptions } from './adapter';
-declare enum ORMTypes {
+export declare enum ORMTypes {
     SEQUELIZE = "sequelize"
 }
 interface ORMCacheOptions {
@@ -7,7 +7,6 @@ interface ORMCacheOptions {
     models: ModelOptions[];
     ormInstance: any;
     debug: boolean;
-    ttl: number;
 }
 export declare const ORMCache: (options: ORMCacheOptions) => void;
 export {};

package/lib/orm-cache/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORMCache = void 0;
+exports.ORMCache = exports.ORMTypes = void 0;
 const sequelize_adapter_1 = __importDefault(require("./sequelize-adapter"));
 const errors_1 = require("./errors");
 const redis_1 = __importDefault(require("../redis"));
@@ -11,7 +11,7 @@ const logger_1 = __importDefault(require("../logger"));
 var ORMTypes;
 (function (ORMTypes) {
     ORMTypes["SEQUELIZE"] = "sequelize";
-})(ORMTypes || (ORMTypes = {}));
+})(ORMTypes = exports.ORMTypes || (exports.ORMTypes = {}));
 const ORMInstanceFactory = (options) => {
     switch (options.type) {
         case ORMTypes.SEQUELIZE: {
@@ -23,13 +23,12 @@ const ORMInstanceFactory = (options) => {
     }
 };
 exports.ORMCache = (options) => {
-    const { type, models, ormInstance, } = options;
+    const { models } = options;
     logger_1.default.info('Starting ORM Cache', { options });
     const adapter = ORMInstanceFactory(options);
     const cache = new redis_1.default({
         host: process.env.REDIS_HOST,
         port: process.env.REDIS_PORT,
-        ttl: options.ttl || 90,
     });
     // eslint-disable-next-line array-callback-return
     models.map((modelOptions) => {

package/lib/orm-cache/sequelize-adapter.d.ts

@@ -1,11 +1,12 @@
 import { Sequelize } from 'sequelize';
-import { Adapter, ModelOptions } from './adapter';
+import { Adapter, AssociationOptions, ModelOptions } from './adapter';
 import RedisCache from '../redis';
 export default class SequelizeAdapter implements Adapter {
     ormInstance: Sequelize;
     debugMode: boolean;
     constructor(sequelize: Sequelize, debug: any);
     getModel(modelName: string): any;
+    getModelDependencies(modelName: string): AssociationOptions[];
     debug(message: any, payload: any): void;
     injectGetWithCacheFunction(cache: RedisCache, modelOptions: ModelOptions): void;
     addInvalidationHooks(cache: RedisCache, modelOptions: ModelOptions): void;

package/lib/orm-cache/sequelize-adapter.js

@@ -12,33 +12,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const newrelic_1 = __importDefault(require("newrelic"));
 const logger_1 = __importDefault(require("../logger"));
 const util_1 = require("util");
 const { AF_SERVICE_NAME } = process.env;
+const ORM_CACHE_PREFIX = 'ormCache';
 const INVALIDATION_HOOKS = ['afterSave', 'afterUpdate', 'afterDestroy'];
 const BULK_HOOKS = ['beforeBulkUpdate', 'beforeBulkDestroy'];
-const generateInstanceKey = (modelOptions, id) => `${AF_SERVICE_NAME}:${modelOptions.name}_${id}_INCLUDING_${modelOptions.associations.map(a => a.name).join('_')}`;
-const generateDependencyKey = (modelName, associationName, associationId) => `${AF_SERVICE_NAME}:${modelName}_${associationName}_${associationId}_DEPENDENCIES`;
-const getAssociation = (instance, associationOptions, associationId) => {
-    const accessKey = associationOptions.accessKey || 'id';
-    if (Array.isArray(instance[associationOptions.alias])) {
-        return instance[associationOptions.alias].find(association => association[accessKey] === associationId);
-    }
-    return instance[associationOptions.alias];
-};
-const getInstanceDependencyKeys = (modelOptions, instance) => {
+const generateInstanceKey = (name, id) => `${AF_SERVICE_NAME}:${ORM_CACHE_PREFIX}:${name}_${id}`;
+const generateDependencyKey = (modelName, associationName, associationId) => `${AF_SERVICE_NAME}:${ORM_CACHE_PREFIX}:${modelName}_${associationName}_${associationId}_DEPENDENCIES`;
+const getInstanceDependencyKeys = (modelOptions, instance) => newrelic_1.default.startSegment('getInstanceDependencyKeys', true, () => {
     const keys = modelOptions.associations
-        .filter((association) => instance[association.alias])
+        .filter((associationOptions) => instance[associationOptions.alias])
         .map((associationOptions) => {
-        const accessKey = associationOptions.accessKey || 'id';
+        const accessKey = associationOptions.accessKey;
+        const depKeys = [];
         if (Array.isArray(instance[associationOptions.alias])) {
-            return instance[associationOptions.alias]
-                .map(associationInstance => generateDependencyKey(modelOptions.name, associationOptions.name, associationInstance[accessKey]));
+            instance[associationOptions.alias].map(associationInstance => {
+                depKeys.push(generateDependencyKey(modelOptions.name, associationOptions.name, associationInstance[accessKey]));
+                if (associationOptions.innerAssociation &&
+                    associationInstance[associationOptions.innerAssociation.alias]) {
+                    depKeys.push(generateDependencyKey(modelOptions.name, associationOptions.innerAssociation.name, associationInstance[associationOptions.innerAssociation.alias][associationOptions.innerAssociation.accessKey]));
+                }
+            });
+            return depKeys;
         }
-        return [generateDependencyKey(modelOptions.name, associationOptions.name, instance[associationOptions.alias][accessKey])];
+        return [
+            generateDependencyKey(modelOptions.name, associationOptions.name, instance[associationOptions.alias][accessKey]),
+        ];
     });
     return keys.reduce((flattenArray, array) => flattenArray.concat(array), []);
-};
+});
 const handleTransactionHook = (instance, options, func) => {
     const { transaction } = options;
     if (transaction) {
@@ -56,15 +60,39 @@ class SequelizeAdapter {
     getModel(modelName) {
         return this.ormInstance.models[modelName];
     }
+    getModelDependencies(modelName) {
+        return newrelic_1.default.startSegment('getModelDependencies', true, () => {
+            const { associations } = this.ormInstance.models[modelName];
+            return [
+                ...Object.keys(associations).map(association => {
+                    const sequelizeAssociation = associations[association];
+                    const associationOptions = {
+                        alias: sequelizeAssociation.as,
+                        name: sequelizeAssociation.target.name,
+                        accessKey: sequelizeAssociation.target.primaryKeyAttribute,
+                    };
+                    if (sequelizeAssociation.through) {
+                        const relationModel = sequelizeAssociation.through.model;
+                        associationOptions.innerAssociation = {
+                            alias: relationModel.name,
+                            name: relationModel.name,
+                            accessKey: relationModel.primaryKeyAttribute,
+                        };
+                    }
+                    return associationOptions;
+                }),
+            ];
+        });
+    }
     debug(message, payload) {
         if (this.debugMode) {
             logger_1.default.info(`[ORM_CACHE Debug] ${message}`, payload);
         }
     }
     injectGetWithCacheFunction(cache, modelOptions) {
-        const addDependencies = (instance) => __awaiter(this, void 0, void 0, function* () {
+        const addDependencies = (instance) => newrelic_1.default.startSegment('addDependencies', true, () => {
             const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
-            const instanceKey = generateInstanceKey(modelOptions, instance.id);
+            const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
             this.debug('Adding dependencies', { instanceKey, dependencyKeys });
             const addDependenciesMulti = cache.getClient().multi();
             const addDependenciesMultiAsync = util_1.promisify(addDependenciesMulti.exec).bind(addDependenciesMulti);
@@ -73,37 +101,38 @@ class SequelizeAdapter {
         });
         const model = this.getModel(modelOptions.name);
         model.findByPkCached = (id, scopes, options) => __awaiter(this, void 0, void 0, function* () {
-            const cacheKey = generateInstanceKey(modelOptions, id);
+            const cacheKey = generateInstanceKey(modelOptions.name, id);
             let value = JSON.parse(yield cache.getClient().getAsync(cacheKey));
             if (!value) {
                 this.debug('Value not found in cache, looking in db', { id, cacheKey });
                 value = yield model.scope(scopes).findByPk(id, options);
                 this.debug('Value from DB', { value: value || 'not found', cacheKey });
-                const [setRes] = yield Promise.all([
+                yield Promise.all([
                     cache.getClient().setAsync(cacheKey, JSON.stringify(value)),
                     value && addDependencies(value),
                 ]);
             }
             else {
+                value = this.getModel(modelOptions.name).build(value, { isNewRecord: false, include: options.include });
                 this.debug('Found cached value', { value, id, cacheKey });
             }
             return value;
         });
     }
     addInvalidationHooks(cache, modelOptions) {
-        const invalidateModelInstance = (instance) => __awaiter(this, void 0, void 0, function* () {
+        const invalidateModelInstance = (hook, instance) => newrelic_1.default.startSegment('invalidateModelInstance', true, () => {
             const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
-            const instanceKey = generateInstanceKey(modelOptions, instance.id);
-            this.debug('Removing dependencies', { instance, instanceKey, dependencyKeys });
+            const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
+            this.debug(`Removing dependencies (triggered by ${hook})`, { instance, instanceKey, dependencyKeys });
             const removeMulti = cache.getClient().multi();
             const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
             dependencyKeys.map(key => removeMulti.srem(key, instanceKey));
             removeMulti.del(instanceKey);
             return removeMultiAsync();
         });
-        const invalidateModelInstanceByAssociation = (association, associationId) => __awaiter(this, void 0, void 0, function* () {
+        const invalidateModelInstanceByAssociation = (hook, association, associationId) => newrelic_1.default.startSegment('invalidateModelInstanceByAssociation', true, () => __awaiter(this, void 0, void 0, function* () {
             const dependentInstancesKeys = yield cache.getClient().smembersAsync(generateDependencyKey(modelOptions.name, association, associationId));
-            this.debug('Invalidating dependent instances', { dependentInstancesKeys });
+            this.debug(`Invalidating dependent instances (triggered by ${hook})`, { dependentInstancesKeys });
             const removeMulti = cache.getClient().multi();
             const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
             const dependenciesToRemove = yield Promise.all(dependentInstancesKeys.map((instanceKey) => __awaiter(this, void 0, void 0, function* () {
@@ -116,16 +145,21 @@ class SequelizeAdapter {
                 removeMulti.del(instanceKey);
                 return dependencyKeys;
             })));
-            this.debug('Removing dependencies', { dependentInstancesKeys, dependenciesToRemove });
+            this.debug(`Removing dependencies (triggered by ${hook})`, { dependentInstancesKeys, dependenciesToRemove });
             return removeMultiAsync();
-        });
+        }));
         const model = this.getModel(modelOptions.name);
-        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(instance))));
+        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(hook, instance))));
         BULK_HOOKS.map(hook => model.addHook(hook, options => options.individualHook = true));
+        modelOptions.associations = this.getModelDependencies(modelOptions.name);
+        this.debug(`Adding Invalidations Hooks to ${modelOptions.name}'s associations`, { associations: modelOptions.associations });
         modelOptions.associations.map((associationOptions) => {
             const associationModel = this.getModel(associationOptions.name);
-            INVALIDATION_HOOKS.map(hook => associationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, associationInstance => invalidateModelInstanceByAssociation(associationOptions.name, associationInstance[associationOptions.accessKey || 'id']))));
-            BULK_HOOKS.map(hook => associationModel.addHook(hook, options => options.individualHook = true));
+            INVALIDATION_HOOKS.map(hook => associationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, associationInstance => invalidateModelInstanceByAssociation(hook, associationOptions.name, associationInstance[associationOptions.accessKey]))));
+            if (associationOptions.innerAssociation) {
+                const innerAssociationModel = this.getModel(associationOptions.innerAssociation.name);
+                INVALIDATION_HOOKS.map(hook => innerAssociationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, innerAssociationInstance => invalidateModelInstanceByAssociation(hook, associationOptions.innerAssociation.name, innerAssociationInstance[associationOptions.innerAssociation.accessKey]))));
+            }
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/matmon",
-  "version": "2.0.1",
+  "version": "2.0.4-beta-1",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,6 +32,7 @@
     "bluebird": "^3.7.2",
     "dotenv": "^8.2.0",
     "lru-cache": "^6.0.0",
+    "newrelic": "^7.5.2",
     "redis": "^3.0.2",
     "redis-lock": "^0.1.4",
     "sequelize": "^6.6.2",