@peers-app/peers-sdk 0.19.6 → 0.19.7

package/dist/logging/console-logs.table.d.ts

@@ -33,16 +33,35 @@ export declare const consoleLogSchema: z.ZodObject<{
     stackTrace?: string | undefined;
 }>;
 export type IConsoleLog = z.infer<typeof consoleLogSchema>;
+/** Cutoff within this many ms of `Date.now()` is treated as "clear all" (manual clear). */
+export declare const CLEAR_ALL_CUTOFF_SLACK_MS = 5000;
+/**
+ * Returns whether a cutoff timestamp should trigger a full-table clear (drop + recreate)
+ * rather than a conditional delete. Used when the UI calls `deleteOldLogs(Date.now())`.
+ * @param cutoffTimestamp - Millisecond cutoff passed to `deleteOldLogs`
+ */
+export declare function isClearAllCutoff(cutoffTimestamp: number): boolean;
+/**
+ * System table for cross-process console log storage with automatic TTL cleanup.
+ */
 export declare class ConsoleLogsTable extends Table<IConsoleLog> {
     readonly LOG_TTL: number;
     readonly LOG_CLEANUP_INTERVAL: number;
     constructor(metaData: ITableMetaData, deps: ITableDependencies);
     private logCleanupInitialized;
+    /** Schedules startup and daily cleanup of logs older than {@link LOG_TTL}. */
     initializeLogCleanup(): Promise<void>;
+    private resolveSqlDataSource;
+    /**
+     * Remove console logs older than `cutoffTimestamp`.
+     *
+     * When the cutoff is near `Date.now()` (within {@link CLEAR_ALL_CUTOFF_SLACK_MS}), uses
+     * drop + recreate for a fast full clear. Otherwise deletes rows with `timestamp < cutoff`.
+     * @param cutoffTimestamp - Defaults to seven days ago for scheduled TTL cleanup
+     */
     deleteOldLogs(cutoffTimestamp?: number): Promise<void>;
 }
 /**
- * We always use the user's personal data context so all logs are written to the same place.  This requires
- * that the table be accessed in an asynchronous way
+ * Returns the user's personal {@link ConsoleLogsTable} (logs are not synced across devices).
  */
 export declare function ConsoleLogs(): Promise<ConsoleLogsTable>;

package/dist/logging/console-logs.table.js

@@ -34,7 +34,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     done = true;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsoleLogsTable = exports.consoleLogSchema = void 0;
+exports.ConsoleLogsTable = exports.CLEAR_ALL_CUTOFF_SLACK_MS = exports.consoleLogSchema = void 0;
+exports.isClearAllCutoff = isClearAllCutoff;
 exports.ConsoleLogs = ConsoleLogs;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
@@ -57,6 +58,8 @@ exports.consoleLogSchema = zod_1.z.object({
     context: zod_types_1.zodAnyObjectOrArray.optional().describe("Additional structured context data"),
     stackTrace: zod_1.z.string().optional().describe("Stack trace for errors"),
 });
+/** Cutoff within this many ms of `Date.now()` is treated as "clear all" (manual clear). */
+exports.CLEAR_ALL_CUTOFF_SLACK_MS = 5000;
 const metaData = {
     name: "ConsoleLogs",
     description: "System-wide console log entries with cross-process visibility.",
@@ -70,6 +73,17 @@ const metaData = {
         { fields: ["processInstanceId"] },
     ],
 };
