@technicity/data-service-generator 0.11.1 → 0.11.3

package/dist/runtime/Cache.d.ts

@@ -1,19 +1,20 @@
-import { RedisClientType } from "redis";
+import Redis, { Cluster } from "ioredis";
 import { TResolveParams } from "./IRuntime";
 import Stats from "./Stats";
 export declare type RedisConfig = {
-    url: string;
-    tls: boolean;
-    db: number;
-    socketTimeout: number;
+    host: string;
+    port: number;
+    tls?: boolean;
+    db?: number;
+    socketTimeout?: number;
+    clusterMode?: boolean;
 };
 declare class Cache {
-    client: RedisClientType;
+    client: Redis | Cluster;
     waiting?: Set<() => void> | undefined;
-    logs?: boolean;
     stats?: Stats;
     constructor(redisConfig: RedisConfig, debug?: string[]);
-    log(message: string): void;
+    debug(message: string): void;
     pending(): Promise<void>;
     from(input: TResolveParams): Promise<{
         request: string;

package/dist/runtime/Cache.js

@@ -1,36 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
-const redis_1 = require("redis");
+const ioredis_1 = require("ioredis");
+const loglevel_1 = require("loglevel");
 const utility_1 = require("./lib/utility");
 const Stats_1 = require("./Stats");
 class Cache {
     constructor(redisConfig, debug) {
         this.waiting = new Set();
-        if (debug?.includes("Cache"))
-            this.logs = true;
-        const { url, tls, db, socketTimeout } = redisConfig;
-        const scheme = tls ? "rediss://" : "redis://";
-        const client = (this.client = (0, redis_1.createClient)({
-            url: `${scheme}${url}/${db}`,
-            socket: {
-                tls,
-                rejectUnauthorized: false,
-                connectTimeout: socketTimeout
-            }
-        }));
+        if (debug?.includes("Cache")) {
+            loglevel_1.default.setLevel("DEBUG");
+        }
+        const { host, port } = redisConfig;
+        const tls = redisConfig.tls ? true : false;
+        const clusterMode = redisConfig.clusterMode ? true : false;
+        const db = redisConfig.db == null ? 0 : redisConfig.db;
+        const socketTimeout = redisConfig.socketTimeout == null ? 50000 : redisConfig.socketTimeout;
+        let client = undefined;
+        if (clusterMode) {
+            client = new ioredis_1.default.Cluster([
+                {
+                    host,
+                    port
+                }
+            ], {
+                dnsLookup: (address, callback) => callback(null, address),
+                redisOptions: {
+                    tls: tls ? {} : undefined,
+                    lazyConnect: true,
+                    commandTimeout: socketTimeout
+                }
+            });
+        }
+        else {
+            client = new ioredis_1.default({
+                host,
+                port,
+                db,
+                lazyConnect: true,
+                tls: tls ? {} : undefined
+            });
+        }
+        this.client = client;
         client.connect();
         client.on("connect", () => {
+            loglevel_1.default.info(`DB SDK connected to redis server at ${host}:${port}`);
             if (this.waiting)
                 this.waiting.forEach((x) => x());
             this.waiting = undefined;
         });
+        client.on("error", (err) => {
+            loglevel_1.default.error("ERROR: redis client");
+            loglevel_1.default.error(err);
+        });
         if (debug?.includes("Stats"))
             this.stats = new Stats_1.default(client);
     }
-    log(message) {
-        if (this.logs)
-            console.log(`\n-- CACHE: ${message}\n`);
+    debug(message) {
+        loglevel_1.default.debug(`\n-- CACHE: ${message}\n`);
     }
     async pending() {
         if (this.waiting)
@@ -60,11 +87,11 @@ class Cache {
             const uuid = result[1];
             if (!uuid)
                 continue;
-            pending.push(redis.sAdd(`deps:${uuid}`, [key]), redis.sAdd(`cached:${key}`, [uuid]));
+            pending.push(redis.sadd(`deps:${uuid}`, [key]), redis.sadd(`cached:${key}`, [uuid]));
         }
         if (!pending.length)
             return;
-        this.log(`insert: ${key.substring(0, 6)}`);
+        this.debug(`insert: ${key.substring(0, 6)}`);
         await Promise.all([redis.set(`cache:${key}`, json), ...pending]);
     }
     async read(key) {
@@ -72,23 +99,23 @@ class Cache {
         const data = await this.client.get(`cache:${key}`);
         const shorthand = key.substring(0, 6);
         if (data) {
-            this.log(`hit: ${shorthand}`);
+            this.debug(`hit: ${shorthand}`);
             return JSON.parse(data);
         }
         else {
-            this.log(`miss: ${shorthand}`);
+            this.debug(`miss: ${shorthand}`);
             return undefined;
         }
     }
     async purge(...uuids) {
         const redis = this.client;
         await (0, utility_1.mapAsync)(uuids, (uuid) => {
-            const getDependancies = redis.sMembers(`deps:${uuid}`);
+            const getDependancies = redis.smembers(`deps:${uuid}`);
             return [
                 (0, utility_1.mapAsync)(getDependancies, (key) => {
-                    const getDependants = redis.sMembers(`cached:${key}`);
+                    const getDependants = redis.smembers(`cached:${key}`);
                     return [
-                        (0, utility_1.mapAsync)(getDependants, (uuid) => redis.sRem(`deps:${uuid}`, [key])),
+                        (0, utility_1.mapAsync)(getDependants, (uuid) => redis.srem(`deps:${uuid}`, [key])),
                         redis.del(`cache:${key}`),
                         redis.del(`cached:${key}`)
                     ];

package/dist/runtime/RuntimeMySQL.js

@@ -17,6 +17,8 @@ const SqlString = require("sqlstring");
 const Cache_1 = require("./Cache");
 const MySQL_1 = require("./lib/MySQL");
 const shared_1 = require("./lib/shared");
+const loglevel_1 = require("loglevel");
+loglevel_1.default.setDefaultLevel("INFO");
 class RuntimeMySQL {
     constructor(clientOpts, otherOpts, artifacts) {
         _RuntimeMySQL_dialect.set(this, "mysql");

package/dist/runtime/Stats.d.ts

@@ -1,7 +1,7 @@
-import { RedisClientType } from '@redis/client';
+import Redis, { Cluster } from "ioredis";
 declare class Stats {
-    client: RedisClientType<any>;
-    constructor(client: RedisClientType<any>);
+    client: Redis | Cluster;
+    constructor(client: Redis | Cluster);
     updateStats: (ms: number, category: string) => Promise<void>;
 }
 declare namespace timer {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -23,13 +23,14 @@
     "fs-extra": "10.0.0",
     "graphql": "15.8.0",
     "graphql-relay": "^0.9.0",
+    "ioredis": "^5.2.4",
     "join-monster": "git+https://github.com/apalm/join-monster.git#3e93d7028ccbf50f728577b2290b5f2638b639cb",
     "json-schema-to-typescript": "10.1.5",
     "lodash": "^4.17.20",
+    "loglevel": "^1.8.1",
     "mssql": "^6.3.1",
     "mysql": "^2.18.1",
     "prettier": "^2.1.2",
-    "redis": "^4.3.0",
     "sqlstring": "^2.3.2",
     "tsqlstring": "^1.0.1",
     "uuid": "^8.3.2"