@kensio/yulin 1.21.0 → 1.21.2

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

@@ -2,6 +2,11 @@ import type { Brand } from "../../../util/brand.type.js";
 import { type SimClock } from "../../../util/clock/sim-clock.js";
 import type { SimS3BucketStorage } from "../storage/s3-bucket-storage.js";
 import type { SimS3Object } from "../object/s3-object.js";
+import type { SimS3ObjectDeletion } from "./sim-s3-object-deletion.js";
+import type { SimS3BucketObjectLock } from "./lock/sim-s3-bucket-object-lock.js";
+import type { SimS3BucketVersioning } from "./versioning/sim-s3-bucket-versioning.js";
+import type { SimS3BucketVersions } from "./versioning/sim-s3-bucket-versions.js";
+import type { SimS3ObjectVersion } from "./versioning/sim-s3-object-version.js";
 import { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
 import { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
 import { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
@@ -9,7 +14,7 @@ import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-config
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimIamPolicyDocument } from "../../iam/policy/sim-iam-policy.js";
 import { SimS3BucketSystemMetadata } from "./sim-s3-bucket-system-metadata.js";
-import { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
+import type { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
 export type SimS3BucketName = Brand<string, "SimS3BucketName">;
 interface SimS3BucketProperties {
     readonly bucketName: SimS3BucketName | string;
@@ -41,47 +46,45 @@ export declare class SimS3Bucket {
     readonly bucketName: SimS3BucketName;
     readonly creationDate: Date;
     private readonly accountRegionScope;
-    private readonly clock;
     private readonly systemMetadata;
-    private readonly multipartUploads;
-    private storage;
+    private readonly objects;
     private website;
     private policy;
     private publicAccessBlock;
     private notifications;
-    private lifecycle;
     constructor(properties: SimS3BucketProperties);
+    /** Put an Object into storage, answering the version it was given, if any. */
+    putObject(object: SimS3Object): Promise<SimS3ObjectVersion | undefined>;
+    /** Get a simulated S3 Object from storage. */
+    getObject(key: string): Promise<SimS3Object | undefined>;
+    /** List simulated S3 Objects from storage. */
+    listObjects(prefix?: string): Promise<SimS3Object[]>;
     /**
-     * Put a simulated S3 Object into storage.
-     */
-    putObject(object: SimS3Object): Promise<void>;
-    /**
-     * Get a simulated S3 Object from storage.
+     * Delete a key, answering what that did to the Bucket.
      *
-     * An Object a lifecycle rule has expired goes on the way past. Every read of
-     * it then finds the key empty.
+     * Real S3 DeleteObject is idempotent, so a key that was not there is not an
+     * error. What happened is still reported, because the event notification a
+     * deletion raises depends on it.
      */
-    getObject(key: string): Promise<SimS3Object | undefined>;
+    deleteObject(key: string): Promise<SimS3ObjectDeletion>;
     /**
-     * List simulated S3 Objects from storage.
+     * Remove one version of a key permanently, answering the version that went.
+     *
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back. Object Lock
+     * refuses the removal of a version it is holding.
      */
-    listObjects(prefix?: string): Promise<SimS3Object[]>;
+    deleteObjectVersion(key: string, versionId: string, bypassGovernance?: boolean): Promise<SimS3ObjectVersion | undefined>;
+    /** The versions this Bucket keeps, and whether it keeps any. */
+    getVersions(): SimS3BucketVersions;
+    /** How this Bucket is locked, and what that does to a write and a delete. */
+    getObjectLock(): SimS3BucketObjectLock;
     /**
-     * Remove a simulated S3 Object from storage.
-     *
-     * Real S3 DeleteObject is idempotent, so a key that was not there is not an
-     * error. Whether there was an Object to remove is still reported, because a
-     * deletion that removed nothing is not an event: real S3 raises
-     * `s3:ObjectRemoved:Delete` when an Object was deleted, not when a deletion
-     * was requested.
+     * Apply a versioning configuration to this Bucket.
      */
-    deleteObject(key: string): Promise<boolean>;
+    configureVersioning(versioning: SimS3BucketVersioning): Promise<void>;
     /**
      * The multipart uploads this Bucket has in progress.
-     *
-     * Kept apart from storage because the parts of an unfinished upload are not
-     * Objects: nothing that lists or reads a Bucket can see them, and only
-     * completing the upload puts anything under a key.
      */
     getMultipartUploads(): SimS3MultipartUploads;
     /**
@@ -172,7 +175,5 @@ export declare class SimS3Bucket {
      * Get the simulated S3 static website URL for this Bucket.
      */
     getWebsiteUrl(): URL;
-    /** What this Bucket's rules have expired, as they stand at this moment. */
-    private sweep;
 }
 export {};

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

@@ -1,15 +1,14 @@
 import { SimRealClock } from "../../../util/clock/sim-clock.js";
 import { MemoryS3BucketStorage } from "../storage/s3-memory-storage.js";
+import { SimS3BucketObjects } from "./sim-s3-bucket-objects.js";
 import { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
 import { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
 import { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
 import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-configuration.js";
-import { SimS3LifecycleSweep } from "./lifecycle/sim-s3-lifecycle-sweep.js";
 import { simS3BucketWebsiteUrl } from "./website/sim-s3-bucket-website-url.js";
 import { validateS3BucketName } from "./validate/validate-s3-bucket-name.js";
 import { simAwsAccountRegionScopeFactory } from "../../aws/sim-aws-account-region-scope.factory.js";
 import { SimS3BucketSystemMetadata } from "./sim-s3-bucket-system-metadata.js";
-import { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
 /**
  * Simulated S3 Bucket.
  */
@@ -17,79 +16,81 @@ export class SimS3Bucket {
     bucketName;
     creationDate;
     accountRegionScope;
-    clock;
     systemMetadata = new SimS3BucketSystemMetadata();
-    multipartUploads = new SimS3MultipartUploads();
-    storage;
+    objects;
     website;
     policy;
     publicAccessBlock;
     notifications;
-    lifecycle;
     constructor(properties) {
         const { bucketName, accountRegionScope = simAwsAccountRegionScopeFactory.make(), storage = new MemoryS3BucketStorage(), website = new SimS3BucketWebsite(), policy, publicAccessBlock = SimS3PublicAccessBlock.blockingAll(), notifications = SimS3NotificationConfiguration.empty(), lifecycle = SimS3LifecycleConfiguration.empty(), clock = new SimRealClock(), creationDate = clock.now(), } = properties;
         validateS3BucketName(bucketName);
         this.bucketName = bucketName;
         this.accountRegionScope = accountRegionScope;
-        this.clock = clock;
-        this.storage = storage;
+        this.objects = new SimS3BucketObjects({ storage, lifecycle, clock });
         this.website = website;
         this.policy = policy;
         this.publicAccessBlock = publicAccessBlock;
         this.notifications = notifications;
-        this.lifecycle = lifecycle;
         this.creationDate = creationDate;
     }
-    /**
-     * Put a simulated S3 Object into storage.
-     */
+    /** Put an Object into storage, answering the version it was given, if any. */
     async putObject(object) {
-        await this.storage.putObject(object);
+        return await this.objects.put(object);
     }
-    /**
-     * Get a simulated S3 Object from storage.
-     *
-     * An Object a lifecycle rule has expired goes on the way past. Every read of
-     * it then finds the key empty.
-     */
+    /** Get a simulated S3 Object from storage. */
     async getObject(key) {
-        return await this.sweep().object(await this.storage.getObject(key));
+        return await this.objects.get(key);
     }
-    /**
-     * List simulated S3 Objects from storage.
-     */
+    /** List simulated S3 Objects from storage. */
     async listObjects(prefix) {
-        return await this.sweep().objects(await this.storage.listObjects(prefix));
+        return await this.objects.list(prefix);
     }
     /**
-     * Remove a simulated S3 Object from storage.
+     * Delete a key, answering what that did to the Bucket.
      *
      * Real S3 DeleteObject is idempotent, so a key that was not there is not an
-     * error. Whether there was an Object to remove is still reported, because a
-     * deletion that removed nothing is not an event: real S3 raises
-     * `s3:ObjectRemoved:Delete` when an Object was deleted, not when a deletion
-     * was requested.
+     * error. What happened is still reported, because the event notification a
+     * deletion raises depends on it.
      */
     async deleteObject(key) {
-        return await this.storage.deleteObject(key);
+        return await this.objects.delete(key);
     }
     /**
-     * The multipart uploads this Bucket has in progress.
+     * Remove one version of a key permanently, answering the version that went.
      *
-     * Kept apart from storage because the parts of an unfinished upload are not
-     * Objects: nothing that lists or reads a Bucket can see them, and only
-     * completing the upload puts anything under a key.
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back. Object Lock
+     * refuses the removal of a version it is holding.
+     */
+    async deleteObjectVersion(key, versionId, bypassGovernance = false) {
+        return await this.objects.deleteVersion(key, versionId, bypassGovernance);
+    }
+    /** The versions this Bucket keeps, and whether it keeps any. */
+    getVersions() {
+        return this.objects.sweptVersions();
+    }
+    /** How this Bucket is locked, and what that does to a write and a delete. */
+    getObjectLock() {
+        return this.objects.objectLock;
+    }
+    /**
+     * Apply a versioning configuration to this Bucket.
+     */
+    async configureVersioning(versioning) {
+        await this.objects.configureVersioning(versioning);
+    }
+    /**
+     * The multipart uploads this Bucket has in progress.
      */
     getMultipartUploads() {
-        const now = this.clock.now();
-        this.multipartUploads.discardAbandoned((upload) => this.lifecycle.abandons(upload, now));
-        return this.multipartUploads;
+        return this.objects.multipartUploads();
     }
     /**
      * Change the storage implementation for this simulated S3 Bucket.
      */
     configureSimStorage(storage) {
-        this.storage = storage;
+        this.objects.configureStorage(storage);
     }
     /**
      * What this Bucket has been told about the Objects under its keys, beyond
@@ -178,13 +179,13 @@ export class SimS3Bucket {
      * this replaces what was there instead of adding to it.
      */
     configureLifecycle(lifecycle) {
-        this.lifecycle = lifecycle;
+        this.objects.configureLifecycle(lifecycle);
     }
     /**
      * Get this Bucket's lifecycle configuration.
      */
     getLifecycle() {
-        return this.lifecycle;
+        return this.objects.getLifecycle();
     }
     /**
      * Remove this Bucket's lifecycle configuration.
@@ -193,7 +194,7 @@ export class SimS3Bucket {
      * whether there were rules to remove.
      */
     deleteLifecycle() {
-        this.lifecycle = SimS3LifecycleConfiguration.empty();
+        this.objects.deleteLifecycle();
     }
     /**
      * Get the simulated AWS account Region scope for this Bucket.
@@ -207,8 +208,4 @@ export class SimS3Bucket {
     getWebsiteUrl() {
         return simS3BucketWebsiteUrl(this.bucketName, this.accountRegionScope, this.website);
     }
-    /** What this Bucket's rules have expired, as they stand at this moment. */
-    sweep() {
-        return new SimS3LifecycleSweep(this.storage, this.lifecycle, this.clock.now());
-    }
 }

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

@@ -0,0 +1,30 @@
+import type { SimS3ObjectVersion } from "./versioning/sim-s3-object-version.js";
+interface SimS3ObjectDeletionProperties {
+    readonly removedObject?: boolean;
+    readonly deleteMarker?: SimS3ObjectVersion | undefined;
+}
+/**
+ * What a delete did to a simulated S3 Bucket.
+ *
+ * The two outcomes are separate because the event notification they raise is.
+ * A Bucket without versioning loses the Object and raises
+ * `s3:ObjectRemoved:Delete`. A versioned Bucket keeps the Object and hides it
+ * behind a marker, which is `s3:ObjectRemoved:DeleteMarkerCreated`. A delete
+ * of a key that held nothing raises neither.
+ */
+export declare class SimS3ObjectDeletion {
+    readonly removedObject: boolean;
+    readonly deleteMarker: SimS3ObjectVersion | undefined;
+    constructor(properties?: SimS3ObjectDeletionProperties);
+    /**
+     * What a response says about this delete.
+     *
+     * A versioned Bucket reports the marker it wrote and the id it wrote it
+     * under. A Bucket without versioning reports neither, as real S3 does.
+     */
+    get reported(): {
+        readonly DeleteMarker?: boolean;
+        readonly VersionId?: string;
+    };
+}
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * What a delete did to a simulated S3 Bucket.
+ *
+ * The two outcomes are separate because the event notification they raise is.
+ * A Bucket without versioning loses the Object and raises
+ * `s3:ObjectRemoved:Delete`. A versioned Bucket keeps the Object and hides it
+ * behind a marker, which is `s3:ObjectRemoved:DeleteMarkerCreated`. A delete
+ * of a key that held nothing raises neither.
+ */
+export class SimS3ObjectDeletion {
+    removedObject;
+    deleteMarker;
+    constructor(properties = {}) {
+        this.removedObject = properties.removedObject ?? false;
+        this.deleteMarker = properties.deleteMarker;
+    }
+    /**
+     * What a response says about this delete.
+     *
+     * A versioned Bucket reports the marker it wrote and the id it wrote it
+     * under. A Bucket without versioning reports neither, as real S3 does.
+     */
+    get reported() {
+        if (this.deleteMarker === undefined) {
+            return {};
+        }
+        return { DeleteMarker: true, VersionId: this.deleteMarker.versionId };
+    }
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Structural shape of an S3 VersioningConfiguration.
+ *
+ * Matches the AWS SDK and CloudFormation property shape, so the same object
+ * can come from either.
+ */
+export interface SimS3VersioningConfiguration {
+    readonly Status?: string | undefined;
+    readonly MFADelete?: string | undefined;
+}
+/**
+ * The version id S3 gives an Object written while versioning was off.
+ *
+ * Real S3 reports the literal string `null` for one, and accepts it back as a
+ * `VersionId` on a read or a delete.
+ */
+export declare const simS3NullVersionId = "null";
+/**
+ * Whether one simulated S3 Bucket keeps Object versions.
+ *
+ * There are three states and only two of them are reachable twice. A Bucket
+ * starts unversioned, and a Bucket that has been versioned can be suspended
+ * but never taken back to unversioned. Real S3 has no request that removes the
+ * configuration, which is what makes versioning the one Bucket setting a
+ * template cannot undo.
+ *
+ * Suspended is the state worth being careful about. It stops new versions
+ * being made without discarding the ones already there. An Object put while
+ * suspended takes the null version id and replaces whatever else holds it,
+ * leaving every earlier version readable by its own id.
+ */
+export declare class SimS3BucketVersioning {
+    private readonly state;
+    private constructor();
+    /**
+     * The state a Bucket nobody has configured is in.
+     */
+    static unversioned(): SimS3BucketVersioning;
+    /**
+     * The state a PutBucketVersioning request asks for.
+     */
+    static fromConfiguration(configuration: SimS3VersioningConfiguration): SimS3BucketVersioning;
+    /**
+     * What GetBucketVersioning answers with.
+     *
+     * A Bucket nobody has configured has no status at all, which real S3 reports
+     * as a response carrying neither `Status` nor `MFADelete`.
+     */
+    get status(): "Enabled" | "Suspended" | undefined;
+    /**
+     * Whether a write to this Bucket is given a version id of its own.
+     */
+    get isEnabled(): boolean;
+    /**
+     * Whether this Bucket holds a version history at all.
+     *
+     * A suspended Bucket still holds one. The versions written before the
+     * suspension stay readable, and only new writes stop adding to them.
+     */
+    get keepsVersions(): boolean;
+}

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

@@ -0,0 +1,65 @@
+/**
+ * The version id S3 gives an Object written while versioning was off.
+ *
+ * Real S3 reports the literal string `null` for one, and accepts it back as a
+ * `VersionId` on a read or a delete.
+ */
+export const simS3NullVersionId = "null";
+/**
+ * Whether one simulated S3 Bucket keeps Object versions.
+ *
+ * There are three states and only two of them are reachable twice. A Bucket
+ * starts unversioned, and a Bucket that has been versioned can be suspended
+ * but never taken back to unversioned. Real S3 has no request that removes the
+ * configuration, which is what makes versioning the one Bucket setting a
+ * template cannot undo.
+ *
+ * Suspended is the state worth being careful about. It stops new versions
+ * being made without discarding the ones already there. An Object put while
+ * suspended takes the null version id and replaces whatever else holds it,
+ * leaving every earlier version readable by its own id.
+ */
+export class SimS3BucketVersioning {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    /**
+     * The state a Bucket nobody has configured is in.
+     */
+    static unversioned() {
+        return new SimS3BucketVersioning("Unversioned");
+    }
+    /**
+     * The state a PutBucketVersioning request asks for.
+     */
+    static fromConfiguration(configuration) {
+        return configuration.Status === "Enabled"
+            ? new SimS3BucketVersioning("Enabled")
+            : new SimS3BucketVersioning("Suspended");
+    }
+    /**
+     * What GetBucketVersioning answers with.
+     *
+     * A Bucket nobody has configured has no status at all, which real S3 reports
+     * as a response carrying neither `Status` nor `MFADelete`.
+     */
+    get status() {
+        return this.state === "Unversioned" ? undefined : this.state;
+    }
+    /**
+     * Whether a write to this Bucket is given a version id of its own.
+     */
+    get isEnabled() {
+        return this.state === "Enabled";
+    }
+    /**
+     * Whether this Bucket holds a version history at all.
+     *
+     * A suspended Bucket still holds one. The versions written before the
+     * suspension stay readable, and only new writes stop adding to them.
+     */
+    get keepsVersions() {
+        return this.state !== "Unversioned";
+    }
+}

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

@@ -0,0 +1,97 @@
+import type { SimS3Object } from "../../object/s3-object.js";
+import type { SimS3BucketStorage } from "../../storage/s3-bucket-storage.js";
+import { SimS3BucketVersioning } from "./sim-s3-bucket-versioning.js";
+import { SimS3ObjectVersion } from "./sim-s3-object-version.js";
+/**
+ * The versioning of one simulated S3 Bucket, and the versions it has kept.
+ *
+ * Storage holds the current Object under each key and nothing else, which is
+ * what lets every reader of a Bucket carry on unchanged. The version history
+ * holds every version including that current one, and the two are kept in step
+ * here: writing a delete marker takes the Object out of storage, and deleting
+ * a version puts back whatever the removal left current.
+ */
+export declare class SimS3BucketVersions {
+    private versioning;
+    private readonly history;
+    /**
+     * How this Bucket is configured.
+     */
+    get configuration(): SimS3BucketVersioning;
+    /**
+     * Whether this Bucket holds a version history.
+     */
+    get keepsVersions(): boolean;
+    /**
+     * Apply a versioning configuration to this Bucket.
+     *
+     * 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. They become the current version
+     * of their key and stay readable by that id afterwards.
+     */
+    configure(versioning: SimS3BucketVersioning, stored: readonly SimS3Object[]): void;
+    /**
+     * Record a write, answering the version it was given.
+     *
+     * A Bucket with versioning enabled gets a new id every time. A suspended one
+     * writes over the null version, because real S3 holds one Object under that
+     * id rather than a run of them. A Bucket nobody has configured records
+     * nothing at all.
+     */
+    recordPut(object: SimS3Object): SimS3ObjectVersion | undefined;
+    /**
+     * Write a delete marker over a key and take the Object out of storage.
+     *
+     * Real S3 writes the marker whether or not the key held anything, so a
+     * delete of a key that was never written still leaves one behind.
+     */
+    markDeleted(storage: SimS3BucketStorage, key: string, at: Date): Promise<SimS3ObjectVersion>;
+    /**
+     * Remove one version permanently, answering the version that went.
+     *
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back and deleting the
+     * current Object exposes the one written before it.
+     */
+    deleteVersion(storage: SimS3BucketStorage, key: string, versionId: string): Promise<SimS3ObjectVersion | undefined>;
+    /**
+     * One version of one key, by the id it was given.
+     */
+    find(key: string, versionId: string): SimS3ObjectVersion | undefined;
+    /**
+     * The version a read of this key without a version id answers with.
+     */
+    current(key: string): SimS3ObjectVersion | undefined;
+    /**
+     * Take a version a lifecycle rule expired out of the history.
+     *
+     * Storage is left alone, unlike `deleteVersion`. A rule for noncurrent
+     * versions never reaches the current one, and a delete marker holds no
+     * bytes, so nothing this removes was in storage to begin with.
+     */
+    removeExpired(key: string, versionId: string): void;
+    /**
+     * Every version this Bucket holds, in the order a listing reports them.
+     */
+    list(prefix?: string): readonly SimS3ObjectVersion[];
+    /**
+     * Remove the null version from a Bucket that keeps no history.
+     *
+     * Real S3 gives every Object in such a Bucket the null version id, so a
+     * delete naming that id removes the Object rather than doing nothing. Any
+     * other id names a version the Bucket never issued.
+     */
+    private removeNullVersion;
+    /**
+     * Make storage hold whatever is now current under a key.
+     */
+    private restoreCurrent;
+    /**
+     * The id the next version of anything gets.
+     *
+     * Real S3 version ids are opaque, and a suspended Bucket writes under the
+     * null id rather than minting one.
+     */
+    private nextVersionId;
+}