+/**
+ * Returns whether a cutoff timestamp should trigger a full-table clear (drop + recreate)
+ * rather than a conditional delete. Used when the UI calls `deleteOldLogs(Date.now())`.
+ * @param cutoffTimestamp - Millisecond cutoff passed to `deleteOldLogs`
+ */
+function isClearAllCutoff(cutoffTimestamp) {
+    return cutoffTimestamp >= Date.now() - exports.CLEAR_ALL_CUTOFF_SLACK_MS;
+}
+/**
+ * System table for cross-process console log storage with automatic TTL cleanup.
+ */
 let ConsoleLogsTable = (() => {
     let _classSuper = orm_1.Table;
     let _instanceExtraInitializers = [];
@@ -93,6 +107,7 @@ let ConsoleLogsTable = (() => {
             }
         }
         logCleanupInitialized = false;
+        /** Schedules startup and daily cleanup of logs older than {@link LOG_TTL}. */
         async initializeLogCleanup() {
             if (this.logCleanupInitialized) {
                 return;
@@ -104,30 +119,57 @@ let ConsoleLogsTable = (() => {
             // TODO - consider doing this as a workflow
             setInterval(() => this.deleteOldLogs(), this.LOG_CLEANUP_INTERVAL);
         }
-        async deleteOldLogs(cutoffTimestamp = Date.now() - 7 * 24 * 60 * 60 * 1000) {
+        resolveSqlDataSource() {
+            let ds = this.dataSource;
+            while (!(ds instanceof orm_1.SQLDataSource) && ds.dataSource) {
+                ds = ds.dataSource;
+            }
+            return ds instanceof orm_1.SQLDataSource ? ds : undefined;
+        }
+        /**
+         * Remove console logs older than `cutoffTimestamp`.
+         *
+         * When the cutoff is near `Date.now()` (within {@link CLEAR_ALL_CUTOFF_SLACK_MS}), uses
+         * drop + recreate for a fast full clear. Otherwise deletes rows with `timestamp < cutoff`.
+         * @param cutoffTimestamp - Defaults to seven days ago for scheduled TTL cleanup
+         */
+        async deleteOldLogs(cutoffTimestamp = Date.now() - 24 * 60 * 60 * 1000) {
+            if (isClearAllCutoff(cutoffTimestamp)) {
+                const sqlDs = this.resolveSqlDataSource();
+                if (sqlDs) {
+                    console.log("clearing all console logs via drop+recreate");
+                    await sqlDs.dropTableIfExists();
+                    await sqlDs.initTable(true);
+                    console.log("cleared all console logs");
+                    return;
+                }
+                if (typeof this.dataSource.clearTable === "function") {
+                    await this.dataSource.clearTable();
+                    console.log("cleared all console logs via clearTable");
+                    return;
+                }
+                console.warn("clear-all requested but no SQL data source available");
+                return;
+            }
             const count = await this.count({ timestamp: { $lt: cutoffTimestamp } });
             if (count === 0) {
                 console.log(`No old logs to clean up older than ${new Date(cutoffTimestamp).toISOString()}`);
                 return;
             }
-            let ds = this.dataSource;
-            while (!(ds instanceof orm_1.SQLDataSource) && ds.dataSource) {
-                ds = ds.dataSource;
-            }
-            if (ds instanceof orm_1.SQLDataSource) {
-                const db = ds.db;
-                const result = await db.exec(`delete from ConsoleLogs where timestamp < $timestamp`, {
-                    timestamp: cutoffTimestamp,
-                });
+            const sqlDs = this.resolveSqlDataSource();
+            if (sqlDs) {
+                const db = sqlDs.db;
+                const result = await db.exec(`DELETE FROM "${sqlDs.tableName}" WHERE "timestamp" < $timestamp`, { timestamp: cutoffTimestamp });
                 console.log(`bulk deleted ${count} logs, changes: ${result.changes}`);
             }
             else {
                 const cursor = this.cursor({ timestamp: { $lt: cutoffTimestamp } }, { sortBy: ["-timestamp"] });
-                const count2 = 0;
+                let deleted = 0;
                 for await (const log of cursor) {
-                    this.delete(log.logId);
+                    await this.delete(log.logId);
+                    deleted++;
                 }
-                console.log(`cursor deleted ${count2} logs`);
+                console.log(`cursor deleted ${deleted} logs`);
             }
             console.log(`cleaned up console logs`, { expectedCount: count });
         }
@@ -136,8 +178,7 @@ let ConsoleLogsTable = (() => {
 exports.ConsoleLogsTable = ConsoleLogsTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.consoleLogSchema, ConsoleLogsTable);
 /**
- * We always use the user's personal data context so all logs are written to the same place.  This requires
- * that the table be accessed in an asynchronous way
+ * Returns the user's personal {@link ConsoleLogsTable} (logs are not synced across devices).
  */
 async function ConsoleLogs() {
     const userContext = await (0, user_context_singleton_1.getUserContext)();

package/dist/logging/console-logs.table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logging/console-logs.table.test.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SQLiteDB = require("better-sqlite3");
+const event_registry_1 = require("../data/orm/event-registry");
+const sql_data_source_1 = require("../data/orm/sql.data-source");
+const types_1 = require("../data/orm/types");
+const utils_1 = require("../utils");
+const console_logs_table_1 = require("./console-logs.table");
+class DBHarness {
+    _db = null;
+    get db() {
+        if (!this._db) {
+            this._db = new SQLiteDB(":memory:");
+            this._db.pragma("journal_mode = WAL");
+        }
+        return this._db;
+    }
+    async get(sql, params = []) {
+        return this.db.prepare(sql).get(params);
+    }
+    async all(sql, params = []) {
+        return this.db.prepare(sql).all(params);
+    }
+    async exec(sql, params = []) {
+        const result = this.db.prepare(sql).run(params);
+        return { changes: result.changes };
+    }
+    async close() {
+        this._db?.close();
+        this._db = null;
+    }
+}
+const consoleLogsMetaData = {
+    name: "ConsoleLogs",
+    description: "System-wide console log entries with cross-process visibility.",
+    primaryKeyName: "logId",
+    fields: (0, types_1.schemaToFields)(console_logs_table_1.consoleLogSchema),
+    localOnly: true,
+    indexes: [
+        { fields: ["timestamp"] },
+        { fields: ["level"] },
+        { fields: ["process"] },
+        { fields: ["processInstanceId"] },
+    ],
+};
+function createConsoleLogsTable(db) {
+    const sqlDs = new sql_data_source_1.SQLDataSource(db, consoleLogsMetaData, console_logs_table_1.consoleLogSchema);
+    const eventRegistry = new event_registry_1.EventRegistry("test-context");
+    const deps = {
+        dataSource: sqlDs,
+        eventRegistry,
+        schema: console_logs_table_1.consoleLogSchema,
+    };
+    return { table: new console_logs_table_1.ConsoleLogsTable(consoleLogsMetaData, deps), sqlDs };
+}
+describe("isClearAllCutoff", () => {
+    it("returns true when cutoff is now", () => {
+        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now())).toBe(true);
+    });
+    it("returns true when cutoff is within slack window", () => {
+        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now() - console_logs_table_1.CLEAR_ALL_CUTOFF_SLACK_MS + 1)).toBe(true);
+    });
+    it("returns false when cutoff is older than slack window", () => {
+        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now() - console_logs_table_1.CLEAR_ALL_CUTOFF_SLACK_MS - 1)).toBe(false);
+        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now() - 7 * 24 * 60 * 60 * 1000)).toBe(false);
+    });
+});
+describe("ConsoleLogsTable.deleteOldLogs", () => {
+    const db = new DBHarness();
+    afterAll(async () => {
+        await db.close();
+    });
+    beforeEach(async () => {
+        const { sqlDs } = createConsoleLogsTable(db);
+        await sqlDs.dropTableIfExists();
+        await sqlDs.initTable(true);
+    });
+    it("uses drop+recreate for clear-all cutoff without calling count", async () => {
+        const { table, sqlDs } = createConsoleLogsTable(db);
+        await sqlDs.initTable(true);
+        const now = Date.now();
+        await table.insert({
+            logId: (0, utils_1.newid)(),
+            timestamp: now - 1000,
+            level: "info",
+            process: "test",
+            processInstanceId: (0, utils_1.newid)(),
+            message: "old log",
+        });
+        const countSpy = jest.spyOn(table, "count");
+        const dropSpy = jest.spyOn(sqlDs, "dropTableIfExists");
+        const initSpy = jest.spyOn(sqlDs, "initTable");
+        await table.deleteOldLogs(Date.now());
+        expect(countSpy).not.toHaveBeenCalled();
+        expect(dropSpy).toHaveBeenCalled();
+        expect(initSpy).toHaveBeenCalledWith(true);
+        const remaining = await table.count();
+        expect(remaining).toBe(0);
+        countSpy.mockRestore();
+        dropSpy.mockRestore();
+        initSpy.mockRestore();
+    });
+    it("uses conditional delete for TTL cutoff and calls count", async () => {
+        const { table, sqlDs } = createConsoleLogsTable(db);
+        await sqlDs.initTable(true);
+        const now = Date.now();
+        const oldCutoff = now - 7 * 24 * 60 * 60 * 1000;
+        await table.insert({
+            logId: (0, utils_1.newid)(),
+            timestamp: oldCutoff - 1000,
+            level: "info",
+            process: "test",
+            processInstanceId: (0, utils_1.newid)(),
+            message: "expired log",
+        });
+        await table.insert({
+            logId: (0, utils_1.newid)(),
+            timestamp: now,
+            level: "info",
+            process: "test",
+            processInstanceId: (0, utils_1.newid)(),
+            message: "recent log",
+        });
+        const countSpy = jest.spyOn(table, "count");
+        const dropSpy = jest.spyOn(sqlDs, "dropTableIfExists");
+        const execSpy = jest.spyOn(sqlDs.db, "exec");
+        await table.deleteOldLogs(oldCutoff);
+        expect(countSpy).toHaveBeenCalledWith({ timestamp: { $lt: oldCutoff } });
+        expect(dropSpy).not.toHaveBeenCalled();
+        expect(execSpy).toHaveBeenCalledWith(`DELETE FROM "${sqlDs.tableName}" WHERE "timestamp" < $timestamp`, { timestamp: oldCutoff });
+        const remaining = await table.count();
+        expect(remaining).toBe(1);
+        countSpy.mockRestore();
+        dropSpy.mockRestore();
+        execSpy.mockRestore();
+    });
+    it("does nothing on partial delete when no rows match cutoff", async () => {
+        const { table, sqlDs } = createConsoleLogsTable(db);
+        await sqlDs.initTable(true);
+        const now = Date.now();
+        await table.insert({
+            logId: (0, utils_1.newid)(),
+            timestamp: now,
+            level: "info",
+            process: "test",
+            processInstanceId: (0, utils_1.newid)(),
+            message: "recent log",
+        });
+        const execSpy = jest.spyOn(sqlDs.db, "exec");
+        const oldCutoff = now - 7 * 24 * 60 * 60 * 1000;
+        await table.deleteOldLogs(oldCutoff);
+        expect(execSpy).not.toHaveBeenCalled();
+        expect(await table.count()).toBe(1);
+        execSpy.mockRestore();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.19.6",
+  "version": "0.19.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"