@lensjs/core 2.2.1 → 2.3.0

package/dist/mixins/queued_store.cjs

@@ -0,0 +1,113 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mixins/queued_store.ts
+var queued_store_exports = {};
+__export(queued_store_exports, {
+  QueuedStore: () => QueuedStore
+});
+module.exports = __toCommonJS(queued_store_exports);
+var import_denque = __toESM(require("denque"), 1);
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new import_denque.default([], { capacity: this.WARN_THRESHOLD * 2 }) : new import_denque.default();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueuedStore
+});

package/dist/mixins/queued_store.d.cts

@@ -0,0 +1,38 @@
+import denque__default from 'denque';
+import { Constructor, WatcherTypeEnum } from '../types/index.cjs';
+import 'sql-formatter';
+
+declare function QueuedStore<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {
+        [x: string]: any;
+        queue: denque__default<{
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }>;
+        processingInterval: NodeJS.Timeout | null;
+        readonly BATCH_SIZE: number;
+        readonly PROCESS_INTERVAL_MS: number;
+        readonly WARN_THRESHOLD: number;
+        readonly PREALLOCATE: boolean;
+        initialize(): Promise<void>;
+        truncate(): Promise<void>;
+        save(entry: {
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }): Promise<void>;
+        startProcessingQueue(): void;
+        processQueue(): Promise<void>;
+        stopProcessingQueue(): Promise<void>;
+        shutdown(): Promise<void>;
+    };
+} & TBase;
+
+export { QueuedStore };

package/dist/mixins/queued_store.d.ts

@@ -0,0 +1,38 @@
+import denque__default from 'denque';
+import { Constructor, WatcherTypeEnum } from '../types/index.js';
+import 'sql-formatter';
+
+declare function QueuedStore<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {
+        [x: string]: any;
+        queue: denque__default<{
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }>;
+        processingInterval: NodeJS.Timeout | null;
+        readonly BATCH_SIZE: number;
+        readonly PROCESS_INTERVAL_MS: number;
+        readonly WARN_THRESHOLD: number;
+        readonly PREALLOCATE: boolean;
+        initialize(): Promise<void>;
+        truncate(): Promise<void>;
+        save(entry: {
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }): Promise<void>;
+        startProcessingQueue(): void;
+        processQueue(): Promise<void>;
+        stopProcessingQueue(): Promise<void>;
+        shutdown(): Promise<void>;
+    };
+} & TBase;
+
+export { QueuedStore };

package/dist/mixins/queued_store.js

@@ -0,0 +1,78 @@
+// src/mixins/queued_store.ts
+import Denque from "denque";
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new Denque([], { capacity: this.WARN_THRESHOLD * 2 }) : new Denque();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+export {
+  QueuedStore
+};

package/dist/stores/better_sqlite.cjs

@@ -36,6 +36,8 @@ module.exports = __toCommonJS(better_sqlite_exports);
 
 // src/abstracts/store.ts
 var Store = class {
+  constructor(...args) {
+  }
   getAllExceptions(_paginationParams) {
     return this.defaultMinimalPaginate();
   }

package/dist/stores/better_sqlite.js

@@ -1,5 +1,7 @@
 // src/abstracts/store.ts
 var Store = class {
+  constructor(...args) {
+  }
   getAllExceptions(_paginationParams) {
     return this.defaultMinimalPaginate();
   }

package/dist/stores/index.cjs

@@ -30,12 +30,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/stores/index.ts
 var stores_exports = {};
 __export(stores_exports, {
-  BetterSqliteStore: () => BetterSqliteStore
+  BetterSqliteStore: () => BetterSqliteStore,
+  QueuedSqliteStore: () => QueuedSqliteStore
 });
 module.exports = __toCommonJS(stores_exports);
 
 // src/abstracts/store.ts
 var Store = class {
+  constructor(...args) {
+  }
   getAllExceptions(_paginationParams) {
     return this.defaultMinimalPaginate();
   }
@@ -186,7 +189,96 @@ var BetterSqliteStore = class extends Store {
     return `SELECT id, minimal_data, type, created_at, lens_entry_id ${includeFullData ? ",data" : ""}`;
   }
 };
+
+// src/mixins/queued_store.ts
+var import_denque = __toESM(require("denque"), 1);
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new import_denque.default([], { capacity: this.WARN_THRESHOLD * 2 }) : new import_denque.default();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+
+// src/utils/compose.ts
+function compose(superclass, ...mixins) {
+  return mixins.reduce((c, mixin) => mixin(c), superclass);
+}
+
+// src/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BetterSqliteStore
+  BetterSqliteStore,
+  QueuedSqliteStore
 });

package/dist/stores/index.d.cts

@@ -1,5 +1,7 @@
 export { default as BetterSqliteStore } from './better_sqlite.cjs';
+export { default as QueuedSqliteStore } from './queued_sqlite.cjs';
 import '../abstracts/store.cjs';
 import '../types/index.cjs';
 import 'sql-formatter';
 import 'libsql';
+import 'denque';

package/dist/stores/index.d.ts

@@ -1,5 +1,7 @@
 export { default as BetterSqliteStore } from './better_sqlite.js';
+export { default as QueuedSqliteStore } from './queued_sqlite.js';
 import '../abstracts/store.js';
 import '../types/index.js';
 import 'sql-formatter';
 import 'libsql';
+import 'denque';

package/dist/stores/index.js

@@ -1,5 +1,7 @@
 // src/abstracts/store.ts
 var Store = class {
+  constructor(...args) {
+  }
   getAllExceptions(_paginationParams) {
     return this.defaultMinimalPaginate();
   }
@@ -150,6 +152,95 @@ var BetterSqliteStore = class extends Store {
     return `SELECT id, minimal_data, type, created_at, lens_entry_id ${includeFullData ? ",data" : ""}`;
   }
 };
+
+// src/mixins/queued_store.ts
+import Denque from "denque";
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new Denque([], { capacity: this.WARN_THRESHOLD * 2 }) : new Denque();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+
+// src/utils/compose.ts
+function compose(superclass, ...mixins) {
+  return mixins.reduce((c, mixin) => mixin(c), superclass);
+}
+
+// src/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};
 export {
-  BetterSqliteStore
+  BetterSqliteStore,
+  QueuedSqliteStore
 };