@kensio/yulin 1.20.17 → 1.21.1

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

@@ -0,0 +1,31 @@
+import type { SimS3Bucket } from "../../bucket/sim-s3-bucket.js";
+import { SimS3ObjectVersion } from "../../bucket/versioning/sim-s3-object-version.js";
+import type { SimS3DeleteMarkerSummary, SimS3ObjectVersionSummary } from "./list-object-versions.command.js";
+/**
+ * The versions a listing reports, and how it describes each of them.
+ *
+ * A Bucket that keeps no versions still answers this operation. Real S3 gives
+ * every Object in one the null version id and marks it latest, so the listing
+ * of an unversioned Bucket reads as a version history one entry deep rather
+ * than as an error or an empty response.
+ */
+export declare class ListObjectVersionsListing {
+    private readonly bucket;
+    constructor(bucket: SimS3Bucket);
+    /**
+     * Every version under a prefix, in the order a listing reports them.
+     */
+    versions(prefix?: string): Promise<readonly SimS3ObjectVersion[]>;
+    /**
+     * Describe the Objects among a page of versions.
+     */
+    objectSummaries(page: readonly SimS3ObjectVersion[]): readonly SimS3ObjectVersionSummary[];
+    /**
+     * Describe the delete markers among a page of versions.
+     */
+    deleteMarkerSummaries(page: readonly SimS3ObjectVersion[]): readonly SimS3DeleteMarkerSummary[];
+    /**
+     * Whether a version is the one a read of its key answers with.
+     */
+    private isLatest;
+}

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

@@ -0,0 +1,55 @@
+import { compareSimS3Keys } from "../../bucket/versioning/sim-s3-compare-keys.js";
+import { SimS3ObjectVersion } from "../../bucket/versioning/sim-s3-object-version.js";
+import { simS3DeleteMarkerSummaries, simS3ObjectVersionSummaries, } from "./list-object-versions-summaries.js";
+/**
+ * The versions a listing reports, and how it describes each of them.
+ *
+ * A Bucket that keeps no versions still answers this operation. Real S3 gives
+ * every Object in one the null version id and marks it latest, so the listing
+ * of an unversioned Bucket reads as a version history one entry deep rather
+ * than as an error or an empty response.
+ */
+export class ListObjectVersionsListing {
+    bucket;
+    constructor(bucket) {
+        this.bucket = bucket;
+    }
+    /**
+     * Every version under a prefix, in the order a listing reports them.
+     */
+    async versions(prefix) {
+        // Read the Objects first either way. That is what applies the lifecycle
+        // rules, and on a versioned Bucket it writes the delete marker an expiry
+        // leaves behind. Reading the history without it would report a version the
+        // rules have already expired as the current one.
+        const objects = await this.bucket.listObjects(prefix);
+        if (this.bucket.getVersions().keepsVersions) {
+            return this.bucket.getVersions().list(prefix);
+        }
+        return objects
+            .toSorted((left, right) => compareSimS3Keys(left.key, right.key))
+            .map((object) => SimS3ObjectVersion.nullVersionOf(object));
+    }
+    /**
+     * Describe the Objects among a page of versions.
+     */
+    objectSummaries(page) {
+        return simS3ObjectVersionSummaries(page, (version) => this.isLatest(version));
+    }
+    /**
+     * Describe the delete markers among a page of versions.
+     */
+    deleteMarkerSummaries(page) {
+        return simS3DeleteMarkerSummaries(page, (version) => this.isLatest(version));
+    }
+    /**
+     * Whether a version is the one a read of its key answers with.
+     */
+    isLatest(version) {
+        const versions = this.bucket.getVersions();
+        if (!versions.keepsVersions) {
+            return true;
+        }
+        return versions.current(version.key)?.versionId === version.versionId;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { SimS3ObjectVersion } from "../../bucket/versioning/sim-s3-object-version.js";
+import type { SimS3DeleteMarkerSummary, SimS3ObjectVersionSummary } from "./list-object-versions.command.js";
+/**
+ * Whether a version is the one a read of its key answers with.
+ */
+export type SimS3IsLatestVersion = (version: SimS3ObjectVersion) => boolean;
+/**
+ * Describe the Objects among a page of versions.
+ */
+export declare function simS3ObjectVersionSummaries(page: readonly SimS3ObjectVersion[], isLatest: SimS3IsLatestVersion): readonly SimS3ObjectVersionSummary[];
+/**
+ * Describe the delete markers among a page of versions.
+ *
+ * A marker holds no bytes, so it carries neither a size nor an ETag, which is
+ * why real S3 sends the two kinds in separate lists.
+ */
+export declare function simS3DeleteMarkerSummaries(page: readonly SimS3ObjectVersion[], isLatest: SimS3IsLatestVersion): readonly SimS3DeleteMarkerSummary[];

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

@@ -0,0 +1,34 @@
+import { simS3QuotedETag } from "../../object/s3-object-etag.js";
+import { simS3DefaultStorageClass } from "../../object/s3-object-summary.js";
+/**
+ * Describe the Objects among a page of versions.
+ */
+export function simS3ObjectVersionSummaries(page, isLatest) {
+    return page
+        .filter((version) => !version.isDeleteMarker)
+        .map((version) => ({
+        Key: version.key,
+        VersionId: version.versionId,
+        IsLatest: isLatest(version),
+        LastModified: version.lastModified,
+        ETag: simS3QuotedETag(version.object.etag),
+        Size: version.object.body.length,
+        StorageClass: simS3DefaultStorageClass,
+    }));
+}
+/**
+ * Describe the delete markers among a page of versions.
+ *
+ * A marker holds no bytes, so it carries neither a size nor an ETag, which is
+ * why real S3 sends the two kinds in separate lists.
+ */
+export function simS3DeleteMarkerSummaries(page, isLatest) {
+    return page
+        .filter((version) => version.isDeleteMarker)
+        .map((version) => ({
+        Key: version.key,
+        VersionId: version.versionId,
+        IsLatest: isLatest(version),
+        LastModified: version.lastModified,
+    }));
+}

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