@kensio/yulin 1.21.3 → 1.21.5

package/dist/service/s3/object/s3-write-metadata.d.ts

@@ -8,8 +8,9 @@ import { SimS3ObjectMetadata } from "./s3-object.js";
  * headers S3 remembers about an Object and returns on a read. There is one for
  * every entry in `simS3SystemMetadataHeaders`, which is what the conversion
  * below reads them by, so a header added to that list without a field here
- * fails to compile. `Expires` is a `Date` because the SDK takes one and formats
- * it as an HTTP date.
+ * fails to compile. `Expires` is a `Date` where the SDK takes one and formats
+ * it as an HTTP date, and the formatted string itself where the write arrived
+ * over HTTP with the date already written out.
  */
 export interface SimS3ObjectWriteMetadata {
     readonly Metadata?: Record<string, string> | undefined;
@@ -18,7 +19,7 @@ export interface SimS3ObjectWriteMetadata {
     readonly ContentEncoding?: string | undefined;
     readonly ContentLanguage?: string | undefined;
     readonly ContentType?: string | undefined;
-    readonly Expires?: Date | undefined;
+    readonly Expires?: Date | string | undefined;
 }
 /**
  * Convert the metadata members of a write into what an Object stores.
@@ -34,3 +35,16 @@ export interface SimS3ObjectWriteMetadata {
  * write named it or not.
  */
 export declare function simS3WriteMetadata(input: SimS3ObjectWriteMetadata): SimS3ObjectMetadata;
+/**
+ * Read the metadata headers of an upload into the members a write carries.
+ *
+ * A request arriving over HTTP states its metadata in the headers real S3
+ * carries it in, which is the form a `PutObjectCommand` is serialized into by
+ * the SDK. Reading them by the same list a write and a read agree on is what
+ * keeps an upload over an endpoint describing an Object exactly as an
+ * in-process one does.
+ *
+ * Every value stays a string, expiry included, because it arrives as the HTTP
+ * date S3 stores rather than as a `Date` waiting to be formatted.
+ */
+export declare function simS3WriteMetadataHeaders(headers: Headers): SimS3ObjectWriteMetadata;

package/dist/service/s3/object/s3-write-metadata.js

@@ -41,3 +41,46 @@ function metadataValue(value) {
     }
     return value;
 }
+/**
+ * Read the metadata headers of an upload into the members a write carries.
+ *
+ * A request arriving over HTTP states its metadata in the headers real S3
+ * carries it in, which is the form a `PutObjectCommand` is serialized into by
+ * the SDK. Reading them by the same list a write and a read agree on is what
+ * keeps an upload over an endpoint describing an Object exactly as an
+ * in-process one does.
+ *
+ * Every value stays a string, expiry included, because it arrives as the HTTP
+ * date S3 stores rather than as a `Date` waiting to be formatted.
+ */
+export function simS3WriteMetadataHeaders(headers) {
+    const written = {};
+    for (const header of simS3SystemMetadataHeaders) {
+        const value = headers.get(header.name);
+        if (value !== null) {
+            written[header.field] = value;
+        }
+    }
+    const attached = simS3AttachedMetadata(headers);
+    return attached === undefined ? written : { ...written, Metadata: attached };
+}
+/**
+ * The user-defined metadata an upload attached, or nothing where it attached
+ * none.
+ *
+ * S3 sends each entry as its own `x-amz-meta-` header and answers a read with
+ * the keys without the prefix, which is the form a write states them in. An
+ * upload that attached nothing leaves `Metadata` absent rather than empty, so
+ * a copy carrying the source's metadata is not handed an empty object to
+ * copy over it.
+ */
+function simS3AttachedMetadata(headers) {
+    const attached = {};
+    for (const [name, value] of headers) {
+        if (name.toLowerCase().startsWith(simS3UserMetadataPrefix)) {
+            attached[name.slice(simS3UserMetadataPrefix.length).toLowerCase()] =
+                value;
+        }
+    }
+    return Object.keys(attached).length === 0 ? undefined : attached;
+}

package/dist/service/s3/object/s3-write-storage.d.ts

