@actualwave/deferred-data-access 2.0.1 → 2.1.1

package/README.md

@@ -1,39 +1,412 @@
 # Deferred Data Access
-Deferred Data Access(DDA) is a framework for building async CRUD APIs. It transforms object calls into commands that can be interpreted by custom function.
+
+Deferred Data Access (DDA) is a TypeScript library that wraps any object or Promise in a `Proxy` and records every property access, assignment, deletion, and function call as a typed **command**. A developer-supplied handler function decides what each command means — fetching from a REST API, forwarding to a Web Worker, replaying in a test, or anything else.
+
+## Table of contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [How it works](#how-it-works)
+- [Lazy vs reactive mode](#lazy-vs-reactive-mode)
+- [Command types](#command-types)
+- [Command handler](#command-handler)
+- [createCommandHandler](#createcommandhandler)
+- [CommandChain API](#commandchain-api)
+- [Resource system](#resource-system)
+- [Cross-context interface](#cross-context-interface)
+- [Sub-package reference](#sub-package-reference)
+- [Projects built on DDA](#projects-built-on-dda)
+
+---
+
+## Installation
+
+```bash
+npm install @actualwave/deferred-data-access
+```
+
+---
+
+## Quick start
+
+```typescript
+import { handle } from '@actualwave/deferred-data-access';
+import { ProxyCommand } from '@actualwave/deferred-data-access/proxy';
+
+// 1. Define a handler that interprets commands
+const handler = async (command, context, wrap) => {
+  if (command.type === ProxyCommand.GET) {
+    const target = await context;
+    return target[command.name];
+  }
+  // ...
+};
+
+// 2. Create a wrap factory for a given handler
+const wrap = handle(handler);
+
+// 3. Wrap an object (or a Promise of one) — returns a Proxy
+const proxy = wrap({ user: { name: 'Alice' } });
+
+// 4. Access properties — in lazy mode handler is called once on .then()
+const name = await proxy.user.name; // → 'Alice'
+```
+
+---
 
 ## How it works
-1. Framework accepts an async handler function and returns an object.
-```javascript
-const obj = handle((command, context) => {
-  let result;
 
-  // Some logic that gets somewhere value and saves in into "result" variable.
+1. `handle(handler)` returns a `wrap` factory.
+2. `wrap(target)` wraps `target` in a `Proxy`. Every property access, assignment, deletion, or call is intercepted.
+3. Intercepted operations are chained into a `CommandChain` — a linked list of `ICommand` nodes, head to tail.
+4. When the result is awaited (`.then()` / `await`), the handler receives the full chain plus a context Promise and must return a Promise with the resolved value.
+5. The handler can call `wrap(result, command)` to return a new proxy that continues the same chain, enabling deeply nested lazy access.
+
+---
+
+## Lazy vs reactive mode
+
+`handle(handler, lazy?)` — second argument controls the mode (default: `true`).
+
+### Lazy mode (default)
+
+The handler is called **once** per `.then()` / `.catch()` invocation. Intermediate GET/APPLY operations build up a `CommandChain` but do not invoke the handler until the result is awaited.
+
+```typescript
+const wrap = handle(handler); // lazy = true
+
+const proxy = wrap(rootObject);
+proxy.a.b.c; // no handler calls yet
+await proxy.a.b.c; // handler called once with chain: GET(c) → GET(b) → GET(a)
+```
+
+The command delivered to the handler is the **head** of the chain. Walk `command.prev` to reach earlier operations.
+
+### Reactive mode
+
+The handler is called on **every** intercepted operation.
+
+```typescript
+const wrap = handle(handler, false); // lazy = false
+
+const proxy = wrap(rootObject);
+proxy.a; // handler called: GET('a')
+proxy.a.b; // handler called: GET('a'), then GET('b') on its result
+```
+
+---
+
+## Command types
+
+Imported from `@actualwave/deferred-data-access/proxy`:
+
+| Constant | Value | Triggered by |
+|---|---|---|
+| `ProxyCommand.GET` | `'P:get'` | `proxy.prop` |
+| `ProxyCommand.SET` | `'P:set'` | `proxy.prop = value` |
+| `ProxyCommand.DELETE_PROPERTY` | `'P:del'` | `delete proxy.prop` |
+| `ProxyCommand.APPLY` | `'P:apply'` | `proxy(args)` |
+| `ProxyCommand.METHOD_CALL` | `'P:call'` | `proxy.method(args)` *(lazy mode only — collapses GET + APPLY)* |
 
-  return result;
-})();
+`METHOD_CALL` is only generated in lazy mode when a `GET` is immediately followed by an `APPLY`. It carries the method name in `command.name` and the arguments in `command.value`.
+
+### Command shape
+
+```typescript
+interface ICommand {
+  type: string;          // ProxyCommand value
+  name?: PropertyName;   // string | symbol — property name
+  value?: unknown;       // SET value, APPLY args, or METHOD_CALL args
+  context?: Promise<unknown>; // Promise resolving to the target object
+}
 ```
-2. Developer accesses object property and gets Promise
-```javascript
-const value = await obj.prop;
+
+---
+
+## Command handler
+
+```typescript
+type CommandHandler = (
+  command: ICommandList,
+  context: CommandContext | undefined,
+  wrap: (context: CommandContext, command?: ICommandChain) => unknown
+) => Promise<unknown>;
+```
+
+| Argument | Description |
+|---|---|
+| `command` | Head of the `CommandChain` — inspect `command.type`, `command.name`, `command.value`. Walk `command.prev` for earlier operations. |
+| `context` | A `Promise` resolving to the target object the command was issued against. `undefined` for the root call. |
+| `wrap` | Re-wraps a new Promise with the same handler, enabling chained lazy access on sub-objects. |
+
+### Example — object property access
+
+```typescript
+const handler = async (command, context, wrap) => {
+  const target = await context;
+
+  switch (command.type) {
+    case ProxyCommand.GET:
+      return target[command.name];
+
+    case ProxyCommand.SET:
+      target[command.name] = command.value;
+      return;
+
+    case ProxyCommand.METHOD_CALL:
+      return target[command.name](...command.value);
+
+    case ProxyCommand.APPLY:
+      return (target as Function)(...command.value);
+
+    case ProxyCommand.DELETE_PROPERTY:
+      return delete target[command.name];
+  }
+};
 ```
-3. Framework records property access into a command object, handler function is called with command object as an argument.
-```javascript
-{ type: ProxyCommand.GET, name: 'prop' }
+
+---
+
+## createCommandHandler
+
+A utility that dispatches to per-type handler functions:
+
+```typescript
+import { createCommandHandler } from '@actualwave/deferred-data-access/command';
+import { ProxyCommand } from '@actualwave/deferred-data-access/proxy';
+
+const handler = createCommandHandler({
+  handlers: {
+    [ProxyCommand.GET]: async (command, context) => {
+      const target = await context;
+      return target[command.name];
+    },
+    [ProxyCommand.SET]: async (command, context) => {
+      const target = await context;
+      target[command.name] = command.value;
+    },
+  },
+  defaultHandler: async (command) => {
+    throw new Error(`Unhandled command: ${command.type}`);
+  },
+});
+
+const wrap = handle(handler, false);
 ```
-4. Whatever function returns is returned as promise value.
 
-DDA can operate in two modes, mode is defined by passing second argument to handle() function.
- * lazy - Default mode, custom handler function is called only when `then()` or `catch()` methods are accessed. Accessing `obj.child.grand.prop.then(func)` calls function once.
- * reactive - Non-lazy, custom handler function called on every operation. Accessing `obj.child.grand.prop.then(func)` calls function 3 times.
+If no matching handler and no `defaultHandler`, the call resolves to `undefined`.
+
+---
+
+## CommandChain API
+
+`CommandChain` extends `Command` and is iterable from head to tail:
+
+```typescript
+import { CommandChain } from '@actualwave/deferred-data-access/command';
+
+// Iterate head → tail
+for (const node of command) {
+  console.log(node.type, node.name);
+}
+
+// Functional traversal
+const types = command.map(node => node.type);
+const path  = command.reduce((acc, node) => [node.name, ...acc], []);
+
+command.forEach(node => { /* head → tail */ });
+command.isTail(); // true if this node has no prev
+```
+
+### withoutPrev()
+
+Creates an immutable copy of the node with the `prev` link removed. Use this instead of mutating `prev` directly to avoid corrupting shared chain references:
+
+```typescript
+const severed = command.withoutPrev();
+// severed.prev === undefined
+// command.prev is unchanged
+```
+
+---
+
+## Resource system
+
+Resources allow objects to be referenced by ID across serialisation boundaries (e.g. `postMessage`). Each `Resource` gets a stable string ID and lives in a `ResourcePool`.
+
+```typescript
+import {
+  ResourcePool,
+  getDefaultResourcePool,
+  isResourceObject,
+} from '@actualwave/deferred-data-access/resource';
+
+const pool = getDefaultResourcePool(); // lazily-created singleton
+
+// Register an object
+const resource = pool.set(myObject);
+console.log(resource.id);     // stable string ID
+console.log(resource.poolId); // pool's own ID
+
+// Serialise for postMessage
+const descriptor = resource.toObject();
+// { id: '...', poolId: '...', type: 'object' }
+
+// Reconstruct on the other side
+const retrieved = pool.getById(descriptor.id);
+
+// Type guard
+if (isResourceObject(value)) {
+  const live = pool.getById(value.id);
+}
+```
+
+Multiple pools can be managed through `ResourcePoolRegistry`:
+
+```typescript
+import { getRegistry } from '@actualwave/deferred-data-access/resource';
+
+const registry = getRegistry(); // lazily-created singleton
+const pool = registry.createPool();
+registry.get(pool.id); // → pool
+```
+
+### Custom FinalizationRegistry
+
+In environments where `globalThis.FinalizationRegistry` is absent or needs to be replaced (e.g. React Native / Hermes), set a custom implementation before any pools are created:
+
+```typescript
+import { setCustomFinalizationRegistryClass } from '@actualwave/deferred-data-access/resource';
+
+setCustomFinalizationRegistryClass(MyFinalizationRegistryPolyfill);
+// All ResourcePools created after this call will use MyFinalizationRegistryPolyfill.
+// Pass null to explicitly disable GC-based cleanup.
+```
+
+The constructor of `ResourcePool` also accepts a `FinalizationRegistry` directly, which takes precedence over the module-level setting:
+
+```typescript
+const pool = new ResourcePool(MyFinalizationRegistryPolyfill);
+```
+
+### Replacing singletons
+
+```typescript
+import {
+  setDefaultResourcePool,
+  setRegistry,
+} from '@actualwave/deferred-data-access/resource';
+
+setDefaultResourcePool(myPool);   // replace the default pool singleton
+setRegistry(myRegistry);          // replace the default registry singleton
+```
+
+---
+
+## Cross-context interface
+
+`initialize()` sets up a **bidirectional proxy channel** between two contexts (main thread ↔ Worker, two iframes, WebSocket peers, etc.). Each side runs `initialize()` and they perform a handshake before exposing proxies to each other's `root` object.
+
+```typescript
+import { initialize, InterfaceType } from '@actualwave/deferred-data-access/interface';
+
+// --- Main thread (HOST) ---
+const worker = new Worker('./worker.js');
+
+const { root, stop } = await initialize({
+  type: InterfaceType.HOST,
+  root: { greet: (name: string) => `Hello, ${name}!` }, // expose to worker
+  subscribe:   (fn) => worker.addEventListener('message', fn),
+  unsubscribe: (fn) => worker.removeEventListener('message', fn),
+  sendMessage: (data) => worker.postMessage(data),
+  handshakeTimeout: 5000,
+  responseTimeout: 10000,
+});
+
+// `root` is a proxy to the worker's exported API
+const result = await root.remoteMethod('arg');
+stop(); // detach message listener
+```
+
+```typescript
+// --- Worker (GUEST) ---
+import { initialize, InterfaceType } from '@actualwave/deferred-data-access/interface';
+
+await initialize({
+  type: InterfaceType.GUEST,
+  root: { remoteMethod: (arg: string) => arg.toUpperCase() },
+  subscribe:   (fn) => self.addEventListener('message', fn),
+  unsubscribe: (fn) => self.removeEventListener('message', fn),
+  sendMessage: (data) => self.postMessage(data),
+  handshakeTimeout: 5000,
+  responseTimeout: 10000,
+});
+```
+
+### InitConfig options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `type` | `InterfaceType` | required | `HOST` waits for the guest; `GUEST` initiates |
+| `root` | `unknown` | — | Object to expose to the remote side |
+| `subscribe` | `(fn) => void` | required | Attach a message listener |
+| `unsubscribe` | `(fn) => void` | required | Detach a message listener |
+| `sendMessage` | `(data) => void` | required | Send a message to the remote side |
+| `id` | `string` | auto | Stable ID for this interface endpoint |
+| `remoteId` | `string` | — | Expected remote ID (skips handshake if both sides know each other's ID) |
+| `handshakeTimeout` | `number` | — | ms before handshake times out |
+| `handshakeInterval` | `number` | — | ms between handshake retry attempts (GUEST only) |
+| `responseTimeout` | `number` | `0` (none) | ms before a remote call times out |
+| `preprocessResponse` | `(data) => unknown` | identity | Transform raw message data before parsing |
+
+### initialize() return value
+
+```typescript
+{
+  stop: () => void;           // detach the message listener
+  pool: ResourcePool;         // local resource pool
+  root: unknown | null;       // proxy to the remote root (null if remote has no root)
+  wrap: Function;             // wrap factory with the same handler (for advanced use)
+  pendingRequests: Map<…>;    // in-flight request map (for advanced use)
+}
+```
+
+---
+
+## Sub-package reference
+
+| Import path | Key exports |
+|---|---|
+| `@actualwave/deferred-data-access` | `handle` |
+| `@actualwave/deferred-data-access/command` | `Command`, `CommandChain`, `createCommandHandler` |
+| `@actualwave/deferred-data-access/proxy` | `ProxyCommand`, `wrapWithProxy`, `isWrappedWithProxy`, `unwrapProxy`, `generateProxyCommand` |
+| `@actualwave/deferred-data-access/resource` | `Resource`, `ResourcePool`, `ResourcePoolRegistry`, `getDefaultResourcePool`, `setDefaultResourcePool`, `getRegistry`, `setRegistry`, `getCustomFinalizationRegistryClass`, `setCustomFinalizationRegistryClass`, `isResourceObject`, `createResource` |
+| `@actualwave/deferred-data-access/record` | `recordHandlerCalls`, `latestCall`, `latestCallFor`, `clearLatestCalls` |
+| `@actualwave/deferred-data-access/utils` | `IdOwner`, `generateId`, `createUIDGenerator`, `isReservedPropertyName`, `ReservedPropertyNames`, `reject` |
+| `@actualwave/deferred-data-access/interface` | `initialize`, `InterfaceType`, `MessageType`, `createSubscriberFns`, `findEventEmitter`, `findMessagePort` |
+
+### recordHandlerCalls
+
+Wraps a `CommandHandler` to track the latest in-flight call Promise, useful for implementing loading indicators or sequential request logic:
+
+```typescript
+import { recordHandlerCalls, latestCall, latestCallFor } from '@actualwave/deferred-data-access/record';
+
+const trackedHandler = recordHandlerCalls(myHandler);
+const wrap = handle(trackedHandler);
+
+const proxy = wrap(rootObject);
+proxy.doWork();
+
+// latestCall() returns the Promise of the most recent handler invocation
+await latestCall();
+
+// latestCallFor(context) returns the Promise for a specific context Promise
+```
 
-There are multiple predefined commands that can be passed to handler function.
- * ProxyCommand.**GET** - when property accessed
- * ProxyCommand.**SET** - when property is set, new value is recorded as `value` in command object
- * ProxyCommand.**DELETE_PROPERTY** - when property is being deleted
- * ProxyCommand.**APPLY** - when function is called, call arguments recorded as `value` of command object
- * ProxyCommand.**METHOD_CALL** - only generated in lazy mode, it combines GET and APPLY commands.
+---
 
+## Projects built on DDA
 
-## Projects made with DDA
- * [RESTObject](https://github.com/burdiuz/js-deferred-data-access/tree/master/packages/rest-object)
- * [WorkerInterface](https://github.com/burdiuz/js-deferred-data-access/tree/master/packages/worker-interface)
+- [RESTObject](https://github.com/burdiuz/js-deferred-data-access/tree/master/packages/rest-object) — REST API access using dot notation
+- [WorkerInterface](https://github.com/burdiuz/js-deferred-data-access/tree/master/packages/worker-interface) — transparent proxy to a Web Worker's API

package/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: "deferred-data-access"
+description: "TypeScript library that wraps objects in an ES Proxy and converts every property access, assignment, deletion, and call into a typed command delivered to a developer-supplied async handler. Use when working on or extending this package; building handlers that depend on it (REST object, worker proxy, etc.); reading or writing command chains; setting up cross-context communication via initialize(); working with ResourcePool and Resource; or writing and debugging tests for DDA-based code."
+license: "MIT"
+compatibility: "Node.js 18+. TypeScript 5+. Tests use Jest 30 + ts-jest. Run `npm test` from packages/deferred-data-access."
+metadata:
+  author: "Oleg Galaburda <burdiuz@gmail.com>"
+  version: "2.0.0"
+  package: "@actualwave/deferred-data-access"
+---
+
+# Deferred Data Access — Agent Skill
+
+## Sub-packages
+
+| Import path | Key exports |
+|---|---|
+| `@actualwave/deferred-data-access` | `handle` |
+| `.../command` | `Command`, `CommandChain`, `createCommandHandler` |
+| `.../proxy` | `ProxyCommand`, `wrapWithProxy`, `isWrappedWithProxy`, `unwrapProxy`, `generateProxyCommand` |
+| `.../resource` | `Resource`, `ResourcePool`, `ResourcePoolRegistry`, `getDefaultResourcePool`, `setDefaultResourcePool`, `getRegistry`, `setRegistry`, `getCustomFinalizationRegistryClass`, `setCustomFinalizationRegistryClass`, `isResourceObject`, `createResource` |
+| `.../record` | `recordHandlerCalls`, `latestCall`, `latestCallFor`, `clearLatestCalls` |
+| `.../utils` | `IdOwner`, `generateId`, `createUIDGenerator`, `isReservedPropertyName`, `ReservedPropertyNames`, `reject` |
+| `.../interface` | `initialize`, `InterfaceType`, `MessageType`, `createSubscriberFns`, `findEventEmitter`, `findMessagePort` |
+
+## Core workflow
+
+```
+handle(handler, lazy?) → wrap(target) → Proxy
+  → property access / call / set
+  → CommandChain (head → prev → … → tail)
+  → .then() / await → handler(command, context, wrap)
+  → Promise<result>
+```
+
+## Command types (`ProxyCommand`)
+
+| Constant | Triggered by |
+|---|---|
+| `GET` `'P:get'` | `proxy.prop` |
+| `SET` `'P:set'` | `proxy.prop = v` |
+| `DELETE_PROPERTY` `'P:del'` | `delete proxy.prop` |
+| `APPLY` `'P:apply'` | `proxy(args)` |
+| `METHOD_CALL` `'P:call'` | `proxy.method(args)` *(lazy only)* |
+
+## Lazy vs reactive
+
+- **Lazy** (default): handler fires once on `await`. Consecutive GET + APPLY collapses to `METHOD_CALL`. Walk `command.prev` for the full chain.
+- **Reactive** (`handle(h, false)`): fires on every operation. `METHOD_CALL` never emitted; `APPLY` has no `name` — derive it from the preceding GET's path segment.
+
+## CommandChain
+
+```typescript
+command.forEach(n => path.push(String(n.name))); // deepest-first
+const nodes = [...command];    // head … tail via Symbol.iterator
+command.withoutPrev();          // immutable copy, prev severed — never mutate prev directly
+```
+
+## Resource system
+
+All singletons are lazily created — no pool or registry is instantiated at module load time.
+
+```typescript
+import {
+  getDefaultResourcePool, setDefaultResourcePool,
+  getRegistry, setRegistry,
+  getCustomFinalizationRegistryClass, setCustomFinalizationRegistryClass,
+} from '@actualwave/deferred-data-access/resource';
+```
+
+- `getDefaultResourcePool()` / `setDefaultResourcePool(pool)` — module-level default `ResourcePool` singleton.
+- `getRegistry()` / `setRegistry(registry)` — module-level `ResourcePoolRegistry` singleton. The registry auto-registers the default pool on first creation.
+- `getCustomFinalizationRegistryClass()` / `setCustomFinalizationRegistryClass(cls)` — module-level fallback `FinalizationRegistry` class passed to every new `ResourcePool`. Set this before any pool is created in environments where `globalThis.FinalizationRegistry` is absent (e.g. Hermes/React Native). Pass `null` to explicitly disable GC cleanup.
+- `ResourcePool` constructor: `new ResourcePool(FinalizationRegistry?)` — explicit argument takes precedence over the module-level setting.
+- `ResourcePoolRegistry.createPool()` — creates and registers a new pool; uses the module-level `FinalizationRegistry` class via `ResourcePool`'s constructor default.
+
+## `initialize()` (cross-context)
+
+```typescript
+import { initialize, InterfaceType } from '@actualwave/deferred-data-access/interface';
+const { root, stop } = await initialize({
+  type: InterfaceType.HOST,      // or GUEST
+  root: myApi,
+  subscribe:   fn => emitter.on('message', fn),
+  unsubscribe: fn => emitter.off('message', fn),
+  sendMessage: data => transport.send(data),
+  preprocessResponse: e => e.data,
+  handshakeTimeout: 5_000,
+});
+```
+
+## Testing
+
+```bash
+cd packages/deferred-data-access && npm test
+```
+
+Jest 30, ts-jest. `moduleNameMapper` in `jest.config.js` + `paths` in `tsconfig.spec.json`.
+
+## Key invariants
+
+- `typeof null === 'object'` — always guard `value != null && typeof value === 'object'`.
+- DDA always wraps root context in `Promise.resolve()`. Avoid unconditional `await`; check `isPromiseLike` first.
+- `APPLY` in reactive mode has no `name` — derive from preceding GET's path.
+- `Command.type`, `Command.name`, `Resource.pool`, `IdOwner.id` are runtime non-writable.
+- `isReservedPropertyName('then')` → `true`; symbol keys always → `false`.

package/command/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../packages/deferred-data-access/command/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

package/command/index.es.js

@@ -0,0 +1,98 @@
+class Command {
+    constructor(type, name, value, context) {
+        this.type = type;
+        this.name = name;
+        this.value = value;
+        this.context = context;
+        Object.defineProperty(this, 'type', { value: type, writable: false, configurable: false });
+        Object.defineProperty(this, 'name', { value: name, writable: false, configurable: false });
+    }
+    toObject(includeContext = false) {
+        const { type, name, value, context } = this;
+        return {
+            type,
+            name,
+            value,
+            context: includeContext ? context : undefined,
+        };
+    }
+    toJSON(includeContext = false) {
+        const { type, name, value, context } = this;
+        return includeContext
+            ? JSON.stringify([type, name, value, context])
+            : JSON.stringify([type, name, value]);
+    }
+    static fromJSON(jsonString) {
+        const [type, name, value, context] = JSON.parse(jsonString);
+        return new Command(type, name, value, context);
+    }
+}
+
+class CommandChain extends Command {
+    constructor(prev, type, name, value, context) {
+        super(type, name, value, context);
+        this.prev = prev;
+    }
+    *[Symbol.iterator]() {
+        let item = this;
+        while (item) {
+            yield item;
+            item = item.prev;
+        }
+    }
+    isTail() {
+        return !this.prev;
+    }
+    forEach(callback) {
+        let node = this;
+        do {
+            callback(node);
+            node = node.prev;
+        } while (node);
+    }
+    map(callback) {
+        let node = this;
+        const list = [];
+        do {
+            list.push(callback(node));
+            node = node.prev;
+        } while (node);
+        return list;
+    }
+    reduce(callback, base) {
+        let node = this;
+        let result = base;
+        do {
+            result = callback(result, node);
+            node = node.prev;
+        } while (node);
+        return result;
+    }
+    /**
+     * Returns a new CommandChain that is identical to this one but with the
+     * `prev` link severed, rather than mutating the existing instance in-place.
+     * Use this instead of `delete command.prev` to avoid corrupting shared chain
+     * references held by other code.
+     */
+    withoutPrev() {
+        return new CommandChain(undefined, this.type, this.name, this.value, this.context);
+    }
+    static fromCommand({ type, name, value, context }, prev) {
+        return new CommandChain(prev, type, name, value, context);
+    }
+}
+
+/*
+  Creates a function that calls handler depending on command type
+*/
+const createCommandHandler = ({ handlers, defaultHandler, }) => (command, ...args) => {
+    const { type } = command;
+    const handler = (handlers && handlers[type]) || defaultHandler;
+    if (handler) {
+        return handler(command, ...args);
+    }
+    return Promise.resolve(undefined);
+};
+
+export { Command, CommandChain, createCommandHandler };
+//# sourceMappingURL=index.es.js.map

package/command/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../packages/deferred-data-access/command/src/command.ts","../../../../../../packages/deferred-data-access/command/src/command-chain.ts","../../../../../../packages/deferred-data-access/command/src/command-handler.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":"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"}