@kensio/yulin 1.21.31 → 1.21.33

package/dist/service/lambda/function/environment/sim-lambda-environment-conflict.js

@@ -0,0 +1,33 @@
+/**
+ * The advice that follows each warning, given the name that was read early.
+ */
+function moveTheReadAdvice(name) {
+    return (`Code read process.env.${name} outside any invocation, as a read at ` +
+        "module scope does when the module is imported, and saw the host value " +
+        "instead. Move the read inside the handler function.");
+}
+/**
+ * The conflict of a function declaring a name the host process also sets,
+ * with a different value.
+ */
+export function simLambdaHostConflict(environment, name) {
+    return {
+        key: `host:${name}`,
+        name,
+        message: `Sim Lambda function "${environment.functionName}" declares ` +
+            `environment variable ${name}, which the host process also sets ` +
+            `with a different value. ${moveTheReadAdvice(name)}`,
+    };
+}
+/**
+ * The conflict of two functions declaring different values for one name.
+ */
+export function simLambdaFunctionConflict(existing, environment, name) {
+    return {
+        key: `function:${name}`,
+        name,
+        message: `Sim Lambda functions "${existing.functionName}" and ` +
+            `"${environment.functionName}" declare different values for ` +
+            `environment variable ${name}. ${moveTheReadAdvice(name)}`,
+    };
+}

package/dist/service/lambda/function/environment/sim-lambda-environment-conflicts.d.ts

@@ -1,15 +1,32 @@
 import type { SimLambdaEnvironment } from "./sim-lambda-environment.js";
+interface SimLambdaEnvironmentConflictsProperties {
+    /**
+     * The environments of the functions the simulated Lambda holds when it is
+     * asked, which a held name is checked against again once it is read. A
+     * check built standalone has none.
+     */
+    readonly currentEnvironments?: () => Iterable<SimLambdaEnvironment>;
+}
 /**
  * Warns about declared environment variables whose value a handler module
- * might not actually see.
+ * did not actually see.
  *
  * A sim Lambda function backed by a real in-process handler only gets its own
  * process.env while the handler runs, so a variable read at module scope is
  * read too early (see SimLambdaProcessEnv). That only changes what the code
- * sees when the value read at module scope differs from the declared one, so
- * these are the two conditions worth reporting: the host process sets the
- * same name with a different value, or another simulated function declares
- * the same name with a different value.
+ * sees when the value read at module scope differs from the declared one.
+ * There are two ways for it to differ. The host process sets the same name
+ * with a different value, or another simulated function declares the same
+ * name with a different value.
+ *
+ * A difference is reported only once code has read the name from process.env
+ * outside any invocation, which SimProcessEnvironment records. The name of a
+ * difference with no such read yet is held. If the read turns up before a
+ * later invocation (a handler module imported after the function was
+ * created), the name is checked again against the functions that exist then,
+ * so a function deleted or reconfigured in between leaves nothing stale to
+ * report. A read made before Yulin was imported is not on record, and leaves
+ * the difference unreported.
  *
  * Staying quiet when the values agree matters as much as warning when they do
  * not. Test suites commonly export the same variables they configure their
@@ -18,30 +35,55 @@ import type { SimLambdaEnvironment } from "./sim-lambda-environment.js";
  */
 export declare class SimLambdaEnvironmentConflicts {
     /**
-     * Variable names already reported, so repeated function creation does not
+     * The environments of the functions that exist now.
+     */
+    private readonly currentEnvironments;
+    /**
+     * Conflict keys already reported, so repeated function creation does not
      * repeat the same warning.
      */
     private readonly warned;
+    /**
+     * Names in conflict that had not been read outside an invocation when the
+     * conflict was found.
+     */
+    private readonly held;
+    constructor(properties?: SimLambdaEnvironmentConflictsProperties);
     /**
      * Check a new function's environment against the host process and against
      * the functions that already exist.
      */
     check(environment: SimLambdaEnvironment, existingEnvironments: Iterable<SimLambdaEnvironment>): void;
     /**
-     * Warn when the host process sets the same name with a different value.
+     * Check the held names that have since been read outside an invocation
+     * again, against the functions that exist now, and report what conflicts.
+     *
+     * Called as a function is invoked, before the handler runs.
      */
-    private checkHostProcess;
+    reportReads(): void;
+    /**
+     * Check one name across the given environments, each against the host
+     * process and against the environments before it.
+     */
+    private checkName;
     /**
-     * Warn when another simulated function declares the same name with a
+     * Find a conflict when the host process sets the same name with a
      * different value.
      */
+    private checkHostProcess;
+    /**
+     * Find a conflict when another simulated function declares the same name
+     * with a different value.
+     */
     private checkOtherFunctions;
     /**
-     * Report a conflict once per variable name.
+     * Warn about a conflict once per key if its name has been read outside an
+     * invocation, and hold the name otherwise.
      *
      * Warnings go to the console because that is where a test runner surfaces
      * them next to the failing expectation they explain; the simulator has no
      * logger of its own to route them through.
      */
-    private warn;
+    private report;
 }
