effect-dynamodb 1.1.0 → 1.3.0

package/dist/Entity.js

@@ -6,11 +6,12 @@
  * carries derived schemas for 7 type extractors (Model, Record, Input, Update,
  * Key, Item, Marshalled).
  */
-import { Duration, Effect, Schema, Stream } from "effect";
+import { DateTime, Duration, Effect, Schema, Stream } from "effect";
 import { DynamoClient } from "./DynamoClient.js";
 import { getEncoding, getIdentifierField, isConfiguredModel, isHidden, isRef, isRefField, } from "./DynamoModel.js";
 import * as DynamoSchema from "./DynamoSchema.js";
 import { CascadePartialFailure, ConditionalCheckFailed, ItemNotFound, isAwsConditionalCheckFailed, isAwsTransactionCancelled, OptimisticLockError, RefNotFound, TransactionOverflow, UniqueConstraintViolation, ValidationError, } from "./Errors.js";
+import { makeBoundDelete, makeBoundPut, makeBoundUpdate } from "./internal/BoundCrud.js";
 import { BoundQueryImpl } from "./internal/BoundQuery.js";
 import { compileExpr, createConditionOps, isExpr, parseShorthand, parseSimpleShorthand, } from "./internal/Expr.js";
 import { compilePath, createPathBuilder } from "./internal/PathBuilder.js";
