@kensio/yulin 1.20.17 → 1.21.1

package/dist/service/s3/command/put-bucket-versioning/put-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 { SimPutBucketVersioningCommand, SimPutBucketVersioningCommandOutput } from "./put-bucket-versioning.command.js";
+interface PutBucketVersioningHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}
+/**
+ * Simulated S3 PutBucketVersioningCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutBucketVersioningCommand/
+ */
+export declare class PutBucketVersioningCommandHandler implements CommandHandler<SimPutBucketVersioningCommand, SimPutBucketVersioningCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    constructor(properties: PutBucketVersioningHandlerProperties);
+    /**
+     * Authorize and apply a Bucket's versioning configuration.
+     *
+     * Enabling versioning over a Bucket that already holds Objects gives each of
+     * them the null version id, which is what real S3 does with the Objects
+     * written before the configuration arrived.
+     */
+    handle(command: SimPutBucketVersioningCommand, options?: SimS3RequestOptions): Promise<SimPutBucketVersioningCommandOutput>;
+}
+export {};

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

@@ -0,0 +1,44 @@
+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 { SimS3BucketVersioning } from "../../bucket/versioning/sim-s3-bucket-versioning.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
+import { SimS3VersioningAuthorizer } from "../versioning/sim-s3-versioning-authorizer.js";
+import { validateSimS3VersioningConfiguration } from "../versioning/sim-s3-versioning-configuration-validation.js";
+/**
+ * Simulated S3 PutBucketVersioningCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutBucketVersioningCommand/
+ */
+export class PutBucketVersioningCommandHandler {
+    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 apply a Bucket's versioning configuration.
+     *
+     * Enabling versioning over a Bucket that already holds Objects gives each of
+     * them the null version id, which is what real S3 does with the Objects
+     * written before the configuration arrived.
+     */
+    async handle(command, options) {
+        assertDefined(command.input.Bucket, "PutBucketVersioningCommand.input.Bucket");
+        assertDefined(command.input.VersioningConfiguration, "PutBucketVersioningCommand.input.VersioningConfiguration");
+        const bucketName = command.input.Bucket;
+        const bucket = requireSimS3Bucket(this.buckets, bucketName);
+        await this.background.sequence();
+        this.authorizer.authorizeWrite(bucket, options);
+        const configuration = command.input.VersioningConfiguration;
+        validateSimS3VersioningConfiguration(configuration, bucketName);
+        await bucket.configureVersioning(SimS3BucketVersioning.fromConfiguration(configuration));
+        return {
+            $metadata: {},
+        };
+    }
+}

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

