@backloghq/opslog 0.1.0 → 0.1.2

package/README.md

@@ -7,13 +7,13 @@ Every mutation is recorded as an operation in an append-only log. Current state
 ## Install
 
 ```bash
-npm install opslog
+npm install @backloghq/opslog
 ```
 
 ## Usage
 
 ```typescript
-import { Store } from "opslog";
+import { Store } from "@backloghq/opslog";
 
 const store = new Store<{ name: string; status: string }>();
 await store.open("./data");

package/dist/archive.js

@@ -1,13 +1,27 @@
 import { readFile, readdir, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { validateArchiveSegment } from "./validate.js";
 export async function writeArchiveSegment(dir, period, records) {
     const filename = `archive-${period}.json`;
     const path = join(dir, "archive", filename);
+    // Merge with existing archive if present
+    let existing = {};
+    try {
+        const content = await readFile(path, "utf-8");
+        const parsed = validateArchiveSegment(JSON.parse(content));
+        existing = parsed.records;
+    }
+    catch (err) {
+        const isNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
+        if (!isNotFound)
+            throw err;
+    }
+    const merged = { ...existing, ...Object.fromEntries(records) };
     const segment = {
         version: 1,
         period,
         timestamp: new Date().toISOString(),
-        records: Object.fromEntries(records),
+        records: merged,
     };
     const tmpPath = path + ".tmp";
     await writeFile(tmpPath, JSON.stringify(segment, null, 2), "utf-8");
@@ -17,7 +31,7 @@ export async function writeArchiveSegment(dir, period, records) {
 export async function loadArchiveSegment(dir, relativePath) {
     const path = join(dir, relativePath);
     const content = await readFile(path, "utf-8");
-    const segment = JSON.parse(content);
+    const segment = validateArchiveSegment(JSON.parse(content));
     return new Map(Object.entries(segment.records));
 }
 export async function listArchiveSegments(dir) {

package/dist/manifest.js

@@ -1,14 +1,16 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { validateManifest } from "./validate.js";
 const MANIFEST_FILE = "manifest.json";
 export async function readManifest(dir) {
+    let content;
     try {
-        const content = await readFile(join(dir, MANIFEST_FILE), "utf-8");
-        return JSON.parse(content);
+        content = await readFile(join(dir, MANIFEST_FILE), "utf-8");
     }
     catch {
-        return null;
+        return null; // File not found — fresh store
     }
+    return validateManifest(JSON.parse(content));
 }
 export async function writeManifest(dir, manifest) {
     const path = join(dir, MANIFEST_FILE);

package/dist/snapshot.js

@@ -1,5 +1,6 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { validateSnapshot } from "./validate.js";
 export async function writeSnapshot(dir, records, version) {
     const timestamp = new Date().toISOString();
     const filename = `snap-${Date.now()}.json`;
@@ -17,7 +18,7 @@ export async function writeSnapshot(dir, records, version) {
 export async function loadSnapshot(dir, relativePath) {
     const path = join(dir, relativePath);
     const content = await readFile(path, "utf-8");
-    const snapshot = JSON.parse(content);
+    const snapshot = validateSnapshot(JSON.parse(content));
     const records = new Map(Object.entries(snapshot.records));
     return { records, version: snapshot.version };
 }

package/dist/store.d.ts

@@ -9,6 +9,7 @@ export declare class Store<T = Record<string, unknown>> {
     private activeOpsPath;
     private created;
     private options;
+    private archivedRecordCount;
     private batching;
     private batchOps;
     open(dir: string, options?: StoreOptions): Promise<void>;

package/dist/store.js

@@ -19,6 +19,7 @@ export class Store {
         version: 1,
         migrate: (r) => r,
     };
+    archivedRecordCount = 0;
     batching = false;
     batchOps = [];
     async open(dir, options) {
@@ -51,6 +52,7 @@ export class Store {
             this.activeOpsPath = manifest.activeOps;
             this.created = manifest.stats.created;
             this.archiveSegments = manifest.archiveSegments;
+            this.archivedRecordCount = manifest.stats.archivedRecords;
             // Migrate if needed
             if (storedVersion < this.options.version) {
                 for (const [id, record] of this.records) {
@@ -163,7 +165,12 @@ export class Store {
         catch (err) {
             // Rollback in-memory changes on failure
             for (const op of this.batchOps.reverse()) {
-                this.reverseOp(op);
+                try {
+                    this.reverseOp(op);
+                }
+                catch (rollbackErr) {
+                    console.error("opslog: rollback failed for op", op.id, rollbackErr);
+                }
             }
             throw err;
         }
@@ -205,7 +212,7 @@ export class Store {
             archiveSegments: this.archiveSegments,
             stats: {
                 activeRecords: this.records.size,
-                archivedRecords: 0,
+                archivedRecords: this.archivedRecordCount,
                 opsCount: 0,
                 created: this.created,
                 lastCheckpoint: new Date().toISOString(),
@@ -232,6 +239,7 @@ export class Store {
         for (const id of toArchive.keys()) {
             this.records.delete(id);
         }
+        this.archivedRecordCount += toArchive.size;
         await this.compact();
         return toArchive.size;
     }

package/dist/validate.d.ts

@@ -0,0 +1,5 @@
+import type { Operation, Manifest, Snapshot, ArchiveSegment } from "./types.js";
+export declare function validateOp<T>(raw: unknown): Operation<T>;
+export declare function validateManifest(raw: unknown): Manifest;
+export declare function validateSnapshot<T>(raw: unknown): Snapshot<T>;
+export declare function validateArchiveSegment<T>(raw: unknown): ArchiveSegment<T>;

package/dist/validate.js

@@ -0,0 +1,71 @@
+export function validateOp(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("Invalid operation: not an object");
+    }
+    const obj = raw;
+    if (typeof obj.ts !== "string")
+        throw new Error("Invalid operation: missing ts");
+    if (obj.op !== "set" && obj.op !== "delete") {
+        throw new Error(`Invalid operation: unknown op "${obj.op}"`);
+    }
+    if (typeof obj.id !== "string")
+        throw new Error("Invalid operation: missing id");
+    return raw;
+}
+export function validateManifest(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("Invalid manifest: not an object");
+    }
+    const obj = raw;
+    if (typeof obj.version !== "number")
+        throw new Error("Invalid manifest: missing version");
+    if (typeof obj.currentSnapshot !== "string")
+        throw new Error("Invalid manifest: missing currentSnapshot");
+    if (typeof obj.activeOps !== "string")
+        throw new Error("Invalid manifest: missing activeOps");
+    if (!Array.isArray(obj.archiveSegments))
+        throw new Error("Invalid manifest: archiveSegments must be an array");
+    if (typeof obj.stats !== "object" || obj.stats === null || Array.isArray(obj.stats)) {
+        throw new Error("Invalid manifest: missing stats");
+    }
+    const stats = obj.stats;
+    if (typeof stats.activeRecords !== "number")
+        throw new Error("Invalid manifest: stats.activeRecords must be a number");
+    if (typeof stats.archivedRecords !== "number")
+        throw new Error("Invalid manifest: stats.archivedRecords must be a number");
+    if (typeof stats.opsCount !== "number")
+        throw new Error("Invalid manifest: stats.opsCount must be a number");
+    if (typeof stats.created !== "string")
+        throw new Error("Invalid manifest: stats.created must be a string");
+    if (typeof stats.lastCheckpoint !== "string")
+        throw new Error("Invalid manifest: stats.lastCheckpoint must be a string");
+    return raw;
+}
+export function validateSnapshot(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("Invalid snapshot: not an object");
+    }
+    const obj = raw;
+    if (typeof obj.version !== "number")
+        throw new Error("Invalid snapshot: missing version");
+    if (typeof obj.records !== "object" || obj.records === null || Array.isArray(obj.records)) {
+        throw new Error("Invalid snapshot: records must be an object");
+    }
+    return raw;
+}
+export function validateArchiveSegment(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("Invalid archive segment: not an object");
+    }
+    const obj = raw;
+    if (typeof obj.version !== "number")
+        throw new Error("Invalid archive segment: missing version");
+    if (typeof obj.period !== "string")
+        throw new Error("Invalid archive segment: missing period");
+    if (typeof obj.timestamp !== "string")
+        throw new Error("Invalid archive segment: missing timestamp");
+    if (typeof obj.records !== "object" || obj.records === null || Array.isArray(obj.records)) {
+        throw new Error("Invalid archive segment: records must be an object");
+    }
+    return raw;
+}

package/dist/wal.js

@@ -1,4 +1,5 @@
 import { appendFile, readFile, writeFile } from "node:fs/promises";
+import { validateOp } from "./validate.js";
 export async function appendOp(path, op) {
     await appendFile(path, JSON.stringify(op) + "\n", "utf-8");
 }
@@ -16,14 +17,18 @@ export async function readOps(path) {
     }
     const lines = content.trim().split("\n").filter(Boolean);
     const ops = [];
+    let skipped = 0;
     for (const line of lines) {
         try {
-            ops.push(JSON.parse(line));
+            ops.push(validateOp(JSON.parse(line)));
         }
         catch {
-            // Skip malformed lines (crash recovery)
+            skipped++;
         }
     }
+    if (skipped > 0) {
+        console.error(`opslog: skipped ${skipped} malformed line(s) in ${path}`);
+    }
     return ops;
 }
 export async function truncateLastOp(path) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backloghq/opslog",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Embedded event-sourced document store. Append-only operation log with immutable snapshots, zero native dependencies.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,12 +33,12 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "@eslint/js": "*",
-    "@types/node": "*",
+    "@eslint/js": "^10.0.0",
+    "@types/node": "^25.0.0",
     "@vitest/coverage-v8": "^4.1.2",
-    "eslint": "*",
-    "typescript": "*",
-    "typescript-eslint": "*",
-    "vitest": "*"
+    "eslint": "^10.0.0",
+    "typescript": "~6.0.2",
+    "typescript-eslint": "^8.58.0",
+    "vitest": "^4.1.2"
   }
 }