@kensio/yulin 1.21.15 → 1.21.17

package/dist/service/cloudformation/stack/update/sim-cfn-stack-resource-updates.js

@@ -0,0 +1,70 @@
+import { SimCfnResourceInPlaceUpdater } from "../../resource/update/sim-cfn-resource-in-place-updater.js";
+import { simCfnResourceServiceFactory } from "../../resource/resolve/service/sim-cfn-resource-service-factory.js";
+import { SimCfnResourceUpdateValidator } from "../../resource/update/sim-cfn-resource-update-validator.js";
+/**
+ * The Resource changes a Stack update applies to the deployed Resources,
+ * rather than by replacing them.
+ *
+ * Which changes those are is the owning service's answer, given before the
+ * update touches anything. A service with no way to change a deployed Resource
+ * answers nothing, and every change to its Resources is a replacement.
+ */
+export class SimCfnStackResourceUpdates {
+    simAws;
+    caller;
+    constructor(properties) {
+        this.simAws = properties.simAws;
+        this.caller = properties.caller;
+    }
+    /**
+     * Whether the service owning a Resource can apply this change to the
+     * deployed Resource.
+     *
+     * A Resource type no service simulates cannot be updated where it is. Its
+     * creation was skipped, so there is nothing deployed to change.
+     */
+    claimed(current, updated) {
+        if (updated.type === undefined || current.type !== updated.type) {
+            return false;
+        }
+        const service = simCfnResourceServiceFactory(this.simAws, updated);
+        // Both halves or neither. A service that can recognise a change it can
+        // apply but cannot apply it would leave the update with nothing to run.
+        if (service?.factory.updatesInPlace === undefined ||
+            service.factory.updateInPlace === undefined) {
+            return false;
+        }
+        return service.factory.updatesInPlace(service.resourceTypeName, current, updated);
+    }
+    /**
+     * Validate every Resource replacement before the update changes the Stack.
+     */
+    async assertAllowed(currentResources, updatedResources, replacements) {
+        await Promise.all(replacements.map(async ({ current, updated }) => {
+            await new SimCfnResourceUpdateValidator({
+                current,
+                updated,
+            }).assertAllowed({
+                simAws: this.simAws,
+                currentResources,
+                updatedResources,
+                caller: this.caller,
+            });
+        }));
+    }
+    /**
+     * Apply the given changes to the deployed Resources.
+     *
+     * Each one is independent of the others, since none of them creates or
+     * deletes anything another could be waiting on.
+     */
+    async apply(resources, updates) {
+        await Promise.all(updates.map(async ({ current, updated }) => {
+            await new SimCfnResourceInPlaceUpdater({ current, updated }).apply({
+                simAws: this.simAws,
+                resources,
+                caller: this.caller,
+            });
+        }));
+    }
+}

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-plan.d.ts

@@ -1,28 +1,33 @@
 import type { SimCfnResource } from "../../resource/sim-cfn-resource.js";
