@autofleet/matmon 1.0.5 → 2.0.0-beta-40

package/lib/index.d.ts

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

package/lib/index.js

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCache = exports.getWithCacheSupport = exports.getNewLRU = void 0;
+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; } });
 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; } });

package/lib/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: any;
+export default logger;

package/lib/logger.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Logger = require('@autofleet/logger');
+const logger = Logger();
+exports.default = logger;

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

@@ -0,0 +1,14 @@
+import RedisCache from '../redis';
+export interface ModelOptions {
+    name: string;
+    associations: {
+        name: string;
+        alias: string;
+    }[];
+}
+export interface Adapter {
+    ormInstance: any;
+    getModel: (modelName: string) => any;
+    injectGetWithCacheFunction: (cache: RedisCache, modelOptions: ModelOptions) => void;
+    addInvalidationHooks: (cache: RedisCache, modelOptions: ModelOptions) => void;
+}

package/lib/orm-cache/adapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+export declare class UnsupportedOrmTypeError extends Error {
+}

package/lib/orm-cache/errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedOrmTypeError = void 0;
+class UnsupportedOrmTypeError extends Error {
+}
+exports.UnsupportedOrmTypeError = UnsupportedOrmTypeError;

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

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

package/lib/orm-cache/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORMCache = void 0;
+const sequelize_adapter_1 = __importDefault(require("./sequelize-adapter"));
+const errors_1 = require("./errors");
+const redis_1 = __importDefault(require("../redis"));
+const logger_1 = __importDefault(require("../logger"));
+var ORMTypes;
+(function (ORMTypes) {
+    ORMTypes["SEQUELIZE"] = "sequelize";
+})(ORMTypes || (ORMTypes = {}));
+const ORMInstanceFactory = (options) => {
+    switch (options.type) {
+        case ORMTypes.SEQUELIZE: {
+            return new sequelize_adapter_1.default(options.ormInstance, options.debug);
+        }
+        default: {
+            throw new errors_1.UnsupportedOrmTypeError(`ORM type ${options.type} is unsupported at the moment`);
+        }
+    }
+};
+exports.ORMCache = (options) => {
+    const { type, models, ormInstance, } = 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) => {
+        adapter.addInvalidationHooks(cache, modelOptions);
+        adapter.injectGetWithCacheFunction(cache, modelOptions);
+    });
+};

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

@@ -0,0 +1,12 @@
+import { Sequelize } from 'sequelize';
+import { Adapter, 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;
+    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

@@ -0,0 +1,113 @@
+"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 logger_1 = __importDefault(require("../logger"));
+const util_1 = require("util");
+const { AF_SERVICE_NAME } = process.env;
+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 handleTransactionHook = (instance, options, func) => {
+    const { transaction } = options;
+    if (transaction) {
+        transaction.afterCommit(() => func(instance));
+    }
+    else {
+        func(instance);
+    }
+};
+class SequelizeAdapter {
+    constructor(sequelize, debug) {
+        this.ormInstance = sequelize;
+        this.debugMode = debug;
+    }
+    getModel(modelName) {
+        return this.ormInstance.models[modelName];
+    }
+    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.map(association => generateDependencyKey(modelName, association.name, instance[association.alias].id));
+            const instanceKey = generateInstanceKey(modelOptions, instance.id);
+            this.debug('Adding dependencies', { instanceKey, dependencyKeys });
+            const addDependenciesMulti = cache.getClient().multi();
+            const addDependenciesMultiAsync = util_1.promisify(addDependenciesMulti.exec).bind(addDependenciesMulti);
+            dependencyKeys.reduce((multi, key) => multi.sadd(key, instanceKey), addDependenciesMulti);
+            return addDependenciesMultiAsync();
+        });
+        const model = this.getModel(modelOptions.name);
+        model.findByPkCached = (id, scopes, options) => __awaiter(this, void 0, void 0, function* () {
+            const cacheKey = generateInstanceKey(modelOptions, 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([
+                    cache.getClient().setAsync(cacheKey, JSON.stringify(value)),
+                    value && addDependencies(modelOptions.name, value),
+                ]);
+            }
+            else {
+                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);
+            this.debug('Removing dependencies', { 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 = (modelName, association, associationId) => __awaiter(this, void 0, void 0, function* () {
+            const dependentInstancesKeys = yield cache.getClient().smembersAsync(generateDependencyKey(modelName, association, associationId));
+            this.debug('Invalidating dependent instances', { 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* () {
+                const instance = JSON.parse(yield cache.getClient().getAsync(instanceKey));
+                const dependencyKeys = modelOptions.associations
+                    .filter(association => instance[association.alias])
+                    .map(association => generateDependencyKey(modelName, association.name, instance[association.alias].id));
+                dependencyKeys.reduce((multi, key) => multi.srem(key, instanceKey), removeMulti);
+                removeMulti.del(instanceKey);
+                return dependencyKeys;
+            })));
+            this.debug('Removing dependencies', { dependentInstancesKeys, dependenciesToRemove });
+            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))));
+        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))));
+            BULK_HOOKS.map(hook => associationModel.addHook(hook, options => options.individualHook = true));
+        });
+    }
+}
+exports.default = SequelizeAdapter;

package/lib/redis/index.d.ts

@@ -11,6 +11,8 @@ declare class RedisCache {
     get(key: any): Promise<any>;
     set(key: any, value: any): Promise<void>;
     remove(key: any): Promise<void>;
+    removeMultiple(keys: any): Promise<void>;
+    getClient(): any;
     private lock;
 }
 export default RedisCache;

package/lib/redis/index.js

@@ -95,10 +95,24 @@ class RedisCache {
                 yield this.client.delAsync(keyWithPrefix);
             }
             catch (err) {
-                throw new errors_1.RedisCacheError(`Failed to invalidate key ${keyWithPrefix}`, err);
+                throw new errors_1.RedisCacheError(`Failed to delete key ${keyWithPrefix}`, err);
             }
         });
     }
+    removeMultiple(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keysWithPrefix = keys.map(key => KEY_PREFIX + key);
+            try {
+                yield this.client.delAsync(keysWithPrefix);
+            }
+            catch (err) {
+                throw new errors_1.RedisCacheError(`Failed to delete multiple keys ${keysWithPrefix.join('|')}`, err);
+            }
+        });
+    }
+    getClient() {
+        return this.client;
+    }
     lock(key) {
         return Promise.race([
             this.locker(key, this.lockDuration),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/matmon",
-  "version": "1.0.5",
+  "version": "2.0.0-beta-40",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -33,7 +33,9 @@
     "dotenv": "^8.2.0",
     "lru-cache": "^6.0.0",
     "redis": "^3.0.2",
-    "redis-lock": "^0.1.4"
+    "redis-lock": "^0.1.4",
+    "sequelize": "^6.6.2",
+    "sequelize-typescript": "^2.1.0"
   },
   "devDependencies": {
     "typescript": "^3.9.5"