@@ -24,9 +24,12 @@ export interface SimPutObjectCommandInput extends SimS3ObjectWriteMetadata {
  *
  * `ETag` is the quoted MD5 of the body S3 has just stored, which is what a
  * caller keeps to recognise the same content later without reading it back.
+ * `VersionId` is the version a Bucket keeping versions gave the write, and is
+ * absent on a Bucket without versioning.
  */
 export interface SimPutObjectCommandOutput {
     readonly ETag?: string;
+    readonly VersionId?: string | undefined;
     readonly $metadata: SimResponseMetadata;
 }
 /**

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

@@ -1,7 +1,7 @@
 import { assertDefined } from "../../../../util/type-guard/defined.js";
 import { BackgroundTasks, } from "../../../../util/background/background.js";
-import { SimS3NoSuchBucket } from "../../error/sim-s3.error.js";
 import { SimIamAllowAllAuth, } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
 import { PutObjectAuthorizer } from "./put-object-authorizer.js";
 import { PutObjectBuilder } from "./put-object-builder.js";
 import { simS3QuotedETag } from "../../object/s3-object-etag.js";
@@ -37,18 +37,16 @@ export class PutObjectCommandHandler {
      * sequencing while body and metadata conversion stay isolated from it.
      */
     async handle(command, options) {
-        assertDefined(command.input.Bucket, "PutObjectCommand.input.Bucket");
-        assertDefined(command.input.Key, "PutObjectCommand.input.Key");
-        const bucketName = command.input.Bucket;
-        const bucket = this.buckets.get(bucketName);
-        if (bucket === undefined) {
-            throw new SimS3NoSuchBucket(`No S3 Bucket named ${bucketName}`);
-        }
+        const { Bucket, Key } = command.input;
+        assertDefined(Bucket, "PutObjectCommand.input.Bucket");
+        assertDefined(Key, "PutObjectCommand.input.Key");
+        const bucket = requireSimS3Bucket(this.buckets, Bucket);
         // Allow for potential non-deterministic sequencing of async events.
         await this.background.sequence();
-        const caller = this.authorizer.authorize(bucket, command.input.Key, options);
+        const caller = this.authorizer.authorize(bucket, Key, options);
         const object = this.objectBuilder.build(command);
-        await bucket.putObject(object);
+        const version = await bucket.putObject(object);
+        const versionId = version?.versionId;
         // Every write path funnels through here, so this one call covers the SDK,
         // an intercepted SDK client and the REST endpoint alike.
         this.notifications.objectCreated({
@@ -56,9 +54,11 @@ export class PutObjectCommandHandler {
             object,
             caller,
             eventName: "s3:ObjectCreated:Put",
+            versionId,
         });
         return {
             ETag: simS3QuotedETag(object.etag),
+            ...(versionId !== undefined && { VersionId: versionId }),
             $metadata: {},
         };
     }

package/dist/service/s3/command/put-object-legal-hold/put-object-legal-hold.command.d.ts

@@ -0,0 +1,24 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3LegalHoldInput } from "../../bucket/lock/sim-s3-object-lock.js";
+/**
+ * Minimal structural sim S3 PutObjectLegalHold command.
+ */
+export interface SimPutObjectLegalHoldCommand {
+    readonly input: SimPutObjectLegalHoldCommandInput;
+}
+/**
+ * Minimal structural sim S3 PutObjectLegalHold input.
+ */
+export interface SimPutObjectLegalHoldCommandInput {
+    readonly Bucket?: string | undefined;
+    readonly Key?: string | undefined;
+    /** The version to hold. A request naming none holds the current one. */
+    readonly VersionId?: string | undefined;
+    readonly LegalHold?: SimS3LegalHoldInput | undefined;
+}
+/**
+ * Minimal structural sim S3 PutObjectLegalHold output.
+ */
+export interface SimPutObjectLegalHoldCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/s3/command/put-object-legal-hold/put-object-legal-hold.command.js

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

package/dist/service/s3/command/put-object-legal-hold/put-object-legal-hold.handler.d.ts

@@ -0,0 +1,32 @@
+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 { SimPutObjectLegalHoldCommand, SimPutObjectLegalHoldCommandOutput } from "./put-object-legal-hold.command.js";
+interface PutObjectLegalHoldHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}
+/**
+ * Simulated S3 PutObjectLegalHoldCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectLegalHoldCommand/
+ */
+export declare class PutObjectLegalHoldCommandHandler implements CommandHandler<SimPutObjectLegalHoldCommand, SimPutObjectLegalHoldCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    constructor(properties: PutObjectLegalHoldHandlerProperties);
+    /**
+     * Authorize and turn the legal hold on one version on or off.
+     *
+     * A hold goes on and comes off through the same request and the same
+     * permission. There is no bypass and no period to wait out, which is what
+     * makes a hold the thing to reach for when the end of the retention is not
+     * knowable in advance.
+     */
+    handle(command: SimPutObjectLegalHoldCommand, options?: SimS3RequestOptions): Promise<SimPutObjectLegalHoldCommandOutput>;
+}
+export {};

package/dist/service/s3/command/put-object-legal-hold/put-object-legal-hold.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 { SimS3ObjectLockAuthorizer } from "../object-lock/sim-s3-object-lock-authorizer.js";
+import { simS3LockedVersion } from "../object-lock/sim-s3-locked-version.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
+/**
+ * Simulated S3 PutObjectLegalHoldCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectLegalHoldCommand/
+ */
+export class PutObjectLegalHoldCommandHandler {
+    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;
+    }
+    /**
+     * Authorize and turn the legal hold on one version on or off.
+     *
+     * A hold goes on and comes off through the same request and the same
+     * permission. There is no bypass and no period to wait out, which is what
+     * makes a hold the thing to reach for when the end of the retention is not
+     * knowable in advance.
+     */
+    async handle(command, options) {
+        const { Bucket, Key, VersionId, LegalHold } = command.input;
+        assertDefined(Bucket, "PutObjectLegalHoldCommand.input.Bucket");
+        assertDefined(Key, "PutObjectLegalHoldCommand.input.Key");
+        assertDefined(LegalHold, "PutObjectLegalHoldCommand.input.LegalHold");
+        const bucket = requireSimS3Bucket(this.buckets, Bucket);
+        await this.background.sequence();
+        this.authorizer.authorizeLegalHold(bucket, Key, options);
+        simS3LockedVersion(bucket, Key, VersionId).lock.applyLegalHold(LegalHold);
+        return { $metadata: {} };
+    }
+}

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