+import { SimCfnResourceRetention } from "../../resource/delete/sim-cfn-resource-retention.js";
+import { type SimCfnStackInPlaceUpdates } from "./sim-cfn-stack-resource-changes.js";
+import { type SimCfnStackResourceChange } from "./sim-cfn-stack-resource-change-pairs.js";
 interface SimCfnStackUpdatePlanProperties {
     readonly current: ReadonlyMap<string, SimCfnResource>;
     readonly updated: ReadonlyMap<string, SimCfnResource>;
-}
-export interface SimCfnStackResourceReplacement {
-    readonly current: SimCfnResource;
-    readonly updated: SimCfnResource;
+    readonly inPlaceUpdates?: SimCfnStackInPlaceUpdates | undefined;
 }
 /**
  * What an update has to do to a Stack's Resources, worked out before any of it
  * happens.
  *
  * The plan compares the Resources the Stack has with the ones its new template
- * describes, and says which to delete, which to create, and what the Stack
- * holds afterwards. A Resource the template still describes unchanged is left
- * alone, keeping whatever it holds in simulated AWS.
+ * describes, and says which to update where they are, which to delete, which to
+ * create, and what the Stack holds afterwards. A Resource the template still
+ * describes unchanged is left alone, keeping whatever it holds in simulated
+ * AWS.
  *
- * It does not delete or create anything, order the work, or decide what counts
- * as a changed Resource. SimCfnStackUpdater runs the plan, and
- * simCfnStackReplacedLogicalIds decides what changed.
+ * It does not delete, create or update anything, order the work, or decide what
+ * counts as a changed Resource. SimCfnStackUpdater runs the plan, and
+ * simCfnStackResourceChanges decides what changed and how.
  */
 export declare class SimCfnStackUpdatePlan {
     /** The current and updated halves of each Resource replacement. */
-    readonly replacements: readonly SimCfnStackResourceReplacement[];
+    readonly replacements: readonly SimCfnStackResourceChange[];
+    /**
+     * The Resources to change where they are, rather than by replacing them.
+     */
+    readonly updates: readonly SimCfnStackResourceChange[];
     /**
      * The deployed Resources to delete: the ones the new template drops, and the
      * deployed halves of the ones it replaces.
@@ -36,14 +41,14 @@ export declare class SimCfnStackUpdatePlan {
     readonly updated: ReadonlyMap<string, SimCfnResource>;
     constructor(properties: SimCfnStackUpdatePlanProperties);
     /**
-     * For each logical ID the update is replacing, whether the definition taking
-     * its place says to keep the deployed Resource.
+     * What the update's deletions are to leave in simulated AWS.
      *
-     * The new half answers it because CloudFormation reads UpdateReplacePolicy
-     * off the template it is applying. An update that adds the attribute keeps
-     * the Resource it replaces, and one that drops it deletes that Resource.
+     * A replacement's new half answers for it, because CloudFormation reads
+     * UpdateReplacePolicy off the template it is applying. An update that adds
+     * the attribute keeps the Resource it replaces, and one that drops it
+     * deletes that Resource.
      */
-    replacementRetentions(): ReadonlyMap<string, boolean>;
+    retention(): SimCfnResourceRetention;
     /**
      * Whether the update changes any Resource at all.
      *
@@ -57,7 +62,9 @@ export declare class SimCfnStackUpdatePlan {
      * The map is changed in place rather than replaced, so anything already
      * holding the Stack's Resources sees the update. A Resource the template
      * leaves alone keeps the object it already had, which is what keeps its
-     * simulated AWS Resource and its creation status.
+     * simulated AWS Resource and its creation status. A Resource updated where it
+     * is takes the new record, which the update has already moved on to the
+     * deployed simulated AWS Resource.
      */
     applyTo(resources: Map<string, SimCfnResource>): void;
 }

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-plan.js