@@ -0,0 +1,27 @@
+import { type SimS3ServerSideEncryption } from "./s3-server-side-encryption.js";
+import { type SimS3StorageClass } from "./s3-storage-class.js";
+/**
+ * The members of a request that say where and how S3 keeps an Object.
+ *
+ * `PutObject`, `CopyObject` and `CreateMultipartUpload` all carry these
+ * alongside the metadata that says what the Object is. Both are read before
+ * anything is stored, because real S3 refuses a write naming a storage class
+ * or an algorithm it has no such thing for.
+ */
+export interface SimS3ObjectWriteStorage {
+    readonly StorageClass?: string | undefined;
+    readonly ServerSideEncryption?: string | undefined;
+}
+/**
+ * The storage class a write asks for, or nothing where it asks for none.
+ */
+export declare function simS3WriteStorageClass(input: SimS3ObjectWriteStorage, context: string): SimS3StorageClass | undefined;
+/**
+ * The encryption S3 stamps on the Object a write is storing.
+ *
+ * The write has the last word, the Bucket's default configuration comes next,
+ * and an Object written into a Bucket carrying neither is SSE-S3 encrypted.
+ * Real S3 has encrypted every new Object that way since January 2023, so
+ * `AES256` is what a read reports for one nobody configured anything for.
+ */
+export declare function simS3WriteEncryption(input: SimS3ObjectWriteStorage, bucketDefault: SimS3ServerSideEncryption | undefined, context: string): SimS3ServerSideEncryption;

package/dist/service/s3/object/s3-write-storage.js

@@ -0,0 +1,21 @@
+import { simS3DefaultServerSideEncryption, simS3ServerSideEncryptionFrom, } from "./s3-server-side-encryption.js";
+import { simS3StorageClassFrom, } from "./s3-storage-class.js";
+/**
+ * The storage class a write asks for, or nothing where it asks for none.
+ */
+export function simS3WriteStorageClass(input, context) {
+    return simS3StorageClassFrom(input.StorageClass, context);
+}
+/**
+ * The encryption S3 stamps on the Object a write is storing.
+ *
+ * The write has the last word, the Bucket's default configuration comes next,
+ * and an Object written into a Bucket carrying neither is SSE-S3 encrypted.
+ * Real S3 has encrypted every new Object that way since January 2023, so
+ * `AES256` is what a read reports for one nobody configured anything for.
+ */
+export function simS3WriteEncryption(input, bucketDefault, context) {
+    return (simS3ServerSideEncryptionFrom(input.ServerSideEncryption, context) ??
+        bucketDefault ??
+        simS3DefaultServerSideEncryption);
+}

package/dist/service/s3/object/s3-write-tagging.d.ts

@@ -0,0 +1,24 @@
+import { SimS3ObjectTagSet } from "./s3-object-tags.js";
+/**
+ * The tagging members of a request that stores an Object.
+ *
+ * `PutObject`, `CopyObject` and `CreateMultipartUpload` all carry `Tagging`,
+ * and only a copy carries a directive, because only a copy has a source tag set
+ * to choose between.
+ */
+export interface SimS3ObjectWriteTagging {
+    /**
+     * The tags to put on the Object, as the URL query string real S3 takes them
+     * in: `department=finance&retention=long`.
+     */
+    readonly Tagging?: string | undefined;
+}
+/**
+ * The tags a write asks S3 to put on the Object it is storing.
+ *
+ * Real S3 sends a tag set on a write as a query string rather than as a list,
+ * because it travels in the `x-amz-tagging` header where a list has nowhere to
+ * go. It is read the same way here, so an SDK caller and an HTTP one produce
+ * the same tag set. A write naming no tags stores an untagged Object.
+ */
+export declare function simS3WriteTags(input: SimS3ObjectWriteTagging, context: string): SimS3ObjectTagSet;

package/dist/service/s3/object/s3-write-tagging.js

@@ -0,0 +1,19 @@
+import { SimS3ObjectTagSet } from "./s3-object-tags.js";
+/**
+ * The tags a write asks S3 to put on the Object it is storing.
+ *
+ * Real S3 sends a tag set on a write as a query string rather than as a list,
+ * because it travels in the `x-amz-tagging` header where a list has nowhere to
+ * go. It is read the same way here, so an SDK caller and an HTTP one produce
+ * the same tag set. A write naming no tags stores an untagged Object.
+ */
+export function simS3WriteTags(input, context) {
+    const tagging = input.Tagging;
+    if (tagging === undefined) {
+        return SimS3ObjectTagSet.empty();
+    }
+    return SimS3ObjectTagSet.from(new URLSearchParams(tagging)
+        .entries()
+        .map(([Key, Value]) => ({ Key, Value }))
+        .toArray(), context);
+}

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

