@kensio/yulin 1.21.0 → 1.21.2

package/dist/service/s3/command/list-object-versions/list-object-versions.command.d.ts

@@ -0,0 +1,59 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+/**
+ * Minimal structural sim S3 ListObjectVersions command.
+ */
+export interface SimListObjectVersionsCommand {
+    readonly input: SimListObjectVersionsCommandInput;
+}
+/**
+ * Minimal structural sim S3 ListObjectVersions input.
+ */
+export interface SimListObjectVersionsCommandInput {
+    readonly Bucket?: string | undefined;
+    readonly Prefix?: string | undefined;
+    readonly MaxKeys?: number | undefined;
+    /** The key the previous page ended on, resumed after rather than at. */
+    readonly KeyMarker?: string | undefined;
+    /** The version the previous page ended on, within `KeyMarker`. */
+    readonly VersionIdMarker?: string | undefined;
+}
+/**
+ * Minimal structural sim S3 ListObjectVersions output.
+ *
+ * Objects and delete markers come back in two lists rather than one, as real
+ * S3 sends them, because a marker holds no size or ETag to describe.
+ */
+export interface SimListObjectVersionsCommandOutput {
+    readonly Versions?: readonly SimS3ObjectVersionSummary[];
+    readonly DeleteMarkers?: readonly SimS3DeleteMarkerSummary[];
+    readonly Name?: string;
+    readonly Prefix?: string | undefined;
+    readonly MaxKeys?: number;
+    readonly IsTruncated?: boolean;
+    readonly KeyMarker?: string | undefined;
+    readonly VersionIdMarker?: string | undefined;
+    readonly NextKeyMarker?: string | undefined;
+    readonly NextVersionIdMarker?: string | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * One version of an Object, as a listing describes it.
+ */
+export interface SimS3ObjectVersionSummary {
+    readonly Key: string;
+    readonly VersionId: string;
+    readonly IsLatest: boolean;
+    readonly LastModified: Date;
+    readonly ETag: string;
+    readonly Size: number;
+    readonly StorageClass: string;
+}
+/**
+ * One delete marker, as a listing describes it.
+ */
+export interface SimS3DeleteMarkerSummary {
+    readonly Key: string;
+    readonly VersionId: string;
+    readonly IsLatest: boolean;
+    readonly LastModified: Date;
+}

package/dist/service/s3/command/list-object-versions/list-object-versions.command.js

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

package/dist/service/s3/command/list-object-versions/list-object-versions.handler.d.ts

@@ -0,0 +1,34 @@
+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 { SimS3ObjectListingLimits } from "../../object/s3-object-listing-limits.js";
+import type { SimS3RequestOptions } from "../sim-s3-request-options.js";
+import type { SimListObjectVersionsCommand, SimListObjectVersionsCommandOutput } from "./list-object-versions.command.js";
+interface ListObjectVersionsHandlerProperties {
+    readonly buckets: Map<SimS3BucketName, SimS3Bucket>;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+    readonly listing?: SimS3ObjectListingLimits;
+}
+/**
+ * Simulated S3 ListObjectVersionsCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/ListObjectVersionsCommand/
+ */
+export declare class ListObjectVersionsCommandHandler implements CommandHandler<SimListObjectVersionsCommand, SimListObjectVersionsCommandOutput> {
+    private readonly buckets;
+    private readonly authorizer;
+    private readonly background;
+    private readonly limits;
+    constructor(properties: ListObjectVersionsHandlerProperties);
+    /**
+     * Authorize and report the versions a Bucket holds.
+     *
+     * Objects and delete markers come back in two lists, as real S3 sends them.
+     * Both are paged together, so a page carrying the maximum number of entries
+     * can hold some of each.
+     */
+    handle(command: SimListObjectVersionsCommand, options?: SimS3RequestOptions): Promise<SimListObjectVersionsCommandOutput>;
+}
+export {};

package/dist/service/s3/command/list-object-versions/list-object-versions.handler.js

@@ -0,0 +1,62 @@
+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 { simS3VersionPage } from "../../bucket/versioning/sim-s3-version-page.js";
+import { simS3EffectiveMaxKeys } from "../../object/s3-object-listing.js";
+import { SimS3ObjectListingLimits } from "../../object/s3-object-listing-limits.js";
+import { requireSimS3Bucket } from "../require-sim-s3-bucket.js";
+import { SimS3VersioningAuthorizer } from "../versioning/sim-s3-versioning-authorizer.js";
+import { ListObjectVersionsListing } from "./list-object-versions-listing.js";
+/**
+ * Simulated S3 ListObjectVersionsCommand handler.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/ListObjectVersionsCommand/
+ */
+export class ListObjectVersionsCommandHandler {
+    buckets;
+    authorizer;
+    background;
+    limits;
+    constructor(properties) {
+        const { buckets, iam = new SimIamAllowAllAuth(), background = new BackgroundTasks(), listing = new SimS3ObjectListingLimits(), } = properties;
+        this.buckets = buckets;
+        this.authorizer = new SimS3VersioningAuthorizer({ iam });
+        this.background = background;
+        this.limits = listing;
+    }
+    /**
+     * Authorize and report the versions a Bucket holds.
+     *
+     * Objects and delete markers come back in two lists, as real S3 sends them.
+     * Both are paged together, so a page carrying the maximum number of entries
+     * can hold some of each.
+     */
+    async handle(command, options) {
+        assertDefined(command.input.Bucket, "ListObjectVersionsCommand.input.Bucket");
+        const bucketName = command.input.Bucket;
+        const bucket = requireSimS3Bucket(this.buckets, bucketName);
+        await this.background.sequence();
+        this.authorizer.authorizeList(bucket, options);
+        const listing = new ListObjectVersionsListing(bucket);
+        const maxKeys = simS3EffectiveMaxKeys(command.input.MaxKeys, this.limits.maxKeysPerPage);
+        const page = simS3VersionPage({
+            versions: await listing.versions(command.input.Prefix),
+            maxKeys,
+            keyMarker: command.input.KeyMarker,
+            versionIdMarker: command.input.VersionIdMarker,
+        });
+        return {
+            Versions: listing.objectSummaries(page.versions),
+            DeleteMarkers: listing.deleteMarkerSummaries(page.versions),
+            Name: bucketName,
+            Prefix: command.input.Prefix,
+            MaxKeys: maxKeys,
+            IsTruncated: page.isTruncated,
+            KeyMarker: command.input.KeyMarker,
+            VersionIdMarker: command.input.VersionIdMarker,
+            NextKeyMarker: page.nextKeyMarker,
+            NextVersionIdMarker: page.nextVersionIdMarker,
+            $metadata: {},
+        };
+    }
+}

package/dist/service/s3/command/object/sim-s3-read-object-version.d.ts

@@ -0,0 +1,34 @@
+import type { SimS3Bucket } from "../../bucket/sim-s3-bucket.js";
+import type { SimS3ObjectLock } from "../../bucket/lock/sim-s3-object-lock.js";
+import type { SimS3Object } from "../../object/s3-object.js";
+/**
+ * An Object a read resolved, and the version it came from.
+ *
+ * The version id travels with the Object because every read reports it, and a
+ * Bucket without versioning has none to report.
+ */
+export interface SimS3ReadObjectVersion {
+    readonly object: SimS3Object;
+    readonly versionId: string | undefined;
+    /**
+     * What Object Lock holds against the version read.
+     *
+     * A Bucket keeping no versions has none, and a Bucket that keeps them but
+     * has never been locked has an empty one. Both report nothing.
+     */
+    readonly lock: SimS3ObjectLock | undefined;
+}
+/**
+ * Read one version of a key, or the current one where no version was named.
+ *
+ * A read without a `VersionId` goes through the Bucket, which is what applies
+ * lifecycle rules and what hides an Object behind a delete marker. A read that
+ * names one goes to the version history instead, so an Object under a marker
+ * is still readable by its own id.
+ *
+ * Answering `undefined` means the key holds nothing to read, which each caller
+ * turns into the error its own command answers with. A named version that was
+ * never issued is a different thing and is raised here, because NoSuchVersion
+ * is what real S3 answers rather than the missing-key error.
+ */
+export declare function simS3ReadObjectVersion(bucket: SimS3Bucket, key: string, versionId?: string): Promise<SimS3ReadObjectVersion | undefined>;

package/dist/service/s3/command/object/sim-s3-read-object-version.js

@@ -0,0 +1,52 @@
+import { simS3NullVersionId } from "../../bucket/versioning/sim-s3-bucket-versioning.js";
+import { SimS3MethodNotAllowed, SimS3NoSuchVersion, } from "../../error/sim-s3.error.js";
+/**
+ * Read one version of a key, or the current one where no version was named.
+ *
+ * A read without a `VersionId` goes through the Bucket, which is what applies
+ * lifecycle rules and what hides an Object behind a delete marker. A read that
+ * names one goes to the version history instead, so an Object under a marker
+ * is still readable by its own id.
+ *
+ * Answering `undefined` means the key holds nothing to read, which each caller
+ * turns into the error its own command answers with. A named version that was
+ * never issued is a different thing and is raised here, because NoSuchVersion
+ * is what real S3 answers rather than the missing-key error.
+ */
+export async function simS3ReadObjectVersion(bucket, key, versionId) {
+    const versions = bucket.getVersions();
+    if (versionId === undefined) {
+        const object = await bucket.getObject(key);
+        if (object === undefined) {
+            return undefined;
+        }
+        const current = versions.current(key);
+        return { object, versionId: current?.versionId, lock: current?.lock };
+    }
+    if (!versions.keepsVersions) {
+        return await simS3ReadUnversioned(bucket, key, versionId);
+    }
+    const version = versions.find(key, versionId);
+    if (version === undefined) {
+        throw new SimS3NoSuchVersion(`No version ${versionId} of S3 Object ${key}`);
+    }
+    if (version.isDeleteMarker) {
+        throw new SimS3MethodNotAllowed(`Version ${versionId} of S3 Object ${key} is a delete marker`);
+    }
+    return { object: version.object, versionId, lock: version.lock };
+}
+/**
+ * Read a named version from a Bucket that keeps none.
+ *
+ * Real S3 gives every Object in such a Bucket the null version id, so that one
+ * reads the Object and any other names a version the Bucket never issued.
+ */
+async function simS3ReadUnversioned(bucket, key, versionId) {
+    if (versionId !== simS3NullVersionId) {
+        throw new SimS3NoSuchVersion(`No version ${versionId} of S3 Object ${key}`);
+    }
+    const object = await bucket.getObject(key);
+    return object === undefined
+        ? undefined
+        : { object, versionId: undefined, lock: undefined };
+}

package/dist/service/s3/command/object-lock/sim-s3-locked-version.d.ts

@@ -0,0 +1,11 @@
+import type { SimS3Bucket } from "../../bucket/sim-s3-bucket.js";
+import type { SimS3ObjectVersion } from "../../bucket/versioning/sim-s3-object-version.js";
+/**
+ * The version a retention or a legal hold is being put on.
+ *
+ * A request naming no version acts on the current one, which is what real S3
+ * does. A Bucket without Object Lock has no version to put either on, and
+ * refusing there is what stops a test believing a retention it set is holding
+ * anything.
+ */
+export declare function simS3LockedVersion(bucket: SimS3Bucket, key: string, versionId: string | undefined): SimS3ObjectVersion;

package/dist/service/s3/command/object-lock/sim-s3-locked-version.js

@@ -0,0 +1,27 @@
+import { SimS3InvalidRequest, SimS3MethodNotAllowed, SimS3NoSuchKey, SimS3NoSuchVersion, } from "../../error/sim-s3.error.js";
+/**
+ * The version a retention or a legal hold is being put on.
+ *
+ * A request naming no version acts on the current one, which is what real S3
+ * does. A Bucket without Object Lock has no version to put either on, and
+ * refusing there is what stops a test believing a retention it set is holding
+ * anything.
+ */
+export function simS3LockedVersion(bucket, key, versionId) {
+    if (!bucket.getObjectLock().isEnabled) {
+        throw new SimS3InvalidRequest(`Bucket ${bucket.bucketName} does not have Object Lock enabled`);
+    }
+    const versions = bucket.getVersions();
+    const version = versionId === undefined
+        ? versions.current(key)
+        : versions.find(key, versionId);
+    if (version === undefined) {
+        throw versionId === undefined
+            ? new SimS3NoSuchKey(`No S3 Object named ${key}`)
+            : new SimS3NoSuchVersion(`No version ${versionId} of S3 Object ${key}`);
+    }
+    if (version.isDeleteMarker) {
+        throw new SimS3MethodNotAllowed(`Version ${version.versionId} of S3 Object ${key} is a delete marker`);
+    }
+    return version;
+}

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

@@ -0,0 +1,42 @@
+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";
+/** The IAM action a caller needs to get past a governance retention period. */
+export declare const simS3BypassGovernanceAction = "s3:BypassGovernanceRetention";
+interface SimS3ObjectLockAuthorizerProperties {
+    readonly iam: SimIamInterServiceAuthZ;
+}
+/**
+ * Applies IAM authorization to the S3 Object Lock commands.
+ *
+ * The two Bucket configuration actions are authorized against the Bucket ARN
+ * and the two version actions against the Object ARN, which is how real S3
+ * splits them: a policy can let a caller retain the Objects under one prefix
+ * without letting it configure the Bucket they are in.
+ *
+ * `s3:BypassGovernanceRetention` is authorized separately from the request it
+ * accompanies. A caller deleting a retained version needs both that and
+ * `s3:DeleteObject`, and real S3 checks them as two decisions.
+ */
+export declare class SimS3ObjectLockAuthorizer {
+    private readonly iam;
+    constructor(properties: SimS3ObjectLockAuthorizerProperties);
+    /** Ensure the caller may read how the Bucket is locked. */
+    authorizeReadConfiguration(bucket: SimS3Bucket, options?: SimS3RequestOptions): void;
+    /** Ensure the caller may change how the Bucket is locked. */
+    authorizeWriteConfiguration(bucket: SimS3Bucket, options?: SimS3RequestOptions): void;
+    /** Ensure the caller may put a retention period on a version. */
+    authorizeRetention(bucket: SimS3Bucket, key: string, options?: SimS3RequestOptions): void;
+    /** Ensure the caller may put a legal hold on a version. */
+    authorizeLegalHold(bucket: SimS3Bucket, key: string, options?: SimS3RequestOptions): void;
+    /**
+     * Ensure the caller may get past a governance retention period, where the
+     * request asked to.
+     *
+     * A request that asked for nothing is answered without a decision, so a
+     * caller who never needed the permission is never refused for lacking it.
+     */
+    authorizeBypass(bucket: SimS3Bucket, key: string, asked: boolean | undefined, options?: SimS3RequestOptions): boolean;
+    private authorize;
+}
+export {};

package/dist/service/s3/command/object-lock/sim-s3-object-lock-authorizer.js

@@ -0,0 +1,66 @@
+import { simS3BucketArn } from "../../bucket/sim-s3-bucket-arn.js";
+import { simS3AuthorizeAction } from "../authorize/sim-s3-authorize-action.js";
+/** The IAM action a caller needs to get past a governance retention period. */
+export const simS3BypassGovernanceAction = "s3:BypassGovernanceRetention";
+const readConfiguration = "s3:GetBucketObjectLockConfiguration";
+const writeConfiguration = "s3:PutBucketObjectLockConfiguration";
+const putRetention = "s3:PutObjectRetention";
+const putLegalHold = "s3:PutObjectLegalHold";
+/**
+ * Applies IAM authorization to the S3 Object Lock commands.
+ *
+ * The two Bucket configuration actions are authorized against the Bucket ARN
+ * and the two version actions against the Object ARN, which is how real S3
+ * splits them: a policy can let a caller retain the Objects under one prefix
+ * without letting it configure the Bucket they are in.
+ *
+ * `s3:BypassGovernanceRetention` is authorized separately from the request it
+ * accompanies. A caller deleting a retained version needs both that and
+ * `s3:DeleteObject`, and real S3 checks them as two decisions.
+ */
+export class SimS3ObjectLockAuthorizer {
+    iam;
+    constructor(properties) {
+        this.iam = properties.iam;
+    }
+    /** Ensure the caller may read how the Bucket is locked. */
+    authorizeReadConfiguration(bucket, options) {
+        this.authorize(readConfiguration, bucketArn(bucket), bucket, options);
+    }
+    /** Ensure the caller may change how the Bucket is locked. */
+    authorizeWriteConfiguration(bucket, options) {
+        this.authorize(writeConfiguration, bucketArn(bucket), bucket, options);
+    }
+    /** Ensure the caller may put a retention period on a version. */
+    authorizeRetention(bucket, key, options) {
+        this.authorize(putRetention, objectArn(bucket, key), bucket, options);
+    }
+    /** Ensure the caller may put a legal hold on a version. */
+    authorizeLegalHold(bucket, key, options) {
+        this.authorize(putLegalHold, objectArn(bucket, key), bucket, options);
+    }
+    /**
+     * Ensure the caller may get past a governance retention period, where the
+     * request asked to.
+     *
+     * A request that asked for nothing is answered without a decision, so a
+     * caller who never needed the permission is never refused for lacking it.
+     */
+    authorizeBypass(bucket, key, asked, options) {
+        if (asked !== true) {
+            return false;
+        }
+        const action = simS3BypassGovernanceAction;
+        this.authorize(action, objectArn(bucket, key), bucket, options);
+        return true;
+    }
+    authorize(action, resource, bucket, options) {
+        simS3AuthorizeAction({ iam: this.iam, action, resource, bucket, options });
+    }
+}
+function bucketArn(bucket) {
+    return simS3BucketArn(bucket.bucketName);
+}
+function objectArn(bucket, key) {
+    return `${bucketArn(bucket)}/${key}`;
+}

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

@@ -0,0 +1,30 @@
+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 Object Lock commands of one simulated S3 scope.
+ *
+ * Two of them configure a Bucket and two of them hold one version of one
+ * Object, and they are kept together because a version can only be held on a
+ * Bucket the first two turned Object Lock on for.
+ */
+export declare class SimS3ObjectLockCommands {
+    private readonly state;
+    constructor(state: SimS3BucketCommandState);
+    /**
+     * Turn Object Lock on for a Bucket, with the default retention it carries.
+     */
+    putConfiguration(command: simS3Commands.SimPutObjectLockConfigurationCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectLockConfigurationCommandOutput>;
+    /**
+     * Read how a Bucket is locked.
+     */
+    getConfiguration(command: simS3Commands.SimGetObjectLockConfigurationCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetObjectLockConfigurationCommandOutput>;
+    /**
+     * Put a retention period on one version.
+     */
+    putRetention(command: simS3Commands.SimPutObjectRetentionCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectRetentionCommandOutput>;
+    /**
+     * Turn the legal hold on one version on or off.
+     */
+    putLegalHold(command: simS3Commands.SimPutObjectLegalHoldCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectLegalHoldCommandOutput>;
+}

package/dist/service/s3/command/object-lock/sim-s3-object-lock-commands.js

@@ -0,0 +1,41 @@
+import { GetObjectLockConfigurationCommandHandler } from "../get-object-lock-configuration/get-object-lock-configuration.handler.js";
+import { PutObjectLegalHoldCommandHandler } from "../put-object-legal-hold/put-object-legal-hold.handler.js";
+import { PutObjectLockConfigurationCommandHandler } from "../put-object-lock-configuration/put-object-lock-configuration.handler.js";
+import { PutObjectRetentionCommandHandler } from "../put-object-retention/put-object-retention.handler.js";
+/**
+ * The Object Lock commands of one simulated S3 scope.
+ *
+ * Two of them configure a Bucket and two of them hold one version of one
+ * Object, and they are kept together because a version can only be held on a
+ * Bucket the first two turned Object Lock on for.
+ */
+export class SimS3ObjectLockCommands {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    /**
+     * Turn Object Lock on for a Bucket, with the default retention it carries.
+     */
+    async putConfiguration(command, options) {
+        return await new PutObjectLockConfigurationCommandHandler(this.state).handle(command, options);
+    }
+    /**
+     * Read how a Bucket is locked.
+     */
+    async getConfiguration(command, options) {
+        return await new GetObjectLockConfigurationCommandHandler(this.state).handle(command, options);
+    }
+    /**
+     * Put a retention period on one version.
+     */
+    async putRetention(command, options) {
+        return await new PutObjectRetentionCommandHandler(this.state).handle(command, options);
+    }
+    /**
+     * Turn the legal hold on one version on or off.
+     */
+    async putLegalHold(command, options) {
+        return await new PutObjectLegalHoldCommandHandler(this.state).handle(command, options);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimS3VersioningConfiguration } from "../../bucket/versioning/sim-s3-bucket-versioning.js";
+/**
+ * Minimal structural sim S3 PutBucketVersioning command.
+ */
+export interface SimPutBucketVersioningCommand {
+    readonly input: SimPutBucketVersioningCommandInput;
+}
+/**
+ * Minimal structural sim S3 PutBucketVersioning input.
+ */
+export interface SimPutBucketVersioningCommandInput {
+    readonly Bucket?: string | undefined;
+    readonly VersioningConfiguration?: SimS3VersioningConfiguration | undefined;
+}
+/**
+ * Minimal structural sim S3 PutBucketVersioning output.
+ */
+export interface SimPutBucketVersioningCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}

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

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

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: {},
         };
     }