@autofleet/matmon 2.0.0 → 2.0.3

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,10 +1,13 @@
 import RedisCache from '../redis';
 export interface ModelOptions {
     name: string;
-    associations: {
-        name: string;
-        alias: string;
-    }[];
+    associations?: AssociationOptions[];
+}
+export interface AssociationOptions {
+    name: string;
+    alias: string;
+    accessKey?: string;
+    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

@@ -15,10 +15,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 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) => {
+    const keys = modelOptions.associations
+        .filter((associationOptions) => instance[associationOptions.alias])
+        .map((associationOptions) => {
+        const accessKey = associationOptions.accessKey;
+        const depKeys = [];
+        if (Array.isArray(instance[associationOptions.alias])) {
+            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 keys.reduce((flattenArray, array) => flattenArray.concat(array), []);
+};
 const handleTransactionHook = (instance, options, func) => {
     const { transaction } = options;
     if (transaction) {
@@ -36,17 +59,37 @@ class SequelizeAdapter {
     getModel(modelName) {
         return this.ormInstance.models[modelName];
     }
+    getModelDependencies(modelName) {
+        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 = (modelName, instance) => __awaiter(this, void 0, void 0, function* () {
-            const dependencyKeys = modelOptions.associations
-                .filter(association => instance[association.alias])
-                .map(association => generateDependencyKey(modelName, association.name, instance[association.alias].id));
-            const instanceKey = generateInstanceKey(modelOptions, instance.id);
+        const addDependencies = (instance) => __awaiter(this, void 0, void 0, function* () {
+            const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
+            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);
@@ -55,29 +98,28 @@ 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(modelOptions.name, 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 = (modelName, instance) => __awaiter(this, void 0, void 0, function* () {
-            const dependencyKeys = modelOptions.associations
-                .filter(association => instance[association.alias])
-                .map(association => generateDependencyKey(modelName, association.name, instance[association.alias].id));
-            const instanceKey = generateInstanceKey(modelOptions, instance.id);
+        const invalidateModelInstance = (instance) => __awaiter(this, void 0, void 0, function* () {
+            const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
+            const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
             this.debug('Removing dependencies', { instance, instanceKey, dependencyKeys });
             const removeMulti = cache.getClient().multi();
             const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
@@ -85,8 +127,8 @@ class SequelizeAdapter {
             removeMulti.del(instanceKey);
             return removeMultiAsync();
         });
-        const invalidateModelInstanceByAssociation = (modelName, association, associationId) => __awaiter(this, void 0, void 0, function* () {
-            const dependentInstancesKeys = yield cache.getClient().smembersAsync(generateDependencyKey(modelName, association, associationId));
+        const invalidateModelInstanceByAssociation = (association, associationId) => __awaiter(this, void 0, void 0, function* () {
+            const dependentInstancesKeys = yield cache.getClient().smembersAsync(generateDependencyKey(modelOptions.name, association, associationId));
             this.debug('Invalidating dependent instances', { dependentInstancesKeys });
             const removeMulti = cache.getClient().multi();
             const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
@@ -95,9 +137,7 @@ class SequelizeAdapter {
                 if (!instance) {
                     return [];
                 }
-                const dependencyKeys = modelOptions.associations
-                    .filter(association => instance[association.alias])
-                    .map(association => generateDependencyKey(modelName, association.name, instance[association.alias].id));
+                const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
                 dependencyKeys.reduce((multi, key) => multi.srem(key, instanceKey), removeMulti);
                 removeMulti.del(instanceKey);
                 return dependencyKeys;
@@ -106,12 +146,19 @@ class SequelizeAdapter {
             return removeMultiAsync();
         });
         const model = this.getModel(modelOptions.name);
-        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(modelOptions.name, instance))));
+        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(instance))));
         BULK_HOOKS.map(hook => model.addHook(hook, options => options.individualHook = true));
-        modelOptions.associations.map(association => {
-            const associationModel = this.getModel(association.name);
-            INVALIDATION_HOOKS.map(hook => associationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, ({ id }) => invalidateModelInstanceByAssociation(modelOptions.name, association.name, id))));
+        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]))));
             BULK_HOOKS.map(hook => associationModel.addHook(hook, options => options.individualHook = true));
+            if (associationOptions.innerAssociation) {
+                const innerAssociationModel = this.getModel(associationOptions.innerAssociation.name);
+                INVALIDATION_HOOKS.map(hook => innerAssociationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, innerAssociationInstance => invalidateModelInstanceByAssociation(associationOptions.innerAssociation.name, innerAssociationInstance[associationOptions.innerAssociation.accessKey]))));
+                BULK_HOOKS.map(hook => innerAssociationModel.addHook(hook, options => options.individualHook = true));
+            }
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/matmon",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",