@kensio/yulin 1.20.17 → 1.21.1

package/dist/service/s3/command/delete-object/delete-object.handler.js

@@ -3,6 +3,8 @@ import { assertDefined } from "../../../../util/type-guard/defined.js";
 import { SimIamAllowAllAuth, } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
 import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
 import { DeleteObjectAuthorizer } from "./delete-object-authorizer.js";
+import { DeleteObjectVersionRemoval } from "./delete-object-version-removal.js";
+import { simS3NotifyDeleted } from "./sim-s3-notify-deleted.js";
 /**
  * Simulated S3 DeleteObjectCommand handler.
  *
@@ -13,40 +15,50 @@ export class DeleteObjectCommandHandler {
     authorizer;
     background;
     notifications;
+    versionRemoval;
     constructor(properties) {
         const { buckets, iam = new SimIamAllowAllAuth(), background = new BackgroundTasks(), } = properties;
         this.buckets = buckets;
         this.authorizer = new DeleteObjectAuthorizer({ iam });
         this.background = background;
         this.notifications = properties.notifications;
+        this.versionRemoval = new DeleteObjectVersionRemoval({
+            notifications: properties.notifications,
+            iam,
+        });
     }
     /**
      * Authorize and remove an Object from a Bucket.
      *
-     * A missing Bucket is reported, but a missing key is not: real S3 answers a
+     * A missing Bucket is reported, but a missing key is not. Real S3 answers a
      * deletion the same way whether or not the Object was there, so code that
      * deletes something twice sees the same success both times.
+     *
+     * A `VersionId` asks for that one version and removes it for good. A request
+     * without one asks for the current version, which a versioned Bucket answers
+     * by writing a delete marker over it. Object Lock holds a named version and
+     * never the marker, since a marker hides an Object without losing it.
      */
     async handle(command, options) {
-        assertDefined(command.input.Bucket, "DeleteObjectCommand.input.Bucket");
-        assertDefined(command.input.Key, "DeleteObjectCommand.input.Key");
-        const bucketName = command.input.Bucket;
-        const bucket = requireSimS3Bucket(this.buckets, bucketName);
+        const { Bucket, Key, VersionId, BypassGovernanceRetention } = command.input;
+        assertDefined(Bucket, "DeleteObjectCommand.input.Bucket");
+        assertDefined(Key, "DeleteObjectCommand.input.Key");
+        const bucket = requireSimS3Bucket(this.buckets, Bucket);
         await this.background.sequence();
-        const caller = this.authorizer.authorize(bucket, command.input.Key, options);
-        const removed = await bucket.deleteObject(command.input.Key);
-        // A deletion that removed nothing is not an event: real S3 raises
-        // ObjectRemoved for an Object that was deleted, not for a request to
-        // delete one.
-        if (removed) {
-            this.notifications.objectRemoved({
+        const caller = this.authorizer.authorize(bucket, Key, options);
+        if (VersionId !== undefined) {
+            return await this.versionRemoval.remove({
                 bucket,
-                key: command.input.Key,
+                key: Key,
+                versionId: VersionId,
                 caller,
+                bypassGovernance: BypassGovernanceRetention,
+                options,
             });
         }
-        return {
-            $metadata: {},
-        };
+        const deletion = await bucket.deleteObject(Key);
+        const notifications = this.notifications;
+        simS3NotifyDeleted({ notifications, bucket, key: Key, caller, deletion });
+        return { ...deletion.reported, $metadata: {} };
     }
 }

package/dist/service/s3/command/delete-object/sim-s3-notify-deleted.d.ts

@@ -0,0 +1,24 @@
+import type { SimAwsResolvedCaller } from "../../../aws/caller/sim-aws-caller-resolver.js";
+import type { SimS3Bucket } from "../../bucket/sim-s3-bucket.js";
+import type { SimS3ObjectDeletion } from "../../bucket/sim-s3-object-deletion.js";
+import type { SimS3ObjectNotifier } from "../../notification/sim-s3-object-notifier.js";
+interface SimS3NotifyDeletedProperties {
+    readonly notifications: SimS3ObjectNotifier;
+    readonly bucket: SimS3Bucket;
+    readonly key: string;
+    readonly caller: SimAwsResolvedCaller;
+    readonly deletion: SimS3ObjectDeletion;
+}
+/**
+ * Raise the event a delete earned, if it earned one.
+ *
+ * Three outcomes and three different events, which is why every delete path
+ * comes through here rather than deciding for itself. A versioned Bucket wrote
+ * a marker, so the event is `s3:ObjectRemoved:DeleteMarkerCreated` and carries
+ * the marker's version id. A Bucket without versioning lost the Object, so it
+ * is `s3:ObjectRemoved:Delete`. A delete that removed nothing raises neither,
+ * because real S3 raises ObjectRemoved for an Object that was deleted rather
+ * than for a request to delete one.
+ */
+export declare function simS3NotifyDeleted(properties: SimS3NotifyDeletedProperties): void;
+export {};

package/dist/service/s3/command/delete-object/sim-s3-notify-deleted.js

@@ -0,0 +1,32 @@
+/**
+ * Raise the event a delete earned, if it earned one.
+ *
+ * Three outcomes and three different events, which is why every delete path
+ * comes through here rather than deciding for itself. A versioned Bucket wrote
+ * a marker, so the event is `s3:ObjectRemoved:DeleteMarkerCreated` and carries
+ * the marker's version id. A Bucket without versioning lost the Object, so it
+ * is `s3:ObjectRemoved:Delete`. A delete that removed nothing raises neither,
+ * because real S3 raises ObjectRemoved for an Object that was deleted rather
+ * than for a request to delete one.
+ */
+export function simS3NotifyDeleted(properties) {
+    const { notifications, bucket, key, caller, deletion } = properties;
+    if (deletion.deleteMarker !== undefined) {
+        notifications.objectRemoved({
+            bucket,
+            key,
+            caller,
+            eventName: "s3:ObjectRemoved:DeleteMarkerCreated",
+            versionId: deletion.deleteMarker.versionId,
+        });
+        return;
+    }
+    if (deletion.removedObject) {
+        notifications.objectRemoved({
+            bucket,
+            key,
+            caller,
+            eventName: "s3:ObjectRemoved:Delete",
+        });
+    }
+}

package/dist/service/s3/command/delete-objects/delete-object-attempt.d.ts

@@ -1,11 +1,15 @@
+import type { SimS3ObjectVersion } from "../../bucket/versioning/sim-s3-object-version.js";
 /**
  * What one key of a DeleteObjects request came to.
  *
  * A batch deletion carries on past a key it could not remove, so the failure
- * travels with the key it belongs to rather than being raised.
+ * travels with the key it belongs to rather than being raised. So does the
+ * delete marker, which a versioned Bucket reports per key alongside the id it
+ * was written under.
  */
 export declare class DeleteObjectAttempt {
     readonly key: string;
     readonly error: unknown;
-    constructor(key: string, error?: unknown);
+    readonly deleteMarker: SimS3ObjectVersion | undefined;
+    constructor(key: string, error?: unknown, deleteMarker?: SimS3ObjectVersion);
 }

package/dist/service/s3/command/delete-objects/delete-object-attempt.js

@@ -2,13 +2,17 @@
  * What one key of a DeleteObjects request came to.
  *
  * A batch deletion carries on past a key it could not remove, so the failure
- * travels with the key it belongs to rather than being raised.
+ * travels with the key it belongs to rather than being raised. So does the
+ * delete marker, which a versioned Bucket reports per key alongside the id it
+ * was written under.
  */
 export class DeleteObjectAttempt {
     key;
     error;
-    constructor(key, error) {
+    deleteMarker;
+    constructor(key, error, deleteMarker) {
         this.key = key;
         this.error = error;
+        this.deleteMarker = deleteMarker;
     }
 }

package/dist/service/s3/command/delete-objects/delete-objects-key-removal.js

@@ -1,5 +1,6 @@
 import { DeleteObjectAuthorizer } from "../delete-object/delete-object-authorizer.js";
 import { DeleteObjectAttempt } from "./delete-object-attempt.js";
+import { simS3NotifyDeleted } from "../delete-object/sim-s3-notify-deleted.js";
 /**
  * Removes one key of a batch deletion.
  *
@@ -21,15 +22,15 @@ export class DeleteObjectsKeyRemoval {
     async remove(bucket, key, options) {
         try {
             const resolvedCaller = this.authorizer.authorize(bucket, key, options);
-            const removed = await bucket.deleteObject(key);
-            if (removed) {
-                this.notifications.objectRemoved({
-                    bucket,
-                    key,
-                    caller: resolvedCaller,
-                });
-            }
-            return new DeleteObjectAttempt(key);
+            const deletion = await bucket.deleteObject(key);
+            simS3NotifyDeleted({
+                notifications: this.notifications,
+                bucket,
+                key,
+                caller: resolvedCaller,
+                deletion,
+            });
+            return new DeleteObjectAttempt(key, undefined, deletion.deleteMarker);
         }
         catch (error) {
             return new DeleteObjectAttempt(key, error);

package/dist/service/s3/command/delete-objects/delete-objects-outcome.js

@@ -33,7 +33,15 @@ export class DeleteObjectsOutcome {
      */
     record(attempt) {
         if (attempt.error === undefined) {
-            this.deleted.push({ Key: attempt.key });
+            this.deleted.push({
+                Key: attempt.key,
+                // Reported per key, as real S3 does, so a caller can tell which keys
+                // of the batch were hidden behind a marker rather than removed.
+                ...(attempt.deleteMarker !== undefined && {
+                    DeleteMarker: true,
+                    DeleteMarkerVersionId: attempt.deleteMarker.versionId,
+                }),
+            });
             return;
         }
         this.recordFailure(attempt.key, attempt.error);

package/dist/service/s3/command/delete-objects/delete-objects.command.d.ts

@@ -38,9 +38,15 @@ export interface SimDeleteObjectsCommandOutput {
 }
 /**
  * One Object a DeleteObjects request removed.
+ *
+ * A versioned Bucket hides the Object behind a marker instead of removing it,
+ * and reports the marker it wrote under `DeleteMarker` and
+ * `DeleteMarkerVersionId`. A Bucket without versioning carries neither.
  */
 export interface SimS3DeletedObject {
     readonly Key: string;
+    readonly DeleteMarker?: boolean | undefined;
+    readonly DeleteMarkerVersionId?: string | undefined;
 }
 /**
  * One Object a DeleteObjects request could not remove.

package/dist/service/s3/command/get-bucket-versioning/get-bucket-versioning.command.d.ts

@@ -0,0 +1,23 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+/**
+ * Minimal structural sim S3 GetBucketVersioning command.
+ */
+export interface SimGetBucketVersioningCommand {
+    readonly input: SimGetBucketVersioningCommandInput;
+}
+/**
+ * Minimal structural sim S3 GetBucketVersioning input.
+ */
+export interface SimGetBucketVersioningCommandInput {
+    readonly Bucket?: string | undefined;
+}
+/**
+ * Minimal structural sim S3 GetBucketVersioning output.
+ *
+ * A Bucket nobody has configured answers with neither field, which is how real
+ * S3 separates an unversioned Bucket from a suspended one.
+ */
+export interface SimGetBucketVersioningCommandOutput {
+    readonly Status?: "Enabled" | "Suspended" | undefined;
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/s3/command/get-bucket-versioning/get-bucket-versioning.command.js

@@ -0,0 +1 @@
+export {};

package/dist/service/s3/command/get-bucket-versioning/get-bucket-versioning.handler.d.ts

@@ -0,0 +1,31 @@
+import type { CommandHandler } from "../../../../command/command-handler.js";
+import { type BackgroundScheduler } from "../../../../util/background/background.js";
+import { type SimIamInterServiceAuthZ } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimS3Bucket, SimS3BucketName } from "../../bucket/sim-s3-bucket.js";
+import type { SimS3RequestOptions } from "../sim-s3-request-options.js";
+import type { SimGetBucketVersioningCommand, SimGetBucketVersioningCommandOutput } from "./get-bucket-versioning.command.js";
+interface GetBucketVersioningHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}
+/**
+ * Simulated S3 GetBucketVersioningCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/GetBucketVersioningCommand/
+ */
+export declare class GetBucketVersioningCommandHandler implements CommandHandler<SimGetBucketVersioningCommand, SimGetBucketVersioningCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    constructor(properties: GetBucketVersioningHandlerProperties);
+    /**
+     * Authorize and report how a Bucket is versioned.
+     *
+     * A Bucket nobody has configured answers with an empty response rather than
+     * an error, which is how real S3 reports one and what distinguishes it from
+     * a Bucket whose versioning was suspended.
+     */
+    handle(command: SimGetBucketVersioningCommand, options?: SimS3RequestOptions): Promise<SimGetBucketVersioningCommandOutput>;
+}
+export {};

package/dist/service/s3/command/get-bucket-versioning/get-bucket-versioning.handler.js

@@ -0,0 +1,40 @@
+import { BackgroundTasks, } from "../../../../util/background/background.js";
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimIamAllowAllAuth, } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
+import { SimS3VersioningAuthorizer } from "../versioning/sim-s3-versioning-authorizer.js";
+/**
+ * Simulated S3 GetBucketVersioningCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/GetBucketVersioningCommand/
+ */
+export class GetBucketVersioningCommandHandler {
+    buckets;
+    authorizer;
+    background;
+    constructor(properties) {
+        const { buckets, iam = new SimIamAllowAllAuth(), background = new BackgroundTasks(), } = properties;
+        this.buckets = buckets;
+        this.authorizer = new SimS3VersioningAuthorizer({ iam });
+        this.background = background;
+    }
+    /**
+     * Authorize and report how a Bucket is versioned.
+     *
+     * A Bucket nobody has configured answers with an empty response rather than
+     * an error, which is how real S3 reports one and what distinguishes it from
+     * a Bucket whose versioning was suspended.
+     */
+    async handle(command, options) {
+        assertDefined(command.input.Bucket, "GetBucketVersioningCommand.input.Bucket");
+        const bucketName = command.input.Bucket;
+        const bucket = requireSimS3Bucket(this.buckets, bucketName);
+        await this.background.sequence();
+        this.authorizer.authorizeRead(bucket, options);
+        const status = bucket.getVersions().configuration.status;
+        return {
+            ...(status !== undefined && { Status: status }),
+            $metadata: {},
+        };
+    }
+}

package/dist/service/s3/command/get-object/get-object-loader.d.ts

@@ -10,7 +10,8 @@ import type { SimGetObjectCommandOutput } from "./get-object.command.js";
  * This class owns both storage lookup and response conversion because the SDK
  * response is a representation of the stored Object:
  *
- * - a missing storage entry becomes the S3 NoSuchKey error;
+ * - a missing storage entry becomes the S3 NoSuchKey error, and a `VersionId`
+ *   naming a version the Bucket never issued becomes NoSuchVersion;
  * - the stored Buffer, or the part of it the read asked for, becomes the
  *   readable response body;
  * - what S3 was told about the Object becomes the response's own fields, and
@@ -25,5 +26,5 @@ export declare class GetObjectLoader {
      * Read an Object, or the range of it that was asked for, from the resolved
      * Bucket, and build its SDK command output.
      */
-    load(bucket: SimS3Bucket, key: string, rangeHeader?: string): Promise<SimGetObjectCommandOutput>;
+    load(bucket: SimS3Bucket, key: string, rangeHeader?: string, versionId?: string): Promise<SimGetObjectCommandOutput>;
 }

package/dist/service/s3/command/get-object/get-object-loader.js

@@ -2,6 +2,7 @@ import { Readable } from "node:stream";
 import { SimS3NoSuchKey } from "../../error/sim-s3.error.js";
 import { simS3QuotedETag } from "../../object/s3-object-etag.js";
 import { simS3ContentRange, simS3ReadObjectRange, } from "../../object/s3-object-range.js";
+import { simS3ReadObjectVersion } from "../object/sim-s3-read-object-version.js";
 /**
  * Loads an authorized S3 Object and converts it to a GetObject response.
  *
@@ -12,7 +13,8 @@ import { simS3ContentRange, simS3ReadObjectRange, } from "../../object/s3-object
  * This class owns both storage lookup and response conversion because the SDK
  * response is a representation of the stored Object:
  *
- * - a missing storage entry becomes the S3 NoSuchKey error;
+ * - a missing storage entry becomes the S3 NoSuchKey error, and a `VersionId`
+ *   naming a version the Bucket never issued becomes NoSuchVersion;
  * - the stored Buffer, or the part of it the read asked for, becomes the
  *   readable response body;
  * - what S3 was told about the Object becomes the response's own fields, and
@@ -27,11 +29,12 @@ export class GetObjectLoader {
      * Read an Object, or the range of it that was asked for, from the resolved
      * Bucket, and build its SDK command output.
      */
-    async load(bucket, key, rangeHeader) {
-        const object = await bucket.getObject(key);
-        if (object === undefined) {
+    async load(bucket, key, rangeHeader, versionId) {
+        const read = await simS3ReadObjectVersion(bucket, key, versionId);
+        if (read === undefined) {
             throw new SimS3NoSuchKey(`No S3 Object named ${key}`);
         }
+        const object = read.object;
         const size = object.body.length;
         const range = simS3ReadObjectRange(rangeHeader, size);
         const body = range === undefined
@@ -47,6 +50,8 @@ export class GetObjectLoader {
             ETag: simS3QuotedETag(object.etag),
             LastModified: object.lastModified,
             ContentLength: body.length,
+            ...(read.versionId !== undefined && { VersionId: read.versionId }),
+            ...read.lock?.reported,
             ...(range !== undefined && {
                 ContentRange: simS3ContentRange(range, size),
             }),

package/dist/service/s3/command/get-object/get-object.command.d.ts

@@ -1,5 +1,6 @@
 import type { Readable } from "node:stream";
 import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3ObjectLockOutput } from "../../bucket/lock/sim-s3-object-lock-output.js";
 import type { SimS3SystemMetadataOutput } from "../../object/s3-system-metadata-read.js";
 /**
  * Minimal structural sim S3 GetObject command.
@@ -19,6 +20,11 @@ export interface SimGetObjectCommandInput {
      * Object.
      */
     readonly Range?: string | undefined;
+    /**
+     * The version to read. A request naming none reads the current version, and
+     * a Bucket keeping no versions answers the Object under the key.
+     */
+    readonly VersionId?: string | undefined;
 }
 /**
  * Minimal structural sim S3 GetObject output.
@@ -35,12 +41,14 @@ export interface SimGetObjectCommandInput {
  * when it was written. `Metadata` is what the caller attached to it, and holds
  * nothing else.
  */
-export interface SimGetObjectCommandOutput extends SimS3SystemMetadataOutput {
+export interface SimGetObjectCommandOutput extends SimS3SystemMetadataOutput, SimS3ObjectLockOutput {
     readonly Body?: Readable;
     readonly Metadata?: Record<string, string>;
     readonly ETag?: string;
     readonly LastModified?: Date;
     readonly ContentLength?: number;
     readonly ContentRange?: string;
+    /** The version read, on a Bucket keeping versions. */
+    readonly VersionId?: string | undefined;
     readonly $metadata: SimResponseMetadata;
 }

package/dist/service/s3/command/get-object/get-object.handler.js

@@ -45,6 +45,6 @@ export class GetObjectCommandHandler {
         // Complete request sequencing before authorization and storage access.
         await this.background.sequence();
         this.authorizer.authorize(bucket, command.input.Key, options);
-        return await this.loader.load(bucket, command.input.Key, command.input.Range);
+        return await this.loader.load(bucket, command.input.Key, command.input.Range, command.input.VersionId);
     }
 }

package/dist/service/s3/command/get-object-lock-configuration/get-object-lock-configuration.command.d.ts

@@ -0,0 +1,25 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3ObjectLockConfigurationInput } from "../../bucket/lock/sim-s3-object-lock-configuration.js";
+/**
+ * Minimal structural sim S3 GetObjectLockConfiguration command.
+ */
+export interface SimGetObjectLockConfigurationCommand {
+    readonly input: SimGetObjectLockConfigurationCommandInput;
+}
+/**
+ * Minimal structural sim S3 GetObjectLockConfiguration input.
+ */
+export interface SimGetObjectLockConfigurationCommandInput {
+    readonly Bucket?: string | undefined;
+}
+/**
+ * Minimal structural sim S3 GetObjectLockConfiguration output.
+ *
+ * A Bucket that has never had Object Lock answers with
+ * `ObjectLockConfigurationNotFoundError` rather than an empty configuration,
+ * so this always carries one.
+ */
+export interface SimGetObjectLockConfigurationCommandOutput {
+    readonly ObjectLockConfiguration: SimS3ObjectLockConfigurationInput;
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/s3/command/get-object-lock-configuration/get-object-lock-configuration.command.js

@@ -0,0 +1 @@
+export {};

package/dist/service/s3/command/get-object-lock-configuration/get-object-lock-configuration.handler.d.ts

@@ -0,0 +1,31 @@
+import type { CommandHandler } from "../../../../command/command-handler.js";
+import { type BackgroundScheduler } from "../../../../util/background/background.js";
+import { type SimIamInterServiceAuthZ } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimS3Bucket, SimS3BucketName } from "../../bucket/sim-s3-bucket.js";
+import type { SimS3RequestOptions } from "../sim-s3-request-options.js";
+import type { SimGetObjectLockConfigurationCommand, SimGetObjectLockConfigurationCommandOutput } from "./get-object-lock-configuration.command.js";
+interface GetObjectLockConfigurationHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}
+/**
+ * Simulated S3 GetObjectLockConfigurationCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/GetObjectLockConfigurationCommand/
+ */
+export declare class GetObjectLockConfigurationCommandHandler implements CommandHandler<SimGetObjectLockConfigurationCommand, SimGetObjectLockConfigurationCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    constructor(properties: GetObjectLockConfigurationHandlerProperties);
+    /**
+     * Report how a Bucket is locked.
+     *
+     * A Bucket that has never had Object Lock is answered with
+     * `ObjectLockConfigurationNotFoundError`, as real S3 answers one, rather
+     * than with a configuration saying it is off.
+     */
+    handle(command: SimGetObjectLockConfigurationCommand, options?: SimS3RequestOptions): Promise<SimGetObjectLockConfigurationCommandOutput>;
+}
+export {};

