@medicine-wheel/storage-provider 0.6.0 → 0.6.2

package/dist/interface.d.ts

@@ -291,6 +291,14 @@ export interface StorageProvider {
     getNodesByType(type: NodeType): Promise<RelationalNode[]>;
     getNodesByDirection(direction: DirectionName): Promise<RelationalNode[]>;
     getAllNodes(limit?: number): Promise<RelationalNode[]>;
+    /**
+     * Cardinality of the whole node collection, never a page of it.
+     * `getAllNodes()` answers with a page (default 100), so its length is
+     * `min(actual, limit)` and cannot be used as a total. Implementations answer
+     * this without materialising the collection — a line count on jsonl, a
+     * `COUNT(*)` on Postgres.
+     */
+    countNodes(): Promise<number>;
     /** Throws NodeNotFoundError when the node does not exist. */
     updateNode(id: string, patch: NodePatch): Promise<RelationalNode>;
     /** Throws NodeNotFoundError or NodeHasRelationsError (refusal, never cascade). */
@@ -310,6 +318,8 @@ export interface StorageProvider {
     getCeremoniesByDirection(direction: DirectionName): Promise<CeremonyLog[]>;
     getCeremoniesByType(type: CeremonyType): Promise<CeremonyLog[]>;
     getAllCeremonies(limit?: number): Promise<CeremonyLog[]>;
+    /** Cardinality of the whole ceremony collection — see `countNodes()`. */
+    countCeremonies(): Promise<number>;
     registerInquiryWeave(record: WeaveRecord): Promise<void>;
     getInquiryWeave(id: string): Promise<WeaveRecord | null>;
     listInquiryWeaves(filters?: InquiryWeaveFilters): Promise<WeaveRecord[]>;

package/dist/jsonl.d.ts

@@ -19,6 +19,7 @@ export declare class JsonlProvider implements StorageProvider {
     getNodesByType(type: NodeType): Promise<RelationalNode[]>;
     getNodesByDirection(direction: DirectionName): Promise<RelationalNode[]>;
     getAllNodes(limit?: number): Promise<RelationalNode[]>;
+    countNodes(): Promise<number>;
     updateNode(id: string, patch: NodePatch): Promise<RelationalNode>;
     deleteNode(id: string): Promise<void>;
     createEdge(edge: RelationalEdge): Promise<void>;
@@ -34,6 +35,7 @@ export declare class JsonlProvider implements StorageProvider {
     getCeremoniesByDirection(direction: DirectionName): Promise<CeremonyLog[]>;
     getCeremoniesByType(type: CeremonyType): Promise<CeremonyLog[]>;
     getAllCeremonies(limit?: number): Promise<CeremonyLog[]>;
+    countCeremonies(): Promise<number>;
     registerInquiryWeave(record: WeaveRecord): Promise<void>;
     getInquiryWeave(id: string): Promise<WeaveRecord | null>;
     listInquiryWeaves(filters?: InquiryWeaveFilters): Promise<WeaveRecord[]>;

package/dist/jsonl.js

@@ -60,6 +60,9 @@ export class JsonlProvider {
             .slice(0, limit)
             .map((node) => this.parseNode(node));
     }
+    async countNodes() {
+        return countJsonl(this.nodesFile);
+    }
     async updateNode(id, patch) {
         return withWriteLock(this.nodesFile, () => {
             const nodes = this.readNodes();
@@ -202,6 +205,9 @@ export class JsonlProvider {
             .slice(0, limit)
             .map((ceremony) => this.parseCeremony(ceremony));
     }
+    async countCeremonies() {
+        return countJsonl(this.ceremoniesFile);
+    }
     async registerInquiryWeave(record) {
         await this.upsertById(this.inquiryWeavesFile, record);
     }
@@ -375,6 +381,34 @@ function readJsonl(filePath) {
     }
     return records;
 }
+/**
+ * How many records the file holds, without building them.
+ *
+ * Counts exactly what `readJsonl` would have returned — a malformed line is
+ * skipped by both, so a count can never disagree with a read — but retains no
+ * objects, sorts nothing, and parses no record into its domain shape. Skipping
+ * is silent here: `readJsonl` already warns about the same line, and counting
+ * must not double the noise.
+ */
+function countJsonl(filePath) {
+    if (!fs.existsSync(filePath))
+        return 0;
+    let count = 0;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            JSON.parse(trimmed);
+            count += 1;
+        }
+        catch {
+            // Same skip readJsonl performs; it owns the warning.
+        }
+    }
+    return count;
+}
 function writeJsonl(filePath, records) {
     ensureDirectory(path.dirname(filePath));
     const tmpPath = `${filePath}.tmp.${process.pid}`;

package/dist/neon.d.ts

@@ -14,6 +14,7 @@ export declare class NeonProvider implements StorageProvider {
     getNodesByType(type: NodeType): Promise<RelationalNode[]>;
     getNodesByDirection(direction: DirectionName): Promise<RelationalNode[]>;
     getAllNodes(limit?: number): Promise<RelationalNode[]>;
+    countNodes(): Promise<number>;
     updateNode(id: string, patch: NodePatch): Promise<RelationalNode>;
     deleteNode(id: string): Promise<void>;
     private parseNode;
@@ -31,6 +32,7 @@ export declare class NeonProvider implements StorageProvider {
     getCeremoniesByDirection(direction: DirectionName): Promise<CeremonyLog[]>;
     getCeremoniesByType(type: CeremonyType): Promise<CeremonyLog[]>;
     getAllCeremonies(limit?: number): Promise<CeremonyLog[]>;
+    countCeremonies(): Promise<number>;
     private parseCeremony;
     registerInquiryWeave(record: WeaveRecord): Promise<void>;
     getInquiryWeave(id: string): Promise<WeaveRecord | null>;

package/dist/neon.js

@@ -64,6 +64,10 @@ export class NeonProvider {
         const rows = await this.db `SELECT * FROM nodes ORDER BY created_at DESC LIMIT ${limit}`;
         return rows.map((row) => this.parseNode(row));
     }
+    async countNodes() {
+        const counts = await this.db `SELECT COUNT(*)::int AS count FROM nodes`;
+        return Number(counts[0]?.count ?? 0);
+    }
     async updateNode(id, patch) {
         const existing = await this.getNode(id);
         if (!existing)
@@ -245,6 +249,10 @@ export class NeonProvider {
     async getAllCeremonies(limit = 100) {
         return this.getCeremoniesTimeline(limit);
     }
+    async countCeremonies() {
+        const counts = await this.db `SELECT COUNT(*)::int AS count FROM ceremonies`;
+        return Number(counts[0]?.count ?? 0);
+    }
     parseCeremony(row) {
         return {
             id: row.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/storage-provider",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "dependencies": {
     "@neondatabase/serverless": "^0.10.0",
     "@upstash/redis": "^1.34.3",
-    "@medicine-wheel/ontology-core": "^0.6.0"
+    "@medicine-wheel/ontology-core": "^0.6.2"
   },
   "devDependencies": {
     "typescript": "^5.7.0"