@@ -1,20 +1,27 @@
-import { simCfnStackReplacedLogicalIds } from "./sim-cfn-stack-replaced-resources.js";
+import { SimCfnResourceRetention } from "../../resource/delete/sim-cfn-resource-retention.js";
+import { simCfnStackResourceChanges, } from "./sim-cfn-stack-resource-changes.js";
+import { simCfnStackResourceChangePairs, } from "./sim-cfn-stack-resource-change-pairs.js";
 /**
  * What an update has to do to a Stack's Resources, worked out before any of it
  * happens.
  *
  * The plan compares the Resources the Stack has with the ones its new template
- * describes, and says which to delete, which to create, and what the Stack
- * holds afterwards. A Resource the template still describes unchanged is left
- * alone, keeping whatever it holds in simulated AWS.
+ * describes, and says which to update where they are, which to delete, which to
+ * create, and what the Stack holds afterwards. A Resource the template still
+ * describes unchanged is left alone, keeping whatever it holds in simulated
+ * AWS.
  *
- * It does not delete or create anything, order the work, or decide what counts
- * as a changed Resource. SimCfnStackUpdater runs the plan, and
- * simCfnStackReplacedLogicalIds decides what changed.
+ * It does not delete, create or update anything, order the work, or decide what
+ * counts as a changed Resource. SimCfnStackUpdater runs the plan, and
+ * simCfnStackResourceChanges decides what changed and how.
  */
 export class SimCfnStackUpdatePlan {
     /** The current and updated halves of each Resource replacement. */
     replacements;
+    /**
+     * The Resources to change where they are, rather than by replacing them.
+     */
+    updates;
     /**
      * The deployed Resources to delete: the ones the new template drops, and the
      * deployed halves of the ones it replaces.
@@ -27,20 +34,15 @@ export class SimCfnStackUpdatePlan {
     creations;
     updated;
     constructor(properties) {
-        const { current, updated } = properties;
-        const replaced = simCfnStackReplacedLogicalIds({ current, updated });
+        const { current, updated, inPlaceUpdates } = properties;
+        const { replaced, updatedInPlace } = simCfnStackResourceChanges({
+            current,
+            updated,
+            inPlaceUpdates,
+        });
         this.updated = updated;
-        this.replacements = replaced
-            .values()
-            .map((logicalId) => {
-            const currentResource = current.get(logicalId);
-            const updatedResource = updated.get(logicalId);
-            if (currentResource === undefined || updatedResource === undefined) {
-                throw new Error(`CloudFormation replacement ${logicalId} is missing one of its Resource definitions`);
-            }
-            return { current: currentResource, updated: updatedResource };
-        })
-            .toArray();
+        this.replacements = simCfnStackResourceChangePairs(current, updated, replaced);
+        this.updates = simCfnStackResourceChangePairs(current, updated, updatedInPlace);
         // Both lists are worked out now rather than on demand, because the Stack's
         // Resource map is the current one and applying the plan changes it.
         this.deletions = current
@@ -57,18 +59,20 @@ export class SimCfnStackUpdatePlan {
             .toArray();
     }
     /**
-     * For each logical ID the update is replacing, whether the definition taking
-     * its place says to keep the deployed Resource.
+     * What the update's deletions are to leave in simulated AWS.
      *
-     * The new half answers it because CloudFormation reads UpdateReplacePolicy
-     * off the template it is applying. An update that adds the attribute keeps
-     * the Resource it replaces, and one that drops it deletes that Resource.
+     * A replacement's new half answers for it, because CloudFormation reads
+     * UpdateReplacePolicy off the template it is applying. An update that adds
+     * the attribute keeps the Resource it replaces, and one that drops it
+     * deletes that Resource.
      */
-    replacementRetentions() {
-        return new Map(this.replacements.map(({ current, updated }) => [
-            current.logicalId,
-            updated.retainedOnReplace,
-        ]));
+    retention() {
+        return new SimCfnResourceRetention({
+            replaced: new Map(this.replacements.map(({ current, updated }) => [
+                current.logicalId,
+                updated.retainedOnReplace,
+            ])),
+        });
     }
     /**
      * Whether the update changes any Resource at all.
@@ -77,7 +81,9 @@ export class SimCfnStackUpdatePlan {
      * updates the Stack, so this is not the whole no-op question.
      */
     get changesResources() {
-        return this.deletions.length > 0 || this.creations.length > 0;
+        return (this.deletions.length > 0 ||
+            this.creations.length > 0 ||
+            this.updates.length > 0);
     }
     /**
      * Move the Stack's Resource map on to the new template.
@@ -85,7 +91,9 @@ export class SimCfnStackUpdatePlan {
      * The map is changed in place rather than replaced, so anything already
      * holding the Stack's Resources sees the update. A Resource the template
      * leaves alone keeps the object it already had, which is what keeps its
-     * simulated AWS Resource and its creation status.
+     * simulated AWS Resource and its creation status. A Resource updated where it
+     * is takes the new record, which the update has already moved on to the
+     * deployed simulated AWS Resource.
      */
     applyTo(resources) {
         const dropped = resources
@@ -98,5 +106,8 @@ export class SimCfnStackUpdatePlan {
         for (const resource of this.creations) {
             resources.set(resource.logicalId, resource);
         }
+        for (const { updated } of this.updates) {
+            resources.set(updated.logicalId, updated);
+        }
     }
 }

package/dist/service/cloudformation/stack/update/sim-cfn-stack-updater.d.ts

@@ -22,11 +22,13 @@ interface SimCfnStackUpdaterProperties {
 /**
  * Applies a changed template to a Stack that is already deployed.
  *
- * The Resources the new template drops or replaces go first, in the reverse of
- * the order they were created in, and the ones it adds or replaces are created
- * after, in dependency order. Everything else is left where it is, which is the
- * point of updating a Stack rather than replacing it: what a Bucket holds and
- * what a Table has in it survive a change elsewhere in the template.
+ * The Resources a service can change where they are go first, while everything
+ * the Stack had is still deployed. Then the Resources the new template drops or
+ * replaces, in the reverse of the order they were created in, and last the ones
+ * it adds or replaces, in dependency order. Everything else is left where it
+ * is, which is the point of updating a Stack rather than replacing it: what a
+ * Bucket holds and what a Table has in it survive a change elsewhere in the
+ * template.
  *
  * It does not own Stack status or the Stack's visible template.
  * SimCfnStackUpdateLifecycle owns the first and SimCfnStack the second.

package/dist/service/cloudformation/stack/update/sim-cfn-stack-updater.js

@@ -2,7 +2,6 @@ import { SimCloudFormationValidationError } from "../../error/sim-cloudformation
 import { makeSimCfnStackResourceMap } from "../resource-map/sim-cfn-stack-resource-map.js";
 import { SimCfnStackUpdatePlan } from "./sim-cfn-stack-update-plan.js";
 import { simCfnStackTemplateChanged } from "./sim-cfn-stack-template-changes.js";
-import { SimCfnResourceRetention } from "../../resource/delete/sim-cfn-resource-retention.js";
 /**
  * What CloudFormation answers an update that would change nothing.
  *
@@ -14,11 +13,13 @@ export const simCfnNoUpdatesMessage = "No updates are to be performed.";
 /**
  * Applies a changed template to a Stack that is already deployed.
  *
- * The Resources the new template drops or replaces go first, in the reverse of
- * the order they were created in, and the ones it adds or replaces are created
- * after, in dependency order. Everything else is left where it is, which is the
- * point of updating a Stack rather than replacing it: what a Bucket holds and
- * what a Table has in it survive a change elsewhere in the template.
+ * The Resources a service can change where they are go first, while everything
+ * the Stack had is still deployed. Then the Resources the new template drops or
+ * replaces, in the reverse of the order they were created in, and last the ones
+ * it adds or replaces, in dependency order. Everything else is left where it
+ * is, which is the point of updating a Stack rather than replacing it: what a
+ * Bucket holds and what a Table has in it survive a change elsewhere in the
+ * template.
  *
  * It does not own Stack status or the Stack's visible template.
  * SimCfnStackUpdateLifecycle owns the first and SimCfnStack the second.
@@ -36,6 +37,7 @@ export class SimCfnStackUpdater {
                 background,
                 template: updated,
             }),
+            inPlaceUpdates: properties.operations,
         });
     }
     /**
@@ -59,7 +61,10 @@ export class SimCfnStackUpdater {
         const { resources, operations } = this.properties;
         const { plan } = this;
         await operations.assertUpdatesAllowed(resources, plan.updated, plan.replacements);
-        await operations.delete(resources, plan.deletions, new SimCfnResourceRetention({ replaced: plan.replacementRetentions() }));
+        // Before anything comes down. An update that fails here has changed some
+        // of the Stack's Resources and deleted none of them.
+        await operations.updateInPlace(resources, plan.updates);
+        await operations.delete(resources, plan.deletions, plan.retention());
         plan.applyTo(resources);
         // Once the Stack has stopped holding them, and before the replacements are
         // created. An update that keeps a Resource and then fails to create the one

package/dist/service/dynamodb/document/sim-dynamodb-document-marshall-options.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The marshalling options a document client was built with.
+ *
+ * `DynamoDBDocumentClient.from(client, { marshallOptions })` changes what the
+ * real conversion does with values it would otherwise refuse, so the simulated
+ * conversion reads the same options rather than always applying the defaults.
+ * Every one of them is off unless the client asked for it, which is how the
+ * real document client leaves them.
+ */
+export interface SimDynamoDbDocumentMarshallOptions {
+    /**
+     * Drop an undefined value out of a map, a list or a set instead of refusing
+     * it.
+     */
+    readonly removeUndefinedValues: boolean;
+    /**
+     * Write an empty string, an empty binary value and an empty set as NULL.
+     */
+    readonly convertEmptyValues: boolean;
+    /**
+     * Read a class instance as a map of its own properties.
+     */
+    readonly convertClassInstanceToMap: boolean;
+    /**
+     * Write a number outside the safe integer range, digits already lost, rather
+     * than refusing it.
+     */
+    readonly allowImpreciseNumbers: boolean;
+}
+/**
+ * What a document client built with no options of its own converts by.
+ */
+export declare const simDynamoDbDocumentMarshallDefaults: SimDynamoDbDocumentMarshallOptions;
+/**
+ * Read the marshalling options off the client a Command was sent through.
+ *
+ * `DynamoDBDocumentClient` keeps the translation config it was built with on
+ * its resolved config, which is where the real marshalling middleware reads it
+ * from. A client that named none, and anything that is not a document client
+ * at all, converts by the defaults.
+ */
+export declare function simDynamoDbDocumentMarshallOptions(client: unknown): SimDynamoDbDocumentMarshallOptions;

package/dist/service/dynamodb/document/sim-dynamodb-document-marshall-options.js

@@ -0,0 +1,36 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+/**
+ * What a document client built with no options of its own converts by.
+ */
+export const simDynamoDbDocumentMarshallDefaults = {
+    removeUndefinedValues: false,
+    convertEmptyValues: false,
+    convertClassInstanceToMap: false,
+    allowImpreciseNumbers: false,
+};
+/**
+ * Read the marshalling options off the client a Command was sent through.
+ *
+ * `DynamoDBDocumentClient` keeps the translation config it was built with on
+ * its resolved config, which is where the real marshalling middleware reads it
+ * from. A client that named none, and anything that is not a document client
+ * at all, converts by the defaults.
+ */
+export function simDynamoDbDocumentMarshallOptions(client) {
+    const config = isRecord(client) ? client["config"] : undefined;
+    const translateConfig = isRecord(config)
+        ? config["translateConfig"]
+        : undefined;
+    const options = isRecord(translateConfig)
+        ? translateConfig["marshallOptions"]
+        : undefined;
+    if (!isRecord(options)) {
+        return simDynamoDbDocumentMarshallDefaults;
+    }
+    return {
+        removeUndefinedValues: options["removeUndefinedValues"] === true,
+        convertEmptyValues: options["convertEmptyValues"] === true,
+        convertClassInstanceToMap: options["convertClassInstanceToMap"] === true,
+        allowImpreciseNumbers: options["allowImpreciseNumbers"] === true,
+    };
+}

package/dist/service/dynamodb/document/sim-dynamodb-document-marshall.d.ts

@@ -1,4 +1,5 @@
 import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+import type { SimDynamoDbDocumentMarshallOptions } from "./sim-dynamodb-document-marshall-options.js";
 /**
  * Read a native JavaScript value as the AttributeValue it stands for.
  *
@@ -7,9 +8,9 @@ import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
  * order, so a value that reaches a simulated table through the document client
  * is the value that would have reached the real one.
  *
- * `undefined` is refused rather than dropped. The real document client drops it
- * when the client was built with `removeUndefinedValues`, which is a translate
- * config this simulation does not read yet, so refusing is what keeps a test
- * from passing against an item AWS would have written differently.
+ * The options are the ones the document client was built with. They decide
+ * what happens to a value the defaults refuse: an undefined member, an empty
+ * string or binary value, a class instance, and a number past the range a
+ * JavaScript number holds exactly.
  */
-export declare function simDynamoDbDocumentAttributeValue(value: unknown, path: string): SimDynamoDbAttributeValue;
+export declare function simDynamoDbDocumentAttributeValue(value: unknown, path: string, options: SimDynamoDbDocumentMarshallOptions): SimDynamoDbAttributeValue;

package/dist/service/dynamodb/document/sim-dynamodb-document-marshall.js

@@ -1,6 +1,5 @@
 import { SimDynamoDbDocumentValueError } from "../error/dynamodb.error.js";
-import { isSimDynamoDbDocumentBinary } from "./sim-dynamodb-document-binary.js";
-import { isSimDynamoDbDocumentNumberValue, simDynamoDbDocumentNumberAttribute, } from "./sim-dynamodb-document-number.js";
+import { simDynamoDbDocumentScalarAttribute } from "./sim-dynamodb-document-scalar.js";
 import { simDynamoDbDocumentSetAttribute } from "./sim-dynamodb-document-set.js";
 /**
  * Read a native JavaScript value as the AttributeValue it stands for.
@@ -10,61 +9,48 @@ import { simDynamoDbDocumentSetAttribute } from "./sim-dynamodb-document-set.js"
  * order, so a value that reaches a simulated table through the document client
  * is the value that would have reached the real one.
  *
- * `undefined` is refused rather than dropped. The real document client drops it
- * when the client was built with `removeUndefinedValues`, which is a translate
- * config this simulation does not read yet, so refusing is what keeps a test
- * from passing against an item AWS would have written differently.
+ * The options are the ones the document client was built with. They decide
+ * what happens to a value the defaults refuse: an undefined member, an empty
+ * string or binary value, a class instance, and a number past the range a
+ * JavaScript number holds exactly.
  */
-export function simDynamoDbDocumentAttributeValue(value, path) {
+export function simDynamoDbDocumentAttributeValue(value, path, options) {
     if (value === undefined) {
-        throw new SimDynamoDbDocumentValueError(`${path} is undefined. The real document client drops it only when it ` +
-            `was built with removeUndefinedValues, which simulated DynamoDB does ` +
-            `not read yet, so leave the attribute out instead`);
+        throw new SimDynamoDbDocumentValueError(`${path} is undefined. Build the document client with ` +
+            `removeUndefinedValues to drop it, which is what the real one asks ` +
+            `for, or leave the attribute out instead`);
     }
     if (value === null) {
         return { NULL: true };
     }
     if (Array.isArray(value)) {
-        return { L: listMembers(value, path) };
+        return { L: listMembers(value, path, options) };
     }
-    return containerOrScalar(value, path);
+    return containerOrScalar(value, path, options);
 }
 /**
  * Read a value that is not null, undefined or a list.
  */
-function containerOrScalar(value, path) {
+function containerOrScalar(value, path, options) {
     if (value instanceof Set) {
-        return simDynamoDbDocumentSetAttribute(value, path);
+        return simDynamoDbDocumentSetAttribute(value, path, options);
     }
     if (value instanceof Map) {
-        return { M: mapEntries([...value], path) };
+        return { M: mapEntries([...value], path, options) };
     }
     if (isPlainObject(value)) {
-        return { M: mapEntries(Object.entries(value), path) };
+        return { M: mapEntries(Object.entries(value), path, options) };
     }
-    return scalar(value, path);
-}
-/**
- * Read a value that stands for one attribute on its own.
- */
-function scalar(value, path) {
-    if (isSimDynamoDbDocumentBinary(value)) {
-        return { B: value };
-    }
-    if (typeof value === "boolean") {
-        return { BOOL: value };
-    }
-    if (typeof value === "number") {
-        return simDynamoDbDocumentNumberAttribute(value, path);
+    const scalar = simDynamoDbDocumentScalarAttribute(value, path, options);
+    if (scalar !== undefined) {
+        return scalar;
     }
-    if (isSimDynamoDbDocumentNumberValue(value)) {
-        return { N: value.toAttributeValue().N };
-    }
-    if (typeof value === "bigint") {
-        return { N: value.toString() };
-    }
-    if (typeof value === "string") {
-        return { S: value };
+    // A class instance is read as a map only when the client asked for it, which
+    // is the last thing the real conversion tries before giving up. Null reached
+    // an answer of its own before any of this.
+    if (typeof value === "object" && options.convertClassInstanceToMap) {
+        const instance = value;
+        return { M: mapEntries(Object.entries(instance), path, options) };
     }
     throw new SimDynamoDbDocumentValueError(`${path} is a ${typeof value} the document client has no attribute type ` +
         `for`);
@@ -72,27 +58,35 @@ function scalar(value, path) {
 /**
  * The members of a list, with the functions left out as the real one leaves
  * them out.
+ *
+ * A dropped undefined member takes its position with it, so the members after
+ * it move up. That is what the real conversion does: it filters before it
+ * converts, rather than writing a NULL where the member was.
  */
-function listMembers(values, path) {
+function listMembers(values, path, options) {
     return values
-        .filter((member) => typeof member !== "function")
-        .map((member, index) => simDynamoDbDocumentAttributeValue(member, `${path}[${index.toString()}]`));
+        .filter((member) => typeof member !== "function" &&
+        !(member === undefined && options.removeUndefinedValues))
+        .map((member, index) => simDynamoDbDocumentAttributeValue(member, `${path}[${index.toString()}]`, options));
 }
 /**
  * The entries of a map, with the functions left out.
  */
-function mapEntries(entries, path) {
+function mapEntries(entries, path, options) {
     const attributes = {};
     for (const [name, member] of entries) {
         if (typeof member === "function") {
             continue;
         }
+        if (member === undefined && options.removeUndefinedValues) {
+            continue;
+        }
         const key = String(name);
         // Defined rather than assigned, so an attribute named `__proto__` becomes
         // an ordinary attribute instead of reaching the prototype setter. The real
         // document client assigns, and so loses that attribute.
         Object.defineProperty(attributes, key, {
-            value: simDynamoDbDocumentAttributeValue(member, `${path}.${key}`),
+            value: simDynamoDbDocumentAttributeValue(member, `${path}.${key}`, options),
             enumerable: true,
             writable: true,
             configurable: true,

package/dist/service/dynamodb/document/sim-dynamodb-document-number.d.ts

@@ -1,4 +1,5 @@
 import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+import type { SimDynamoDbDocumentMarshallOptions } from "./sim-dynamodb-document-marshall-options.js";
 /**
  * A value carrying its own Number attribute, which is what lib-dynamodb's
  * `NumberValue` is.
@@ -23,9 +24,10 @@ export declare function isSimDynamoDbDocumentNumberValue(value: unknown): value
  * than storing one that has already lost digits. A simulated table holds the
  * digits it is given exactly, so this refusal is the only thing standing
  * between an application and a silently rounded identifier, which is why it is
- * kept rather than relaxed. A decimal inside the range is written as it stands.
+ * kept until a client asks for `allowImpreciseNumbers` and takes the rounding
+ * on. A decimal inside the range is written as it stands.
  */
-export declare function simDynamoDbDocumentNumberAttribute(value: number, path: string): SimDynamoDbAttributeValue;
+export declare function simDynamoDbDocumentNumberAttribute(value: number, path: string, options: SimDynamoDbDocumentMarshallOptions): SimDynamoDbAttributeValue;
 /**
  * Read a Number attribute back as the document client answers with it.
  *

package/dist/service/dynamodb/document/sim-dynamodb-document-number.js

@@ -15,13 +15,15 @@ export function isSimDynamoDbDocumentNumberValue(value) {
  * than storing one that has already lost digits. A simulated table holds the
  * digits it is given exactly, so this refusal is the only thing standing
  * between an application and a silently rounded identifier, which is why it is
- * kept rather than relaxed. A decimal inside the range is written as it stands.
+ * kept until a client asks for `allowImpreciseNumbers` and takes the rounding
+ * on. A decimal inside the range is written as it stands.
  */
-export function simDynamoDbDocumentNumberAttribute(value, path) {
+export function simDynamoDbDocumentNumberAttribute(value, path, options) {
     if (!Number.isFinite(value)) {
         throw new SimDynamoDbDocumentValueError(`${path} is ${value.toString()}, and DynamoDB has no such number`);
     }
-    if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+    if (!options.allowImpreciseNumbers &&
+        (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER)) {
         throw new SimDynamoDbDocumentValueError(`${path} is ${value.toString()}, which is outside the range a ` +
             `JavaScript number holds exactly. Write it as a bigint, or as a ` +
             `NumberValue from @aws-sdk/lib-dynamodb, so its digits survive`);

package/dist/service/dynamodb/document/sim-dynamodb-document-path.d.ts

@@ -16,10 +16,6 @@ export interface SimDynamoDbDocumentPath {
      */
     convert(value: unknown, conversion: SimDynamoDbDocumentConversion, path: string): unknown;
 }
-/**
- * A path to one attribute value.
- */
-export declare function simDynamoDbDocumentValue(): SimDynamoDbDocumentPath;
 /**
  * A path to a record or list whose every member is one attribute value, which
  * is what an Item, a Key and a set of expression values are.