@spytecgps/nova-orm 1.4.240 → 1.4.242

package/dist/cache/InstrumentedQueryResultCache.d.ts

@@ -0,0 +1,81 @@
+import { QueryRunner } from 'typeorm';
+import { QueryResultCache } from 'typeorm/cache/QueryResultCache';
+import { QueryResultCacheOptions } from 'typeorm/cache/QueryResultCacheOptions';
+import { Logger } from '../types/logger';
+export type CacheKind = 'lru' | 'redis' | 'unknown' | (string & Record<never, never>);
+export interface InstrumentedQueryResultCacheOptions {
+    /**
+     * Tag for the underlying backend. Surfaces as the `kind` attribute on every
+     * emitted metric so dashboards can split LRU vs Redis cost/hit behavior.
+     */
+    kind: CacheKind;
+    /**
+     * Optional logger. When provided, a summary line is logged via `flushSummary()`
+     * and sampled per-op trace logs are emitted if `traceSampleRate > 0`.
+     */
+    logger?: Logger;
+    /**
+     * Fraction in [0, 1] of get/store ops to log at trace level with the full
+     * identifier. Useful for tracking down hot keys; default 0 (off).
+     */
+    traceSampleRate?: number;
+    /**
+     * Cap on how many distinct key prefixes are tracked in the per-instance
+     * miss-count map. Prevents unbounded memory growth on services with
+     * unexpected key shapes. Default 256.
+     */
+    maxTrackedPrefixes?: number;
+}
+interface InstrumentationStats {
+    hit: number;
+    miss: number;
+    expired: number;
+    store: number;
+    remove: number;
+    error: number;
+    getLatencyMsSum: number;
+    getLatencyMsMax: number;
+    storeLatencyMsSum: number;
+    storeLatencyMsMax: number;
+    payloadBytesSum: number;
+    payloadBytesMax: number;
+    missesByPrefix: Map<string, number>;
+}
+/**
+ * Decorates any QueryResultCache (LRU, Redis-backed, or otherwise) with
+ * OTel metrics + a lightweight in-process counter that can be dumped as a
+ * single log line per Lambda invocation.
+ *
+ * Hit-rate, lookup latency, payload size, and a low-cardinality miss-by-prefix
+ * breakdown all become visible without per-callsite changes. Same wrapper for
+ * every backend, so cross-service comparisons (Redis hit% on alerts-2.0 vs
+ * forwarder, LRU thrash on api-auth) come for free.
+ */
+export declare class InstrumentedQueryResultCache implements QueryResultCache {
+    private readonly inner;
+    private readonly kind;
+    private readonly logger?;
+    private readonly traceSampleRate;
+    private readonly maxTrackedPrefixes;
+    private stats;
+    constructor(inner: QueryResultCache, options: InstrumentedQueryResultCacheOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    synchronize(queryRunner?: QueryRunner): Promise<void>;
+    getFromCache(options: QueryResultCacheOptions, queryRunner?: QueryRunner): Promise<QueryResultCacheOptions | undefined>;
+    storeInCache(options: QueryResultCacheOptions, savedCache?: QueryResultCacheOptions, queryRunner?: QueryRunner): Promise<void>;
+    isExpired(saved: QueryResultCacheOptions): boolean;
+    remove(identifiers: string[], queryRunner?: QueryRunner): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Emit one log line summarizing every op since the last call, then reset.
+     * Intended for per-Lambda-invocation middleware hooks; safe to call
+     * periodically from long-running processes.
+     */
+    flushSummary(): void;
+    /** Test-only / introspection accessor. Do not rely on shape across versions. */
+    snapshotStats(): Readonly<InstrumentationStats>;
+    private trackMissPrefix;
+    private maybeTraceLog;
+}
+export {};

package/dist/cache/InstrumentedQueryResultCache.js

@@ -0,0 +1 @@
+"use strict";var t=require("@opentelemetry/api");const e=()=>({hit:0,miss:0,expired:0,store:0,remove:0,error:0,getLatencyMsSum:0,getLatencyMsMax:0,storeLatencyMsSum:0,storeLatencyMsMax:0,payloadBytesSum:0,payloadBytesMax:0,missesByPrefix:new Map}),s=t.metrics.getMeter("@spytecgps/nova-orm"),r=s.createCounter("nova.cache.ops",{description:"Count of nova-orm query-result cache operations"}),i=s.createHistogram("nova.cache.lookup_duration_ms",{description:"Duration of nova-orm query-result cache lookups",unit:"ms"}),o=s.createHistogram("nova.cache.store_duration_ms",{description:"Duration of nova-orm query-result cache stores",unit:"ms"}),a=s.createHistogram("nova.cache.payload_bytes",{description:"Approximate cached payload size (JSON length proxy)",unit:"By"});const n=/[0-9]/;function c(){const t=process.hrtime();return 1e3*t[0]+t[1]/1e6}function h(t){if(null==t)return 0;if("string"==typeof t)return t.length;if(Buffer.isBuffer(t))return t.length;try{return JSON.stringify(t).length}catch{return 0}}exports.InstrumentedQueryResultCache=class InstrumentedQueryResultCache{inner;kind;logger;traceSampleRate;maxTrackedPrefixes;stats=e();constructor(t,e){this.inner=t,this.kind=e.kind,this.logger=e.logger,this.traceSampleRate=e.traceSampleRate??0,this.maxTrackedPrefixes=e.maxTrackedPrefixes??256}async connect(){return this.inner.connect()}async disconnect(){return this.inner.disconnect()}async synchronize(t){return this.inner.synchronize?.(t)}async getFromCache(t,e){const s=c();try{const o=await this.inner.getFromCache(t,e),n=c()-s;let d;d=o?this.inner.isExpired(o)?"expired":"hit":"miss",this.stats[d]+=1,this.stats.getLatencyMsSum+=n,n>this.stats.getLatencyMsMax&&(this.stats.getLatencyMsMax=n);const u={kind:this.kind,op:"get",outcome:d};if(r.add(1,u),i.record(n,u),"hit"===d&&o){const t=h(o.result);t>0&&a.record(t,{kind:this.kind,op:"get"})}return"hit"!==d&&this.trackMissPrefix(t),this.maybeTraceLog("get",t,n,d),o}catch(t){this.stats.error+=1;const e=c()-s,o={kind:this.kind,op:"get",outcome:"error"};throw r.add(1,o),i.record(e,o),t}}async storeInCache(t,e,s){const i=c();try{await this.inner.storeInCache(t,e,s);const n=c()-i;this.stats.store+=1,this.stats.storeLatencyMsSum+=n,n>this.stats.storeLatencyMsMax&&(this.stats.storeLatencyMsMax=n);const d={kind:this.kind,op:"store",outcome:"ok"};r.add(1,d),o.record(n,d);const u=h(t.result);u>0&&(a.record(u,{kind:this.kind,op:"store"}),this.stats.payloadBytesSum+=u,u>this.stats.payloadBytesMax&&(this.stats.payloadBytesMax=u)),this.maybeTraceLog("store",t,n,"ok")}catch(t){throw this.stats.error+=1,r.add(1,{kind:this.kind,op:"store",outcome:"error"}),t}}isExpired(t){return this.inner.isExpired(t)}async remove(t,e){try{await this.inner.remove(t,e),this.stats.remove+=t.length,r.add(t.length,{kind:this.kind,op:"remove",outcome:"ok"})}catch(t){throw this.stats.error+=1,r.add(1,{kind:this.kind,op:"remove",outcome:"error"}),t}}async clear(){return this.inner.clear()}flushSummary(){if(!this.logger)return void(this.stats=e());const t=this.stats,s=t.hit+t.miss+t.expired,r=s>0?t.hit/s:null,i=s>0?t.getLatencyMsSum/s:0,o=t.store>0?t.storeLatencyMsSum/t.store:0,a=[...t.missesByPrefix.entries()].sort(((t,e)=>e[1]-t[1])).slice(0,10).map((([t,e])=>({prefix:t,count:e})));(s>0||t.store>0||t.remove>0)&&this.logger.info({cache:{kind:this.kind,gets:s,hits:t.hit,misses:t.miss,expired:t.expired,hitRate:r,stores:t.store,removes:t.remove,errors:t.error,avgGetMs:Number(i.toFixed(3)),maxGetMs:Number(t.getLatencyMsMax.toFixed(3)),avgStoreMs:Number(o.toFixed(3)),maxStoreMs:Number(t.storeLatencyMsMax.toFixed(3)),payloadBytesMax:t.payloadBytesMax,payloadBytesAvgStore:t.store>0?Math.round(t.payloadBytesSum/t.store):0,topMissPrefixes:a}},"nova-orm cache summary"),this.stats=e()}snapshotStats(){return this.stats}trackMissPrefix(t){const e=t.identifier??t.query;if(!e)return;const s=function(t){const e=t.split(":"),s=[];for(const t of e)if(t){if(n.test(t[0]))break;if(s.push(t),s.length>=3)break}if(0===s.length){const e=t.indexOf(" ");return e>0?t.slice(0,e):t.slice(0,32)}return s.join(":")}(e),r=this.stats.missesByPrefix,i=r.get(s);void 0!==i?r.set(s,i+1):r.size<this.maxTrackedPrefixes&&r.set(s,1)}maybeTraceLog(t,e,s,r){!this.logger||this.traceSampleRate<=0||Math.random()>=this.traceSampleRate||this.logger.trace({cache:{kind:this.kind,op:t,outcome:r,durationMs:Number(s.toFixed(3)),identifier:e.identifier}},"nova-orm cache op")}};

package/dist/cache/LruQueryResultCache.d.ts

@@ -6,7 +6,15 @@ export interface LruQueryResultCacheConfig {
 }
 export declare class LruQueryResultCache implements QueryResultCache {
     private readonly cache;
+    private readonly maxSize;
     constructor(config?: LruQueryResultCacheConfig);
+    /**
+     * Emit `nova.cache.lru.size` and `nova.cache.lru.max` as observable gauges so
+     * dashboards can tell "is the LRU full?" directly instead of inferring from
+     * hit-rate decay. Filter by `ServiceName` to disambiguate when multiple
+     * DataSources share a process.
+     */
+    private registerSizeGauges;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     synchronize(): Promise<void>;

package/dist/cache/LruQueryResultCache.js

@@ -1 +1 @@
-"use strict";var e=require("lru-cache");exports.LruQueryResultCache=class LruQueryResultCache{cache;constructor(c={}){this.cache=new e.LRUCache({max:c.max??1e3,ttl:c.maxTtlMs})}async connect(){}async disconnect(){this.cache.clear()}async synchronize(){}async getFromCache(e){const c=this.keyFor(e);if(c)return this.cache.get(c)}async storeInCache(e){const c=this.keyFor(e);if(!c)return;const t={...e,time:e.time??Date.now()};this.cache.set(c,t)}isExpired(e){const c=e.time??0;return Date.now()-c>=e.duration}async remove(e){for(const c of e)this.cache.delete(c)}async clear(){this.cache.clear()}keyFor(e){return e.identifier??e.query}};
+"use strict";var e=require("@opentelemetry/api"),c=require("lru-cache");exports.LruQueryResultCache=class LruQueryResultCache{cache;maxSize;constructor(e={}){this.maxSize=e.max??1e3,this.cache=new c.LRUCache({max:this.maxSize,ttl:e.maxTtlMs}),this.registerSizeGauges()}registerSizeGauges(){const c=e.metrics.getMeter("@spytecgps/nova-orm");c.createObservableGauge("nova.cache.lru.size",{description:"Current entry count in the in-process LRU query result cache"}).addCallback((e=>{e.observe(this.cache.size)})),c.createObservableGauge("nova.cache.lru.max",{description:"Configured max entry count for the in-process LRU query result cache"}).addCallback((e=>{e.observe(this.maxSize)}))}async connect(){}async disconnect(){this.cache.clear()}async synchronize(){}async getFromCache(e){const c=this.keyFor(e);if(c)return this.cache.get(c)}async storeInCache(e){const c=this.keyFor(e);if(!c)return;const t={...e,time:e.time??Date.now()};this.cache.set(c,t)}isExpired(e){const c=e.time??0;return Date.now()-c>=e.duration}async remove(e){for(const c of e)this.cache.delete(c)}async clear(){this.cache.clear()}keyFor(e){return e.identifier??e.query}};

package/dist/cache/attachIoredisErrorHandler.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from '../types/logger';
+/**
+ * Shape of TypeORM's RedisQueryResultCache once the underlying client is
+ * materialized. We reach into it via duck-typing because TypeORM does not
+ * export the type.
+ */
+export interface RedisQueryResultCacheLike {
+    client?: {
+        on?: (event: string, fn: (err: Error) => void) => void;
+    };
+    clientType?: string;
+    __novaErrorHandlerAttached?: boolean;
+}
+/**
+ * TypeORM's RedisQueryResultCache only attaches an `error` listener on the
+ * underlying redis client for `clientType === 'redis'`. With `'ioredis'` (what
+ * every hapn service uses to talk to ElastiCache Valkey) the client is an
+ * EventEmitter that crashes the host process on the first unhandled `error`
+ * event — a TLS hiccup or `MOVED` redirect during failover takes down the
+ * Lambda even with `ignoreErrors: true` set in TypeORM config.
+ *
+ * Idempotent: re-running on the same cache is a no-op.
+ *
+ * Returns true if a handler was attached on this call (useful for tests and
+ * for callers that want to observe whether anything happened).
+ */
+export declare function attachIoredisErrorHandler(cache: RedisQueryResultCacheLike | undefined | null, logger: Logger): boolean;

package/dist/cache/attachIoredisErrorHandler.js

@@ -0,0 +1 @@
+"use strict";exports.attachIoredisErrorHandler=function(e,r){return!!e&&(!e.__novaErrorHandlerAttached&&(!!e.clientType?.startsWith("ioredis")&&("function"==typeof e.client?.on&&(e.client.on("error",(e=>{r.warn({message:e.message},"Redis cache connection problem (ignored)")})),e.__novaErrorHandlerAttached=!0,!0))))};

package/dist/cache/buildCacheFromEnv.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Build the TypeORM `cache:` config object from REDIS_* env vars so consumers
+ * don't have to embed mode-switching logic in every service. SSM-driven
+ * `/${stage}/cache/<name>/redis/{host,port,tls,mode}` keys map 1:1 to the env
+ * vars and this helper returns the right TypeORM shape.
+ *
+ * Returns undefined if REDIS_HOST is absent, so it's safe to spread into a
+ * DataSource config that may or may not have a cache configured.
+ *
+ * Supported modes:
+ *   - "standalone" (default): uses TypeORM's built-in RedisQueryResultCache
+ *     with the `ioredis` client type. One node, no cluster topology.
+ *   - "cluster": custom client passed through TypeORM's `client` field; uses
+ *     `ioredis` Cluster mode with the ElastiCache-cluster-mode safety
+ *     defaults baked in (enableOfflineQueue:false, checkServerIdentity bypass
+ *     for TLS — see project_elasticache_cluster_ioredis_tls).
+ */
+export type CacheMode = 'standalone' | 'cluster';
+export interface CacheFromEnvOptions {
+    /** Env var name for host. Default: REDIS_HOST. Override to support multiple caches in one process. */
+    hostEnv?: string;
+    portEnv?: string;
+    tlsEnv?: string;
+    modeEnv?: string;
+}
+export interface BuiltCacheConfig {
+    type?: 'ioredis';
+    options?: Record<string, unknown>;
+    client?: unknown;
+    ignoreErrors?: boolean;
+}
+export declare function buildCacheFromEnv(options?: CacheFromEnvOptions): BuiltCacheConfig | undefined;

package/dist/cache/buildCacheFromEnv.js

@@ -0,0 +1 @@
+"use strict";let e;exports.buildCacheFromEnv=function(r={}){const t=r.hostEnv??"REDIS_HOST",n=r.portEnv??"REDIS_PORT",o=r.tlsEnv??"REDIS_TLS",s=r.modeEnv??"REDIS_MODE",i=process.env[t];if(!i)return;const u=Number(process.env[n]??"6379"),c="true"===process.env[o];if("cluster"===(process.env[s]??"standalone")){const r=function(){if(void 0!==e)return e;try{e=require("ioredis")}catch{e=null}return e}();if(!r)throw new Error("buildCacheFromEnv: REDIS_MODE=cluster requires `ioredis` to be installed");return{client:new r.Cluster([{host:i,port:u}],{redisOptions:c?{tls:{checkServerIdentity:()=>{}}}:{},enableOfflineQueue:!1}),ignoreErrors:!0}}return{type:"ioredis",options:{host:i,port:u,tls:c?{}:void 0},ignoreErrors:!0}};

package/dist/cache/index.d.ts

@@ -1 +1,4 @@
+export { attachIoredisErrorHandler, RedisQueryResultCacheLike } from './attachIoredisErrorHandler';
+export { buildCacheFromEnv, BuiltCacheConfig, CacheFromEnvOptions, CacheMode, } from './buildCacheFromEnv';
+export { CacheKind, InstrumentedQueryResultCache, InstrumentedQueryResultCacheOptions, } from './InstrumentedQueryResultCache';
 export { LruQueryResultCache, LruQueryResultCacheConfig } from './LruQueryResultCache';

package/dist/cache/index.js

@@ -1 +1 @@
-"use strict";var e=require("./LruQueryResultCache.js");exports.LruQueryResultCache=e.LruQueryResultCache;
+"use strict";var e=require("./attachIoredisErrorHandler.js"),r=require("./buildCacheFromEnv.js"),u=require("./InstrumentedQueryResultCache.js"),t=require("./LruQueryResultCache.js");exports.attachIoredisErrorHandler=e.attachIoredisErrorHandler,exports.buildCacheFromEnv=r.buildCacheFromEnv,exports.InstrumentedQueryResultCache=u.InstrumentedQueryResultCache,exports.LruQueryResultCache=t.LruQueryResultCache;

package/dist/migration/_virtual/_virtual_multi-entry.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var _1684483704434AddLowerCaseIndex = require('../1684483704434-addLowerCaseIndex.js');
-var _1684483705002UpdateSecurityUserViewsV2 = require('../1684483705002-updateSecurityUserViewsV2.js');
 var _1684483705001UpdateSecurityUserViewsV1 = require('../1684483705001-updateSecurityUserViewsV1.js');
+var _1684483705002UpdateSecurityUserViewsV2 = require('../1684483705002-updateSecurityUserViewsV2.js');
 var _1746434400000AddQuickSearchFulltextIndexes = require('../1746434400000-addQuickSearchFulltextIndexes.js');
 
 
 
 exports.addLowerCaseIndex1684483704434 = _1684483704434AddLowerCaseIndex.addLowerCaseIndex1684483704434;
-exports.updateSecurityUserViewsV21684483705002 = _1684483705002UpdateSecurityUserViewsV2.updateSecurityUserViewsV21684483705002;
 exports.updateSecurityUserViewsV11684483705001 = _1684483705001UpdateSecurityUserViewsV1.updateSecurityUserViewsV11684483705001;
+exports.updateSecurityUserViewsV21684483705002 = _1684483705002UpdateSecurityUserViewsV2.updateSecurityUserViewsV21684483705002;
 exports.addQuickSearchFulltextIndexes1746434400000 = _1746434400000AddQuickSearchFulltextIndexes.addQuickSearchFulltextIndexes1746434400000;

package/dist/novaDataSource.d.ts

@@ -55,6 +55,18 @@ export declare class NovaDataSource {
      * Performs connection to the database.
      */
     connect(): Promise<void>;
+    /**
+     * Wrap whatever cache provider TypeORM materialized (Redis, our LRU, or any
+     * future provider) with `InstrumentedQueryResultCache` so every consumer gets
+     * hit-rate / latency / payload-size metrics with zero callsite changes. Idempotent.
+     */
+    private wrapQueryResultCache;
+    /**
+     * If the active cache is instrumented, emit its summary log and reset stats.
+     * Safe to call at any time; no-op when the cache isn't instrumented.
+     * Intended for per-Lambda-invocation middleware hooks.
+     */
+    flushCacheSummary(): void;
     /**
      * Closes connection with the database.
      * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.

package/dist/novaDataSource.js

@@ -1 +1 @@
-"use strict";var e=require("@opentelemetry/api"),r=require("typeorm");require("lru-cache");var t=require("./entities/index.js"),a=require("./subscribers/index.js"),s=require("./utils/mysqlSpanProcessor.js"),i=require("./utils/queryLogger.js"),o=require("./utils/queryTags.js"),n=require("./utils/spanSubscriber.js");require("fs"),require("mysql2/promise"),require("path"),require("./types/enums.js"),require("./types/logger.js"),require("./entities/retailAlertExternalRecipient.js"),require("./utils/dateTool.js");exports.NovaDataSource=class NovaDataSource{dataSource;logger;constructor(e,s,o){this.logger=s;const n=[];for(const e in t){const r=t[e];n.push(r)}const c=[];for(const e in a){const r=a[e];c.push(r)}const u={host:"aws.connect.psdb.cloud",port:3306,database:"nova",ssl:{rejectUnauthorized:!0}};this.dataSource=new r.DataSource({type:"mysql",connectorPackage:"mysql2",synchronize:!1,logging:!0,logger:new i.QueryLogger(this.logger,e.logging),entities:n,subscribers:c,migrations:["node_modules/@spytecgps/nova-orm/dist/migration/*.js"],supportBigNumbers:!0,bigNumberStrings:!1,extra:{decimalNumbers:!0},...u,...e,replication:{master:{...u,...e},slaves:o?[{...u,...o}]:[{...u,...e}],defaultMode:e.replicationMode??"master"}})}async connect(){if(!this.dataSource.isInitialized){const r=e.trace.getTracer("@spytecgps/nova-orm");await r.startActiveSpan("nova-orm.connect",(async r=>{try{await this.dataSource.initialize(),r.setAttribute("db.system","mysql");const e=this.dataSource.options;e.database&&r.setAttribute("db.name",e.database),r.setAttribute("nova_orm.entity_count",this.dataSource.entityMetadatas.length)}catch(t){throw r.recordException(t),r.setStatus({code:e.SpanStatusCode.ERROR}),t}finally{r.end()}}))}if(s.isOtelAutoInstrumented())s.installMysqlSpanRenamer();else if(!this.dataSource.subscribers.some((e=>e._spanSubscriber))){const e=n.createSpanSubscriber(this.logger);e._spanSubscriber=!0,this.dataSource.subscribers.push(e)}}async disconnect(){try{this.dataSource.isInitialized&&await this.dataSource.destroy()}catch(e){this.logger.error({error:e},"Failed to close connection to database")}}getRepository(e){return this.dataSource.getRepository(e)}async query(e,r,t){const a=/^\s*(?:\/\*[\s\S]*?\*\/\s*)*(INSERT|UPDATE|DELETE|REPLACE|TRUNCATE|CREATE|ALTER|DROP|RENAME|GRANT|REVOKE|LOCK|UNLOCK|SET|CALL|START|COMMIT|ROLLBACK)\b/i.test(e);if(t?.usePrimary||a)return this.dataSource.query(e,r,null);const s=this.dataSource.createQueryRunner("slave");try{return await s.query(e,r)}finally{await s.release()}}async createQueryBuilder(e,r){return this.dataSource.createQueryBuilder(e,r,null)}createQueryRunner(e){return this.dataSource.createQueryRunner(e)}createQueryRunnerFromParams(e){const r=e?.queryOptions?.forceUseReplica?"slave":"master";return this.logger.trace({replicationMode:r},"Creating query runner with replication mode"),this.dataSource.createQueryRunner(r)}async safeQuery(e,r,t){try{await this.connect();return await e(this,t)}catch(e){throw this.logger.error({error:e},r?r+" ":"Error while executing query"),e}finally{t&&await t.release(),await this.disconnect()}}async safeQuery2(r,t,a){this.dataSource.isInitialized||(this.logger.info("nova-orm new connection"),await this.connect());return e.trace.getTracer("nova-orm").startActiveSpan(t??"safeQuery2",(async s=>{try{return await r(this,a)}catch(r){throw s.recordException(r),s.setStatus({code:e.SpanStatusCode.ERROR,message:r?.message}),this.logger.error({error:r},t?t+" ":"Error while executing query"),r}finally{s.end(),a&&await a.release()}}))}async safeQuery3(e,r,t,{replicationMode:a,tag:s}={}){return(async()=>{let i;try{await this.connect(),a?(this.logger.trace({replicationMode:a},"Creating query runner with replication mode"),i=this.dataSource.createQueryRunner(a)):this.logger.trace({replicationMode:this.dataSource.defaultReplicationModeForReads},"Creating query builder with default replication mode for reads");const n=this.dataSource.createQueryBuilder(e,r,i);s&&n.comment(o.queryTags({action:s}));return await t(n)}catch(e){throw this.logger.error({error:e},s?s+" ":"Error while executing query"),e}finally{i&&await i.release()}})()}async syncSchema(e=!0){this.logger.warn("Initiating schema sync"),await this.connect(),await this.dataSource.synchronize(e),await this.dataSource.runMigrations()}async clearCache(){this.dataSource.queryResultCache?(this.logger.info("Clearing query result cache"),await this.dataSource.queryResultCache.clear()):this.logger.info("No query result cache to clear")}async invalidateCacheKey(e){this.dataSource.queryResultCache&&(this.logger.info("Invalidating cache key",{key:e}),await this.dataSource.queryResultCache.remove([e]))}};
+"use strict";var e=require("@opentelemetry/api"),r=require("typeorm"),t=require("./cache/attachIoredisErrorHandler.js"),a=require("./cache/InstrumentedQueryResultCache.js"),s=require("./cache/LruQueryResultCache.js"),i=require("./entities/index.js"),n=require("./subscribers/index.js"),o=require("./utils/mysqlSpanProcessor.js"),c=require("./utils/queryLogger.js"),u=require("./utils/queryTags.js"),l=require("./utils/spanSubscriber.js");require("fs"),require("mysql2/promise"),require("path"),require("./types/enums.js"),require("./types/logger.js"),require("./entities/retailAlertExternalRecipient.js"),require("./utils/dateTool.js");exports.NovaDataSource=class NovaDataSource{dataSource;logger;constructor(e,t,a){this.logger=t;const s=[];for(const e in i){const r=i[e];s.push(r)}const o=[];for(const e in n){const r=n[e];o.push(r)}const u={host:"aws.connect.psdb.cloud",port:3306,database:"nova",ssl:{rejectUnauthorized:!0}};this.dataSource=new r.DataSource({type:"mysql",connectorPackage:"mysql2",synchronize:!1,logging:!0,logger:new c.QueryLogger(this.logger,e.logging),entities:s,subscribers:o,migrations:["node_modules/@spytecgps/nova-orm/dist/migration/*.js"],supportBigNumbers:!0,bigNumberStrings:!1,extra:{decimalNumbers:!0},...u,...e,replication:{master:{...u,...e},slaves:a?[{...u,...a}]:[{...u,...e}],defaultMode:e.replicationMode??"master"}})}async connect(){if(!this.dataSource.isInitialized){const r=e.trace.getTracer("@spytecgps/nova-orm");await r.startActiveSpan("nova-orm.connect",(async r=>{try{await this.dataSource.initialize(),r.setAttribute("db.system","mysql");const e=this.dataSource.options;e.database&&r.setAttribute("db.name",e.database),r.setAttribute("nova_orm.entity_count",this.dataSource.entityMetadatas.length)}catch(t){throw r.recordException(t),r.setStatus({code:e.SpanStatusCode.ERROR}),t}finally{r.end()}}))}if(o.isOtelAutoInstrumented())o.installMysqlSpanRenamer();else if(!this.dataSource.subscribers.some((e=>e._spanSubscriber))){const e=l.createSpanSubscriber(this.logger);e._spanSubscriber=!0,this.dataSource.subscribers.push(e)}this.wrapQueryResultCache()}wrapQueryResultCache(){const e=this.dataSource.queryResultCache;if(!e||e.__novaInstrumented)return;let r="unknown";e instanceof s.LruQueryResultCache?r="lru":"RedisQueryResultCache"===e.constructor?.name&&(r="redis",t.attachIoredisErrorHandler(e,this.logger));const i=new a.InstrumentedQueryResultCache(e,{kind:r,logger:this.logger});i.__novaInstrumented=!0,this.dataSource.queryResultCache=i}flushCacheSummary(){const e=this.dataSource.queryResultCache;e instanceof a.InstrumentedQueryResultCache&&e.flushSummary()}async disconnect(){try{this.dataSource.isInitialized&&await this.dataSource.destroy()}catch(e){this.logger.error({error:e},"Failed to close connection to database")}}getRepository(e){return this.dataSource.getRepository(e)}async query(e,r,t){const a=/^\s*(?:\/\*[\s\S]*?\*\/\s*)*(INSERT|UPDATE|DELETE|REPLACE|TRUNCATE|CREATE|ALTER|DROP|RENAME|GRANT|REVOKE|LOCK|UNLOCK|SET|CALL|START|COMMIT|ROLLBACK)\b/i.test(e);if(t?.usePrimary||a)return this.dataSource.query(e,r,null);const s=this.dataSource.createQueryRunner("slave");try{return await s.query(e,r)}finally{await s.release()}}async createQueryBuilder(e,r){return this.dataSource.createQueryBuilder(e,r,null)}createQueryRunner(e){return this.dataSource.createQueryRunner(e)}createQueryRunnerFromParams(e){const r=e?.queryOptions?.forceUseReplica?"slave":"master";return this.logger.trace({replicationMode:r},"Creating query runner with replication mode"),this.dataSource.createQueryRunner(r)}async safeQuery(e,r,t){try{await this.connect();return await e(this,t)}catch(e){throw this.logger.error({error:e},r?r+" ":"Error while executing query"),e}finally{t&&await t.release(),await this.disconnect()}}async safeQuery2(r,t,a){this.dataSource.isInitialized||(this.logger.info("nova-orm new connection"),await this.connect());return e.trace.getTracer("nova-orm").startActiveSpan(t??"safeQuery2",(async s=>{try{return await r(this,a)}catch(r){throw s.recordException(r),s.setStatus({code:e.SpanStatusCode.ERROR,message:r?.message}),this.logger.error({error:r},t?t+" ":"Error while executing query"),r}finally{s.end(),a&&await a.release()}}))}async safeQuery3(e,r,t,{replicationMode:a,tag:s}={}){return(async()=>{let i;try{await this.connect(),a?(this.logger.trace({replicationMode:a},"Creating query runner with replication mode"),i=this.dataSource.createQueryRunner(a)):this.logger.trace({replicationMode:this.dataSource.defaultReplicationModeForReads},"Creating query builder with default replication mode for reads");const n=this.dataSource.createQueryBuilder(e,r,i);s&&n.comment(u.queryTags({action:s}));return await t(n)}catch(e){throw this.logger.error({error:e},s?s+" ":"Error while executing query"),e}finally{i&&await i.release()}})()}async syncSchema(e=!0){this.logger.warn("Initiating schema sync"),await this.connect(),await this.dataSource.synchronize(e),await this.dataSource.runMigrations()}async clearCache(){this.dataSource.queryResultCache?(this.logger.info("Clearing query result cache"),await this.dataSource.queryResultCache.clear()):this.logger.info("No query result cache to clear")}async invalidateCacheKey(e){this.dataSource.queryResultCache&&(this.logger.info("Invalidating cache key",{key:e}),await this.dataSource.queryResultCache.remove([e]))}};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spytecgps/nova-orm",
-  "version": "1.4.240",
+  "version": "1.4.242",
   "description": "ORM with PlanetScale",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/schema.sql

@@ -1,6 +1,6 @@
--- nova-orm-schema-checksum: 974548f26b51576a57369da39c7884de
+-- nova-orm-schema-checksum: bdf84e9724e3cf6c308f89f1c1871778
 -- Nova ORM Schema Dump
--- Generated at: 2026-05-20T16:22:54.266Z
+-- Generated at: 2026-05-24T15:55:45.644Z
 
 SET FOREIGN_KEY_CHECKS = 0;