+export {};

package/dist/service/lambda/function/environment/sim-lambda-environment-conflicts.js

@@ -1,18 +1,25 @@
+import { simLambdaFunctionConflict, simLambdaHostConflict, } from "./sim-lambda-environment-conflict.js";
 import { simProcessEnvironment } from "../../../../util/process/sim-process-environment.js";
-const moveTheReadAdvice = "A read of process.env at module scope happens when the module is " +
-    "imported, before any invocation, so it sees the host value instead. " +
-    "Move the read inside the handler function.";
 /**
  * Warns about declared environment variables whose value a handler module
- * might not actually see.
+ * did not actually see.
  *
  * A sim Lambda function backed by a real in-process handler only gets its own
  * process.env while the handler runs, so a variable read at module scope is
  * read too early (see SimLambdaProcessEnv). That only changes what the code
- * sees when the value read at module scope differs from the declared one, so
- * these are the two conditions worth reporting: the host process sets the
- * same name with a different value, or another simulated function declares
- * the same name with a different value.
+ * sees when the value read at module scope differs from the declared one.
+ * There are two ways for it to differ. The host process sets the same name
+ * with a different value, or another simulated function declares the same
+ * name with a different value.
+ *
+ * A difference is reported only once code has read the name from process.env
+ * outside any invocation, which SimProcessEnvironment records. The name of a
+ * difference with no such read yet is held. If the read turns up before a
+ * later invocation (a handler module imported after the function was
+ * created), the name is checked again against the functions that exist then,
+ * so a function deleted or reconfigured in between leaves nothing stale to
+ * report. A read made before Yulin was imported is not on record, and leaves
+ * the difference unreported.
  *
  * Staying quiet when the values agree matters as much as warning when they do
  * not. Test suites commonly export the same variables they configure their
@@ -21,22 +28,68 @@ const moveTheReadAdvice = "A read of process.env at module scope happens when th
  */
 export class SimLambdaEnvironmentConflicts {
     /**
-     * Variable names already reported, so repeated function creation does not
+     * The environments of the functions that exist now.
+     */
+    currentEnvironments;
+    /**
+     * Conflict keys already reported, so repeated function creation does not
      * repeat the same warning.
      */
     warned = new Set();
+    /**
+     * Names in conflict that had not been read outside an invocation when the
+     * conflict was found.
+     */
+    held = new Set();
+    constructor(properties = {}) {
+        this.currentEnvironments =
+            properties.currentEnvironments ?? (() => []);
+    }
     /**
      * Check a new function's environment against the host process and against
      * the functions that already exist.
      */
     check(environment, existingEnvironments) {
+        const existing = [...existingEnvironments];
         for (const [name, value] of environment.declaredVariables) {
             this.checkHostProcess(environment, name, value);
-            this.checkOtherFunctions(environment, name, value, existingEnvironments);
+            this.checkOtherFunctions(environment, name, value, existing);
+        }
+    }
+    /**
+     * Check the held names that have since been read outside an invocation
+     * again, against the functions that exist now, and report what conflicts.
+     *
+     * Called as a function is invoked, before the handler runs.
+     */
+    reportReads() {
+        const read = [...this.held].filter((name) => simProcessEnvironment.wasReadOutsideRun(name));
+        if (read.length === 0) {
+            return;
+        }
+        const environments = [...this.currentEnvironments()];
+        for (const name of read) {
+            this.held.delete(name);
+            this.checkName(name, environments);
+        }
+    }
+    /**
+     * Check one name across the given environments, each against the host
+     * process and against the environments before it.
+     */
+    checkName(name, environments) {
+        for (const [index, environment] of environments.entries()) {
+            const value = environment.declaredVariables.get(name);
+            if (value === undefined) {
+                continue;
+            }
+            this.checkHostProcess(environment, name, value);
+            this.checkOtherFunctions(environment, name, value, environments.slice(0, index));
         }
     }
     /**
-     * Warn when the host process sets the same name with a different value.
+     * Find a conflict when the host process sets the same name with a
+     * different value.
      */
     checkHostProcess(environment, name, value) {
         // Read-only lookup of a name the function itself declared.
@@ -45,13 +98,11 @@ export class SimLambdaEnvironmentConflicts {
         if (hostValue === undefined || hostValue === value) {
             return;
         }
-        this.warn(`host:${name}`, `Sim Lambda function "${environment.functionName}" declares ` +
-            `environment variable ${name}, which the host process also sets ` +
-            `with a different value. ${moveTheReadAdvice}`);
+        this.report(simLambdaHostConflict(environment, name));
     }
     /**
-     * Warn when another simulated function declares the same name with a
-     * different value.
+     * Find a conflict when another simulated function declares the same name
+     * with a different value.
      */
     checkOtherFunctions(environment, name, value, existingEnvironments) {
         for (const existing of existingEnvironments) {
@@ -59,25 +110,28 @@ export class SimLambdaEnvironmentConflicts {
             if (existingValue === undefined || existingValue === value) {
                 continue;
             }
-            this.warn(`function:${name}`, `Sim Lambda functions "${existing.functionName}" and ` +
-                `"${environment.functionName}" declare different values for ` +
-                `environment variable ${name}. ${moveTheReadAdvice}`);
+            this.report(simLambdaFunctionConflict(existing, environment, name));
             return;
         }
     }
     /**
-     * Report a conflict once per variable name.
+     * Warn about a conflict once per key if its name has been read outside an
+     * invocation, and hold the name otherwise.
      *
      * Warnings go to the console because that is where a test runner surfaces
      * them next to the failing expectation they explain; the simulator has no
      * logger of its own to route them through.
      */
-    warn(key, message) {
-        if (this.warned.has(key)) {
+    report(conflict) {
+        if (this.warned.has(conflict.key)) {
+            return;
+        }
+        if (!simProcessEnvironment.wasReadOutsideRun(conflict.name)) {
+            this.held.add(conflict.name);
             return;
         }
-        this.warned.add(key);
+        this.warned.add(conflict.key);
         // oxlint-disable-next-line no-console
-        console.warn(message);
+        console.warn(conflict.message);
     }
 }

package/dist/service/lambda/function/policy/sim-lambda-permission.js

@@ -82,20 +82,21 @@ export class SimLambdaPermission {
      */
     condition() {
         const stringEquals = this.stringEqualsConditions();
-        const condition = {};
-        if (Object.keys(stringEquals).length > 0) {
-            condition["StringEquals"] = stringEquals;
-        }
-        if (this.sourceArn !== undefined) {
-            condition["ArnLike"] = {
-                [simLambdaSourceArnConditionKey]: this.sourceArn,
-            };
-        }
-        if (this.invokedViaFunctionUrl !== undefined) {
-            condition["Bool"] = {
-                [simLambdaInvokedViaFunctionUrlConditionKey]: this.invokedViaFunctionUrl,
-            };
-        }
+        const condition = {
+            ...(Object.keys(stringEquals).length > 0 && {
+                StringEquals: stringEquals,
+            }),
+            ...(this.sourceArn !== undefined && {
+                ArnLike: {
+                    [simLambdaSourceArnConditionKey]: this.sourceArn,
+                },
+            }),
+            ...(this.invokedViaFunctionUrl !== undefined && {
+                Bool: {
+                    [simLambdaInvokedViaFunctionUrlConditionKey]: this.invokedViaFunctionUrl,
+                },
+            }),
+        };
         return Object.keys(condition).length === 0 ? undefined : condition;
     }
     stringEqualsConditions() {

package/dist/service/lambda/function/sim-lambda-function.js

@@ -194,6 +194,7 @@ export class SimLambdaFunction {
             logStreamName: this.logging.logStreamName(),
         });
         this.logging.recordFrom(this.#code);
+        this.properties.environmentConflicts?.reportReads();
         return await this.metrics.around(String(this.name), async () => simAwsRunAsContext.run(this.runAsOwner, { kind: "arn", arn: this.roleArn }, async () => await this.environment.runWith(async () => await this.runInHostScope(async () => await this.logging.around(async () => await invocation.run(this.#code.handlerFunction(), event))))));
     }
     /**

package/dist/service/lambda/function/sim-lambda-function.type.d.ts

@@ -8,6 +8,7 @@ import type { SimLambdaOutput } from "./logging/sim-lambda-output.js";
 import type { SimLogsServiceWriter } from "../../logs/write/sim-logs-service-writer.js";
 import type { SimLambdaExecutableCode } from "./code/sim-lambda-executable-code.js";
 import type { SimLambdaEnvironment } from "./environment/sim-lambda-environment.js";
+import type { SimLambdaEnvironmentConflicts } from "./environment/sim-lambda-environment-conflicts.js";
 import type { SimLambdaOutboundHttp } from "./outbound/sim-lambda-outbound-http.js";
 import type { SimLambdaFunctionState } from "./sim-lambda-function-configuration.js";
 import type { SimLambdaHandler } from "./sim-lambda-handler.type.js";
@@ -27,6 +28,13 @@ export interface SimLambdaFunctionProperties {
     timeoutSeconds?: number | undefined;
     memorySizeMb?: number | undefined;
     environment?: SimLambdaEnvironment | undefined;
+    /**
+     * The check that warns about declared variables read too early, shared with
+     * every other function of the same simulated Lambda. It reports, as this
+     * function is invoked, a difference found earlier whose name has since been
+     * read outside an invocation. A function built standalone has none.
+     */
+    environmentConflicts?: SimLambdaEnvironmentConflicts | undefined;
     /**
      * The queue or topic this function's abandoned asynchronous events are sent
      * to, which is what `DeadLetterConfig.TargetArn` names.

package/dist/service/lambda/metric/sim-lambda-function-metrics.js

@@ -69,15 +69,17 @@ function invocationData(outcome) {
             value: outcome.durationMilliseconds,
             unit: "Milliseconds",
         },
+        ...(outcome.failed
+            ? [
+                {
+                    namespace: simLambdaMetricNamespace,
+                    metricName: "Errors",
+                    dimensions,
+                    value: 1,
+                    unit: "Count",
+                },
+            ]
+            : []),
     ];
-    if (outcome.failed) {
-        data.push({
-            namespace: simLambdaMetricNamespace,
-            metricName: "Errors",
-            dimensions,
-            value: 1,
-            unit: "Count",
-        });
-    }
     return data;
 }

package/dist/service/lambda/sim-lambda-commands.js

@@ -146,7 +146,9 @@ export class SimLambdaCommands {
             runAsOwner: properties.runAsOwner,
             // Shared across function creations so a conflicting environment variable
             // is only reported once for this simulated Lambda.
-            environmentConflicts: new SimLambdaEnvironmentConflicts(),
+            environmentConflicts: new SimLambdaEnvironmentConflicts({
+                currentEnvironments: () => properties.functions.values().map((existing) => existing.environment),
+            }),
             eventInvokeConfigs: this.eventInvokeConfigStore,
             destinations,
             codeStore,

package/dist/service/logs/metric/sim-logs-metric-filter.js

@@ -84,12 +84,5 @@ export class SimLogsMetricFilter {
  * A batch's events grouped into the aggregation periods they were taken in.
  */
 function byPeriod(events) {
-    const grouped = new Map();
-    for (const event of events) {
-        const period = Math.floor(event.ingestionTime / periodMilliseconds) * periodMilliseconds;
-        const inPeriod = grouped.get(period) ?? [];
-        inPeriod.push(event);
-        grouped.set(period, inPeriod);
-    }
-    return grouped;
+    return Map.groupBy(events, (event) => Math.floor(event.ingestionTime / periodMilliseconds) * periodMilliseconds);
 }

package/dist/service/route53/dns/answer/sim-route53-dns-zone-finder.js

@@ -19,11 +19,12 @@ export class SimRoute53DnsZoneFinder {
         let bestZoneNameLength = -1;
         for (const hostedZone of this.hostedZones.values()) {
             const zoneName = simRoute53ZoneName(hostedZone);
-            if (zoneContainsName(zoneName, name) &&
-                zoneName.length > bestZoneNameLength) {
-                bestZone = hostedZone;
-                bestZoneNameLength = zoneName.length;
+            if (!zoneContainsName(zoneName, name) ||
+                zoneName.length <= bestZoneNameLength) {
+                continue;
             }
+            bestZone = hostedZone;
+            bestZoneNameLength = zoneName.length;
         }
         return bestZone;
     }

package/dist/service/route53/resolve/sim-r53-zone-record-finder.js

@@ -20,10 +20,11 @@ export class SimRoute53HostedZoneRecordFinder {
                 continue;
             }
             const record = hostedZone.records.get(name, type);
-            if (record !== undefined && zoneName.length > bestZoneNameLength) {
-                bestRecord = record;
-                bestZoneNameLength = zoneName.length;
+            if (record === undefined || zoneName.length <= bestZoneNameLength) {
+                continue;
             }
+            bestRecord = record;
+            bestZoneNameLength = zoneName.length;
         }
         return bestRecord;
     }
@@ -43,10 +44,11 @@ export class SimRoute53HostedZoneRecordFinder {
             if (!this.zoneContainsName(zoneName, name)) {
                 continue;
             }
-            if (zoneName.length > bestZoneNameLength) {
-                bestHostedZone = hostedZone;
-                bestZoneNameLength = zoneName.length;
+            if (zoneName.length <= bestZoneNameLength) {
+                continue;
             }
+            bestHostedZone = hostedZone;
+            bestZoneNameLength = zoneName.length;
         }
         return bestHostedZone;
     }

package/dist/service/s3/bucket/notification/sim-s3-notification-filter.js

@@ -55,13 +55,10 @@ export class SimS3NotificationFilter {
      * filters nothing.
      */
     toOutput() {
-        const rules = [];
-        if (this.prefix !== "") {
-            rules.push({ Name: "prefix", Value: this.prefix });
-        }
-        if (this.suffix !== "") {
-            rules.push({ Name: "suffix", Value: this.suffix });
-        }
+        const rules = [
+            ...(this.prefix === "" ? [] : [{ Name: "prefix", Value: this.prefix }]),
+            ...(this.suffix === "" ? [] : [{ Name: "suffix", Value: this.suffix }]),
+        ];
         if (rules.length === 0) {
             return undefined;
         }

package/dist/service/s3/bucket/sim-s3-bucket.d.ts

@@ -23,9 +23,17 @@ export declare class SimS3Bucket extends SimS3BucketConfiguration {
     private readonly accountRegionScope;
     private readonly systemMetadata;
     private readonly objects;
+    private readonly keyWrites;
     constructor(properties: SimS3BucketProperties);
     /** Put an Object into storage, answering the version it was given, if any. */
     putObject(object: SimS3Object): Promise<SimS3ObjectVersion | undefined>;
+    /**
+     * Run a write to a key once every earlier write to it has finished.
+     *
+     * A write that checks the key before replacing it does both inside this,
+     * so no other write to the key lands between the check and the put.
+     */
+    writeKey<T>(key: string, write: () => Promise<T>): Promise<T>;
     /** Get a simulated S3 Object from storage. */
     getObject(key: string): Promise<SimS3Object | undefined>;
     /** List simulated S3 Objects from storage. */

package/dist/service/s3/bucket/sim-s3-bucket.js

@@ -1,6 +1,7 @@
 import { SimRealClock } from "../../../util/clock/sim-clock.js";
 import { MemoryS3BucketStorage } from "../storage/s3-memory-storage.js";
 import { SimS3BucketObjects } from "./sim-s3-bucket-objects.js";
+import { SimS3KeyWrites } from "./sim-s3-key-writes.js";
 import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-configuration.js";
 import { simS3BucketWebsiteUrl } from "./website/sim-s3-bucket-website-url.js";
 import { validateS3BucketName } from "./validate/validate-s3-bucket-name.js";
@@ -16,6 +17,7 @@ export class SimS3Bucket extends SimS3BucketConfiguration {
     accountRegionScope;
     systemMetadata = new SimS3BucketSystemMetadata();
     objects;
+    keyWrites = new SimS3KeyWrites();
     constructor(properties) {
         super(properties);
         const { bucketName, accountRegionScope = simAwsAccountRegionScopeFactory.make(), storage = new MemoryS3BucketStorage(), lifecycle = SimS3LifecycleConfiguration.empty(), clock = new SimRealClock(), creationDate = clock.now(), } = properties;
@@ -29,6 +31,15 @@ export class SimS3Bucket extends SimS3BucketConfiguration {
     async putObject(object) {
         return await this.objects.put(object);
     }
+    /**
+     * Run a write to a key once every earlier write to it has finished.
+     *
+     * A write that checks the key before replacing it does both inside this,
+     * so no other write to the key lands between the check and the put.
+     */
+    async writeKey(key, write) {
+        return await this.keyWrites.exclusive(key, write);
+    }
     /** Get a simulated S3 Object from storage. */
     async getObject(key) {
         return await this.objects.get(key);

package/dist/service/s3/bucket/sim-s3-key-writes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The writes in progress against each key of a Bucket, run one at a time.
+ *
+ * A conditional write reads the key and then writes it, with awaits between
+ * the two. Real S3 lets the first of several conditional writes to one key
+ * finish and refuses the rest. Running each key's writes in turn gives the
+ * same answer, because a write's condition is read after the write before it
+ * has landed. Writes to different keys still run side by side.
+ */
+export declare class SimS3KeyWrites {
+    private readonly pending;
+    /**
+     * Run a write once every earlier write to the same key has settled.
+     */
+    exclusive<T>(key: string, write: () => Promise<T>): Promise<T>;
+}

package/dist/service/s3/bucket/sim-s3-key-writes.js

@@ -0,0 +1,43 @@
+/**
+ * The writes in progress against each key of a Bucket, run one at a time.
+ *
+ * A conditional write reads the key and then writes it, with awaits between
+ * the two. Real S3 lets the first of several conditional writes to one key
+ * finish and refuses the rest. Running each key's writes in turn gives the
+ * same answer, because a write's condition is read after the write before it
+ * has landed. Writes to different keys still run side by side.
+ */
+export class SimS3KeyWrites {
+    pending = new Map();
+    /**
+     * Run a write once every earlier write to the same key has settled.
+     */
+    async exclusive(key, write) {
+        const running = afterEarlier(this.pending.get(key), write);
+        const settled = settle(running);
+        this.pending.set(key, settled);
+        try {
+            return await running;
+        }
+        finally {
+            if (this.pending.get(key) === settled) {
+                this.pending.delete(key);
+            }
+        }
+    }
+}
+async function afterEarlier(earlier, write) {
+    await earlier;
+    return await write();
+}
+/**
+ * Wait for a write without taking on its failure, which its own caller sees.
+ */
+async function settle(running) {
+    try {
+        await running;
+    }
+    catch {
+        // The next write to the key runs whether this one failed or not.
+    }
+}

package/dist/service/s3/bucket/versioning/sim-s3-bucket-versioning.js

@@ -34,9 +34,7 @@ export class SimS3BucketVersioning {
      * The state a PutBucketVersioning request asks for.
      */
     static fromConfiguration(configuration) {
-        return configuration.Status === "Enabled"
-            ? new SimS3BucketVersioning("Enabled")
-            : new SimS3BucketVersioning("Suspended");
+        return new SimS3BucketVersioning(configuration.Status === "Enabled" ? "Enabled" : "Suspended");
     }
     /**
      * What GetBucketVersioning answers with.

package/dist/service/s3/command/complete-multipart-upload/complete-multipart-upload.command.d.ts

@@ -1,4 +1,5 @@
 import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3WritePrecondition } from "../object/sim-s3-write-precondition.js";
 /**
  * Minimal structural sim S3 CompleteMultipartUpload command.
  */
@@ -18,7 +19,7 @@ export interface SimCompletedUploadPart {
  * The parts are named by the request rather than assumed by S3, so a client can
  * finish an upload it sent a part of twice.
  */
-export interface SimCompleteMultipartUploadCommandInput {
+export interface SimCompleteMultipartUploadCommandInput extends SimS3WritePrecondition {
     readonly Bucket?: string | undefined;
     readonly Key?: string | undefined;
     readonly UploadId?: string | undefined;

package/dist/service/s3/command/complete-multipart-upload/complete-multipart-upload.handler.js

@@ -3,6 +3,7 @@ import { simS3BucketUrl } from "../../bucket/sim-s3-endpoint-url.js";
 import { simS3QuotedETag } from "../../object/s3-object-etag.js";
 import { simS3CompletedUploadObject, } from "../../upload/sim-s3-completed-upload.js";
 import { SimS3MultipartAccess, } from "../multipart/sim-s3-multipart-access.js";
+import { simS3RequireWritePrecondition } from "../object/sim-s3-write-precondition.js";
 /**
  * Simulated S3 CompleteMultipartUploadCommand handler.
  *
@@ -34,7 +35,10 @@ export class CompleteMultipartUploadCommandHandler {
             parts: namedParts(command.input.MultipartUpload?.Parts ?? []),
             completedAt: this.access.now(),
         });
-        const version = await bucket.putObject(object);
+        const version = await bucket.writeKey(Key, async () => {
+            await simS3RequireWritePrecondition(bucket, Key, command.input);
+            return await bucket.putObject(object);
+        });
         bucket.getMultipartUploads().discard(UploadId);
         this.notifications.objectCreated({
             bucket,