@kensio/yulin 1.21.3 → 1.21.5

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

@@ -60,7 +60,7 @@ export class SimS3LifecycleConfiguration {
      * shortest one.
      */
     expires(object, now) {
-        return this.enabledRules().some((rule) => rule.Expiration !== undefined &&
+        return this.enabledRules.some((rule) => rule.Expiration !== undefined &&
             simS3LifecycleRuleSelects(rule, object) &&
             simS3LifecycleReached(simS3ObjectExpiryInstant(rule.Expiration, object.lastModified), now));
     }
@@ -73,7 +73,7 @@ export class SimS3LifecycleConfiguration {
      * reaches the third and everything older.
      */
     expiresNoncurrent(version, now) {
-        return this.enabledRules().some((rule) => {
+        return this.enabledRules.some((rule) => {
             const expiration = rule.NoncurrentVersionExpiration;
             return (expiration !== undefined &&
                 version.newerVersionsAhead >=
@@ -91,7 +91,7 @@ export class SimS3LifecycleConfiguration {
      * key in a listing once its last version has gone.
      */
     expiresDeleteMarker(key) {
-        return this.enabledRules().some((rule) => rule.Expiration?.ExpiredObjectDeleteMarker === true &&
+        return this.enabledRules.some((rule) => rule.Expiration?.ExpiredObjectDeleteMarker === true &&
             simS3LifecycleRuleSelects(rule, { key }));
     }
     /**
@@ -99,7 +99,7 @@ export class SimS3LifecycleConfiguration {
      * instant.
      */
     abandons(upload, now) {
-        return this.enabledRules().some((rule) => rule.AbortIncompleteMultipartUpload !== undefined &&
+        return this.enabledRules.some((rule) => rule.AbortIncompleteMultipartUpload !== undefined &&
             simS3LifecycleRuleSelects(rule, { key: upload.key }) &&
             simS3LifecycleReached(simS3UploadAbortInstant(rule.AbortIncompleteMultipartUpload, upload.initiated), now));
     }
@@ -108,9 +108,10 @@ export class SimS3LifecycleConfiguration {
      *
      * Read from the stored rules rather than from `rules`, because every read of
      * a Bucket asks and cloning the whole configuration each time would be the
-     * cost of having one.
+     * cost of having one. A transition is worked out from these by
+     * `simS3TransitionedObjectClass`.
      */
-    enabledRules() {
+    get enabledRules() {
         return this.storedRules.filter((rule) => rule.Status === "Enabled");
     }
 }

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

@@ -32,3 +32,8 @@ export declare function simS3UploadAbortInstant(abort: SimS3LifecycleAbortIncomp
  * Whether simulated time has reached a boundary.
  */
 export declare function simS3LifecycleReached(boundary: Date | undefined, now: Date): boolean;
+/**
+ * The instant a number of days after another one, which is how every lifecycle
+ * boundary measured in days is reached.
+ */
+export declare function simS3LifecycleAfterDays(from: Date, days: number): Date;

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

@@ -14,7 +14,7 @@ const millisecondsPerDay = 24 * 60 * 60 * 1000;
  */
 export function simS3ObjectExpiryInstant(expiration, writtenAt) {
     if (expiration.Days !== undefined) {
-        return afterDays(writtenAt, expiration.Days);
+        return simS3LifecycleAfterDays(writtenAt, expiration.Days);
     }
     if (expiration.Date !== undefined) {
         return new Date(expiration.Date);
@@ -35,7 +35,7 @@ export function simS3NoncurrentExpiryInstant(expiration, noncurrentSince) {
         expiration.NoncurrentDays === undefined) {
         return undefined;
     }
-    return afterDays(noncurrentSince, expiration.NoncurrentDays);
+    return simS3LifecycleAfterDays(noncurrentSince, expiration.NoncurrentDays);
 }
 /**
  * The instant an `AbortIncompleteMultipartUpload` abandons an upload started
@@ -45,7 +45,7 @@ export function simS3UploadAbortInstant(abort, initiated) {
     if (abort.DaysAfterInitiation === undefined) {
         return undefined;
     }
-    return afterDays(initiated, abort.DaysAfterInitiation);
+    return simS3LifecycleAfterDays(initiated, abort.DaysAfterInitiation);
 }
 /**
  * Whether simulated time has reached a boundary.
@@ -53,6 +53,10 @@ export function simS3UploadAbortInstant(abort, initiated) {
 export function simS3LifecycleReached(boundary, now) {
     return boundary !== undefined && now.getTime() >= boundary.getTime();
 }
-function afterDays(from, days) {
+/**
+ * The instant a number of days after another one, which is how every lifecycle
+ * boundary measured in days is reached.
+ */
+export function simS3LifecycleAfterDays(from, days) {
     return new Date(from.getTime() + days * millisecondsPerDay);
 }

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

@@ -1,23 +1,10 @@
 import type { SimS3LifecycleRule } from "../../command/put-bucket-lifecycle-configuration/put-bucket-lifecycle-configuration.command.js";
-/**
- * What a lifecycle rule looks at to decide whether it selects something.
- *
- * An Object states its size and a multipart upload leaves it out. Half an
- * upload has no size for a rule to measure, and real S3 has no size to
- * measure either until the parts are joined.
- */
-export interface SimS3LifecycleSubject {
-    readonly key: string;
-    readonly size?: number | undefined;
-}
+import type { SimS3LifecycleSubject } from "./sim-s3-lifecycle-subject.js";
 /**
  * Whether a rule selects the Object or upload a key names.
  *
  * A rule states its scope either as the older top-level `Prefix` or as a
  * `Filter`. A rule with no scope at all covers every key in the Bucket. Real
  * S3 refuses a rule stating both.
- *
- * Simulated S3 has no Object tags. A `Tag` or a `TagFilters` entry names a
- * condition the simulator has no answer for, and selects no key.
  */
 export declare function simS3LifecycleRuleSelects(rule: SimS3LifecycleRule, subject: SimS3LifecycleSubject): boolean;

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

@@ -4,9 +4,6 @@
  * A rule states its scope either as the older top-level `Prefix` or as a
  * `Filter`. A rule with no scope at all covers every key in the Bucket. Real
  * S3 refuses a rule stating both.
- *
- * Simulated S3 has no Object tags. A `Tag` or a `TagFilters` entry names a
- * condition the simulator has no answer for, and selects no key.
  */
 export function simS3LifecycleRuleSelects(rule, subject) {
     if (rule.Filter === undefined) {
@@ -19,16 +16,27 @@ function filterSelects(filter, subject) {
         return conjunctionSelects(filter.And, subject);
     }
     if (filter.Tag !== undefined) {
-        return false;
+        // A bare `Tag` filter is scoped by the tag alone. It says nothing about
+        // the key, so every Object carrying the tag is selected wherever it is.
+        return tagsSelect([filter.Tag], subject);
     }
     return (subject.key.startsWith(filter.Prefix ?? "") && sizeWithin(filter, subject));
 }
 function conjunctionSelects(operator, subject) {
-    if ((operator.Tags ?? []).length > 0) {
-        return false;
-    }
     return (subject.key.startsWith(operator.Prefix ?? "") &&
-        sizeWithin(operator, subject));
+        sizeWithin(operator, subject) &&
+        tagsSelect(operator.Tags ?? [], subject));
+}
+/**
+ * Whether the subject carries every tag the filter names.
+ *
+ * Both halves of a tag have to match, because a rule for `archive=true` says
+ * nothing about an Object tagged `archive=false`. A subject carrying no tag
+ * set at all, meaning an upload in progress or a delete marker, matches no
+ * named tag and is selected only by a filter naming none.
+ */
+function tagsSelect(tags, subject) {
+    return tags.every((tag) => subject.tags?.has(tag.Key ?? "", tag.Value ?? "") === true);
 }
 /**
  * Whether the subject's size falls inside the bounds a filter states.

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

@@ -0,0 +1,41 @@
+import type { SimS3ObjectTagSet } from "../../object/s3-object-tags.js";
+/**
+ * What a lifecycle rule looks at to decide whether it selects something.
+ *
+ * An Object states its size and its tags, and a multipart upload states
+ * neither. Half an upload has no size for a rule to measure, and real S3 has no
+ * size to measure either until the parts are joined. A delete marker holds no
+ * Object, so it carries no tags for a rule to match.
+ */
+export interface SimS3LifecycleSubject {
+    readonly key: string;
+    readonly size?: number | undefined;
+    readonly tags?: SimS3ObjectTagSet | undefined;
+}
+/**
+ * An Object as a lifecycle rule reads it.
+ */
+export interface SimS3LifecycleObject extends SimS3LifecycleSubject {
+    readonly size: number;
+    readonly lastModified: Date;
+}
+/**
+ * A noncurrent version as a lifecycle rule reads it.
+ *
+ * `newerVersionsAhead` is how many noncurrent versions of the same key are
+ * newer than this one, which is what `NewerNoncurrentVersions` counts. The
+ * current version is not one of them, since a rule for noncurrent versions
+ * never reaches it.
+ */
+export interface SimS3LifecycleNoncurrentVersion extends SimS3LifecycleSubject {
+    readonly size: number;
+    readonly noncurrentSince: Date | undefined;
+    readonly newerVersionsAhead: number;
+}
+/**
+ * A multipart upload in progress as a lifecycle rule reads it.
+ */
+export interface SimS3LifecycleUpload {
+    readonly key: string;
+    readonly initiated: Date;
+}

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

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

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

@@ -14,6 +14,11 @@ import type { SimS3LifecycleConfiguration } from "./sim-s3-lifecycle-configurati
  * `simS3ObjectExpiryInstant` for why the boundary is a pure function of the
  * current time.
  *
+ * A transition is answered here as well. An Object past the day a
+ * `Transitions` rule names reads back in the class that rule moves it to, and
+ * the bytes stay where they are, which is all a transition does to an Object a
+ * caller can still read.
+ *
  * Nothing is announced. Real S3 raises `s3:LifecycleExpiration:Delete` for an
  * expiry, and that event family is among the ones simulated S3 leaves out.
  *
@@ -41,6 +46,15 @@ export declare class SimS3LifecycleSweep {
      * ones still there.
      */
     objects(objects: readonly SimS3Object[]): Promise<SimS3Object[]>;
+    /**
+     * The Object in the class the rules have transitioned it into.
+     *
+     * The class is worked out on each read rather than written back, for the
+     * same reason an expiry is: it is a pure function of the rules and the
+     * current time, and storage that maps Objects onto files has nowhere to
+     * record one. See `simS3ObjectExpiryInstant`.
+     */
+    private transitioned;
     /**
      * Take one expired key out of what a read of the Bucket can see.
      *

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

@@ -1,3 +1,4 @@
+import { simS3TransitionedObjectClass } from "./sim-s3-lifecycle-transition.js";
 /**
  * One pass over what a Bucket's lifecycle rules have expired.
  *
@@ -10,6 +11,11 @@
  * `simS3ObjectExpiryInstant` for why the boundary is a pure function of the
  * current time.
  *
+ * A transition is answered here as well. An Object past the day a
+ * `Transitions` rule names reads back in the class that rule moves it to, and
+ * the bytes stay where they are, which is all a transition does to an Object a
+ * caller can still read.
+ *
  * Nothing is announced. Real S3 raises `s3:LifecycleExpiration:Delete` for an
  * expiry, and that event family is among the ones simulated S3 leaves out.
  *
@@ -37,9 +43,12 @@ export class SimS3LifecycleSweep {
      * so a read hands on whatever it gets. A key holding nothing stays nothing.
      */
     async object(object) {
-        if (object === undefined || !this.expires(object)) {
+        if (object === undefined) {
             return object;
         }
+        if (!this.expires(object)) {
+            return this.transitioned(object);
+        }
         await this.expire(object.key);
         return undefined;
     }
@@ -55,7 +64,27 @@ export class SimS3LifecycleSweep {
         await Promise.all(expiredKeys.values().map(async (key) => {
             await this.expire(key);
         }));
-        return objects.filter((object) => !expiredKeys.has(object.key));
+        return objects
+            .filter((object) => !expiredKeys.has(object.key))
+            .map((object) => this.transitioned(object));
+    }
+    /**
+     * The Object in the class the rules have transitioned it into.
+     *
+     * The class is worked out on each read rather than written back, for the
+     * same reason an expiry is: it is a pure function of the rules and the
+     * current time, and storage that maps Objects onto files has nowhere to
+     * record one. See `simS3ObjectExpiryInstant`.
+     */
+    transitioned(object) {
+        if (this.lifecycle.isEmpty) {
+            return object;
+        }
+        const storageClass = simS3TransitionedObjectClass(this.lifecycle.enabledRules, lifecycleObject(object), this.now);
+        if (storageClass === undefined || storageClass === object.storageClass) {
+            return object;
+        }
+        return object.withStorageClass(storageClass);
     }
     /**
      * Take one expired key out of what a read of the Bucket can see.
@@ -85,5 +114,6 @@ function lifecycleObject(object) {
         key: object.key,
         size: object.body.length,
         lastModified: object.lastModified,
+        tags: object.tags,
     };
 }

package/dist/service/s3/bucket/lifecycle/sim-s3-lifecycle-transition-instant.d.ts

@@ -0,0 +1,33 @@
+import type { SimS3LifecycleNoncurrentVersionTransition, SimS3LifecycleTransition } from "../../command/put-bucket-lifecycle-configuration/put-bucket-lifecycle-configuration.command.js";
+import { type SimS3StorageClass } from "../../object/s3-storage-class.js";
+import type { SimS3LifecycleNoncurrentVersion } from "./sim-s3-lifecycle-subject.js";
+/**
+ * One transition a rule has reached, as the class it moves an Object into and
+ * the instant it moved.
+ *
+ * The instant is what decides between two transitions that have both been
+ * reached. Real S3 walks an Object down the classes a rule lists as their days
+ * pass, so the one that came last is where the Object is now.
+ */
+export interface SimS3ReachedTransition {
+    readonly storageClass: SimS3StorageClass;
+    readonly at: Date;
+}
+/**
+ * The transition a `Transitions` entry has made by an instant, if it has.
+ *
+ * `Days` counts from when the Object was written and `Date` names the day
+ * itself, the same two forms an `Expiration` takes. A transition naming
+ * neither, or naming no storage class, moves nothing.
+ */
+export declare function simS3ReachedTransitionOf(transition: SimS3LifecycleTransition, writtenAt: Date, now: Date): SimS3ReachedTransition | undefined;
+/**
+ * The transition a `NoncurrentVersionTransitions` entry has made by an
+ * instant, counted from when the version stopped being the current one.
+ *
+ * A version that is still current has no such instant, as it has none for a
+ * `NoncurrentVersionExpiration`. `NewerNoncurrentVersions` holds back the most
+ * recent noncurrent versions as it does for an expiry, so a rule keeping two
+ * reaches the third and everything older.
+ */
+export declare function simS3ReachedNoncurrentTransitionOf(transition: SimS3LifecycleNoncurrentVersionTransition, version: SimS3LifecycleNoncurrentVersion, now: Date): SimS3ReachedTransition | undefined;

package/dist/service/s3/bucket/lifecycle/sim-s3-lifecycle-transition-instant.js

@@ -0,0 +1,48 @@
+import { simS3StorageClassFrom, } from "../../object/s3-storage-class.js";
+import { simS3LifecycleAfterDays, simS3LifecycleReached, } from "./sim-s3-lifecycle-expiry.js";
+/**
+ * The transition a `Transitions` entry has made by an instant, if it has.
+ *
+ * `Days` counts from when the Object was written and `Date` names the day
+ * itself, the same two forms an `Expiration` takes. A transition naming
+ * neither, or naming no storage class, moves nothing.
+ */
+export function simS3ReachedTransitionOf(transition, writtenAt, now) {
+    return reached(transitionInstant(transition, writtenAt), transition.StorageClass, now);
+}
+/**
+ * The transition a `NoncurrentVersionTransitions` entry has made by an
+ * instant, counted from when the version stopped being the current one.
+ *
+ * A version that is still current has no such instant, as it has none for a
+ * `NoncurrentVersionExpiration`. `NewerNoncurrentVersions` holds back the most
+ * recent noncurrent versions as it does for an expiry, so a rule keeping two
+ * reaches the third and everything older.
+ */
+export function simS3ReachedNoncurrentTransitionOf(transition, version, now) {
+    const { noncurrentSince } = version;
+    if (noncurrentSince === undefined ||
+        transition.NoncurrentDays === undefined ||
+        version.newerVersionsAhead < (transition.NewerNoncurrentVersions ?? 0)) {
+        return undefined;
+    }
+    return reached(simS3LifecycleAfterDays(noncurrentSince, transition.NoncurrentDays), transition.StorageClass, now);
+}
+function transitionInstant(transition, writtenAt) {
+    if (transition.Days !== undefined) {
+        return simS3LifecycleAfterDays(writtenAt, transition.Days);
+    }
+    if (transition.Date !== undefined) {
+        return new Date(transition.Date);
+    }
+    return undefined;
+}
+function reached(at, storageClass, now) {
+    const target = simS3StorageClassFrom(storageClass, "a lifecycle transition");
+    if (at === undefined || target === undefined) {
+        return undefined;
+    }
+    return simS3LifecycleReached(at, now)
+        ? { storageClass: target, at }
+        : undefined;
+}

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

@@ -0,0 +1,16 @@
+import type { SimS3LifecycleRule } from "../../command/put-bucket-lifecycle-configuration/put-bucket-lifecycle-configuration.command.js";
+import type { SimS3StorageClass } from "../../object/s3-storage-class.js";
+import type { SimS3LifecycleNoncurrentVersion, SimS3LifecycleObject } from "./sim-s3-lifecycle-subject.js";
+/**
+ * The class the rules have transitioned an Object into by an instant.
+ *
+ * Every rule selecting the Object contributes the transitions it has reached,
+ * because real S3 applies the whole configuration to a key rather than the
+ * first rule that matches it.
+ */
+export declare function simS3TransitionedObjectClass(rules: readonly SimS3LifecycleRule[], object: SimS3LifecycleObject, now: Date): SimS3StorageClass | undefined;
+/**
+ * The class the rules have transitioned a noncurrent version into by an
+ * instant.
+ */
+export declare function simS3TransitionedVersionClass(rules: readonly SimS3LifecycleRule[], version: SimS3LifecycleNoncurrentVersion, now: Date): SimS3StorageClass | undefined;

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

@@ -0,0 +1,44 @@
+import { simS3ReachedNoncurrentTransitionOf, simS3ReachedTransitionOf, } from "./sim-s3-lifecycle-transition-instant.js";
+import { simS3LifecycleRuleSelects } from "./sim-s3-lifecycle-selection.js";
+/**
+ * The class the rules have transitioned an Object into by an instant.
+ *
+ * Every rule selecting the Object contributes the transitions it has reached,
+ * because real S3 applies the whole configuration to a key rather than the
+ * first rule that matches it.
+ */
+export function simS3TransitionedObjectClass(rules, object, now) {
+    return latestReached(rules
+        .filter((rule) => simS3LifecycleRuleSelects(rule, object))
+        .flatMap((rule) => reachedTransitions(rule.Transitions, (transition) => simS3ReachedTransitionOf(transition, object.lastModified, now))));
+}
+/**
+ * The class the rules have transitioned a noncurrent version into by an
+ * instant.
+ */
+export function simS3TransitionedVersionClass(rules, version, now) {
+    return latestReached(rules
+        .filter((rule) => simS3LifecycleRuleSelects(rule, version))
+        .flatMap((rule) => reachedTransitions(rule.NoncurrentVersionTransitions, (transition) => simS3ReachedNoncurrentTransitionOf(transition, version, now))));
+}
+/**
+ * The transitions among a rule's that have been reached.
+ */
+function reachedTransitions(transitions, reach) {
+    return (transitions ?? [])
+        .map((transition) => reach(transition))
+        .filter((transition) => transition !== undefined);
+}
+/**
+ * The class an Object is in once every transition that has been reached has
+ * been applied, or nothing where none has.
+ *
+ * The latest one wins. Two reached at the same instant are settled by the
+ * order the rules list them in, so the last transition a configuration states
+ * is where an Object past all of them ends up.
+ */
+function latestReached(transitions) {
+    return transitions
+        .toSorted((one, other) => one.at.getTime() - other.at.getTime())
+        .at(-1)?.storageClass;
+}

package/dist/service/s3/bucket/lifecycle/sim-s3-noncurrent-sweep.d.ts

@@ -41,5 +41,13 @@ export declare class SimS3NoncurrentSweep {
      * marker was the only thing left holding the key there.
      */
     private sweepDeleteMarker;
+    /**
+     * Move a surviving noncurrent version into the class the rules have
+     * transitioned it to.
+     *
+     * The current version and a delete marker are left alone. Neither is
+     * something a `NoncurrentVersionTransitions` rule reaches.
+     */
+    private transition;
     private expires;
 }

package/dist/service/s3/bucket/lifecycle/sim-s3-noncurrent-sweep.js

@@ -1,3 +1,4 @@
+import { simS3TransitionedVersionClass } from "./sim-s3-lifecycle-transition.js";
 /**
  * One pass over what a Bucket's rules have expired in its version history.
  *
@@ -45,6 +46,7 @@ export class SimS3NoncurrentSweep {
         for (const [index, version] of held.entries()) {
             if (index === 0 || !this.expires(version, index - 1)) {
                 kept.push(version);
+                this.transition(version, index - 1);
                 continue;
             }
             versions.removeExpired(version.key, version.versionId);
@@ -66,12 +68,37 @@ export class SimS3NoncurrentSweep {
             versions.removeExpired(marker.key, marker.versionId);
         }
     }
+    /**
+     * Move a surviving noncurrent version into the class the rules have
+     * transitioned it to.
+     *
+     * The current version and a delete marker are left alone. Neither is
+     * something a `NoncurrentVersionTransitions` rule reaches.
+     */
+    transition(version, ahead) {
+        if (ahead < 0 || version.isDeleteMarker) {
+            return;
+        }
+        const storageClass = simS3TransitionedVersionClass(this.lifecycle.enabledRules, {
+            key: version.key,
+            size: version.object.body.length,
+            noncurrentSince: version.noncurrentSince,
+            newerVersionsAhead: ahead,
+            tags: version.object.tags,
+        }, this.now);
+        if (storageClass !== undefined) {
+            version.transitionTo(storageClass);
+        }
+    }
     expires(version, ahead) {
         return this.lifecycle.expiresNoncurrent({
             key: version.key,
             size: version.isDeleteMarker ? 0 : version.object.body.length,
             noncurrentSince: version.noncurrentSince,
             newerVersionsAhead: ahead,
+            // A delete marker holds no Object, so it carries no tags and a rule
+            // filtering on one leaves it alone.
+            tags: version.isDeleteMarker ? undefined : version.object.tags,
         }, this.now);
     }
 }

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

@@ -5,7 +5,7 @@
  * has many more, and the ones it has that this simulator cannot produce are
  * refused by name rather than accepted and never delivered.
  */
-export declare const SIM_S3_NOTIFICATION_EVENTS: readonly ["s3:ObjectCreated:Put", "s3:ObjectCreated:Copy", "s3:ObjectCreated:CompleteMultipartUpload", "s3:ObjectRemoved:Delete", "s3:ObjectRemoved:DeleteMarkerCreated"];
+export declare const SIM_S3_NOTIFICATION_EVENTS: readonly ["s3:ObjectCreated:Put", "s3:ObjectCreated:Copy", "s3:ObjectCreated:CompleteMultipartUpload", "s3:ObjectRemoved:Delete", "s3:ObjectRemoved:DeleteMarkerCreated", "s3:ObjectTagging:Put", "s3:ObjectTagging:Delete"];
 export type SimS3NotificationEvent = (typeof SIM_S3_NOTIFICATION_EVENTS)[number];
 /**
  * The concrete events a configured event type covers.

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

@@ -13,6 +13,8 @@ export const SIM_S3_NOTIFICATION_EVENTS = [
     "s3:ObjectCreated:CompleteMultipartUpload",
     "s3:ObjectRemoved:Delete",
     "s3:ObjectRemoved:DeleteMarkerCreated",
+    "s3:ObjectTagging:Put",
+    "s3:ObjectTagging:Delete",
 ];
 /**
  * What each configurable event type expands to.
@@ -50,6 +52,9 @@ const eventExpansions = new Map([
         "s3:ObjectRemoved:DeleteMarkerCreated",
         ["s3:ObjectRemoved:DeleteMarkerCreated"],
     ],
+    ["s3:ObjectTagging:*", ["s3:ObjectTagging:Put", "s3:ObjectTagging:Delete"]],
+    ["s3:ObjectTagging:Put", ["s3:ObjectTagging:Put"]],
+    ["s3:ObjectTagging:Delete", ["s3:ObjectTagging:Delete"]],
 ]);
 /**
  * The concrete events a configured event type covers.

package/dist/service/s3/bucket/notification/sim-s3-unsimulated-notification-events.js

@@ -21,9 +21,6 @@ export const SIM_S3_UNSIMULATED_NOTIFICATION_EVENTS = new Set([
     "s3:ObjectRestore:Completed",
     "s3:ObjectRestore:Delete",
     "s3:ObjectRestore:Post",
-    "s3:ObjectTagging:*",
-    "s3:ObjectTagging:Delete",
-    "s3:ObjectTagging:Put",
     "s3:ReducedRedundancyLostObject",
     "s3:Replication:*",
     "s3:Replication:OperationFailedReplication",

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

@@ -59,6 +59,9 @@ export declare class SimS3BucketAccess {
      * cached. A deployment into the same Bucket has already said it, so the mount
      * inherits what the Bucket was told, and `systemMetadata` is where it
      * declares the rest or answers differently.
+     *
+     * The Bucket serves and accepts writes but refuses a delete, since the files
+     * are the user's own. `allowDelete` is how a mount asks for one.
      */
     mountFilesystem(bucketName: SimS3BucketName | string, directoryPath: string, options?: SimS3MountFilesystemOptions): void;
     /**

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

@@ -1,5 +1,5 @@
 import { assertDefined } from "../../../util/type-guard/defined.js";
-import { FilesystemS3BucketStorage } from "../storage/filesystem/s3-filesystem-storage.js";
+import { filesystemS3MountStorage } from "../storage/filesystem/s3-filesystem-deleting-storage.js";
 import { simS3BucketUrl, simS3ServiceUrl } from "./sim-s3-endpoint-url.js";
 import { SimS3DeclaredSystemMetadata } from "../object/s3-declared-system-metadata.js";
 import { SimS3MountWatches } from "../mount/sim-s3-mount-watches.js";
@@ -73,6 +73,9 @@ export class SimS3BucketAccess {
      * cached. A deployment into the same Bucket has already said it, so the mount
      * inherits what the Bucket was told, and `systemMetadata` is where it
      * declares the rest or answers differently.
+     *
+     * The Bucket serves and accepts writes but refuses a delete, since the files
+     * are the user's own. `allowDelete` is how a mount asks for one.
      */
     mountFilesystem(bucketName, directoryPath, options = {}) {
         const bucket = this.required(bucketName);
@@ -80,11 +83,12 @@ export class SimS3BucketAccess {
             inherited: bucket.getDeclaredSystemMetadata(),
             declarations: options.systemMetadata,
         });
-        bucket.configureSimStorage(new FilesystemS3BucketStorage({
+        bucket.configureSimStorage(filesystemS3MountStorage({
             directoryPath,
             ...(options.additionalFileExtensions !== undefined && {
                 additionalFileExtensions: options.additionalFileExtensions,
             }),
+            allowDelete: options.allowDelete,
             systemMetadata,
         }));
         this.mountWatches.register(bucketName, directoryPath, options);