@kensio/yulin 1.21.2 → 1.21.4

package/dist/service/lambda/sim-lambda-commands.d.ts

@@ -18,6 +18,7 @@ import type { SimLambdaVmSdkModuleProvider } from "./function/code/vm/sdk/sim-la
 import type { SimCloudWatchServiceWriter } from "../cloudwatch/write/sim-cloudwatch-service-writer.js";
 import type { SimLogsServiceWriter } from "../logs/write/sim-logs-service-writer.js";
 import type { SimLambdaOutboundHttp } from "./function/outbound/sim-lambda-outbound-http.js";
+import { SimLambdaOutput } from "./function/logging/sim-lambda-output.js";
 import { SimLambdaEventInvokeConfigStore } from "./function/event-invoke/sim-lambda-event-invoke-config-store.js";
 import { type SimLambdaDestinationTargets } from "./destination/sim-lambda-destination-targets.js";
 import type { SimLambdaFunctionMap } from "./function/sim-lambda-function.js";
@@ -79,6 +80,15 @@ export declare class SimLambdaCommands {
     readonly functionUrlStore: SimLambdaFunctionUrlStore;
     readonly versionStore: SimLambdaFunctionVersionStore;
     readonly aliasStore: SimLambdaFunctionAliasStore;
+    /**
+     * Where this simulated Lambda's functions send what they print, besides
+     * their own log groups.
+     *
+     * Shared across every function so that one setting covers a simulation with
+     * several of them, and read as each line is written so that a function that
+     * has already cold started follows a change.
+     */
+    readonly output: SimLambdaOutput;
     readonly functionLookup: SimLambdaFunctionLookup;
     readonly eventInvokeConfigStore: SimLambdaEventInvokeConfigStore;
     readonly functions: SimLambdaFunctionCommands;

package/dist/service/lambda/sim-lambda-commands.js

@@ -14,6 +14,7 @@ import { SimLambdaNoEventSourceStreams, } from "./event-source/stream/sim-lambda
 import { SimLambdaNoKinesisStreams } from "./event-source/stream/kinesis/sim-lambda-no-kinesis-streams.js";
 import { SimLambdaNoContainerImages, } from "./function/code/image/sim-lambda-container-images.js";
 import { SimLambdaEnvironmentConflicts } from "./function/environment/sim-lambda-environment-conflicts.js";
+import { SimLambdaOutput } from "./function/logging/sim-lambda-output.js";
 import { SimLambdaEventInvokeConfigStore } from "./function/event-invoke/sim-lambda-event-invoke-config-store.js";
 import { SimLambdaNoDestinationTargets, } from "./destination/sim-lambda-destination-targets.js";
 import { SimLambdaFunctionLookup } from "./function/url/sim-lambda-function-lookup.js";
@@ -41,6 +42,15 @@ export class SimLambdaCommands {
     aliasStore = new SimLambdaFunctionAliasStore({
         versions: this.versionStore,
     });
+    /**
+     * Where this simulated Lambda's functions send what they print, besides
+     * their own log groups.
+     *
+     * Shared across every function so that one setting covers a simulation with
+     * several of them, and read as each line is written so that a function that
+     * has already cold started follows a change.
+     */
+    output = new SimLambdaOutput();
     functionLookup;
     eventInvokeConfigStore;
     functions;
@@ -142,6 +152,7 @@ export class SimLambdaCommands {
             containerImages,
             vmSdkModuleProvider,
             logs,
+            output: this.output,
             metrics,
             outboundHttp,
         });

package/dist/service/lambda/sim-lambda.d.ts

@@ -1,6 +1,7 @@
 import type { SimSdkCommandRouter } from "../../sdk/index.js";
 import type { SimCfnServiceResourceFactory } from "../cloudformation/resource/factory/sim-cfn-resource-factory.type.js";
 import type { SimLambdaContainerImages } from "./function/code/image/sim-lambda-container-images.js";
+import type { SimLambdaOutput } from "./function/logging/sim-lambda-output.js";
 import type { SimLambdaFunctionMap } from "./function/sim-lambda-function.js";
 import type * as simLambdaCommands from "./command/sim-lambda-command.types.js";
 import { SimLambdaCommands, type SimLambdaProperties } from "./sim-lambda-commands.js";
@@ -32,6 +33,17 @@ export declare class SimLambda extends SimLambdaEventInvokeOperations {
      * @internal
      */
     containerImages(): SimLambdaContainerImages;
+    /**
+     * Where this simulated Lambda's functions send what they print, besides the
+     * log group they always reach. The host console gets a copy until told
+     * otherwise, and these settings belong to one Account and Region as the
+     * functions do.
+     *
+     * ```typescript
+     * simAws.lambda().output().captureOnly();
+     * ```
+     */
+    output(): SimLambdaOutput;
     /** Handle a Create Function Command from the SDK. */
     createFunction(command: simLambdaCommands.SimCreateFunctionCommand, options?: SimLambdaRequestOptions): Promise<simLambdaCommands.SimCreateFunctionCommandOutput>;
     /** Handle a Get Function Command from the SDK. */

package/dist/service/lambda/sim-lambda.js

@@ -39,6 +39,19 @@ export class SimLambda extends SimLambdaEventInvokeOperations {
     containerImages() {
         return this.commands.containerImages;
     }
+    /**
+     * Where this simulated Lambda's functions send what they print, besides the
+     * log group they always reach. The host console gets a copy until told
+     * otherwise, and these settings belong to one Account and Region as the
+     * functions do.
+     *
+     * ```typescript
+     * simAws.lambda().output().captureOnly();
+     * ```
+     */
+    output() {
+        return this.commands.output;
+    }
     /** Handle a Create Function Command from the SDK. */
     async createFunction(command, options) {
         return await this.commands.functions.create(command, options);

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

@@ -0,0 +1,67 @@
+import { type SimS3ServerSideEncryption } from "../../object/s3-server-side-encryption.js";
+/**
+ * The encryption a Bucket applies to an Object whose write named none.
+ */
+export interface SimS3ServerSideEncryptionByDefault {
+    readonly SSEAlgorithm?: string | undefined;
+    readonly KMSMasterKeyID?: string | undefined;
+}
+/**
+ * One rule of a Bucket's default encryption configuration.
+ *
+ * Real S3 takes exactly one. `BucketKeyEnabled` says whether S3 uses a bucket
+ * key to cut KMS calls, and is stored and read back here without acting.
+ */
+export interface SimS3ServerSideEncryptionRule {
+    readonly ApplyServerSideEncryptionByDefault?: SimS3ServerSideEncryptionByDefault | undefined;
+    readonly BucketKeyEnabled?: boolean | undefined;
+}
+/**
+ * A Bucket's default encryption configuration, as a request states it.
+ */
+export interface SimS3ServerSideEncryptionConfiguration {
+    readonly Rules?: readonly SimS3ServerSideEncryptionRule[] | undefined;
+}
+interface SimS3BucketEncryptionProperties {
+    readonly rules?: readonly SimS3ServerSideEncryptionRule[] | undefined;
+}
+/**
+ * The default encryption of one simulated S3 Bucket.
+ *
+ * Nothing is encrypted. The bytes of an Object are stored as they arrive, and
+ * its ETag stays the MD5 of them, which is what real S3 reports for an
+ * SSE-S3 Object as well. What this decides is the algorithm a write stamps on
+ * an Object when it names none itself, and what `GetBucketEncryption` answers.
+ *
+ * A Bucket nobody has configured is SSE-S3 encrypted. Real S3 has applied that
+ * default to every Bucket since January 2023, and answers a read of an
+ * unconfigured Bucket with the same `AES256` rule as one configured that way.
+ */
+export declare class SimS3BucketEncryption {
+    private readonly storedRules;
+    constructor(properties?: SimS3BucketEncryptionProperties);
+    /**
+     * The encryption a Bucket nobody has configured has, which is what
+     * `DeleteBucketEncryption` puts a Bucket back to.
+     */
+    static default(): SimS3BucketEncryption;
+    /**
+     * The encryption a PutBucketEncryption request asks for.
+     *
+     * Every algorithm named is read here, before the Bucket is changed, so a
+     * configuration real S3 refuses leaves the Bucket as it was.
+     */
+    static fromConfiguration(configuration: SimS3ServerSideEncryptionConfiguration, bucketName: string): SimS3BucketEncryption;
+    /**
+     * The algorithm this Bucket stamps on an Object written without one.
+     */
+    get algorithm(): SimS3ServerSideEncryption;
+    /**
+     * The configuration a read of the Bucket answers with.
+     *
+     * Cloned on the way out, so a caller holding what it was given cannot change
+     * what the Bucket applies by mutating it.
+     */
+    get configuration(): SimS3ServerSideEncryptionConfiguration;
+}
+export {};

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

@@ -0,0 +1,69 @@
+import { simS3DefaultServerSideEncryption, simS3ServerSideEncryptionFrom, } from "../../object/s3-server-side-encryption.js";
+/**
+ * The default encryption of one simulated S3 Bucket.
+ *
+ * Nothing is encrypted. The bytes of an Object are stored as they arrive, and
+ * its ETag stays the MD5 of them, which is what real S3 reports for an
+ * SSE-S3 Object as well. What this decides is the algorithm a write stamps on
+ * an Object when it names none itself, and what `GetBucketEncryption` answers.
+ *
+ * A Bucket nobody has configured is SSE-S3 encrypted. Real S3 has applied that
+ * default to every Bucket since January 2023, and answers a read of an
+ * unconfigured Bucket with the same `AES256` rule as one configured that way.
+ */
+export class SimS3BucketEncryption {
+    storedRules;
+    constructor(properties = {}) {
+        this.storedRules = structuredClone(properties.rules ?? defaultRules);
+    }
+    /**
+     * The encryption a Bucket nobody has configured has, which is what
+     * `DeleteBucketEncryption` puts a Bucket back to.
+     */
+    static default() {
+        return new SimS3BucketEncryption();
+    }
+    /**
+     * The encryption a PutBucketEncryption request asks for.
+     *
+     * Every algorithm named is read here, before the Bucket is changed, so a
+     * configuration real S3 refuses leaves the Bucket as it was.
+     */
+    static fromConfiguration(configuration, bucketName) {
+        const rules = configuration.Rules ?? [];
+        for (const rule of rules) {
+            simS3ServerSideEncryptionFrom(rule.ApplyServerSideEncryptionByDefault?.SSEAlgorithm, `the default encryption of Bucket ${bucketName}`);
+        }
+        return new SimS3BucketEncryption({ rules });
+    }
+    /**
+     * The algorithm this Bucket stamps on an Object written without one.
+     */
+    get algorithm() {
+        const named = this.storedRules
+            .map((rule) => rule.ApplyServerSideEncryptionByDefault?.SSEAlgorithm)
+            .find((algorithm) => algorithm !== undefined);
+        return (simS3ServerSideEncryptionFrom(named, "a stored Bucket configuration") ??
+            simS3DefaultServerSideEncryption);
+    }
+    /**
+     * The configuration a read of the Bucket answers with.
+     *
+     * Cloned on the way out, so a caller holding what it was given cannot change
+     * what the Bucket applies by mutating it.
+     */
+    get configuration() {
+        return { Rules: structuredClone(this.storedRules) };
+    }
+}
+/**
+ * The rule real S3 reports for a Bucket nobody has configured.
+ */
+const defaultRules = [
+    {
+        ApplyServerSideEncryptionByDefault: {
+            SSEAlgorithm: simS3DefaultServerSideEncryption,
+        },
+        BucketKeyEnabled: false,
+    },
+];

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

@@ -1,36 +1,8 @@
 import type { SimS3LifecycleConfiguration as SimS3LifecycleConfigurationInput, SimS3LifecycleRule } from "../../command/put-bucket-lifecycle-configuration/put-bucket-lifecycle-configuration.command.js";
+import type { SimS3LifecycleNoncurrentVersion, SimS3LifecycleObject, SimS3LifecycleUpload } from "./sim-s3-lifecycle-subject.js";
 interface SimS3LifecycleConfigurationProperties {
     readonly rules?: readonly SimS3LifecycleRule[];
 }
-/**
- * An Object as a lifecycle rule reads it.
- */
-export interface SimS3LifecycleObject {
-    readonly key: string;
-    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 {
-    readonly key: string;
-    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;
-}
 /**
  * The lifecycle configuration of one simulated S3 Bucket.
  *
@@ -107,8 +79,9 @@ export declare 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`.
      */
-    private enabledRules;
+    get enabledRules(): readonly SimS3LifecycleRule[];
 }
 export {};

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;