npm - @bandeira-tech/b3nd-save - Versions diffs - 0.8.1 → 0.13.1 - Mend

@bandeira-tech/b3nd-save 0.8.1 → 0.13.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (161) hide show

package/esm/mongo/store.js CHANGED Viewed

@@ -1,26 +1,85 @@
 /**
- * MongoStore — MongoDB implementation of Store.
+ * MongoStore — MongoDB implementation of `EntityStore`.
  *
- * Pure mechanical byte storage with no protocol awareness. Uses an
- * injected MongoExecutor so the package does not depend on a specific
- * MongoDB driver. Payload is stored as a BSON `Binary` value (the
- * `mongodb` driver maps `Uint8Array` to it transparently).
+ * One layout for every schema: a per-entity collection named
+ * `{prefix}_{entity}_data` with a `uri` primary key and one document
+ * key per supported field, plus `createdAt` / `updatedAt`.
+ * `BYTES_ENTITY` is just an entity with one `payload` field of BSON
+ * binary — no legacy special case.
  *
- * `fn=ls`/`fn=count` push down to a regex prefix query that enforces
- * the shallow-direct-leaves contract: `^<prefix>[^/]+$`.
+ * ## Lifecycle
+ *
+ * `entitySupport(schema)` is pure — it runs `planFields` and returns
+ * a `MongoEntityMeta` with the target collection name, declared field
+ * set, bytes-field set, canonical-tag-per-field signature, and the
+ * support report. No IO.
+ *
+ * `provisionEntity(meta)` materialises the entity:
+ *
+ *   1. Reads the meta collection `{prefix}_meta` for a prior entry
+ *      under `meta.support.entity`.
+ *   2. If found with a matching signature → no-op (idempotent).
+ *   3. If found with a different signature → throws (collision: a
+ *      same-name entity is already live in a different shape).
+ *   4. Otherwise: creates the entity collection, creates the `uri`
+ *      index, and upserts the meta entry.
+ *
+ * `entityStatus(meta)` reads the meta collection and reports `"live"`
+ * only when the stored signature matches. Mongo is schemaless on the
+ * wire — without an explicit meta record there is nothing to
+ * introspect, so the meta collection is how shape collisions get
+ * detected (the same approach MemoryStore uses; the SQL backends get
+ * the same guarantee for free via column-type introspection).
+ *
+ * Writes/reads/deletes consume the meta directly: no per-call cache
+ * gate. The store enforces the extras check (a record with keys not
+ * declared in `meta` produces a per-entry write failure); value-type
+ * enforcement is left to higher layers because Mongo will accept any
+ * value at the BSON level.
+ *
+ * `fn=ls` / `fn=count` push down to MongoDB via a regex prefix filter
+ * on `uri` that enforces the shallow-direct-leaves contract
+ * (`^<prefix>[^/]+$`).
+ *
+ * `fn=find` (v2 §3.3) reuses the same regex query shape but composes
+ * the body for the broader grammar (`**` → `.*`, crosses `/`). The
+ * literal prefix stays escaped; the glob tail is compiled via
+ * `saveGlobToRegexBody` — the same helper `_ls` uses, which already
+ * emits `.*` for `**` regardless of fn (the wildcard semantics are a
+ * property of the glob token, not the verb). The `[^/]+` shallow
+ * fallback that `_ls` uses for "no pattern" is NOT used here: `find`
+ * always arrives with a pattern (parseUrl mirrors the URI-embedded
+ * glob into `params.pattern`; dispatch pushes it through under
+ * `pushDownFind: true`).
+ *
+ * Perf note: an anchored `^<literal-prefix><body>$` regex with a long
+ * literal prefix can use the per-collection `uri` index for prefix
+ * scans; broader patterns (`**` at the start) degrade to a collection
+ * scan. The contract advertises `find` with that caveat — callers that
+ * need fast deep walks under shallow prefixes should keep their root
+ * literal (`<root><room>/alice/**` scans only `alice/`).
+ *
+ * Mongo does not provide a portable single-collection batch
+ * write/delete primitive that fits the package's per-entry result
+ * contract, so writes happen one document at a time and
+ * `capabilities.atomicBatch` is `false`. Stream-shaped values on
+ * bytes fields are collected to `Uint8Array` up front per entry.
  */