package/dist/service/s3/command/get-object-lock-configuration/get-object-lock-configuration.handler.js

@@ -0,0 +1,41 @@
+import { BackgroundTasks, } from "../../../../util/background/background.js";
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimIamAllowAllAuth, } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import { SimS3ObjectLockConfigurationNotFound } from "../../error/sim-s3-object-lock.error.js";
+import { SimS3ObjectLockAuthorizer } from "../object-lock/sim-s3-object-lock-authorizer.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
+/**
+ * Simulated S3 GetObjectLockConfigurationCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/GetObjectLockConfigurationCommand/
+ */
+export class GetObjectLockConfigurationCommandHandler {
+    buckets;
+    authorizer;
+    background;
+    constructor(properties) {
+        const { buckets, iam = new SimIamAllowAllAuth(), background = new BackgroundTasks(), } = properties;
+        this.buckets = buckets;
+        this.authorizer = new SimS3ObjectLockAuthorizer({ iam });
+        this.background = background;
+    }
+    /**
+     * Report how a Bucket is locked.
+     *
+     * A Bucket that has never had Object Lock is answered with
+     * `ObjectLockConfigurationNotFoundError`, as real S3 answers one, rather
+     * than with a configuration saying it is off.
+     */
+    async handle(command, options) {
+        const { Bucket } = command.input;
+        assertDefined(Bucket, "GetObjectLockConfigurationCommand.input.Bucket");
+        const bucket = requireSimS3Bucket(this.buckets, Bucket);
+        await this.background.sequence();
+        this.authorizer.authorizeReadConfiguration(bucket, options);
+        const configuration = bucket.getObjectLock().configuration;
+        if (configuration === undefined) {
+            throw new SimS3ObjectLockConfigurationNotFound(`S3 Bucket ${Bucket} does not have an Object Lock configuration`);
+        }
+        return { ObjectLockConfiguration: configuration.reported, $metadata: {} };
+    }
+}