@@ -64,6 +64,18 @@ export function simS3SdkBucketRoutes(simS3) {
             "GetBucketVersioningCommand",
             async (command, context) => await simS3.getBucketVersioning(command, simSdkCallerOptions(context)),
         ],
+        [
+            "PutBucketEncryptionCommand",
+            async (command, context) => await simS3.putBucketEncryption(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetBucketEncryptionCommand",
+            async (command, context) => await simS3.getBucketEncryption(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteBucketEncryptionCommand",
+            async (command, context) => await simS3.deleteBucketEncryption(command, simSdkCallerOptions(context)),
+        ],
         [
             "PutBucketWebsiteCommand",
             async (command, context) => await simS3.putBucketWebsite(command, simSdkCallerOptions(context)),

package/dist/service/s3/sdk/sim-s3-sdk-command-router.js

@@ -1,6 +1,7 @@
 import { simS3SdkBucketRoutes } from "./sim-s3-sdk-bucket-routes.js";
 import { simS3SdkObjectLockRoutes } from "./sim-s3-sdk-object-lock-routes.js";
 import { simS3SdkObjectRoutes } from "./sim-s3-sdk-object-routes.js";
+import { simS3SdkObjectTaggingRoutes } from "./sim-s3-sdk-object-tagging-routes.js";
 /**
  * Routes intercepted SDK Commands to one scoped simulated S3 instance.
  */
@@ -11,6 +12,7 @@ export class SimS3SdkCommandRouter {
             ...simS3SdkBucketRoutes(simS3),
             ...simS3SdkObjectRoutes(simS3),
             ...simS3SdkObjectLockRoutes(simS3),
+            ...simS3SdkObjectTaggingRoutes(simS3),
         ]);
     }
     /**

package/dist/service/s3/sdk/sim-s3-sdk-object-tagging-routes.d.ts

@@ -0,0 +1,9 @@
+import type { SimSdkCommandRoute } from "../../../sdk/index.js";
+import type { SimS3 } from "../sim-s3.js";
+/**
+ * The SDK Commands that hold tags against an Object.
+ *
+ * They route together because each is granted by a permission of its own, and
+ * none of them is reachable through `PutObject` or `GetObject`.
+ */
+export declare function simS3SdkObjectTaggingRoutes(simS3: SimS3): readonly (readonly [string, SimSdkCommandRoute])[];

package/dist/service/s3/sdk/sim-s3-sdk-object-tagging-routes.js

@@ -0,0 +1,23 @@
+import { simSdkCallerOptions } from "../../../sdk/index.js";
+/**
+ * The SDK Commands that hold tags against an Object.
+ *
+ * They route together because each is granted by a permission of its own, and
+ * none of them is reachable through `PutObject` or `GetObject`.
+ */
+export function simS3SdkObjectTaggingRoutes(simS3) {
+    return [
+        [
+            "PutObjectTaggingCommand",
+            async (command, context) => await simS3.putObjectTagging(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetObjectTaggingCommand",
+            async (command, context) => await simS3.getObjectTagging(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteObjectTaggingCommand",
+            async (command, context) => await simS3.deleteObjectTagging(command, simSdkCallerOptions(context)),
+        ],
+    ];
+}

package/dist/service/s3/serve/api/sim-s3-api-bucket-routes.js

@@ -1,4 +1,5 @@
 import { readSimS3NotificationConfiguration } from "./sim-s3-api-notification-read.js";
+import { readSimS3EncryptionConfiguration } from "./sim-s3-api-encryption-read.js";
 import { readSimS3DeleteRequest, readSimS3PublicAccessBlock, readSimS3WebsiteConfiguration, } from "./sim-s3-api-xml-read.js";
 import { bucketBodyInput, bucketInput, listBucketsInput, listObjectsInput, listObjectsV2Input, } from "./sim-s3-api-input.js";
 import { listMultipartUploadsInput } from "./sim-s3-api-multipart-input.js";
@@ -35,6 +36,13 @@ export const simS3BucketApiRoutes = [
         commandName: "GetPublicAccessBlockCommand",
         input: bucketInput,
     },
+    {
+        method: "GET",
+        target: "bucket",
+        subResource: "encryption",
+        commandName: "GetBucketEncryptionCommand",
+        input: bucketInput,
+    },
     {
         method: "GET",
         target: "bucket",
@@ -84,6 +92,13 @@ export const simS3BucketApiRoutes = [
         commandName: "PutPublicAccessBlockCommand",
         input: (request) => bucketBodyInput(request, "PublicAccessBlockConfiguration", readSimS3PublicAccessBlock),
     },
+    {
+        method: "PUT",
+        target: "bucket",
+        subResource: "encryption",
+        commandName: "PutBucketEncryptionCommand",
+        input: (request) => bucketBodyInput(request, "ServerSideEncryptionConfiguration", readSimS3EncryptionConfiguration),
+    },
     {
         method: "PUT",
         target: "bucket",
@@ -111,6 +126,13 @@ export const simS3BucketApiRoutes = [
         commandName: "DeleteBucketPolicyCommand",
         input: bucketInput,
     },
+    {
+        method: "DELETE",
+        target: "bucket",
+        subResource: "encryption",
+        commandName: "DeleteBucketEncryptionCommand",
+        input: bucketInput,
+    },
     {
         method: "DELETE",
         target: "bucket",

package/dist/service/s3/serve/api/sim-s3-api-configuration-output.d.ts

@@ -8,6 +8,10 @@
  * Write a Block Public Access configuration.
  */
 export declare function publicAccessBlockXml(output: Record<string, unknown>): string;
+/**
+ * Write a Bucket's default encryption configuration.
+ */
+export declare function encryptionConfigurationXml(output: Record<string, unknown>): string;
 /**
  * Write an event notification configuration.
  */

package/dist/service/s3/serve/api/sim-s3-api-configuration-output.js

@@ -16,6 +16,16 @@ export function publicAccessBlockXml(output) {
         xmlValue("BlockPublicPolicy", configuration["BlockPublicPolicy"]) +
         xmlValue("RestrictPublicBuckets", configuration["RestrictPublicBuckets"]));
 }
+/**
+ * Write a Bucket's default encryption configuration.
+ */
+export function encryptionConfigurationXml(output) {
+    const configuration = (output["ServerSideEncryptionConfiguration"] ?? {});
+    return xmlDocument("ServerSideEncryptionConfiguration", (configuration.Rules ?? [])
+        .map((rule) => xmlElement("Rule", xmlElement("ApplyServerSideEncryptionByDefault", xmlValue("SSEAlgorithm", rule.ApplyServerSideEncryptionByDefault?.SSEAlgorithm) +
+        xmlValue("KMSMasterKeyID", rule.ApplyServerSideEncryptionByDefault?.KMSMasterKeyID)) + xmlValue("BucketKeyEnabled", rule.BucketKeyEnabled)))
+        .join(""));
+}
 /**
  * Write an event notification configuration.
  */

package/dist/service/s3/serve/api/sim-s3-api-encryption-read.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read a default encryption configuration.
+ *
+ * Real S3 takes one rule and the SDK sends a list, so the list is read here
+ * and the Bucket decides what to do with more than one of them.
+ */
+export declare function readSimS3EncryptionConfiguration(body: string): object;

package/dist/service/s3/serve/api/sim-s3-api-encryption-read.js

@@ -0,0 +1,30 @@
+import { parseXmlDocument, xmlBoolean, xmlChild, xmlChildren, xmlText, } from "../../../../util/xml/xml-document.js";
+/**
+ * Read a default encryption configuration.
+ *
+ * Real S3 takes one rule and the SDK sends a list, so the list is read here
+ * and the Bucket decides what to do with more than one of them.
+ */
+export function readSimS3EncryptionConfiguration(body) {
+    const root = parseXmlDocument(body);
+    return {
+        Rules: xmlChildren(root, "Rule").map((rule) => {
+            const byDefault = xmlChild(rule, "ApplyServerSideEncryptionByDefault");
+            return {
+                ...(byDefault !== undefined && {
+                    ApplyServerSideEncryptionByDefault: {
+                        ...defined("SSEAlgorithm", xmlText(byDefault, "SSEAlgorithm")),
+                        ...defined("KMSMasterKeyID", xmlText(byDefault, "KMSMasterKeyID")),
+                    },
+                }),
+                ...defined("BucketKeyEnabled", xmlBoolean(rule, "BucketKeyEnabled")),
+            };
+        }),
+    };
+}
+/**
+ * One member of a request document, or nothing where it was absent.
+ */
+function defined(name, value) {
+    return value === undefined ? {} : { [name]: value };
+}

package/dist/service/s3/serve/api/sim-s3-api-head-output.d.ts

@@ -9,9 +9,11 @@
  * Answer a HEAD with what a read would have said and none of the Object.
  *
  * The `content-length` describes the Object rather than the response, which is
- * what makes a HEAD worth sending.
+ * what makes a HEAD worth sending. A HEAD reads the same `response-` parameters
+ * a GET does, so a caller can see what a presigned URL would serve without
+ * fetching the Object.
  */
-export declare function simS3HeadObjectResponse(output: Record<string, unknown>): Response;
+export declare function simS3HeadObjectResponse(output: Record<string, unknown>, overrides: Readonly<Record<string, string>>): Response;
 /**
  * Answer that a Bucket is there and reachable.
  *

package/dist/service/s3/serve/api/sim-s3-api-head-output.js

@@ -11,16 +11,22 @@ import { simS3SystemMetadataHeadersFrom } from "../../object/s3-system-metadata-
  * Answer a HEAD with what a read would have said and none of the Object.
  *
  * The `content-length` describes the Object rather than the response, which is
- * what makes a HEAD worth sending.
+ * what makes a HEAD worth sending. A HEAD reads the same `response-` parameters
+ * a GET does, so a caller can see what a presigned URL would serve without
+ * fetching the Object.
  */
-export function simS3HeadObjectResponse(output) {
+export function simS3HeadObjectResponse(output, overrides) {
     return new Response(undefined, {
         status: 200,
         headers: simS3ObjectResponseHeaders({
             metadata: simS3SystemMetadataHeadersFrom(output),
+            userMetadata: output["Metadata"],
+            overrides,
             bodyLength: output["ContentLength"] ?? 0,
             etag: output["ETag"],
             lastModified: output["LastModified"],
+            storageClass: output["StorageClass"],
+            serverSideEncryption: output["ServerSideEncryption"],
         }),
     });
 }

package/dist/service/s3/serve/api/sim-s3-api-input.d.ts

@@ -26,12 +26,6 @@ export declare function listObjectsV2Input(request: SimS3ApiRequest): object;
  * The first ListObjects input, which pages by marker.
  */
 export declare function listObjectsInput(request: SimS3ApiRequest): object;
-/**
- * The user metadata an upload carried, which S3 sends as `x-amz-meta-` headers.
- */
-export declare function simS3UserMetadata(headers: Headers): {
-    Metadata?: Record<string, string>;
-};
 /**
  * Include a member only when the request stated it, since an operation treats
  * an absent member and an empty one differently.

package/dist/service/s3/serve/api/sim-s3-api-input.js

@@ -38,6 +38,7 @@ export function listObjectsV2Input(request) {
         ...optional("ContinuationToken", request.query.get("continuation-token")),
         ...optional("StartAfter", request.query.get("start-after")),
         ...optionalNumber("MaxKeys", request.query.get("max-keys")),
+        ...optional("EncodingType", request.query.get("encoding-type")),
     };
 }
 /**
@@ -50,21 +51,9 @@ export function listObjectsInput(request) {
         ...optional("Delimiter", request.query.get("delimiter")),
         ...optional("Marker", request.query.get("marker")),
         ...optionalNumber("MaxKeys", request.query.get("max-keys")),
+        ...optional("EncodingType", request.query.get("encoding-type")),
     };
 }
-/**
- * The user metadata an upload carried, which S3 sends as `x-amz-meta-` headers.
- */
-export function simS3UserMetadata(headers) {
-    const prefix = "x-amz-meta-";
-    const metadata = {};
-    for (const [name, value] of headers) {
-        if (name.toLowerCase().startsWith(prefix)) {
-            metadata[name.slice(prefix.length).toLowerCase()] = value;
-        }
-    }
-    return Object.keys(metadata).length === 0 ? {} : { Metadata: metadata };
-}
 /**
  * Include a member only when the request stated it, since an operation treats
  * an absent member and an empty one differently.

package/dist/service/s3/serve/api/sim-s3-api-listing.d.ts

@@ -26,6 +26,7 @@ interface ListObjectsOutput {
     readonly StartAfter?: string | undefined;
     readonly Marker?: string | undefined;
     readonly NextMarker?: string | undefined;
+    readonly EncodingType?: string | undefined;
 }
 interface ListBucketsOutput {
     readonly Buckets?: readonly BucketSummary[] | undefined;
@@ -42,6 +43,10 @@ export declare function simS3ListBucketsXml(output: ListBucketsOutput): string;
  * Both listing versions answer in a `ListBucketResult`, and differ only in how
  * they say where the next page starts. The version is passed in because the
  * output alone cannot say which was asked for.
+ *
+ * The keys arrive encoded or not according to what the listing was asked for,
+ * so nothing is encoded here. `EncodingType` says which of the two a client is
+ * reading, and is absent from a listing that asked for no encoding.
  */
 export declare function simS3ListObjectsXml(output: ListObjectsOutput, version: 1 | 2): string;
 export {};

package/dist/service/s3/serve/api/sim-s3-api-listing.js

@@ -17,6 +17,10 @@ export function simS3ListBucketsXml(output) {
  * Both listing versions answer in a `ListBucketResult`, and differ only in how
  * they say where the next page starts. The version is passed in because the
  * output alone cannot say which was asked for.
+ *
+ * The keys arrive encoded or not according to what the listing was asked for,
+ * so nothing is encoded here. `EncodingType` says which of the two a client is
+ * reading, and is absent from a listing that asked for no encoding.
  */
 export function simS3ListObjectsXml(output, version) {
     const contents = (output.Contents ?? []).map(objectSummaryXml).join("");
@@ -26,6 +30,7 @@ export function simS3ListObjectsXml(output, version) {
     return xmlDocument("ListBucketResult", xmlValue("Name", output.Name) +
         xmlValue("Prefix", output.Prefix) +
         xmlValue("Delimiter", output.Delimiter) +
+        xmlValue("EncodingType", output.EncodingType) +
         xmlValue("MaxKeys", output.MaxKeys) +
         xmlValue("IsTruncated", output.IsTruncated ?? false) +
         pagingXml(output, version) +

package/dist/service/s3/serve/api/sim-s3-api-object-input.d.ts

@@ -15,6 +15,17 @@ export declare const simS3CopySourceHeader = "x-amz-copy-source";
  * The input of an operation naming one Object.
  */
 export declare function objectInput(request: SimS3ApiRequest): object;
+/**
+ * The input of an operation naming one Object, or one version of it.
+ *
+ * Real S3 names the version in the query string alongside the sub-resource, so
+ * a request naming none acts on whatever a plain read of the key answers with.
+ */
+export declare function versionedObjectInput(request: SimS3ApiRequest): object;
+/**
+ * The input of a tagging write, which carries its tag set as a document.
+ */
+export declare function putObjectTaggingInput(request: SimS3ApiRequest): object;
 /**
  * The input of a read, which can ask for part of an Object.
  */
@@ -36,5 +47,10 @@ export declare function copyObjectInput(request: SimS3ApiRequest): object;
 /**
  * The input of a request that describes an Object without carrying its bytes,
  * which is what starting a multipart upload is.
+ *
+ * The metadata headers are read by the list a write and a read share, so an
+ * upload over this endpoint describes an Object exactly as a `PutObjectCommand`
+ * does. Where S3 keeps the Object and how it encrypts it are read alongside
+ * them, being facts about the storage rather than metadata about the Object.
  */
 export declare function createMultipartUploadInput(request: SimS3ApiRequest): object;

package/dist/service/s3/serve/api/sim-s3-api-object-input.js

@@ -1,4 +1,6 @@
-import { optional, simS3UserMetadata } from "./sim-s3-api-input.js";
+import { simS3WriteMetadataHeaders } from "../../object/s3-write-metadata.js";
+import { optional, utf8 } from "./sim-s3-api-input.js";
+import { readSimS3Tagging } from "./sim-s3-api-tagging-read.js";
 /**
  * Reading the Object operations' inputs out of a request.
  *
@@ -17,6 +19,27 @@ export const simS3CopySourceHeader = "x-amz-copy-source";
 export function objectInput(request) {
     return { Bucket: request.bucketName, Key: request.objectKey };
 }
+/**
+ * The input of an operation naming one Object, or one version of it.
+ *
+ * Real S3 names the version in the query string alongside the sub-resource, so
+ * a request naming none acts on whatever a plain read of the key answers with.
+ */
+export function versionedObjectInput(request) {
+    return {
+        ...objectInput(request),
+        ...optional("VersionId", request.query.get("versionId")),
+    };
+}
+/**
+ * The input of a tagging write, which carries its tag set as a document.
+ */
+export function putObjectTaggingInput(request) {
+    return {
+        ...versionedObjectInput(request),
+        Tagging: readSimS3Tagging(utf8(request.body)),
+    };
+}
 /**
  * The input of a read, which can ask for part of an Object.
  */
@@ -46,21 +69,25 @@ export function copyObjectInput(request) {
         ...createMultipartUploadInput(request),
         ...optional("CopySource", request.headers.get(simS3CopySourceHeader)),
         ...optional("MetadataDirective", request.headers.get("x-amz-metadata-directive")),
+        ...optional("TaggingDirective", request.headers.get("x-amz-tagging-directive")),
     };
 }
 /**
  * The input of a request that describes an Object without carrying its bytes,
  * which is what starting a multipart upload is.
+ *
+ * The metadata headers are read by the list a write and a read share, so an
+ * upload over this endpoint describes an Object exactly as a `PutObjectCommand`
+ * does. Where S3 keeps the Object and how it encrypts it are read alongside
+ * them, being facts about the storage rather than metadata about the Object.
  */
 export function createMultipartUploadInput(request) {
     return {
         Bucket: request.bucketName,
         Key: request.objectKey,
-        ...optional("ContentType", request.headers.get("content-type")),
-        ...optional("CacheControl", request.headers.get("cache-control")),
-        ...optional("ContentDisposition", request.headers.get("content-disposition")),
-        ...optional("ContentEncoding", request.headers.get("content-encoding")),
-        ...optional("ContentLanguage", request.headers.get("content-language")),
-        ...simS3UserMetadata(request.headers),
+        ...simS3WriteMetadataHeaders(request.headers),
+        ...optional("StorageClass", request.headers.get("x-amz-storage-class")),
+        ...optional("Tagging", request.headers.get("x-amz-tagging")),
+        ...optional("ServerSideEncryption", request.headers.get("x-amz-server-side-encryption")),
     };
 }

package/dist/service/s3/serve/api/sim-s3-api-object-output.d.ts

@@ -11,13 +11,30 @@ interface CopyObjectOutput {
  * reads the new ETag and write time out of this body and nowhere else.
  */
 export declare function simS3CopyObjectXml(output: CopyObjectOutput): string;
+interface TagSetOutput {
+    readonly TagSet?: readonly {
+        readonly Key?: string;
+        readonly Value?: string;
+    }[];
+}
+/**
+ * Write the tags on an Object as the document real S3 answers them with.
+ *
+ * An Object nobody has tagged answers with an empty `TagSet` element rather
+ * than none at all, which is what tells a client the Object exists and carries
+ * no tags.
+ */
+export declare function simS3ObjectTaggingXml(output: TagSetOutput): string;
 /**
  * Answer a read with the Object itself, headers and all.
  *
+ * The headers the read named in its `response-` parameters are served in place
+ * of the Object's own, leaving what the Object was written with alone.
+ *
  * A read that asked for part of the Object is answered `206 Partial Content`
  * and says which part it carries, because a client reading a large Object in
  * pieces at once writes each response at the offset it asked for, and a `200`
  * carrying the whole Object would be written over its neighbours.
  */
-export declare function simS3GetObjectResponse(output: Record<string, unknown>): Promise<Response>;
+export declare function simS3GetObjectResponse(output: Record<string, unknown>, overrides: Readonly<Record<string, string>>): Promise<Response>;
 export {};