@metreeca/keep 0.9.0 → 0.11.0

package/README.md

@@ -2,9 +2,13 @@
 
 [![npm](https://img.shields.io/npm/v/@metreeca/keep)](https://www.npmjs.com/package/@metreeca/keep)
 
-{TBD: one-line description}
+Core model-driven storage API for the [@metreeca/keep](https://github.com/metreeca/keep) linked data storage framework.
 
-{TBD: value proposition and key capabilities}
+Provides one backend-agnostic API for persisting and retrieving linked data resources, validated against their models
+and retrieved through client-defined templates and queries. Resource models are defined with
+[@metreeca/blue](https://github.com/metreeca/blue), and resource states and retrieval templates follow the data and
+query models of [@metreeca/qest](https://github.com/metreeca/qest). Actual storage is delegated to backend
+[connector packages](https://github.com/metreeca/keep#installation).
 
 # Installation
 
@@ -12,37 +16,237 @@
 npm install @metreeca/keep
 ```
 
-> [!WARNING]
->
-> TypeScript consumers must use `"moduleResolution": "nodenext"/"node16"/"bundler"` in `tsconfig.json`.
-> The legacy `"node"` resolver is not supported.
-
 # Usage
 
 > [!NOTE]
 >
-> This section introduces essential concepts; for complete coverage, see the API reference:
->
-> | Module | Description |
-> |--------|-------------|
-> | {TBD}  | {TBD}       |
+> This section introduces essential concepts; for complete coverage, see the
+> [API reference](https://metreeca.github.io/keep/modules/_metreeca_keep.html).
 
-{TBD: usage overview and examples}
+| Module                                  | Description              |
+|-----------------------------------------|--------------------------|
+| [@metreeca/keep][keep]                  | Model-driven storage API |
+| **Stores**                              |                          |
+| [@metreeca/keep/caching][caching]       | Caching store wrapper    |
+| [@metreeca/keep/managing][managing]     | Managing store wrapper   |
+| **Store Clients**                       |                          |
+| [@metreeca/keep/validating][validating] | Validating store wrapper |
+| [@metreeca/keep/batching][batching]     | Batching store client    |
 
-# Integrated Ecosystem
+[keep]: https://metreeca.github.io/keep/modules/_metreeca_keep.html
 
-> [!IMPORTANT]
->
-> **@metreeca/keep** defines {TBD}; applications are free to {TBD}.
+[validating]: https://metreeca.github.io/keep/modules/_metreeca_keep.validating.html
+
+[batching]: https://metreeca.github.io/keep/modules/_metreeca_keep.batching.html
+
+[caching]: https://metreeca.github.io/keep/modules/_metreeca_keep.caching.html
+
+[managing]: https://metreeca.github.io/keep/modules/_metreeca_keep.managing.html
+
+All store methods accept an `entry` that MUST be an absolute IRI without query string or fragment: non-conforming
+entries reject with `RangeError`. `create` takes as `entry` the resource holding the collection, and as `model` a slice
+naming the multi-valued property that holds it. An `id` stated in a `create` state MUST be nested under `entry`.
+`model` and `state` are validated against the supplied shape, and validation failures reject with a `TraceError`.
+Network, storage, and other processing errors reject with a structured `Problem`.
+
+## Retrieving Resources
+
+```typescript
+// single resource retrieval
+
+const product = await store.lookup({
+	entry: "http://example.com/products/1",
+	shape: ProductShape,
+	model: {
+		name: {},
+		price: {},
+		vendor: {
+			id: {},
+			name: {}
+		}
+	}
+});
+
+// collection retrieval with filtering, ordering, and pagination
+
+const catalogue = await store.lookup({
+	entry: "http://example.com/products/",
+	shape: CatalogueShape,
+	model: {
+		products: {
+			id: {},
+			name: {},
+			price: {},
+			">=price": 50,        // price ≥ 50
+			"~name": "widget",    // name contains "widget"
+			"^price": 1,          // sort by price ascending
+			"@": 0,               // offset
+			"#": 25               // limit
+		}
+	}
+});
+```
+
+## Creating and Updating Resources
+
+```typescript
+// creation within the collection holding the new resource, its identifier minted by the store unless stated
+
+const product = await store.create({
+	entry: "http://example.com/products/", shape: CatalogueShape, model: { products: {} }, state: {
+		name: "Widget",
+		price: 29.99,
+		vendor: "http://example.com/vendors/acme"
+	}
+});
+
+await store.update({
+	entry: "http://example.com/products/42", shape: ProductShape, state: {
+		id: "http://example.com/products/42",
+		name: "Widget",
+		price: 39.99,
+		vendor: "http://example.com/vendors/acme"
+	}
+});
+```
+
+## Deleting Resources
+
+```typescript
+await store.delete({ entry: "http://example.com/products/42", shape: ProductShape });
+```
+
+## Loading Data
+
+```typescript
+// unconditionally upsert (create or replace)
+
+await store.insert({
+	entry: "http://example.com/products/42", shape: ProductShape, state: {
+		id: "http://example.com/products/42",
+		name: "Widget",
+		price: 39.99,
+		vendor: "http://example.com/vendors/acme"
+	}
+});
+
+// unconditionally remove (silently succeeds if absent)
+
+await store.remove({ entry: "http://example.com/products/42", shape: ProductShape });
+```
+
+## Observing Mutations
+
+```typescript
+const unsubscribe = store.observe(mutations => {
+	for (const [id, exists] of Object.entries(mutations)) {
+		console.log(exists ? "upserted" : "removed", id);
+	}
+}, "http://example.com/products/");
+
+unsubscribe(); // stop receiving events
+```
 
-**@metreeca/keep** is part of an integrated ecosystem for rapid application development:
+The second argument scopes the observer to the given resources and their descendants: pass a single reference or any
+collection of them, omit it to receive all mutations, or pass an empty collection to skip registration altogether.
+
+## Executing Transactions
+
+```typescript
+await store.execute(async store => {
+	await store.create({ entry: catalogue, shape: CatalogueShape, model: { products: {} }, state: product });
+	await store.update({ entry: inventory.id, shape: InventoryShape, state: inventory });
+});
+```
+
+Cross-backend atomicity and isolation semantics, concurrency models, and the buffer-and-flush emulation pattern are
+documented in the [Transaction Design](https://metreeca.github.io/keep/documents/_metreeca_keep.Transaction_Design.html)
+companion document.
+
+# Implementing Connectors
+
+A backend connector implements the bare `StoreClient` interface against its native primitives, then wraps it with the
+`createValidatingStore` helper from
+[@metreeca/keep/validating](https://metreeca.github.io/keep/modules/_metreeca_keep.validating.html) for shape-driven
+input validation and `createManagingStore` from
+[@metreeca/keep/managing](https://metreeca.github.io/keep/modules/_metreeca_keep.managing.html) for mutation events,
+transactional execution, and lifecycle:
+
+```typescript
+import type { StoreClient, Store } from "@metreeca/keep";
+import { createManagingStore } from "@metreeca/keep/managing";
+import { createValidatingStore } from "@metreeca/keep/validating";
+
+function createMyStore(): Store {
+
+	const backend: StoreClient = {
+
+		lookup({ entry, shape, model }, scope) { /* query the backend, return matching data or undefined */ },
+
+		create({ entry, shape, model, state }) { /* create under the collection, return the new entry or undefined */ },
+		update({ entry, shape, state }) { /* update if present, return entry or undefined */ },
+		delete({ entry, shape }) { /* delete if present, return entry or undefined */ },
+
+		insert({ entry, shape, state }) { /* upsert unconditionally, return entry */ },
+		remove({ entry, shape }) { /* remove unconditionally, return entry */ }
+
+	};
+
+	const client = createValidatingStore(backend, { trusted: true });
+
+	return createManagingStore({
+
+		execute: task => { /* run task(client) within a backend transaction */ },
+		close: () => { /* release connections */ }
+
+	});
+
+}
+```
+
+Pass `trusted: true` to `createValidatingStore` when the backend is trusted to deliver shape-conforming data, so
+`lookup` responses skip the redundant validation pass. The `execute` option of `createManagingStore` is required: it runs
+every standalone call and the entire `execute` task body within the backend's transaction primitive, and MUST call the
+task with a store client dedicated to that transaction. A non-transactional backend supplies an `execute` applying the
+task directly to the client, and documents that a failing task does not roll back. `close` defaults to a no-op.
+
+All errors reach the caller as promise rejections through the unified store error channel: `RangeError` for malformed
+entries, `TraceError` for shape validation failures, `Problem` for network, storage, or other processing failures.
+Connectors MUST preserve this contract: convert backend-specific exceptions into `Problem` rejections and let validation
+rejections propagate untouched.
+
+Each connector MUST document its supported transaction isolation level and mutation event scope per the conventions
+defined in the [Transaction Design](https://metreeca.github.io/keep/documents/_metreeca_keep.Transaction_Design.html)
+companion document.
+
+## Testing
+
+Use [@metreeca/keep-suite](https://github.com/metreeca/keep/tree/main/packages/components/keep-suite) to run the full
+conformance suite against your connector:
+
+```typescript
+import { testStore } from "@metreeca/keep-suite";
+import { describe } from "vitest";
+
+describe("my-store", () => testStore({
+
+	open: () => createMyStore(), // open a store with schema but no data
+
+	contains: entry => { /* true if the resource has any stored data */ },
+	includes: (probe, shape) => { /* true if every fact described by `probe` is present */ },
+	excludes: (probe, shape) => { /* true if every fact described by `probe` is absent */ },
+
+	populate: () => { /* clear and reload the sample dataset */ },
+	generate: (sample, shape) => { /* insert an isolated copy of `sample` with a unique id */ },
+
+	close: () => { /* optional: release store resources after all tests */ }
+
+}));
+```
 
-| Package                     | Description                                                |
-|-----------------------------|------------------------------------------------------------|
-| @metreeca/qest              | Data types for client-driven, queryable REST/JSON APIs     |
-| @metreeca/blue _(upcoming)_ | Shape-based validation for resources, patches, and queries |
-| **@metreeca/keep**          | Shape-driven storage framework with pluggable adapters     |
-| @metreeca/gate _(upcoming)_ | Shape-driven REST/JSON API publishing                      |
+Narrow the run to a subset of sub-suites or tests with the `target` and `ignore` options (for example,
+`target: ["Retrieve", "PersistCreate"]`); see the
+[API reference](https://metreeca.github.io/keep/modules/_metreeca_keep-suite.html) for the full list.
 
 # Support
 

package/dist/clients/batching.core.d.ts

@@ -0,0 +1,49 @@
+import type { ResourceShape } from "@metreeca/blue/resource";
+import { type Lazy } from "@metreeca/core";
+import type { Reference, Resource } from "@metreeca/qest/state";
+import type { Broker, Detail, Detect, Handler, Modify, Select } from "./batching.js";
+/**
+ * Creates a batching request {@link Broker}.
+ *
+ * Backs {@link createBatchingStore}: the broker queues each submitted request by type and serves the queues in rounds
+ * against the supplied handlers, running all four concurrently, until every queue is empty. Requests issued
+ * mid-round, whether forwarded by a handler or freshly submitted, are served in a later round, so handlers must not
+ * assume any ordering between handlers.
+ *
+ * A handler throw fails the whole run: every pending {@link Deferred} is rejected with the originating error, so
+ * callers see a deterministic failure rather than a hang.
+ *
+ * @param handlers The batch handlers, one per request type. Each settles every {@link Deferred} in
+ *     its batch and may issue nested {@link Broker.detail} / {@link Broker.select} calls while
+ *     processing; its returned promise must settle only after every owned request, including
+ *     transitively nested ones, has settled.
+ *
+ * @returns An immutable {@link Broker} surface for enqueuing requests and receiving their
+ *     materialised results; each call returns a promise that settles when the relevant batch
+ *     completes
+ */
+export declare function createBroker(handlers: {
+    detect: Handler<Detect>;
+    detail: Handler<Detail>;
+    select: Handler<Select>;
+    modify: Handler<Modify>;
+}): Broker;
+/**
+ * Mints the identifier of a resource created under a collection.
+ *
+ * Returns an identifier nested under `entry`, matching the identifier {@link ResourceShape.pattern | pattern} declared
+ * by the shape, if any. Each `{name}` slot is filled with the like-named member of `state`, or with an opaque segment
+ * if the state has no such member. A trailing `/*` slot is always filled with an opaque segment. A root-relative
+ * pattern is resolved against `entry`. If the shape declares no pattern, the identifier is an opaque segment under
+ * `entry`.
+ *
+ * @param entry The absolute identifier of the resource collecting the new one
+ * @param shape The shape describing the new resource, possibly deferred to break definition cycles
+ * @param state The initial state of the new resource
+ *
+ * @returns The absolute identifier of the new resource
+ *
+ * @throws {@link !RangeError RangeError} If a member filling a slot is not a single non-empty path segment
+ */
+export declare function mint(entry: Reference, shape: Lazy<ResourceShape>, state: Resource): Reference;
+//# sourceMappingURL=batching.core.d.ts.map

package/dist/clients/batching.core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batching.core.d.ts","sourceRoot":"","sources":["../../src/clients/batching.core.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAA8C,KAAK,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAIvF,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAS,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM,eAAe,CAAC;AAYxG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE;IAEtC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;CAEvB,GAAG,MAAM,CA+IT;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,SAAS,CAwB7F"}

package/dist/clients/batching.core.js

@@ -0,0 +1,159 @@
+/*
+ * Copyright © 2025-2026 Metreeca srl
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { eager } from "@metreeca/blue/value";
+import { error, isNumber, isString } from "@metreeca/core";
+import { resolve } from "@metreeca/core/resource";
+import { immutable } from "@metreeca/core/values";
+/**
+ * The form a value read off a state has to take to stand as a path segment: non-empty, with no delimiter or
+ * whitespace.
+ */
+const SegmentFormat = /^[^\s/?#]+$/;
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ * Creates a batching request {@link Broker}.
+ *
+ * Backs {@link createBatchingStore}: the broker queues each submitted request by type and serves the queues in rounds
+ * against the supplied handlers, running all four concurrently, until every queue is empty. Requests issued
+ * mid-round, whether forwarded by a handler or freshly submitted, are served in a later round, so handlers must not
+ * assume any ordering between handlers.
+ *
+ * A handler throw fails the whole run: every pending {@link Deferred} is rejected with the originating error, so
+ * callers see a deterministic failure rather than a hang.
+ *
+ * @param handlers The batch handlers, one per request type. Each settles every {@link Deferred} in
+ *     its batch and may issue nested {@link Broker.detail} / {@link Broker.select} calls while
+ *     processing; its returned promise must settle only after every owned request, including
+ *     transitively nested ones, has settled.
+ *
+ * @returns An immutable {@link Broker} surface for enqueuing requests and receiving their
+ *     materialised results; each call returns a promise that settles when the relevant batch
+ *     completes
+ */
+export function createBroker(handlers) {
+    const queues = Object.fromEntries(Object.entries(handlers).map(([key, handler]) => {
+        const items = [];
+        return [key, {
+                items,
+                // snapshots the queued requests and hands them to the handler, keeping them queued until the round
+                // is settled by the drain loop, which removes exactly the snapshot in the same step it re-checks the
+                // queues: a queue emptied any earlier would let a submission landing in between kick a second drain
+                // over the same snapshot, whose own removal would then drop whatever was queued behind it
+                round: () => {
+                    const batch = items.slice();
+                    return {
+                        done: batch.length > 0 ? handler(batch, broker) : Promise.resolve(),
+                        settle: () => { items.splice(0, batch.length); }
+                    };
+                },
+                purge: error => {
+                    items.forEach(deferred => deferred.reject(error));
+                    items.length = 0;
+                }
+            }];
+    }));
+    // Inner surface handed to the handlers: nested calls enqueue without kicking a drain.
+    const broker = immutable({
+        detect(request) {
+            return new Promise((resolve, reject) => queues.detect.items.push({ request, resolve, reject }));
+        },
+        detail(request) {
+            return new Promise((resolve, reject) => queues.detail.items.push({ request, resolve, reject }));
+        },
+        select(request) {
+            return new Promise((resolve, reject) => queues.select.items.push({ request, resolve, reject }));
+        },
+        modify(request) {
+            return new Promise((resolve, reject) => queues.modify.items.push({ request, resolve, reject }));
+        }
+    });
+    // Public surface: every call enqueues through the inner broker and kicks a drain via `process`.
+    return immutable({
+        detect(request) {
+            return process(() => broker.detect(request));
+        },
+        detail(request) {
+            return process(() => broker.detail(request));
+        },
+        select(request) {
+            return process(() => broker.select(request));
+        },
+        modify(request) {
+            return process(() => broker.modify(request));
+        }
+    });
+    // Kicks a drain only when every queue is idle: a running drain keeps its snapshots queued until the
+    // step that re-checks the queues, so "all empty" means "no drain in flight". The kick is a microtask,
+    // so a synchronous burst of submissions coalesces into one drain. The check runs before `submit`
+    // enqueues, or it would always see the request it just pushed.
+    function process(submit) {
+        if (Object.values(queues).every(queue => queue.items.length === 0)) {
+            Promise.resolve().then(async () => {
+                // Drain in rounds until every queue is quiescent, all four handlers concurrently per
+                // round. Every snapshot stays queued across the `await` and is removed in the same
+                // synchronous step as the next idle check, so no submission can ever find the queues empty
+                // while the loop is alive; anything pushed mid-round is served next round. A throw leaves
+                // the snapshots queued to purge.
+                try {
+                    while (Object.values(queues).some(queue => queue.items.length > 0)) {
+                        const rounds = Object.values(queues).map(queue => queue.round());
+                        await Promise.all(rounds.map(round => round.done));
+                        rounds.forEach(round => round.settle());
+                    }
+                }
+                catch (error) {
+                    // A handler throw poisons the run: purge every queue so pending callers reject
+                    // instead of hanging; already-settled entries no-op.
+                    Object.values(queues).forEach(queue => queue.purge(error));
+                }
+            });
+        }
+        return submit();
+    }
+}
+/**
+ * Mints the identifier of a resource created under a collection.
+ *
+ * Returns an identifier nested under `entry`, matching the identifier {@link ResourceShape.pattern | pattern} declared
+ * by the shape, if any. Each `{name}` slot is filled with the like-named member of `state`, or with an opaque segment
+ * if the state has no such member. A trailing `/*` slot is always filled with an opaque segment. A root-relative
+ * pattern is resolved against `entry`. If the shape declares no pattern, the identifier is an opaque segment under
+ * `entry`.
+ *
+ * @param entry The absolute identifier of the resource collecting the new one
+ * @param shape The shape describing the new resource, possibly deferred to break definition cycles
+ * @param state The initial state of the new resource
+ *
+ * @returns The absolute identifier of the new resource
+ *
+ * @throws {@link !RangeError RangeError} If a member filling a slot is not a single non-empty path segment
+ */
+export function mint(entry, shape, state) {
+    const { pattern } = eager(shape);
+    return pattern === undefined
+        ? resolve(entry.endsWith("/") ? entry : `${entry}/`, crypto.randomUUID())
+        : resolve(entry, pattern.replace(/\{(\w*)}|(?<=\/)\*$/g, (_, name) => name === undefined ? crypto.randomUUID() : segment(name)));
+    /**
+     * Reads a pattern slot off the like-named member of the state, or fills it with an opaque segment.
+     */
+    function segment(name) {
+        const value = state[name];
+        return value === undefined ? crypto.randomUUID()
+            : (isString(value) || isNumber(value)) && SegmentFormat.test(String(value)) ? String(value)
+                : error(new RangeError(`illegal identifier segment <${String(value)}> for slot <${name}>`));
+    }
+}
+//# sourceMappingURL=batching.core.js.map

package/dist/clients/batching.core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batching.core.js","sourceRoot":"","sources":["../../src/clients/batching.core.ts"],"names":[],"mappings":"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"}