package/dist/service/s3/command/head-object/head-object-loader.d.ts

@@ -12,5 +12,5 @@ export declare class HeadObjectLoader {
     /**
      * Describe an Object in the resolved Bucket.
      */
-    describe(bucket: SimS3Bucket, key: string): Promise<SimHeadObjectCommandOutput>;
+    describe(bucket: SimS3Bucket, key: string, versionId?: string): Promise<SimHeadObjectCommandOutput>;
 }

package/dist/service/s3/command/head-object/head-object-loader.js

@@ -1,5 +1,6 @@
 import { SimS3NotFound } from "../../error/sim-s3.error.js";
 import { simS3QuotedETag } from "../../object/s3-object-etag.js";
+import { simS3ReadObjectVersion } from "../object/sim-s3-read-object-version.js";
 /**
  * Describes an authorized S3 Object without reading it out.
  *
@@ -12,17 +13,20 @@ export class HeadObjectLoader {
     /**
      * Describe an Object in the resolved Bucket.
      */
-    async describe(bucket, key) {
-        const object = await bucket.getObject(key);
-        if (object === undefined) {
+    async describe(bucket, key, versionId) {
+        const read = await simS3ReadObjectVersion(bucket, key, versionId);
+        if (read === undefined) {
             throw new SimS3NotFound(`No S3 Object named ${key}`);
         }
+        const object = read.object;
         return {
             ...object.metadata.system,
             ContentLength: object.body.length,
             Metadata: object.metadata.userDefined,
             ETag: simS3QuotedETag(object.etag),
             LastModified: object.lastModified,
+            ...(read.versionId !== undefined && { VersionId: read.versionId }),
+            ...read.lock?.reported,
             $metadata: {},
         };
     }

package/dist/service/s3/command/head-object/head-object.command.d.ts

@@ -1,4 +1,5 @@
 import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3ObjectLockOutput } from "../../bucket/lock/sim-s3-object-lock-output.js";
 import type { SimS3SystemMetadataOutput } from "../../object/s3-system-metadata-read.js";
 /**
  * Minimal structural sim S3 HeadObject command.
@@ -12,6 +13,11 @@ export interface SimHeadObjectCommand {
 export interface SimHeadObjectCommandInput {
     readonly Bucket?: string | undefined;
     readonly Key?: string | undefined;
+    /**
+     * The version to read. A request naming none reads the current version, and
+     * a Bucket keeping no versions answers the Object under the key.
+     */
+    readonly VersionId?: string | undefined;
 }
 /**
  * Minimal structural sim S3 HeadObject output.
@@ -20,10 +26,12 @@ export interface SimHeadObjectCommandInput {
  * the Object itself, so this is a GetObject output without its body and with
  * the length that body would have had.
  */
-export interface SimHeadObjectCommandOutput extends SimS3SystemMetadataOutput {
+export interface SimHeadObjectCommandOutput extends SimS3SystemMetadataOutput, SimS3ObjectLockOutput {
     readonly ContentLength?: number;
     readonly Metadata?: Record<string, string>;
     readonly ETag?: string;
     readonly LastModified?: Date;
+    /** The version described, on a Bucket keeping versions. */
+    readonly VersionId?: string | undefined;
     readonly $metadata: SimResponseMetadata;
 }

package/dist/service/s3/command/head-object/head-object.handler.js

@@ -44,6 +44,6 @@ export class HeadObjectCommandHandler {
         // Authorization runs before the key is looked up, so a denied caller
         // cannot learn whether an Object exists.
         this.authorizer.authorize(bucket, command.input.Key, options);
-        return await this.loader.describe(bucket, command.input.Key);
+        return await this.loader.describe(bucket, command.input.Key, command.input.VersionId);
     }
 }