@technicity/data-service-generator 0.11.0-next.0 → 0.11.0-next.2

package/dist/generation/generate.js

@@ -249,7 +249,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 param1: ${findOnes
                 .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
                 .join(" | ")}, 
-                param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
+                param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
               ): Promise<${x.typeReturnBaseName}> {
               return this.runtime.resolve(
                 {
@@ -258,7 +258,8 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                   args: { $where: param1 },
                   fields: param2?.fields,
                   artifacts,
-                  context: param2?.context
+                  context: param2?.context,
+                  skipCache: param2?.skipCache
                 }
               );
             }`;
@@ -266,7 +267,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
         if (x.kind === "getList") {
             return `async ${x.methodName}(
             param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
           ): Promise<Array<${x.typeReturnBaseName}>> {
             return this.runtime.resolve(
               {
@@ -275,7 +276,8 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 args: param1,
                 fields: param2?.fields,
                 artifacts,
-                context: param2?.context
+                context: param2?.context,
+                skipCache: param2?.skipCache
               }
             );
           }`;
@@ -283,7 +285,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
         if (x.kind === "getListPaginated") {
             return `async ${x.methodName}(
             param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
           ): Promise<ListPaginated<${x.typeReturnBaseName}>> {
             return this.runtime.resolve(
               {
@@ -292,7 +294,8 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 args: param1,
                 fields: param2?.fields,
                 artifacts,
-                context: param2?.context
+                context: param2?.context,
+                skipCache: param2?.skipCache
               }
             );
           }`;

package/dist/runtime/Cache.d.ts

@@ -1,10 +1,12 @@
 import { RedisClientType } from 'redis';
 import { TResolveParams } from './IRuntime';
+import Stats from './Stats';
 declare class Cache {
-    protected logs?: boolean | undefined;
     client: RedisClientType;
     waiting?: Set<() => void> | undefined;
-    constructor(url: string, logs?: boolean | undefined);
+    logs?: boolean;
+    stats?: Stats;
+    constructor(url: string, debug?: string[]);
     log(message: string): void;
     pending(): Promise<void>;
     from(input: TResolveParams): Promise<{

package/dist/runtime/Cache.js

@@ -3,21 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
 const redis_1 = require("redis");
 const utility_1 = require("./lib/utility");
+const Stats_1 = require("./Stats");
 class Cache {
-    constructor(url, logs) {
-        this.logs = logs;
+    constructor(url, debug) {
         this.waiting = new Set();
-        this.client = (0, redis_1.createClient)({ url: `redis://${url}` });
-        this.client.connect();
-        this.client.on("connect", () => {
+        if (debug?.includes("Cache"))
+            this.logs = true;
+        const client = this.client =
+            (0, redis_1.createClient)({ url: `redis://${url}` });
+        client.connect();
+        client.on("connect", () => {
             if (this.waiting)
                 this.waiting.forEach(x => x());
             this.waiting = undefined;
         });
+        if (debug?.includes("Stats"))
+            this.stats = new Stats_1.default(client);
     }
     log(message) {
         if (this.logs)
-            console.log(message);
+            console.log(`\n-- CACHE: ${message}\n`);
     }
     async pending() {
         if (this.waiting)
@@ -50,7 +55,7 @@ class Cache {
         }
         if (!pending.length)
             return;
-        this.log(`Cache insert: ${key.substring(0, 6)}`);
+        this.log(`insert: ${key.substring(0, 6)}`);
         await Promise.all([
             redis.set(`cache:${key}`, json),
             ...pending
@@ -61,11 +66,11 @@ class Cache {
         const data = await this.client.get(`cache:${key}`);
         const shorthand = key.substring(0, 6);
         if (data) {
-            this.log(`Cache hit: ${shorthand}`);
+            this.log(`hit: ${shorthand}`);
             return JSON.parse(data);
         }
         else {
-            this.log(`Cache miss: ${shorthand}`);
+            this.log(`miss: ${shorthand}`);
             return undefined;
         }
     }

package/dist/runtime/IRuntime.d.ts

@@ -14,6 +14,7 @@ export declare type TResolveParams = {
     artifacts: IArtifacts;
     fields?: IField[] | undefined;
     context?: TContext | undefined;
+    skipCache?: boolean;
 };
 export declare type TContext = {
     [k: string]: any;

package/dist/runtime/RuntimeMySQL.js

@@ -24,9 +24,8 @@ class RuntimeMySQL {
         _RuntimeMySQL_clientCache.set(this, void 0);
         _RuntimeMySQL_middlewareHandler.set(this, void 0);
         __classPrivateFieldSet(this, _RuntimeMySQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
-        const debugCache = clientOpts?.debug?.includes("Cache");
         if (otherOpts.redisHost)
-            __classPrivateFieldSet(this, _RuntimeMySQL_clientCache, new Cache_1.default(otherOpts.redisHost, debugCache), "f");
+            __classPrivateFieldSet(this, _RuntimeMySQL_clientCache, new Cache_1.default(otherOpts.redisHost, clientOpts?.debug), "f");
         if (otherOpts.supplementClientOpts) {
             clientOpts = {
                 supportBigNumbers: true,

package/dist/runtime/Stats.d.ts

@@ -0,0 +1,12 @@
+import { RedisClientType } from '@redis/client';
+declare class Stats {
+    client: RedisClientType<any>;
+    constructor(client: RedisClientType<any>);
+    updateStats: (ms: number, category: string) => Promise<void>;
+}
+declare namespace timer {
+    type Callback = (time: number, ...params: any[]) => void;
+    type Params<T> = T extends (ms: number, ...params: infer U) => any ? U : never;
+}
+export declare function timer(): <T extends timer.Callback>(callback: T, ...args: timer.Params<T>) => void;
+export default Stats;

package/dist/runtime/Stats.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timer = void 0;
+const perf_hooks_1 = require("perf_hooks");
+class Stats {
+    constructor(client) {
+        this.client = client;
+        this.updateStats = async (ms, category) => {
+            const redis = this.client;
+            const requests = Number(await redis.get(`stats:${category}_requests`)) || 0;
+            const average = Number(await redis.get(`stats:${category}_avg`)) || 0;
+            const max = Number(await redis.get(`stats:${category}_max`)) || 0;
+            const min = Number(await redis.get(`stats:${category}_min`)) || Infinity;
+            const newTotalRequests = requests + 1;
+            const newAverage = (average * requests + ms) / newTotalRequests;
+            await redis.set(`stats:${category}_requests`, newTotalRequests);
+            await redis.set(`stats:${category}_avg`, newAverage);
+            if (ms > max)
+                await redis.set(`stats:${category}_max`, ms);
+            if (ms < min)
+                await redis.set(`stats:${category}_min`, ms);
+        };
+    }
+}
+function timer() {
+    const start = perf_hooks_1.performance.now();
+    return (callback, ...args) => {
+        callback(perf_hooks_1.performance.now() - start, ...args);
+    };
+}
+exports.timer = timer;
+exports.default = Stats;

package/dist/runtime/lib/shared.js

@@ -22,6 +22,7 @@ const SDKNotFoundError_1 = require("./SDKNotFoundError");
 const SDKBadWhereError_1 = require("./SDKBadWhereError");
 const stringifyWhere_1 = require("./stringifyWhere");
 const getOrderBy_1 = require("./getOrderBy");
+const Stats_1 = require("../Stats");
 async function resolve(input, dbCall, formatQuery, beginTransaction, dialect, middlewareHandler, context, cache) {
     // https://github.com/prisma/prisma/blob/822198e5ba21535364d20c86901b8c3778ebf6a3/packages/client/src/runtime/getPrismaClient.ts#L1087
     let index = -1;
@@ -46,7 +47,7 @@ function _resolve(input, dbCall, formatQuery, beginTransaction, dialect, context
         case "findUnique":
         case "findMany":
         case "findManyPaginated":
-            return cache ?
+            return cache && !input.skipCache ?
                 getCached(input, dbCall, formatQuery, dialect, cache) :
                 getData(input, dbCall, formatQuery, dialect);
         case "create":
@@ -266,12 +267,24 @@ async function getData(input, dbCall, formatQuery, dialect) {
     return data;
 }
 async function getCached(input, dbCall, formatQuery, dialect, cache) {
+    const done = (0, Stats_1.timer)();
+    const { stats } = cache;
     const { request, cached } = await cache.from(input);
-    if (cached)
-        return cached;
-    ensureUuidSelect(input);
-    const results = await getData(input, dbCall, formatQuery, dialect);
-    cache.insert(request, results);
+    let results;
+    if (cached) {
+        if (stats)
+            done(stats.updateStats, "get_redis");
+        results = cache;
+    }
+    else {
+        ensureUuidSelect(input);
+        results = await getData(input, dbCall, formatQuery, dialect);
+        cache.insert(request, results);
+        if (stats)
+            done(stats.updateStats, "get_mysql");
+    }
+    if (stats)
+        done(stats.updateStats, "get");
     return results;
 }
 function ensureUuidSelect(input) {
@@ -281,7 +294,7 @@ function ensureUuidSelect(input) {
         const { scalarFields, relationFields } = artifacts[type];
         if (!scalarFields.includes("uuid"))
             return;
-        const fields = input.fields || [];
+        const fields = input.fields;
         if (!fields.includes("uuid"))
             fields.unshift("uuid");
         for (const field of fields)

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.11.0-next.0",
+  "version": "0.11.0-next.2",
   "main": "./dist/index.js",
   "files": [
     "dist"
   ],
   "scripts": {
     "compile": "rm -rf dist && tsc",
-    "publish:next": "npm version preminor --preid next",
+    "publish:next": "npm version prerelease --preid next",
     "preversion": "npm run compile",
-    "postversion": "npm publish",
     "generate": "npm run compile && concurrently \"node ./test/mysql/generate.js\" \"node ./test/mysql8/generate.js\"",
     "test": "npm run generate && mocha ./test/addNullFallbacks.test.js && mocha ./test/stringifyWhere.test.js && npm run test:sdk",
     "test:prepare": "docker-compose down --volumes && docker-compose up -d --build",