@@ -0,0 +1,21 @@
+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 PutObjectLockConfiguration command.
+ */
+export interface SimPutObjectLockConfigurationCommand {
+    readonly input: SimPutObjectLockConfigurationCommandInput;
+}
+/**
+ * Minimal structural sim S3 PutObjectLockConfiguration input.
+ */
+export interface SimPutObjectLockConfigurationCommandInput {
+    readonly Bucket?: string | undefined;
+    readonly ObjectLockConfiguration?: SimS3ObjectLockConfigurationInput | undefined;
+}
+/**
+ * Minimal structural sim S3 PutObjectLockConfiguration output.
+ */
+export interface SimPutObjectLockConfigurationCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}

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

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

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

@@ -0,0 +1,32 @@
+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 { SimPutObjectLockConfigurationCommand, SimPutObjectLockConfigurationCommandOutput } from "./put-object-lock-configuration.command.js";
+interface PutObjectLockConfigurationHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}
+/**
+ * Simulated S3 PutObjectLockConfigurationCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectLockConfigurationCommand/
+ */
+export declare class PutObjectLockConfigurationCommandHandler implements CommandHandler<SimPutObjectLockConfigurationCommand, SimPutObjectLockConfigurationCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    constructor(properties: PutObjectLockConfigurationHandlerProperties);
+    /**
+     * Authorize and apply a Bucket's Object Lock configuration.
+     *
+     * Object Lock protects a version and has no meaning without one, so a Bucket
+     * that keeps none is refused. Real S3 requires versioning underneath it for
+     * the same reason, and a Bucket that appeared to accept the configuration
+     * would report a retention nothing was enforcing.
+     */
+    handle(command: SimPutObjectLockConfigurationCommand, options?: SimS3RequestOptions): Promise<SimPutObjectLockConfigurationCommandOutput>;
+}
+export {};

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

@@ -0,0 +1,47 @@
+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 { SimS3ObjectLockConfiguration } from "../../bucket/lock/sim-s3-object-lock-configuration.js";
+import { SimS3InvalidBucketState } 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 PutObjectLockConfigurationCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectLockConfigurationCommand/
+ */
+export class PutObjectLockConfigurationCommandHandler {
+    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;
+    }
+    /**
+     * Authorize and apply a Bucket's Object Lock configuration.
+     *
+     * Object Lock protects a version and has no meaning without one, so a Bucket
+     * that keeps none is refused. Real S3 requires versioning underneath it for
+     * the same reason, and a Bucket that appeared to accept the configuration
+     * would report a retention nothing was enforcing.
+     */
+    async handle(command, options) {
+        const { Bucket, ObjectLockConfiguration } = command.input;
+        assertDefined(Bucket, "PutObjectLockConfigurationCommand.input.Bucket");
+        assertDefined(ObjectLockConfiguration, "PutObjectLockConfigurationCommand.input.ObjectLockConfiguration");
+        const bucket = requireSimS3Bucket(this.buckets, Bucket);
+        await this.background.sequence();
+        this.authorizer.authorizeWriteConfiguration(bucket, options);
+        if (!bucket.getVersions().configuration.isEnabled) {
+            throw new SimS3InvalidBucketState(`Object Lock cannot be enabled on Bucket ${Bucket}, which does not ` +
+                `have versioning enabled`);
+        }
+        bucket
+            .getObjectLock()
+            .configure(SimS3ObjectLockConfiguration.parse(ObjectLockConfiguration));
+        return { $metadata: {} };
+    }
+}

package/dist/service/s3/command/put-object-retention/put-object-retention.command.d.ts

@@ -0,0 +1,29 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3RetentionInput } from "../../bucket/lock/sim-s3-object-retention.js";
+/**
+ * Minimal structural sim S3 PutObjectRetention command.
+ */
+export interface SimPutObjectRetentionCommand {
+    readonly input: SimPutObjectRetentionCommandInput;
+}
+/**
+ * Minimal structural sim S3 PutObjectRetention input.
+ */
+export interface SimPutObjectRetentionCommandInput {
+    readonly Bucket?: string | undefined;
+    readonly Key?: string | undefined;
+    /** The version to retain. A request naming none retains the current one. */
+    readonly VersionId?: string | undefined;
+    readonly Retention?: SimS3RetentionInput | undefined;
+    /**
+     * Whether to shorten a governance retention period already on the version,
+     * which the caller also needs `s3:BypassGovernanceRetention` for.
+     */
+    readonly BypassGovernanceRetention?: boolean | undefined;
+}
+/**
+ * Minimal structural sim S3 PutObjectRetention output.
+ */
+export interface SimPutObjectRetentionCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/s3/command/put-object-retention/put-object-retention.command.js

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

