@lensjs/core 2.2.2 → 2.3.1

package/dist/stores/queued_sqlite.cjs

@@ -0,0 +1,313 @@
+"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/stores/queued_sqlite.ts
+var queued_sqlite_exports = {};
+__export(queued_sqlite_exports, {
+  default: () => QueuedSqliteStore
+});
+module.exports = __toCommonJS(queued_sqlite_exports);
+
+// 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.storeConfig = config;
+      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/abstracts/store.ts
+var Store = class {
+  storeConfig;
+  constructor(...args) {
+  }
+  getAllExceptions(_paginationParams) {
+    return this.defaultMinimalPaginate();
+  }
+  stringifyData(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    try {
+      return JSON.stringify(data);
+    } catch (e) {
+      console.error(`Failed to stringify lens data: ${e}`);
+    }
+  }
+  defaultMinimalPaginate() {
+    return Promise.resolve({
+      data: [],
+      meta: {
+        currentPage: 0,
+        lastPage: 0,
+        total: 0
+      }
+    });
+  }
+};
+
+// src/stores/better_sqlite.ts
+var import_crypto = require("crypto");
+var import_libsql = __toESM(require("libsql"), 1);
+var import_date = require("@lensjs/date");
+var TABLE_NAME = "lens_entries";
+var BYTES_IN_GB = 1024 * 1024 * 1024;
+var PRUNE_BATCH_SIZE = 1e3;
+var BetterSqliteStore = class extends Store {
+  connection;
+  async initialize() {
+    this.connection = new import_libsql.default("lens.db");
+    this.setupSchema();
+    console.log("Connected to Lens (SQLite) database.");
+  }
+  async truncate() {
+    this.connection.prepare(`DELETE FROM ${TABLE_NAME};`).run();
+  }
+  async save(entry) {
+    this.connection.prepare(
+      `INSERT INTO ${TABLE_NAME} (id, data, type, created_at, lens_entry_id, minimal_data) values($id, $data, $type, $created_at, $lens_entry_id, $minimalData)`
+    ).run({
+      id: entry.id ?? (0, import_crypto.randomUUID)(),
+      data: this.stringifyData(entry.data),
+      type: entry.type,
+      created_at: entry.timestamp ?? (0, import_date.nowISO)(),
+      lens_entry_id: entry.requestId || null,
+      minimalData: this.stringifyData(entry.minimal_data ?? {})
+    });
+    this.maybePruneDatabase();
+  }
+  async getAllQueries(pagination) {
+    return await this.paginate("query" /* QUERY */, pagination);
+  }
+  async getAllRequests(pagination) {
+    return await this.paginate("request" /* REQUEST */, pagination, false);
+  }
+  async getAllCacheEntries(pagination) {
+    return await this.paginate("cache" /* CACHE */, pagination);
+  }
+  async getAllExceptions(pagination) {
+    return await this.paginate("exception" /* EXCEPTION */, pagination, false);
+  }
+  async allByRequestId(requestId, type, includeFullData = true) {
+    const rows = this.connection.prepare(
+      `${this.getSelectedColumns(includeFullData)} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
+    ).all({ type, requestId });
+    return this.mapRows(rows, includeFullData);
+  }
+  async paginate(type, { page, perPage }, includeFullData = true) {
+    const offset = (page - 1) * perPage;
+    const query = `${this.getSelectedColumns(
+      includeFullData
+    )} FROM ${TABLE_NAME} WHERE type = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+    const count = await this.count(type);
+    const rows = this.connection.prepare(query).all(type, perPage, offset);
+    const mappedRows = this.mapRows(rows, includeFullData);
+    return {
+      meta: {
+        total: count,
+        lastPage: Math.ceil(count / perPage),
+        currentPage: page
+      },
+      data: mappedRows
+    };
+  }
+  async count(type) {
+    const result = this.connection.prepare(`SELECT count(*) as count FROM ${TABLE_NAME} WHERE type = ?`).get(type);
+    return Number(result.count);
+  }
+  async find(type, id) {
+    const row = this.connection.prepare(
+      `${this.getSelectedColumns()} FROM ${TABLE_NAME} WHERE id = ? AND type = ? LIMIT 1`
+    ).get(id, type);
+    if (!row) {
+      return null;
+    }
+    return this.mapRow(row, true);
+  }
+  setupSchema() {
+    this.connection.exec("PRAGMA journal_mode = WAL;");
+    this.connection.exec("PRAGMA synchronous = NORMAL;");
+    const createTable = `
+      CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (
+        id TEXT PRIMARY KEY,
+        minimal_data TEXT,
+        data TEXT NOT NULL,
+        type TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        lens_entry_id TEXT NULL
+      );
+    `;
+    const createIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entries_id_type_index
+      ON ${TABLE_NAME} (id, type);
+    `;
+    const lensEntryIdIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entry_id_index
+      ON ${TABLE_NAME} (lens_entry_id);
+    `;
+    this.connection.exec(createTable);
+    this.connection.exec(createIndex);
+    this.connection.exec(lensEntryIdIndex);
+  }
+  maybePruneDatabase() {
+    const maxGb = this.storeConfig?.dbMaxSizeGb;
+    const pruneGb = this.storeConfig?.dbPruneSizeGb;
+    if (!maxGb || !pruneGb) return;
+    const maxBytes = maxGb * BYTES_IN_GB;
+    const pruneBytes = pruneGb * BYTES_IN_GB;
+    if (maxBytes <= 0 || pruneBytes <= 0) return;
+    const targetBytes = Math.max(0, maxBytes - pruneBytes);
+    let usedBytes = this.getDatabaseUsedBytes();
+    if (usedBytes < maxBytes) return;
+    while (usedBytes > targetBytes) {
+      const deletedRows = this.deleteOldestEntries(PRUNE_BATCH_SIZE);
+      if (deletedRows === 0) break;
+      usedBytes = this.getDatabaseUsedBytes();
+    }
+    this.connection.exec("PRAGMA wal_checkpoint(TRUNCATE);");
+  }
+  getDatabaseUsedBytes() {
+    const pageSizeResult = this.connection.prepare("PRAGMA page_size;").get();
+    const pageCountResult = this.connection.prepare("PRAGMA page_count;").get();
+    const freelistCountResult = this.connection.prepare("PRAGMA freelist_count;").get();
+    const usedPages = pageCountResult.page_count - freelistCountResult.freelist_count;
+    return usedPages * pageSizeResult.page_size;
+  }
+  deleteOldestEntries(batchSize) {
+    const result = this.connection.prepare(
+      `DELETE FROM ${TABLE_NAME} WHERE id IN (SELECT id FROM ${TABLE_NAME} ORDER BY created_at ASC LIMIT ?)`
+    ).run(batchSize);
+    return Number(result.changes ?? 0);
+  }
+  mapRow(row, includeFullData = true) {
+    let data = includeFullData ? JSON.parse(row.data) : {};
+    if (!includeFullData) {
+      data = JSON.parse(row.minimal_data);
+    }
+    return {
+      id: row.id,
+      type: row.type,
+      created_at: row.created_at,
+      lens_entry_id: row.lens_entry_id,
+      data
+    };
+  }
+  mapRows(rows, includeFullData = true) {
+    let mappedRows = [];
+    for (const row of rows) {
+      mappedRows.push(this.mapRow(row, includeFullData));
+    }
+    return mappedRows;
+  }
+  getSelectedColumns(includeFullData = true) {
+    return `SELECT id, minimal_data, type, created_at, lens_entry_id ${includeFullData ? ",data" : ""}`;
+  }
+};
+
+// src/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};

package/dist/stores/queued_sqlite.d.cts

@@ -0,0 +1,43 @@
+import BetterSqliteStore from './better_sqlite.cjs';
+import * as denque from 'denque';
+import { WatcherTypeEnum } from '../types/index.cjs';
+import '../abstracts/store.cjs';
+import 'sql-formatter';
+import 'libsql';
+
+declare const QueuedSqliteStore_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        queue: denque<{
+            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>;
+    };
+} & typeof BetterSqliteStore;
+declare class QueuedSqliteStore extends QueuedSqliteStore_base {
+}
+
+export { QueuedSqliteStore as default };