-import { bytesOnlyDelete, bytesOnlyEntitySupport, bytesOnlyRead, bytesOnlyWrite, } from "../byte-entity-shim.js";
 import { dispatchRead } from "../dispatch.js";
 import { storageFailure } from "../errors.js";
 import { toBytes } from "../payload.js";
 import { validateReadParams } from "../read.js";
+import { saveGlobToRegexBody } from "../glob.js";
+import { TYPE_TAGS, } from "../entity.js";
+import { IDENTIFIER_PATTERN, isValidIdentifier } from "../identifiers.js";
+import { computeSignature, planFields } from "./fields.js";
 const STORE_NAME = "MongoStore";
-/** Escape special regex characters for safe use in a RegExp pattern. */
+/** Escape special regex characters for safe use in a `$regex` filter. */
 function escapeRegex(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 /**
- * Normalize a Mongo document field into a `Uint8Array`. The driver may
+ * Normalise a Mongo document field into a `Uint8Array`. The driver may
  * surface BSON `Binary` (which exposes `.buffer`) or a raw
  * `Uint8Array` depending on options.
  */
@@ -37,123 +96,136 @@ function docToBytes(value) {
         value.buffer instanceof ArrayBuffer) {
         return new Uint8Array(value.buffer);
     }
-    throw new Error(`MongoStore: unexpected payload type ${typeof value}`);
+    throw new Error(`${STORE_NAME}: unexpected payload type ${typeof value}`);
+}
+function entityCollectionName(prefix, entityName) {
+    if (!isValidIdentifier(entityName)) {
+        throw new Error(`${STORE_NAME}: entity name '${entityName}' must match ${IDENTIFIER_PATTERN.source}`);
+    }
+    return `${prefix}_${entityName}_data`;
+}
+function metaCollectionName(prefix) {
+    return `${prefix}_meta`;
 }
 export class MongoStore {
-    collectionName;
+    collectionPrefix;
     executor;
-    constructor(collectionName, executor) {
-        if (!collectionName)
-            throw new Error("collectionName is required");
+    constructor(collectionPrefix, executor) {
+        if (!collectionPrefix)
+            throw new Error("collectionPrefix is required");
+        if (!isValidIdentifier(collectionPrefix)) {
+            throw new Error(`collectionPrefix must match ${IDENTIFIER_PATTERN.source}; got '${collectionPrefix}'`);
+        }
         if (!executor)
             throw new Error("executor is required");
-        this.collectionName = collectionName;
+        this.collectionPrefix = collectionPrefix;
         this.executor = executor;
     }
-    // ── EntityStore surface ──────────────────────────────────────────
+    // ── Lifecycle ────────────────────────────────────────────────────
     entitySupport(schema) {
-        return bytesOnlyEntitySupport(schema);
-    }
-    entityStatus(meta) {
-        return Promise.resolve(meta.isBytes ? "live" : "unprovisioned");
-    }
-    provisionEntity(_meta) {
-        return Promise.resolve();
+        const { fields, unsupported } = planFields(schema.fields);
+        const support = {
+            entity: schema.name,
+            supported: fields.map((f) => f.name),
+            unsupported,
+        };
+        return {
+            support,
+            collectionName: entityCollectionName(this.collectionPrefix, schema.name),
+            fields,
+            declared: new Set(fields.map((f) => f.name)),
+            bytesFields: new Set(fields.filter((f) => f.tag === TYPE_TAGS.BYTES).map((f) => f.name)),
+            signature: computeSignature(schema.name, fields),
+        };
     }
-    write(meta, entries) {
-        return bytesOnlyWrite(meta, STORE_NAME, entries, (e) => this._writeBytes(e));
+    async entityStatus(meta) {
+        const metaDoc = await this.executor
+            .collection(metaCollectionName(this.collectionPrefix))
+            .findOne({ _id: meta.support.entity });
+        if (!metaDoc)
+            return "unprovisioned";
+        return metaDoc.signature === meta.signature ? "live" : "unprovisioned";
     }
-    read(meta, urls) {
-        return bytesOnlyRead(meta, STORE_NAME, urls, (u) => this._readBytes(u));
-    }
-    delete(meta, uris) {
-        return bytesOnlyDelete(meta, STORE_NAME, uris, (u) => this._deleteBytes(u));
+    async provisionEntity(meta) {
+        const metaColl = this.executor.collection(metaCollectionName(this.collectionPrefix));
+        const existing = await metaColl.findOne({ _id: meta.support.entity });
+        if (existing) {
+            if (existing.signature !== meta.signature) {
+                throw new Error(`${STORE_NAME}: entity '${meta.support.entity}' is already ` +
+                    `provisioned with a different shape at collection '${meta.collectionName}'`);
+            }
+            return;
+        }
+        await this.executor.createCollection(meta.collectionName);
+        await this.executor.collection(meta.collectionName).createIndex({ uri: 1 });
+        await metaColl.updateOne({ _id: meta.support.entity }, { $set: { _id: meta.support.entity, signature: meta.signature } }, { upsert: true });
     }
-    // ── Byte ops (BYTES_ENTITY routing) ──────────────────────────────
-    async _writeBytes(entries) {
-        const results = [];
-        for (const entry of entries) {
+    // ── Write ────────────────────────────────────────────────────────
+    async write(meta, entries) {
+        if (entries.length === 0)
+            return [];
+        const out = new Array(entries.length);
+        const coll = this.executor.collection(meta.collectionName);
+        for (let i = 0; i < entries.length; i++) {
+            const { uri, record } = entries[i];
+            const extras = Object.keys(record).filter((k) => !meta.declared.has(k));
+            if (extras.length > 0) {
+                out[i] = {
+                    success: false,
+                    ...storageFailure(new Error(`${STORE_NAME}: record contains keys not declared in schema '${meta.support.entity}': ${extras.join(", ")}`), "Schema mismatch", uri),
+                };
+                continue;
+            }
             try {
-                const bytes = await toBytes(entry.payload);
-                await this.executor.updateOne({ uri: entry.uri }, {
-                    $set: {
-                        uri: entry.uri,
-                        payload: bytes,
-                        updatedAt: new Date(),
-                    },
+                const doc = await buildDocument(meta, uri, record);
+                await coll.updateOne({ uri }, {
+                    $set: { ...doc, updatedAt: new Date() },
+                    $setOnInsert: { createdAt: new Date() },
                 }, { upsert: true });
-                results.push({ success: true });
+                out[i] = { success: true };
             }
             catch (err) {
-                results.push({
+                out[i] = {
                     success: false,
-                    ...storageFailure(err, "Write failed", entry.uri),
-                });
+                    ...storageFailure(err, "Write failed", uri),
+                };
             }
         }
-        return results;
+        return out;
     }
-    _readBytes(urls) {
+    // ── Read ─────────────────────────────────────────────────────────
+    read(meta, urls) {
         return dispatchRead(urls, STORE_NAME, {
-            read: (p) => this._readOne(p.uri),
-            ls: (p) => this._ls(p),
-            count: (p) => this._count(p),
+            read: (p) => this._readOne(meta, p.uri),
+            ls: (p) => this._ls(meta, p),
+            count: (p) => this._count(meta, p),
+            find: (p) => this._find(meta, p),
+            pushDownPattern: true,
+            pushDownCursor: true,
+            pushDownSortBy: true,
+            pushDownFind: true,
         });
     }
-    async _readOne(uri) {
-        const doc = await this.executor.findOne({ uri });
-        if (!doc)
-            return undefined;
-        return docToBytes(doc.payload);
-    }
-    /** Build the shallow-direct-leaves regex filter for a prefix. */
-    _leafFilter(prefixUri) {
-        return { uri: { $regex: `^${escapeRegex(prefixUri)}[^/]+$` } };
-    }
-    async _ls(parsed) {
-        validateReadParams(parsed.params, STORE_NAME);
-        const { params } = parsed;
-        const format = params.format ?? "full";
-        const options = {};
-        if (params.sortBy === "uri") {
-            options.sort = { uri: params.sortOrder === "desc" ? -1 : 1 };
-        }
-        if (params.limit !== undefined) {
-            const page = params.page ?? 1;
-            options.limit = params.limit;
-            options.skip = (page - 1) * params.limit;
-        }
-        if (format === "uris") {
-            options.projection = { uri: 1, _id: 0 };
-        }
-        const docs = await this.executor.findMany(this._leafFilter(parsed.uri), options);
-        if (format === "uris")
-            return docs.map((d) => d.uri);
-        return docs.map((d) => [d.uri, docToBytes(d.payload)]);
-    }
-    async _count(parsed) {
-        if (parsed.params.pattern !== undefined) {
-            throw new Error(`${STORE_NAME}: pattern filter not supported`);
-        }
-        return await this.executor.countDocuments(this._leafFilter(parsed.uri));
-    }
-    async _deleteBytes(uris) {
-        const results = [];
-        for (const uri of uris) {
+    async delete(meta, uris) {
+        if (uris.length === 0)
+            return [];
+        const coll = this.executor.collection(meta.collectionName);
+        const out = new Array(uris.length);
+        for (let i = 0; i < uris.length; i++) {
             try {
-                await this.executor.deleteOne({ uri });
-                results.push({ success: true });
+                await coll.deleteOne({ uri: uris[i] });
+                out[i] = { success: true };
             }
             catch (err) {
-                results.push({
+                out[i] = {
                     success: false,
-                    ...storageFailure(err, "Delete failed", uri),
-                });
+                    ...storageFailure(err, "Delete failed", uris[i]),
+                };
             }
         }
-        return results;
+        return out;
     }
-    // ── Status ───────────────────────────────────────────────────────
+    // ── Status / capabilities ────────────────────────────────────────
     async status() {
         try {
             const ok = await this.executor.ping();
@@ -161,25 +233,206 @@ export class MongoStore {
                 return {
                     status: "unhealthy",
                     message: "MongoDB ping failed",
-                    fns: ["read", "ls", "count"],
+                    fns: ["read", "ls", "find", "count"],
                 };
             }
             return {
                 status: "healthy",
                 message: "MongoDB store is operational",
-                fns: ["read", "ls", "count"],
-                details: { collectionName: this.collectionName },
+                fns: ["read", "ls", "find", "count"],
+                details: { collectionPrefix: this.collectionPrefix },
             };
         }
         catch (error) {
             return {
                 status: "unhealthy",
                 message: error instanceof Error ? error.message : String(error),
-                fns: ["read", "ls", "count"],
+                fns: ["read", "ls", "find", "count"],
             };
         }
     }
     capabilities() {
         return { atomicBatch: false };
     }
+    // ── Internals ────────────────────────────────────────────────────
+    async _readOne(meta, uri) {
+        const doc = await this.executor.collection(meta.collectionName).findOne({
+            uri,
+        });
+        if (!doc)
+            return undefined;
+        if (meta.fields.length === 0)
+            return {};
+        return adaptDocForRead(meta, doc);
+    }
+    /**
+     * Compose the Mongo filter for shallow-direct-leaves under
+     * `prefixUri`, optionally tightened by a glob `pattern` (regex body
+     * spliced in place of `[^/]+`) and a `cursor` (`$gt` or `$lt` on
+     * `uri` matching the active sort order).
+     */
+    _leafFilter(prefixUri, pattern, cursor, sortOrder) {
+        const body = pattern !== undefined ? saveGlobToRegexBody(pattern) : "[^/]+";
+        const uriFilter = {
+            $regex: `^${escapeRegex(prefixUri)}${body}$`,
+        };
+        if (cursor !== undefined) {
+            uriFilter[sortOrder === "desc" ? "$lt" : "$gt"] = cursor;
+        }
+        return { uri: uriFilter };
+    }
+    async _ls(meta, parsed) {
+        validateReadParams(parsed.params, STORE_NAME);
+        const { params } = parsed;
+        const format = params.format ?? "full";
+        const options = {};
+        // sortBy: "uri" sorts on the implicit URI key; any other value
+        // must be a declared field. Dispatch only routes non-uri sortBy
+        // through here when pushDownSortBy is true, which it is for this
+        // backend; we still gate on meta.declared so an unrecognised
+        // field falls through to no sort rather than a Mongo error.
+        if (params.sortBy === "uri") {
+            options.sort = { uri: params.sortOrder === "desc" ? -1 : 1 };
+        }
+        else if (params.sortBy !== undefined && meta.declared.has(params.sortBy)) {
+            options.sort = {
+                [params.sortBy]: params.sortOrder === "desc" ? -1 : 1,
+            };
+        }
+        if (params.limit !== undefined) {
+            const page = params.page ?? 1;
+            options.limit = params.limit;
+            options.skip = (page - 1) * params.limit;
+        }
+        if (format === "uris") {
+            options.projection = { uri: 1, _id: 0 };
+        }
+        const docs = await this.executor.collection(meta.collectionName).findMany(this._leafFilter(parsed.uri, params.pattern, params.cursor, params.sortOrder), options);
+        if (format === "uris")
+            return docs.map((d) => d.uri);
+        return docs.map((d) => [
+            d.uri,
+            adaptDocForRead(meta, d),
+        ]);
+    }
+    /**
+     * Compose the Mongo filter for a `find` (deep walk) under
+     * `prefixUri`. Same shape as `_leafFilter` — `$regex` anchored on
+     * both ends, optional cursor `$gt`/`$lt` — but the body is the glob
+     * compiled with `**` → `.*` semantics (crosses `/`). For find we
+     * REQUIRE a pattern: parseUrl guarantees `params.pattern` is set
+     * whenever fn=find dispatches to this handler (URI-embedded glob or
+     * the dual-accept `?pattern=` form). If pattern is absent we throw
+     * loudly rather than silently widening to `.*` — that would conflate
+     * "find everything" with a parser bug.
+     */
+    _subtreeFilter(prefixUri, pattern, cursor, sortOrder) {
+        if (pattern === undefined) {
+            throw new Error(`${STORE_NAME}: fn=find handler reached without params.pattern set ` +
+                `(parser invariant violated)`);
+        }
+        const body = saveGlobToRegexBody(pattern);
+        const uriFilter = {
+            $regex: `^${escapeRegex(prefixUri)}${body}$`,
+        };
+        if (cursor !== undefined) {
+            uriFilter[sortOrder === "desc" ? "$lt" : "$gt"] = cursor;
+        }
+        return { uri: uriFilter };
+    }
+    async _find(meta, parsed) {
+        validateReadParams(parsed.params, STORE_NAME);
+        const { params } = parsed;
+        const format = params.format ?? "full";
+        const options = {};
+        if (params.sortBy === "uri") {
+            options.sort = { uri: params.sortOrder === "desc" ? -1 : 1 };
+        }
+        else if (params.sortBy !== undefined && meta.declared.has(params.sortBy)) {
+            options.sort = {
+                [params.sortBy]: params.sortOrder === "desc" ? -1 : 1,
+            };
+        }
+        if (params.limit !== undefined) {
+            const page = params.page ?? 1;
+            options.limit = params.limit;
+            options.skip = (page - 1) * params.limit;
+        }
+        if (format === "uris") {
+            options.projection = { uri: 1, _id: 0 };
+        }
+        const docs = await this.executor.collection(meta.collectionName).findMany(this._subtreeFilter(parsed.uri, params.pattern, params.cursor, params.sortOrder), options);
+        if (format === "uris")
+            return docs.map((d) => d.uri);
+        return docs.map((d) => [
+            d.uri,
+            adaptDocForRead(meta, d),
+        ]);
+    }
+    async _count(meta, parsed) {
+        return await this.executor.collection(meta.collectionName).countDocuments(this._leafFilter(parsed.uri, parsed.params.pattern, parsed.params.cursor, parsed.params.sortOrder));
+    }
+}
+/**
+ * Build the document to upsert: `uri` + every declared field, with
+ * stream-shaped bytes fields collected up front so a stream failure
+ * surfaces as a per-entry write failure (caught by the caller) before
+ * any I/O against the collection.
+ */
+async function buildDocument(meta, uri, record) {
+    const doc = { uri };
+    for (const field of meta.fields) {
+        const value = record[field.name];
+        if (value === undefined)
+            continue;
+        if (meta.bytesFields.has(field.name)) {
+            if (value === null) {
+                doc[field.name] = null;
+                continue;
+            }
+            if (value instanceof Uint8Array) {
+                doc[field.name] = value;
+                continue;
+            }
+            if (value instanceof ReadableStream) {
+                doc[field.name] = await toBytes(value);
+                continue;
+            }
+            throw new Error(`${STORE_NAME}: field '${field.name}' must be Uint8Array or ReadableStream, got ${typeof value}`);
+        }
+        doc[field.name] = adaptValueForWrite(field, value);
+    }
+    return doc;
+}
+function adaptValueForWrite(field, value) {
+    if (value === null)
+        return null;
+    if (field.tag === TYPE_TAGS.TIMESTAMP) {
+        if (value instanceof Date)
+            return value.toISOString();
+        if (typeof value === "number")
+            return new Date(value).toISOString();
+        return value;
+    }
+    return value;
+}
+function adaptDocForRead(meta, doc) {
+    const rec = {};
+    for (const field of meta.fields) {
+        const v = doc[field.name];
+        if (v === undefined || v === null) {
+            rec[field.name] = undefined;
+            continue;
+        }
+        if (field.tag === TYPE_TAGS.BYTES) {
+            rec[field.name] = docToBytes(v);
+        }
+        else if (field.tag === TYPE_TAGS.TIMESTAMP) {
+            rec[field.name] = v instanceof Date ? v : new Date(v);
+        }
+        else {
+            rec[field.name] = v;
+        }
+    }
+    return rec;
 }

package/esm/postgres/store.d.ts CHANGED Viewed

@@ -27,12 +27,33 @@
  * predicate (`uri LIKE prefix% AND uri NOT LIKE prefix%/%`) is
  * enforced in the WHERE clause against the entity's table.
  *
+ * `fn=find` (v2 §3.5) push down to SQL too — same shape minus the
+ * `NOT LIKE %/%` shallow clause. With `pushDownFind: true` dispatch
+ * trusts the backend to combine the URI-embedded glob with pagination,
+ * cursor, and sort inside the query.
+ *
+ * `fn=count` honours deep (`**`) URLs by dropping the shallow clause
+ * when `parsed.glob.includes("**")`. With `pushDownCount: true`,
+ * dispatch routes every count shape — shallow and deep — to the
+ * backend's own `COUNT(*)` (faster than walking-and-counting through
+ * find).
+ *
+ * ## LIKE-injection safety
+ *
+ * Every value spliced into a SQL `LIKE` pattern via concatenation is
+ * pre-escaped with `escapeSqlLike()` (`%` → `\%`, `_` → `\_`,
+ * `\` → `\\`) and the surrounding clauses declare `ESCAPE '\\'`. This
+ * prevents a URI prefix or cursor containing `%` or `_` from matching
+ * siblings (e.g. `store://r/100%/` must NOT match `store://r/100x/...`
+ * under `fn=ls`). The glob body produced by `globToSqlLike` already
+ * encodes its own escaping for literal `%`/`_` in the pattern source.
+ *
  * Writes are wrapped in a transaction (`capabilities.atomicBatch =
  * true`). Stream-shaped values on `BYTEA` columns are collected to
  * `Uint8Array` *before* the transaction opens, so a stream failure
  * can't leave a half-applied commit.
  */
-import type { DeleteResult, Output, StatusResult } from "../deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/types/types.js";
+import type { DeleteResult, Output, StatusResult } from "../deps/jsr.io/@bandeira-tech/b3nd-core/0.25.0/src/types/types.js";
 import type { EntityStore } from "../entity-store.js";
 import type { EntityMeta, EntityRecord, EntitySchema } from "../entity.js";
 import type { StoreCapabilities, StoreWriteResult } from "../types.js";
@@ -70,6 +91,34 @@ export declare class PostgresStore implements EntityStore<PostgresEntityMeta> {
     capabilities(): StoreCapabilities;
     private _readOne;
     private _ls;
+    /**
+     * `fn=find` handler — deep walk under the prefix. Same query shape as
+     * `_ls` minus the `NOT LIKE prefix || '%/%'` shallow clause: every
+     * descendant URI matches the prefix; the URI-embedded glob (passed in
+     * via `params.pattern` by the parser) tightens the set with a SQL
+     * `LIKE` body. `pushDownFind: true` is declared so dispatch trusts the
+     * backend with pattern + pagination + sort.
+     */
+    private _find;
+    /**
+     * Shared SELECT for `_ls` and `_find`. The only structural difference
+     * is the shallow clause: `_ls` includes `uri NOT LIKE prefix || '%/%'
+     * ESCAPE '\\'`; `_find` drops it. Everything else — pattern body,
+     * cursor, sort, pagination — is identical.
+     *
+     * LIKE-injection safety: `parsed.uri` is pre-escaped with
+     * `escapeSqlLike()` before being bound. The bind value is the escaped
+     * prefix; the surrounding `LIKE $1 || '%' ESCAPE '\\'` then treats
+     * any `%`/`_` in the original prefix as literals.
+     */
+    private _listQuery;
+    /**
+     * `fn=count` handler. Honours both shallow (`*`/`?` or no glob) and
+     * deep (`**`) URL shapes — the latter drops the `NOT LIKE %/%`
+     * predicate so descendants at any depth get counted. With
+     * `pushDownCount: true`, dispatch routes every count call through
+     * here (no walk-then-length fallback).
+     */
     private _count;
 }
 //# sourceMappingURL=store.d.ts.map

package/esm/postgres/store.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/postgres/store.ts"],"names":[],"mappings":"AAAA~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG~~;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,YAAY,EACb,MAAM,mEAAmE,CAAC;~~AAM3E~~,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EAEb,MAAM,cAAc,CAAC;~~AACtB~~,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;~~AAM5C~~;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC5C;~~AAoCD~~,qBAAa,aAAc,YAAW,WAAW,CAAC,kBAAkB,CAAC;IACnE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;gBAE3B,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW;IAetD,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB;IAkBjD,YAAY,CAChB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC;IA4B9B,eAAe,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBxD,KAAK,CACT,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,GAC/C,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA4E9B,IAAI,CAAC,CAAC,GAAG,YAAY,GAAG,SAAS,EAC/B,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;~~IAQjB~~,MAAM,CACV,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,YAAY,EAAE,CAAC;IAkBpB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAoBrC,YAAY,IAAI,iBAAiB;YAMnB,QAAQ;YAqBR,GAAG;~~YAgCH~~,MAAM;~~CAcrB~~"}
1	+ {"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/postgres/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,YAAY,EACb,MAAM,mEAAmE,CAAC;AAO3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EAEb,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAI5C;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC5C;AAqDD,qBAAa,aAAc,YAAW,WAAW,CAAC,kBAAkB,CAAC;IACnE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;gBAE3B,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW;IAetD,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB;IAkBjD,YAAY,CAChB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC;IA4B9B,eAAe,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBxD,KAAK,CACT,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,GAC/C,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA4E9B,IAAI,CAAC,CAAC,GAAG,YAAY,GAAG,SAAS,EAC/B,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IAcjB,MAAM,CACV,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,YAAY,EAAE,CAAC;IAkBpB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAoBrC,YAAY,IAAI,iBAAiB;YAMnB,QAAQ;YAqBR,GAAG;IAOjB;;;;;;;OAOG;YACW,KAAK;IAOnB;;;;;;;;;;OAUG;YACW,UAAU;IAiExB;;;;;;OAMG;YACW,MAAM;CAwBrB"}