package/dist/service/s3/command/put-object-retention/put-object-retention.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 { SimPutObjectRetentionCommand, SimPutObjectRetentionCommandOutput } from "./put-object-retention.command.js";
+interface PutObjectRetentionHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}
+/**
+ * Simulated S3 PutObjectRetentionCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectRetentionCommand/
+ */
+export declare class PutObjectRetentionCommandHandler implements CommandHandler<SimPutObjectRetentionCommand, SimPutObjectRetentionCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    constructor(properties: PutObjectRetentionHandlerProperties);
+    /**
+     * Authorize and put a retention period on one version.
+     *
+     * Lengthening a period is always allowed. Shortening one is what the modes
+     * differ over, and the version itself is what refuses it, so a template and
+     * an SDK caller are held to the same rule.
+     */
+    handle(command: SimPutObjectRetentionCommand, options?: SimS3RequestOptions): Promise<SimPutObjectRetentionCommandOutput>;
+}
+export {};

package/dist/service/s3/command/put-object-retention/put-object-retention.handler.js

@@ -0,0 +1,42 @@
+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 { SimS3ObjectRetention } from "../../bucket/lock/sim-s3-object-retention.js";
+import { SimS3ObjectLockAuthorizer } from "../object-lock/sim-s3-object-lock-authorizer.js";
+import { simS3LockedVersion } from "../object-lock/sim-s3-locked-version.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
+/**
+ * Simulated S3 PutObjectRetentionCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectRetentionCommand/
+ */
+export class PutObjectRetentionCommandHandler {
+    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;
+    }
+    /**
+     * Authorize and put a retention period on one version.
+     *
+     * Lengthening a period is always allowed. Shortening one is what the modes
+     * differ over, and the version itself is what refuses it, so a template and
+     * an SDK caller are held to the same rule.
+     */
+    async handle(command, options) {
+        const { Bucket, Key, VersionId, Retention, BypassGovernanceRetention } = command.input;
+        assertDefined(Bucket, "PutObjectRetentionCommand.input.Bucket");
+        assertDefined(Key, "PutObjectRetentionCommand.input.Key");
+        assertDefined(Retention, "PutObjectRetentionCommand.input.Retention");
+        const bucket = requireSimS3Bucket(this.buckets, Bucket);
+        await this.background.sequence();
+        this.authorizer.authorizeRetention(bucket, Key, options);
+        const bypassed = this.authorizer.authorizeBypass(bucket, Key, BypassGovernanceRetention, options);
+        simS3LockedVersion(bucket, Key, VersionId).lock.applyRetention(SimS3ObjectRetention.parse(Retention), bypassed);
+        return { $metadata: {} };
+    }
+}

package/dist/service/s3/command/sim-s3-command.types.d.ts