package/dist/stores/queued_sqlite.d.ts

@@ -0,0 +1,43 @@
+import BetterSqliteStore from './better_sqlite.js';
+import * as denque from 'denque';
+import { WatcherTypeEnum } from '../types/index.js';
+import '../abstracts/store.js';
+import 'sql-formatter';
+import 'libsql';
+
+declare const QueuedSqliteStore_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        queue: denque<{
+            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>;
+    };
+} & typeof BetterSqliteStore;
+declare class QueuedSqliteStore extends QueuedSqliteStore_base {
+}
+
+export { QueuedSqliteStore as default };

package/dist/stores/queued_sqlite.js

@@ -0,0 +1,280 @@
+// 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.storeConfig = config;
+      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/abstracts/store.ts
+var Store = class {
+  storeConfig;
+  constructor(...args) {
+  }
+  getAllExceptions(_paginationParams) {
+    return this.defaultMinimalPaginate();
+  }
+  stringifyData(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    try {
+      return JSON.stringify(data);
+    } catch (e) {
+      console.error(`Failed to stringify lens data: ${e}`);
+    }
+  }
+  defaultMinimalPaginate() {
+    return Promise.resolve({
+      data: [],
+      meta: {
+        currentPage: 0,
+        lastPage: 0,
+        total: 0
+      }
+    });
+  }
+};
+
+// src/stores/better_sqlite.ts
+import { randomUUID } from "crypto";
+import Database from "libsql";
+import { nowISO } from "@lensjs/date";
+var TABLE_NAME = "lens_entries";
+var BYTES_IN_GB = 1024 * 1024 * 1024;
+var PRUNE_BATCH_SIZE = 1e3;
+var BetterSqliteStore = class extends Store {
+  connection;
+  async initialize() {
+    this.connection = new Database("lens.db");
+    this.setupSchema();
+    console.log("Connected to Lens (SQLite) database.");
+  }
+  async truncate() {
+    this.connection.prepare(`DELETE FROM ${TABLE_NAME};`).run();
+  }
+  async save(entry) {
+    this.connection.prepare(
+      `INSERT INTO ${TABLE_NAME} (id, data, type, created_at, lens_entry_id, minimal_data) values($id, $data, $type, $created_at, $lens_entry_id, $minimalData)`
+    ).run({
+      id: entry.id ?? randomUUID(),
+      data: this.stringifyData(entry.data),
+      type: entry.type,
+      created_at: entry.timestamp ?? nowISO(),
+      lens_entry_id: entry.requestId || null,
+      minimalData: this.stringifyData(entry.minimal_data ?? {})
+    });
+    this.maybePruneDatabase();
+  }
+  async getAllQueries(pagination) {
+    return await this.paginate("query" /* QUERY */, pagination);
+  }
+  async getAllRequests(pagination) {
+    return await this.paginate("request" /* REQUEST */, pagination, false);
+  }
+  async getAllCacheEntries(pagination) {
+    return await this.paginate("cache" /* CACHE */, pagination);
+  }
+  async getAllExceptions(pagination) {
+    return await this.paginate("exception" /* EXCEPTION */, pagination, false);
+  }
+  async allByRequestId(requestId, type, includeFullData = true) {
+    const rows = this.connection.prepare(
+      `${this.getSelectedColumns(includeFullData)} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
+    ).all({ type, requestId });
+    return this.mapRows(rows, includeFullData);
+  }
+  async paginate(type, { page, perPage }, includeFullData = true) {
+    const offset = (page - 1) * perPage;
+    const query = `${this.getSelectedColumns(
+      includeFullData
+    )} FROM ${TABLE_NAME} WHERE type = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+    const count = await this.count(type);
+    const rows = this.connection.prepare(query).all(type, perPage, offset);
+    const mappedRows = this.mapRows(rows, includeFullData);
+    return {
+      meta: {
+        total: count,
+        lastPage: Math.ceil(count / perPage),
+        currentPage: page
+      },
+      data: mappedRows
+    };
+  }
+  async count(type) {
+    const result = this.connection.prepare(`SELECT count(*) as count FROM ${TABLE_NAME} WHERE type = ?`).get(type);
+    return Number(result.count);
+  }
+  async find(type, id) {
+    const row = this.connection.prepare(
+      `${this.getSelectedColumns()} FROM ${TABLE_NAME} WHERE id = ? AND type = ? LIMIT 1`
+    ).get(id, type);
+    if (!row) {
+      return null;
+    }
+    return this.mapRow(row, true);
+  }
+  setupSchema() {
+    this.connection.exec("PRAGMA journal_mode = WAL;");
+    this.connection.exec("PRAGMA synchronous = NORMAL;");
+    const createTable = `
+      CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (
+        id TEXT PRIMARY KEY,
+        minimal_data TEXT,
+        data TEXT NOT NULL,
+        type TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        lens_entry_id TEXT NULL
+      );
+    `;
+    const createIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entries_id_type_index
+      ON ${TABLE_NAME} (id, type);
+    `;
+    const lensEntryIdIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entry_id_index
+      ON ${TABLE_NAME} (lens_entry_id);
+    `;
+    this.connection.exec(createTable);
+    this.connection.exec(createIndex);
+    this.connection.exec(lensEntryIdIndex);
+  }
+  maybePruneDatabase() {
+    const maxGb = this.storeConfig?.dbMaxSizeGb;
+    const pruneGb = this.storeConfig?.dbPruneSizeGb;
+    if (!maxGb || !pruneGb) return;
+    const maxBytes = maxGb * BYTES_IN_GB;
+    const pruneBytes = pruneGb * BYTES_IN_GB;
+    if (maxBytes <= 0 || pruneBytes <= 0) return;
+    const targetBytes = Math.max(0, maxBytes - pruneBytes);
+    let usedBytes = this.getDatabaseUsedBytes();
+    if (usedBytes < maxBytes) return;
+    while (usedBytes > targetBytes) {
+      const deletedRows = this.deleteOldestEntries(PRUNE_BATCH_SIZE);
+      if (deletedRows === 0) break;
+      usedBytes = this.getDatabaseUsedBytes();
+    }
+    this.connection.exec("PRAGMA wal_checkpoint(TRUNCATE);");
+  }
+  getDatabaseUsedBytes() {
+    const pageSizeResult = this.connection.prepare("PRAGMA page_size;").get();
+    const pageCountResult = this.connection.prepare("PRAGMA page_count;").get();
+    const freelistCountResult = this.connection.prepare("PRAGMA freelist_count;").get();
+    const usedPages = pageCountResult.page_count - freelistCountResult.freelist_count;
+    return usedPages * pageSizeResult.page_size;
+  }
+  deleteOldestEntries(batchSize) {
+    const result = this.connection.prepare(
+      `DELETE FROM ${TABLE_NAME} WHERE id IN (SELECT id FROM ${TABLE_NAME} ORDER BY created_at ASC LIMIT ?)`
+    ).run(batchSize);
+    return Number(result.changes ?? 0);
+  }
+  mapRow(row, includeFullData = true) {
+    let data = includeFullData ? JSON.parse(row.data) : {};
+    if (!includeFullData) {
+      data = JSON.parse(row.minimal_data);
+    }
+    return {
+      id: row.id,
+      type: row.type,
+      created_at: row.created_at,
+      lens_entry_id: row.lens_entry_id,
+      data
+    };
+  }
+  mapRows(rows, includeFullData = true) {
+    let mappedRows = [];
+    for (const row of rows) {
+      mappedRows.push(this.mapRow(row, includeFullData));
+    }
+    return mappedRows;
+  }
+  getSelectedColumns(includeFullData = true) {
+    return `SELECT id, minimal_data, type, created_at, lens_entry_id ${includeFullData ? ",data" : ""}`;
+  }
+};
+
+// src/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};
+export {
+  QueuedSqliteStore as default
+};