@@ -100,7 +101,20 @@ const makeImpl = (config) => {
     const isSchemaClass = typeof rawModel === "function";
     const modelFields = getFields(rawModel);
     const hasHiddenFields = Object.values(modelFields).some(isHidden);
-    const systemFields = resolveSystemFields(config.timestamps, config.versioned, config.timeSeries);
+    const systemFields = resolveSystemFields(config.timestamps, config.versioned, config.timeSeries, modelFields, configuredAttributes);
+    // System-field collision policy:
+    //   - Timestamp collisions with a non-date model field silently yield the
+    //     field to the user (see `resolveSystemFields`).
+    //   - `version` collision is allowed. The field is stripped from
+    //     `inputSchema` / `createSchema` / `updateSchema` (see
+    //     `buildDerivedSchemas`), so user code cannot supply it via `put` /
+    //     `create` / `.set()`. Library continues to own the write path
+    //     (auto-increment + `.expectedVersion()` optimistic locking). The model
+    //     declaration is purely for type-level visibility — callers can
+    //     construct Schema.Class instances and read `version` off the record.
+    //   - Manual version fixups remain available by dropping to the raw
+    //     `DynamoClient` service; they deliberately do not appear on the
+    //     `Entity` surface to keep the locking invariant visibly inviolable.
     // ---------------------------------------------------------------------------
     // Validate indexes
     // ---------------------------------------------------------------------------
@@ -415,6 +429,10 @@ const makeImpl = (config) => {
     /**
      * Generate a timestamp value appropriate for the field's encoding.
      * Default (no encoding): ISO string. Custom encoding: serialized primitive.
+     *
+     * Used for non-colliding system fields (field not declared in model) — the
+     * value is written straight into the DynamoDB item and is NOT routed through
+     * `serializeDateFields` (because the field is absent from `fieldEncodings`).
      */
     const generateTimestamp = (encoding) => {
         if (!encoding)
@@ -422,6 +440,22 @@ const makeImpl = (config) => {
         const now = new Date();
         return serializeDateForDynamo(now, encoding);
     };
+    /**
+     * Generate a timestamp as a domain value (DateTime.Utc / DateTime.Zoned / Date),
+     * matching the field's declared domain. Used for system fields that COLLIDE
+     * with a model-declared field — the value flows through `serializeDateFields`
+     * (which requires a domain value) alongside any user-supplied override.
+     */
+    const generateDomainTimestamp = (encoding) => {
+        switch (encoding.domain) {
+            case "DateTime.Utc":
+                return DateTime.makeUnsafe(new Date());
+            case "DateTime.Zoned":
+                return DateTime.makeZonedUnsafe(new Date(), { timeZone: "UTC" });
+            case "Date":
+                return new Date();
+        }
+    };
     // ---------------------------------------------------------------------------
     // Lifecycle config helpers
     // ---------------------------------------------------------------------------
@@ -710,7 +744,7 @@ const makeImpl = (config) => {
         const client = yield* DynamoClient;
         const { name: tableName } = yield* tableTag;
         // Decode input
-        const decodedInput = yield* Schema.decodeUnknownEffect(schemas.inputSchema)(input).pipe(Effect.mapError((cause) => new ValidationError({
+        const decodedInput = yield* Schema.decodeUnknownEffect(schemas.inputDecodeSchema)(input).pipe(Effect.mapError((cause) => new ValidationError({
             entityType,
             operation: "put.decode",
             cause,
@@ -723,11 +757,29 @@ const makeImpl = (config) => {
             : decodedInput;
         // Build the DynamoDB item
         const item = { ...decoded };
-        // Add system fields (encoding-aware timestamps)
-        if (systemFields.createdAt)
-            item[systemFields.createdAt] = generateTimestamp(systemFields.createdAtEncoding);
-        if (systemFields.updatedAt)
-            item[systemFields.updatedAt] = generateTimestamp(systemFields.updatedAtEncoding);
+        // Add system fields. When a timestamp field collides with a
+        // model-declared field, the user may have supplied their own value
+        // (see `inputDecodeSchema` — optional on collision). Respect their
+        // value if present; otherwise generate. In the collision path the
+        // value is a DOMAIN value (DateTime.Utc / Date / ...) so it flows
+        // through `serializeDateFields` downstream. Non-colliding fields
+        // get a storage primitive directly (no `serializeDateFields` pass).
+        if (systemFields.createdAt) {
+            if (item[systemFields.createdAt] === undefined) {
+                item[systemFields.createdAt] =
+                    systemFields.createdAtCollision && systemFields.createdAtEncoding
+                        ? generateDomainTimestamp(systemFields.createdAtEncoding)
+                        : generateTimestamp(systemFields.createdAtEncoding);
+            }
+        }
+        if (systemFields.updatedAt) {
+            if (item[systemFields.updatedAt] === undefined) {
+                item[systemFields.updatedAt] =
+                    systemFields.updatedAtCollision && systemFields.updatedAtEncoding
+                        ? generateDomainTimestamp(systemFields.updatedAtEncoding)
+                        : generateTimestamp(systemFields.updatedAtEncoding);
+            }
+        }
         if (systemFields.version)
             item[systemFields.version] = 1;
         // Add entity type discriminator
@@ -935,7 +987,7 @@ const makeImpl = (config) => {
             cause,
         })));
         // Decode updates
-        const decodedUpdates = yield* Schema.decodeUnknownEffect(schemas.updateSchema)(updates ?? {}).pipe(Effect.mapError((cause) => new ValidationError({
+        const decodedUpdates = yield* Schema.decodeUnknownEffect(schemas.updateDecodeSchema)(updates ?? {}).pipe(Effect.mapError((cause) => new ValidationError({
             entityType,
             operation: "update.decodeUpdates",
             cause,
@@ -1031,12 +1083,19 @@ const makeImpl = (config) => {
                     }
                 }
             }
-            // Increment version and update timestamp
+            // Increment version and update timestamp. If the caller supplied a
+            // value for `updatedAt` (allowed when the field collides with a
+            // model-declared field), respect it; else generate.
             const newVersion = currentVersion + 1;
             if (systemFields.version)
                 newItem[systemFields.version] = newVersion;
-            if (systemFields.updatedAt)
-                newItem[systemFields.updatedAt] = generateTimestamp(systemFields.updatedAtEncoding);
+            if (systemFields.updatedAt) {
+                const userSupplied = hydratedUpdates[systemFields.updatedAt];
+                newItem[systemFields.updatedAt] =
+                    userSupplied !== undefined
+                        ? userSupplied
+                        : generateTimestamp(systemFields.updatedAtEncoding);
+            }
             // Convert DynamoDB attribute names to domain names for key composition
             // and sentinel value comparison (newItem was built from currentRaw which
             // uses DynamoDB names; composites and unique fields use domain names)
@@ -1202,10 +1261,22 @@ const makeImpl = (config) => {
         const names = {};
         const values = {};
         let counter = 0;
+        // Serialize any domain-value date fields in updates to storage primitives.
+        // Without this, a `.set({ occurredAt: DateTime.Utc })` would marshal as a
+        // class-instance map.
+        const serializedUpdates = { ...hydratedUpdates };
+        serializeDateFields(serializedUpdates);
+        // System-colliding updatedAt is handled by the system-field block below.
+        // createdAt and version are already excluded by `updateDecodeSchema`.
+        const updateSystemColliders = new Set();
+        if (systemFields.updatedAtCollision && systemFields.updatedAt)
+            updateSystemColliders.add(systemFields.updatedAt);
         // Add user-provided updates
-        for (const [attr, val] of Object.entries(hydratedUpdates)) {
+        for (const [attr, val] of Object.entries(serializedUpdates)) {
             if (val === undefined)
                 continue;
+            if (updateSystemColliders.has(attr))
+                continue;
             const nameKey = `#u${counter}`;
             const valKey = `:u${counter}`;
             names[nameKey] = resolveDbName(attr);
@@ -1213,52 +1284,16 @@ const makeImpl = (config) => {
             setClauses.push(`${nameKey} = ${valKey}`);
             counter++;
         }
-        // Shared sets for GSI removal detection (used by both compose and REMOVE)
-        const removedSet = uState.remove ? new Set(uState.remove) : undefined;
-        const pkCompositeSet = new Set(primaryKeyComposites(config.indexes));
-        // Compose GSI keys for indexes whose composites are in the update,
-        // filtering out any GSI whose composites are targeted by REMOVE
-        const indexesForGsiUpdate = removedSet
-            ? (() => {
-                const filtered = {};
-                for (const [indexName, indexDef] of Object.entries(allIndexes)) {
-                    if (!("index" in indexDef)) {
-                        filtered[indexName] = indexDef;
-                        continue;
-                    }
-                    const gsiComposites = [...indexDef.pk.composite, ...indexDef.sk.composite].filter((attr) => !pkCompositeSet.has(attr));
-                    if (!gsiComposites.some((attr) => removedSet.has(attr))) {
-                        filtered[indexName] = indexDef;
-                    }
-                }
-                return filtered;
-            })()
-            : allIndexes;
-        let gsiKeys;
-        try {
-            gsiKeys = KeyComposer.composeGsiKeysForUpdate(schema, entityType, entityVersion, indexesForGsiUpdate, hydratedUpdates, decodedKey);
-        }
-        catch (e) {
-            return yield* new ValidationError({
-                entityType,
-                operation: "update.gsiComposites",
-                cause: e instanceof Error ? e.message : e,
-            });
-        }
-        for (const [field, value] of Object.entries(gsiKeys)) {
-            const nameKey = `#u${counter}`;
-            const valKey = `:u${counter}`;
-            names[nameKey] = field;
-            values[valKey] = toAttributeValue(value);
-            setClauses.push(`${nameKey} = ${valKey}`);
-            counter++;
-        }
-        // Add updatedAt timestamp (encoding-aware)
+        // Add updatedAt timestamp. User-supplied value wins (pre-serialized
+        // above); else fall back to a freshly generated storage primitive.
         if (systemFields.updatedAt) {
+            const userSupplied = serializedUpdates[systemFields.updatedAt];
             const nameKey = `#u${counter}`;
             const valKey = `:u${counter}`;
             names[nameKey] = systemFields.updatedAt;
-            values[valKey] = toAttributeValue(generateTimestamp(systemFields.updatedAtEncoding));
+            values[valKey] = toAttributeValue(userSupplied !== undefined
+                ? userSupplied
+                : generateTimestamp(systemFields.updatedAtEncoding));
             setClauses.push(`${nameKey} = ${valKey}`);
             counter++;
         }
@@ -1297,6 +1332,7 @@ const makeImpl = (config) => {
             }
         }
         // REMOVE
+        const removedSet = uState.remove ? new Set(uState.remove) : undefined;
         if (uState.remove) {
             for (const attr of uState.remove) {
                 const nameKey = `#r${removeClauses.length}`;
@@ -1304,22 +1340,23 @@ const makeImpl = (config) => {
                 removeClauses.push(nameKey);
             }
         }
-        // Cascade REMOVE to GSI key fields: when a removed attribute is a GSI
-        // composite, the GSI pk/sk fields must also be removed so the item drops
-        // out of the sparse index.
-        if (removedSet) {
-            for (const [, indexDef] of Object.entries(allIndexes)) {
-                if (!("index" in indexDef))
-                    continue;
-                const gsiComposites = [...indexDef.pk.composite, ...indexDef.sk.composite].filter((attr) => !pkCompositeSet.has(attr));
-                if (gsiComposites.some((attr) => removedSet.has(attr))) {
-                    for (const keyField of [indexDef.pk.field, indexDef.sk.field]) {
-                        const nameKey = `#r${removeClauses.length}`;
-                        names[nameKey] = keyField;
-                        removeClauses.push(nameKey);
-                    }
-                }
-            }
+        // Policy-aware GSI key composition. One call covers SETs (full
+        // recompose or half-wise), sparse dropout REMOVEs, and cascade
+        // REMOVEs when an Entity.remove() targets a GSI composite.
+        // See DESIGN.md §7 Policy-Aware GSI Composition.
+        const gsiUpdate = KeyComposer.composeGsiKeysForUpdatePolicyAware(schema, entityType, entityVersion, allIndexes, hydratedUpdates, decodedKey, { removedSet });
+        for (const [field, value] of Object.entries(gsiUpdate.sets)) {
+            const nameKey = `#u${counter}`;
+            const valKey = `:u${counter}`;
+            names[nameKey] = field;
+            values[valKey] = toAttributeValue(value);
+            setClauses.push(`${nameKey} = ${valKey}`);
+            counter++;
+        }
+        for (const keyField of gsiUpdate.removes) {
+            const nameKey = `#r${removeClauses.length}`;
+            names[nameKey] = keyField;
+            removeClauses.push(nameKey);
         }
         // ADD (atomic numeric increment / set addition)
         if (uState.add) {
@@ -1677,7 +1714,7 @@ const makeImpl = (config) => {
         const client = yield* DynamoClient;
         const { name: tableName } = yield* tableTag;
         // Decode input
-        const decodedInput = yield* Schema.decodeUnknownEffect(schemas.inputSchema)(input).pipe(Effect.mapError((cause) => new ValidationError({
+        const decodedInput = yield* Schema.decodeUnknownEffect(schemas.inputDecodeSchema)(input).pipe(Effect.mapError((cause) => new ValidationError({
             entityType,
             operation: "upsert.decode",
             cause,
@@ -1697,6 +1734,15 @@ const makeImpl = (config) => {
         let counter = 0;
         // Determine primary key composite attribute names
         const pkComposites = new Set(primaryKeyComposites(config.indexes));
+        // System-colliding fields are written below in the system-field block
+        // (so their semantics — if_not_exists / always-set — stay consistent).
+        const systemColliders = new Set();
+        if (systemFields.createdAtCollision && systemFields.createdAt)
+            systemColliders.add(systemFields.createdAt);
+        if (systemFields.updatedAtCollision && systemFields.updatedAt)
+            systemColliders.add(systemFields.updatedAt);
+        if (systemFields.versionCollision && systemFields.version)
+            systemColliders.add(systemFields.version);
         // Serialize date fields on the decoded item
         if (hasDateFields) {
             serializeDateFields(item);
@@ -1705,6 +1751,8 @@ const makeImpl = (config) => {
         for (const [attr, val] of Object.entries(item)) {
             if (pkComposites.has(attr))
                 continue;
+            if (systemColliders.has(attr))
+                continue;
             if (val === undefined)
                 continue;
             const nameKey = `#u${counter}`;
@@ -1743,21 +1791,29 @@ const makeImpl = (config) => {
             setClauses.push(`${nameKey} = ${valKey}`);
             counter++;
         }
-        // Add createdAt with if_not_exists — only set on first create
+        // Add createdAt with if_not_exists — only set on first create.
+        // User-supplied value wins (domain input → already serialized above);
+        // else fall back to a freshly generated storage primitive.
         if (systemFields.createdAt) {
+            const userSupplied = item[systemFields.createdAt];
             const nameKey = `#u${counter}`;
             const valKey = `:u${counter}`;
             names[nameKey] = systemFields.createdAt;
-            values[valKey] = toAttributeValue(generateTimestamp(systemFields.createdAtEncoding));
+            values[valKey] = toAttributeValue(userSupplied !== undefined
+                ? userSupplied
+                : generateTimestamp(systemFields.createdAtEncoding));
             setClauses.push(`${nameKey} = if_not_exists(${nameKey}, ${valKey})`);
             counter++;
         }
-        // Add updatedAt — always set to current time
+        // Add updatedAt — user-supplied wins, else always set to current time.
         if (systemFields.updatedAt) {
+            const userSupplied = item[systemFields.updatedAt];
             const nameKey = `#u${counter}`;
             const valKey = `:u${counter}`;
             names[nameKey] = systemFields.updatedAt;
-            values[valKey] = toAttributeValue(generateTimestamp(systemFields.updatedAtEncoding));
+            values[valKey] = toAttributeValue(userSupplied !== undefined
+                ? userSupplied
+                : generateTimestamp(systemFields.updatedAtEncoding));
             setClauses.push(`${nameKey} = ${valKey}`);
             counter++;
         }
@@ -1874,29 +1930,48 @@ const makeImpl = (config) => {
             counter++;
         }
         // GSI key recomposition: any GSI whose composites are touched by input.
-        // Reuses the same machinery as `.update()`. PK composites are excluded
-        // from the update payload: they're already in the key and never change
-        // during an append. Non-PK composites that overlap between appendInput
-        // and a GSI trigger recomposition, which requires the full GSI composite
-        // set (partial presence raises `PartialGsiCompositeError`).
+        // Reuses the policy-aware helper from `.update()`. PK composites are
+        // excluded from the update payload — they're already in the key and
+        // never change during an append. Non-PK composites in appendInput that
+        // overlap a GSI's composites trigger per-GSI resolution via indexPolicy.
         const nonPkAppendFields = {};
         for (const [attr, val] of Object.entries(decoded)) {
             if (!pkCompositeSet.has(attr)) {
                 nonPkAppendFields[attr] = val;
             }
         }
-        let gsiKeys;
-        try {
-            gsiKeys = KeyComposer.composeGsiKeysForUpdate(schema, entityType, entityVersion, allIndexes, nonPkAppendFields, decoded);
-        }
-        catch (e) {
-            return yield* new ValidationError({
-                entityType,
-                operation: "append.gsiComposites",
-                cause: e instanceof Error ? e.message : e,
-            });
+        // At append-time, indexPolicy is restricted to composites that are
+        // members of appendInput. Non-appendInput composites are owned by
+        // other writers and are by contract never touched by .append(); their
+        // policy cannot fire at append-time. Each GSI's indexPolicy return is
+        // filtered to appendInput attrs only — non-appendInput keys fall through
+        // to the implicit `"preserve"` default, leaving the half containing
+        // them untouched.
+        const appendInputFieldSet = new Set(Object.keys(appendInputSchema
+            .fields ?? {}));
+        const policyAwareIndexes = {};
+        for (const [indexName, indexDef] of Object.entries(allIndexes)) {
+            if (!indexDef.indexPolicy) {
+                policyAwareIndexes[indexName] = indexDef;
+                continue;
+            }
+            const originalPolicy = indexDef.indexPolicy;
+            policyAwareIndexes[indexName] = {
+                ...indexDef,
+                indexPolicy: (item) => {
+                    const raw = originalPolicy(item);
+                    const filtered = {};
+                    for (const [attr, policy] of Object.entries(raw)) {
+                        if (appendInputFieldSet.has(attr) && policy !== undefined) {
+                            filtered[attr] = policy;
+                        }
+                    }
+                    return filtered;
+                },
+            };
         }
-        for (const [field, value] of Object.entries(gsiKeys)) {
+        const gsiUpdate = KeyComposer.composeGsiKeysForUpdatePolicyAware(schema, entityType, entityVersion, policyAwareIndexes, nonPkAppendFields, decoded);
+        for (const [field, value] of Object.entries(gsiUpdate.sets)) {
             const nameKey = `#a${counter}`;
             const valKey = `:a${counter}`;
             names[nameKey] = field;
@@ -1904,6 +1979,13 @@ const makeImpl = (config) => {
             setClauses.push(`${nameKey} = ${valKey}`);
             counter++;
         }
+        const appendRemoveClauses = [];
+        for (const keyField of gsiUpdate.removes) {
+            const nameKey = `#a${counter}`;
+            names[nameKey] = keyField;
+            appendRemoveClauses.push(nameKey);
+            counter++;
+        }
         // Entity type discriminator — idempotent; ensures existing items
         // without __edd_e__ still get tagged on first append.
         {
@@ -1940,7 +2022,12 @@ const makeImpl = (config) => {
             Object.assign(names, uc.names);
             Object.assign(values, uc.values);
         }
-        const updateExpression = `SET ${setClauses.join(", ")}`;
+        const exprParts = [];
+        if (setClauses.length > 0)
+            exprParts.push(`SET ${setClauses.join(", ")}`);
+        if (appendRemoveClauses.length > 0)
+            exprParts.push(`REMOVE ${appendRemoveClauses.join(", ")}`);
+        const updateExpression = exprParts.join(" ");
         // ---------- Build Put of event item ----------
         const eventSk = KeyComposer.composeEventSk(currentSk, newObValue, schema.casing);
         const eventItem = { ...decoded };
@@ -2505,6 +2592,7 @@ const makeImpl = (config) => {
         _resolvedRefs: resolvedRefs,
         /** @internal Full decode pipeline: rename + date deser + schema decode. Used by Batch/Aggregate. */
         _decodeRecord: decodeRecord,
+        _serializeDateFields: serializeDateFields,
         _attachPrototype: attachPrototype,
         _configure: (injectedSchema, injectedTableTag) => {
             schema = injectedSchema;
@@ -2572,26 +2660,12 @@ const makeImpl = (config) => {
 export const bind = (entity) => Effect.gen(function* () {
     const ctx = yield* Effect.context();
     const provide = (effect) => Effect.provide(effect, ctx);
-    // Helper: apply combinators to an EntityUpdate, then run in record mode + provide
-    const applyUpdate = (op, combinators) => {
-        let result = op;
-        for (const fn of combinators)
-            result = fn(result);
-        return provide(result._run("record"));
-    };
-    // Helper: apply combinators to an EntityPut, then run in record mode + provide
-    const applyPut = (op, combinators) => {
-        let result = op;
-        for (const fn of combinators)
-            result = fn(result);
-        return provide(result._run("record"));
-    };
-    // Helper: apply combinators to an EntityDelete, then asEffect + provide
-    const applyDelete = (op, combinators) => {
-        let result = op;
-        for (const fn of combinators)
-            result = fn(result);
-        return provide(result.asEffect());
+    // Shared config for the bound-CRUD builders — pre-resolved services plus
+    // a typed PathBuilder/ConditionOps so `.condition((t, ops) => ...)` works.
+    const boundCrudConfig = {
+        pathBuilder: createPathBuilder(),
+        conditionOps: createConditionOps(),
+        provide,
     };
     // Helper: apply query combinators then execute
     const applyQuery = (q, combinators) => {
@@ -2613,15 +2687,15 @@ export const bind = (entity) => Effect.gen(function* () {
         return new BoundQueryImpl(q, bqConfig);
     };
     return {
-        // CRUD — all ops return Effect (auto-wrapped)
+        // CRUD — fluent bound builders (yieldable, no .run() terminal)
         get: (key) => provide(entity.get(key)._run("record")),
-        put: (input, ...combinators) => applyPut(entity.put(input), combinators),
-        create: (input, ...combinators) => applyPut(entity.create(input), combinators),
-        update: (key, ...combinators) => applyUpdate(entity.update(key), combinators),
-        delete: (key, ...combinators) => applyDelete(entity.delete(key), combinators),
-        upsert: (input, ...combinators) => applyPut(entity.upsert(input), combinators),
-        patch: (key, ...combinators) => applyUpdate(entity.patch(key), combinators),
-        deleteIfExists: (key, ...combinators) => applyDelete(entity.deleteIfExists(key), combinators),
+        put: (input) => makeBoundPut(entity.put(input), boundCrudConfig),
+        create: (input) => makeBoundPut(entity.create(input), boundCrudConfig),
+        update: (key) => makeBoundUpdate(entity.update(key), boundCrudConfig),
+        delete: (key) => makeBoundDelete(entity.delete(key), boundCrudConfig),
+        upsert: (input) => makeBoundPut(entity.upsert(input), boundCrudConfig),
+        patch: (key) => makeBoundUpdate(entity.patch(key), boundCrudConfig),
+        deleteIfExists: (key) => makeBoundDelete(entity.deleteIfExists(key), boundCrudConfig),
         // Lifecycle
         getVersion: (key, version) => provide(entity.getVersion(key, version)._run("record")),
         versions: (key) => wrapAsBoundQuery(entity.versions(key)),