@@ -16,6 +16,9 @@ export type { SimDeletePublicAccessBlockCommand, SimDeletePublicAccessBlockComma
 export type { SimDeleteBucketLifecycleCommand, SimDeleteBucketLifecycleCommandOutput, } from "./delete-bucket-lifecycle/delete-bucket-lifecycle.command.js";
 export type { SimGetBucketLifecycleConfigurationCommand, SimGetBucketLifecycleConfigurationCommandOutput, } from "./get-bucket-lifecycle-configuration/get-bucket-lifecycle-configuration.command.js";
 export type { SimPutBucketLifecycleConfigurationCommand, SimPutBucketLifecycleConfigurationCommandOutput, SimS3LifecycleConfiguration, SimS3LifecycleRule, } from "./put-bucket-lifecycle-configuration/put-bucket-lifecycle-configuration.command.js";
+export type { SimGetBucketVersioningCommand, SimGetBucketVersioningCommandOutput, } from "./get-bucket-versioning/get-bucket-versioning.command.js";
+export type { SimPutBucketVersioningCommand, SimPutBucketVersioningCommandOutput, } from "./put-bucket-versioning/put-bucket-versioning.command.js";
+export type { SimListObjectVersionsCommand, SimListObjectVersionsCommandOutput, SimS3DeleteMarkerSummary, SimS3ObjectVersionSummary, } from "./list-object-versions/list-object-versions.command.js";
 export type { SimGetBucketPolicyCommand, SimGetBucketPolicyCommandOutput, } from "./get-bucket-policy/get-bucket-policy.command.js";
 export type { SimGetBucketNotificationConfigurationCommand, SimGetBucketNotificationConfigurationCommandOutput, } from "./get-bucket-notification-configuration/get-bucket-notification-configuration.command.js";
 export type { SimGetObjectCommand, SimGetObjectCommandOutput, } from "./get-object/get-object.command.js";
@@ -34,3 +37,7 @@ export type { SimCreateMultipartUploadCommand, SimCreateMultipartUploadCommandOu
 export type { SimListMultipartUploadsCommand, SimListMultipartUploadsCommandOutput, SimMultipartUploadSummary, } from "./list-multipart-uploads/list-multipart-uploads.command.js";
 export type { SimListPartsCommand, SimListPartsCommandOutput, SimUploadPartSummary, } from "./list-parts/list-parts.command.js";
 export type { SimUploadPartCommand, SimUploadPartCommandOutput, } from "./upload-part/upload-part.command.js";
+export type { SimPutObjectLockConfigurationCommand, SimPutObjectLockConfigurationCommandInput, SimPutObjectLockConfigurationCommandOutput, } from "./put-object-lock-configuration/put-object-lock-configuration.command.js";
+export type { SimGetObjectLockConfigurationCommand, SimGetObjectLockConfigurationCommandInput, SimGetObjectLockConfigurationCommandOutput, } from "./get-object-lock-configuration/get-object-lock-configuration.command.js";
+export type { SimPutObjectRetentionCommand, SimPutObjectRetentionCommandInput, SimPutObjectRetentionCommandOutput, } from "./put-object-retention/put-object-retention.command.js";
+export type { SimPutObjectLegalHoldCommand, SimPutObjectLegalHoldCommandInput, SimPutObjectLegalHoldCommandOutput, } from "./put-object-legal-hold/put-object-legal-hold.command.js";

package/dist/service/s3/command/versioning/sim-s3-versioning-authorizer.d.ts

@@ -0,0 +1,35 @@
+import type { SimIamInterServiceAuthZ } from "../../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimS3Bucket } from "../../bucket/sim-s3-bucket.js";
+import type { SimS3RequestOptions } from "../sim-s3-request-options.js";
+interface SimS3VersioningAuthorizerProperties {
+    readonly iam: SimIamInterServiceAuthZ;
+}
+/**
+ * Applies IAM authorization to the S3 versioning commands.
+ *
+ * Three actions rather than two, because listing the versions is a read of the
+ * Objects rather than of the Bucket's configuration. s3:ListBucketVersions is
+ * the one a caller reading a version history needs, and it says nothing about
+ * whether that caller may see how the Bucket is configured.
+ */
+export declare class SimS3VersioningAuthorizer {
+    private static readonly readAction;
+    private static readonly writeAction;
+    private static readonly listAction;
+    private readonly iam;
+    constructor(properties: SimS3VersioningAuthorizerProperties);
+    /**
+     * Ensure the caller may read the Bucket's versioning configuration.
+     */
+    authorizeRead(bucket: SimS3Bucket, options?: SimS3RequestOptions): void;
+    /**
+     * Ensure the caller may change the Bucket's versioning configuration.
+     */
+    authorizeWrite(bucket: SimS3Bucket, options?: SimS3RequestOptions): void;
+    /**
+     * Ensure the caller may list the versions the Bucket holds.
+     */
+    authorizeList(bucket: SimS3Bucket, options?: SimS3RequestOptions): void;
+    private authorize;
+}
+export {};

package/dist/service/s3/command/versioning/sim-s3-versioning-authorizer.js

@@ -0,0 +1,57 @@
+import { SimIamAccessDenied } from "../../../iam/error/sim-iam.error.js";
+import { simS3BucketArn } from "../../bucket/sim-s3-bucket-arn.js";
+import { simS3BucketResourcePolicies } from "../authorize/sim-s3-bucket-resource-policies.js";
+import { simS3ConditionContext } from "../authorize/sim-s3-condition-context.js";
+/**
+ * Applies IAM authorization to the S3 versioning commands.
+ *
+ * Three actions rather than two, because listing the versions is a read of the
+ * Objects rather than of the Bucket's configuration. s3:ListBucketVersions is
+ * the one a caller reading a version history needs, and it says nothing about
+ * whether that caller may see how the Bucket is configured.
+ */
+export class SimS3VersioningAuthorizer {
+    static readAction = "s3:GetBucketVersioning";
+    static writeAction = "s3:PutBucketVersioning";
+    static listAction = "s3:ListBucketVersions";
+    iam;
+    constructor(properties) {
+        this.iam = properties.iam;
+    }
+    /**
+     * Ensure the caller may read the Bucket's versioning configuration.
+     */
+    authorizeRead(bucket, options) {
+        this.authorize(SimS3VersioningAuthorizer.readAction, bucket, options);
+    }
+    /**
+     * Ensure the caller may change the Bucket's versioning configuration.
+     */
+    authorizeWrite(bucket, options) {
+        this.authorize(SimS3VersioningAuthorizer.writeAction, bucket, options);
+    }
+    /**
+     * Ensure the caller may list the versions the Bucket holds.
+     */
+    authorizeList(bucket, options) {
+        this.authorize(SimS3VersioningAuthorizer.listAction, bucket, options);
+    }
+    authorize(action, bucket, options) {
+        const resource = simS3BucketArn(bucket.bucketName);
+        const decision = this.iam.authorize({
+            action,
+            resource,
+            caller: options?.caller,
+            conditionContext: simS3ConditionContext(options),
+            resourcePolicies: simS3BucketResourcePolicies(bucket),
+        });
+        if (decision.isDenied) {
+            throw new SimIamAccessDenied({
+                principal: decision.caller.principal,
+                reason: decision.denialReason,
+                action,
+                resource,
+            });
+        }
+    }
+}

package/dist/service/s3/command/versioning/sim-s3-versioning-commands.d.ts

@@ -0,0 +1,26 @@
+import type { SimS3BucketCommandState } from "../sim-s3-bucket-command-state.js";
+import type * as simS3Commands from "../sim-s3-command.types.js";
+import type { SimS3RequestOptions } from "../sim-s3-request-options.js";
+/**
+ * The versioning commands of one simulated S3 scope.
+ *
+ * Listing the versions belongs here rather than with the Object listings,
+ * because what it reports is the version history rather than the keys a Bucket
+ * currently holds, and it is governed by its own IAM action.
+ */
+export declare class SimS3VersioningCommands {
+    private readonly state;
+    constructor(state: SimS3BucketCommandState);
+    /**
+     * Apply a Bucket's versioning configuration.
+     */
+    put(command: simS3Commands.SimPutBucketVersioningCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutBucketVersioningCommandOutput>;
+    /**
+     * Read how a Bucket is versioned.
+     */
+    get(command: simS3Commands.SimGetBucketVersioningCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetBucketVersioningCommandOutput>;
+    /**
+     * List the versions a Bucket holds.
+     */
+    list(command: simS3Commands.SimListObjectVersionsCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimListObjectVersionsCommandOutput>;
+}

package/dist/service/s3/command/versioning/sim-s3-versioning-commands.js

@@ -0,0 +1,34 @@
+import { GetBucketVersioningCommandHandler } from "../get-bucket-versioning/get-bucket-versioning.handler.js";
+import { ListObjectVersionsCommandHandler } from "../list-object-versions/list-object-versions.handler.js";
+import { PutBucketVersioningCommandHandler } from "../put-bucket-versioning/put-bucket-versioning.handler.js";
+/**
+ * The versioning commands of one simulated S3 scope.
+ *
+ * Listing the versions belongs here rather than with the Object listings,
+ * because what it reports is the version history rather than the keys a Bucket
+ * currently holds, and it is governed by its own IAM action.
+ */
+export class SimS3VersioningCommands {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    /**
+     * Apply a Bucket's versioning configuration.
+     */
+    async put(command, options) {
+        return await new PutBucketVersioningCommandHandler(this.state).handle(command, options);
+    }
+    /**
+     * Read how a Bucket is versioned.
+     */
+    async get(command, options) {
+        return await new GetBucketVersioningCommandHandler(this.state).handle(command, options);
+    }
+    /**
+     * List the versions a Bucket holds.
+     */
+    async list(command, options) {
+        return await new ListObjectVersionsCommandHandler(this.state).handle(command, options);
+    }
+}