@felipedsvit/s3node 0.1.2

package/src/handlers/config.js

@@ -0,0 +1,129 @@
+import { S3Error } from '../errors.js'
+import { collectBody, sendEmpty, sendXml } from '../http.js'
+import { corsXml, parseCorsXml } from '../features/cors.js'
+import { lifecycleXml, parseLifecycleXml } from '../features/lifecycle.js'
+import { notificationXml, parseNotificationXml } from '../features/notifications.js'
+import { parsePolicy } from '../features/policy.js'
+import { MAX_BUCKET_TAGS, parseTaggingXml, taggingXml } from '../features/tagging.js'
+import { childText, document, parseXml, text } from '../xml.js'
+
+/* ----------------------------- versioning ----------------------------- */
+
+export function getBucketVersioning(ctx, res, { store }) {
+  const status = store.bucketVersioning(ctx.bucket)
+  sendXml(ctx, res, 200, document('VersioningConfiguration',
+    status === 'Unset' ? '' : text('Status', status)))
+}
+
+export async function putBucketVersioning(ctx, res, { store }) {
+  store.requireBucket(ctx.bucket)
+  const root = parseXml(await collectBody(ctx.bodyStreams))
+  if (root.name !== 'VersioningConfiguration') {
+    throw new S3Error('MalformedXML', 'Expected a VersioningConfiguration element')
+  }
+  const status = childText(root, 'Status')
+  if (status !== 'Enabled' && status !== 'Suspended') {
+    throw new S3Error('IllegalVersioningConfigurationException',
+      'The versioning status must be Enabled or Suspended')
+  }
+  store.putBucketConfig(ctx.bucket, 'versioning', { status })
+  sendEmpty(ctx, res, 200)
+}
+
+/* ------------------------------- policy ------------------------------- */
+
+export function getBucketPolicy(ctx, res, { store }) {
+  const policy = store.getBucketConfig(ctx.bucket, 'policy')
+  if (!policy) throw new S3Error('NoSuchBucketPolicy')
+  const body = Buffer.from(JSON.stringify(policy), 'utf8')
+  res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': body.length })
+  res.end(body)
+}
+
+export async function putBucketPolicy(ctx, res, { store }) {
+  store.requireBucket(ctx.bucket)
+  const policy = parsePolicy(await collectBody(ctx.bodyStreams))
+  store.putBucketConfig(ctx.bucket, 'policy', policy)
+  sendEmpty(ctx, res, 204)
+}
+
+export function deleteBucketPolicy(ctx, res, { store }) {
+  store.deleteBucketConfig(ctx.bucket, 'policy')
+  sendEmpty(ctx, res, 204)
+}
+
+/* -------------------------------- CORS -------------------------------- */
+
+export function getBucketCors(ctx, res, { store }) {
+  const config = store.getBucketConfig(ctx.bucket, 'cors')
+  if (!config) throw new S3Error('NoSuchCORSConfiguration')
+  sendXml(ctx, res, 200, corsXml(config))
+}
+
+export async function putBucketCors(ctx, res, { store }) {
+  store.requireBucket(ctx.bucket)
+  store.putBucketConfig(ctx.bucket, 'cors', parseCorsXml(await collectBody(ctx.bodyStreams)))
+  sendEmpty(ctx, res, 200)
+}
+
+export function deleteBucketCors(ctx, res, { store }) {
+  store.deleteBucketConfig(ctx.bucket, 'cors')
+  sendEmpty(ctx, res, 204)
+}
+
+/* ----------------------------- lifecycle ------------------------------ */
+
+export function getBucketLifecycle(ctx, res, { store }) {
+  const config = store.getBucketConfig(ctx.bucket, 'lifecycle')
+  if (!config) throw new S3Error('NoSuchLifecycleConfiguration')
+  sendXml(ctx, res, 200, lifecycleXml(config))
+}
+
+export async function putBucketLifecycle(ctx, res, { store }) {
+  store.requireBucket(ctx.bucket)
+  store.putBucketConfig(ctx.bucket, 'lifecycle', parseLifecycleXml(await collectBody(ctx.bodyStreams)))
+  sendEmpty(ctx, res, 200)
+}
+
+export function deleteBucketLifecycle(ctx, res, { store }) {
+  store.deleteBucketConfig(ctx.bucket, 'lifecycle')
+  sendEmpty(ctx, res, 204)
+}
+
+/* ------------------------------ tagging ------------------------------- */
+
+export function getBucketTagging(ctx, res, { store }) {
+  const tags = store.getBucketConfig(ctx.bucket, 'tagging')
+  if (!tags || Object.keys(tags).length === 0) throw new S3Error('NoSuchTagSet')
+  sendXml(ctx, res, 200, taggingXml(tags))
+}
+
+export async function putBucketTagging(ctx, res, { store }) {
+  store.requireBucket(ctx.bucket)
+  const tags = parseTaggingXml(await collectBody(ctx.bodyStreams), { max: MAX_BUCKET_TAGS })
+  store.putBucketConfig(ctx.bucket, 'tagging', tags)
+  sendEmpty(ctx, res, 204)
+}
+
+export function deleteBucketTagging(ctx, res, { store }) {
+  store.deleteBucketConfig(ctx.bucket, 'tagging')
+  sendEmpty(ctx, res, 204)
+}
+
+/* --------------------------- notifications ---------------------------- */
+
+export function getBucketNotification(ctx, res, { store }) {
+  const config = store.getBucketConfig(ctx.bucket, 'notification')
+  sendXml(ctx, res, 200, notificationXml(config ?? { targets: [] }))
+}
+
+export async function putBucketNotification(ctx, res, { store }) {
+  store.requireBucket(ctx.bucket)
+  const config = parseNotificationXml(await collectBody(ctx.bodyStreams))
+  if (config.targets.length === 0) {
+    store.deleteBucketConfig(ctx.bucket, 'notification')
+  } else {
+    store.putBucketConfig(ctx.bucket, 'notification', config)
+  }
+  sendEmpty(ctx, res, 200)
+}

package/src/handlers/index.js

@@ -0,0 +1,6 @@
+export * from './service.js'
+export * from './bucket.js'
+export * from './config.js'
+export * from './object.js'
+export * from './multipart.js'
+export * from './post.js'

package/src/handlers/multipart.js

@@ -0,0 +1,109 @@
+import { S3Error } from '../errors.js'
+import { encryptionResponseHeaders } from '../features/encryption.js'
+import { parseTaggingHeader } from '../features/tagging.js'
+import { collectBody, isoDate, sendEmpty, sendXml, userMetadata } from '../http.js'
+import { childText, childrenNamed, document, parseXml, text } from '../xml.js'
+import {
+  checksumHeaders, integerParam, integrityOptions, notify, ownerXml, sseRequest, versionHeaders,
+} from './shared.js'
+
+export function createMultipartUpload(ctx, res, { store }) {
+  const { uploadId, encryption } = store.createMultipartUpload({
+    bucket: ctx.bucket,
+    key: ctx.key,
+    contentType: ctx.headers['content-type'],
+    metadata: userMetadata(ctx.headers),
+    tags: parseTaggingHeader(ctx.headers['x-amz-tagging']),
+    encryptionRequest: sseRequest(ctx, store),
+  })
+  sendXml(ctx, res, 200, document('InitiateMultipartUploadResult',
+    text('Bucket', ctx.bucket) + text('Key', ctx.key) + text('UploadId', uploadId)),
+  encryptionResponseHeaders(encryption))
+}
+
+export async function uploadPart(ctx, res, { store }) {
+  const partNumber = Number.parseInt(ctx.query.get('partNumber'), 10)
+  const result = await store.uploadPart({
+    bucket: ctx.bucket,
+    key: ctx.key,
+    uploadId: ctx.query.get('uploadId'),
+    partNumber,
+    body: ctx.bodyStreams,
+    encryptionRequest: sseRequest(ctx, store),
+    ...integrityOptions(ctx),
+  })
+  sendEmpty(ctx, res, 200, { ETag: result.etag, ...encryptionResponseHeaders(result.encryption) })
+}
+
+export async function completeMultipartUpload(ctx, res, { store, server }) {
+  const uploadId = ctx.query.get('uploadId')
+  const root = parseXml(await collectBody(ctx.bodyStreams))
+  if (root.name !== 'CompleteMultipartUpload') {
+    throw new S3Error('MalformedXML', 'Expected a CompleteMultipartUpload element')
+  }
+
+  const requestedParts = childrenNamed(root, 'Part').map((part) => {
+    const partNumber = Number.parseInt(childText(part, 'PartNumber') ?? '', 10)
+    const etag = childText(part, 'ETag')
+    if (!Number.isInteger(partNumber) || !etag) {
+      throw new S3Error('MalformedXML', 'Each Part requires PartNumber and ETag')
+    }
+    return { partNumber, etag }
+  })
+
+  const result = await store.completeMultipartUpload({
+    bucket: ctx.bucket, key: ctx.key, uploadId, requestedParts,
+  })
+
+  notify(server, {
+    bucket: ctx.bucket, eventName: 'ObjectCreated:CompleteMultipartUpload', key: ctx.key,
+    size: result.size, etag: result.etag, versionId: result.versionId,
+  })
+
+  const location = `http://${ctx.headers.host ?? 'localhost'}/${ctx.bucket}/${encodeURIComponent(ctx.key)}`
+  sendXml(ctx, res, 200, document('CompleteMultipartUploadResult',
+    text('Location', location) + text('Bucket', ctx.bucket) +
+    text('Key', ctx.key) + text('ETag', result.etag)),
+  { ...versionHeaders(result), ...encryptionResponseHeaders(result.encryption) })
+}
+
+export async function abortMultipartUpload(ctx, res, { store }) {
+  await store.abortMultipartUpload({
+    bucket: ctx.bucket, key: ctx.key, uploadId: ctx.query.get('uploadId'),
+  })
+  sendEmpty(ctx, res, 204)
+}
+
+export function listParts(ctx, res, { store }) {
+  const uploadId = ctx.query.get('uploadId')
+  const partNumberMarker = integerParam(ctx.query, 'part-number-marker', 0)
+  const maxParts = integerParam(ctx.query, 'max-parts', 1000, { min: 0, max: 1000 })
+  const parts = store.listParts(ctx.bucket, ctx.key, uploadId, { partNumberMarker, maxParts })
+
+  const body =
+    text('Bucket', ctx.bucket) + text('Key', ctx.key) + text('UploadId', uploadId) +
+    text('PartNumberMarker', partNumberMarker) + text('MaxParts', maxParts) +
+    text('IsTruncated', String(parts.length === maxParts)) +
+    text('StorageClass', 'STANDARD') + ownerXml +
+    parts.map((part) =>
+      `<Part>${text('PartNumber', part.partNumber)}${text('LastModified', isoDate(part.uploadedAt))
+      }${text('ETag', part.etag)}${text('Size', part.size)}</Part>`
+    ).join('')
+
+  sendXml(ctx, res, 200, document('ListPartsResult', body))
+}
+
+export function listMultipartUploads(ctx, res, { store }) {
+  const maxUploads = integerParam(ctx.query, 'max-uploads', 1000, { min: 0, max: 1000 })
+  const uploads = store.listMultipartUploads(ctx.bucket, maxUploads)
+  const body =
+    text('Bucket', ctx.bucket) + text('MaxUploads', maxUploads) +
+    text('IsTruncated', String(uploads.length === maxUploads)) +
+    uploads.map((upload) =>
+      `<Upload>${text('Key', upload.key.toString('utf8'))}${text('UploadId', upload.uploadId)
+      }${ownerXml}${text('StorageClass', 'STANDARD')}${text('Initiated', isoDate(upload.initiatedAt))}</Upload>`
+    ).join('')
+  sendXml(ctx, res, 200, document('ListMultipartUploadsResult', body))
+}
+
+export { checksumHeaders }

package/src/handlers/object.js

@@ -0,0 +1,211 @@
+import { pipeline } from 'node:stream/promises'
+import { S3Error } from '../errors.js'
+import { encryptionResponseHeaders } from '../features/encryption.js'
+import { parseTaggingHeader, parseTaggingXml, taggingXml } from '../features/tagging.js'
+import {
+  baseHeaders,
+  collectBody,
+  evaluatePreconditions,
+  httpDate,
+  isoDate,
+  parseRange,
+  sendEmpty,
+  sendXml,
+  userMetadata,
+} from '../http.js'
+import { document, text } from '../xml.js'
+import { checksumHeaders, integrityOptions, notify, sseRequest, versionHeaders } from './shared.js'
+
+function requestedVersionId(ctx) {
+  const versionId = ctx.query.get('versionId')
+  return versionId || null
+}
+
+export async function putObject(ctx, res, { store, server }) {
+  const result = await store.putObject({
+    bucket: ctx.bucket,
+    key: ctx.key,
+    body: ctx.bodyStreams,
+    contentType: ctx.headers['content-type'],
+    metadata: userMetadata(ctx.headers),
+    tags: parseTaggingHeader(ctx.headers['x-amz-tagging']),
+    encryptionRequest: sseRequest(ctx, store),
+    ...integrityOptions(ctx),
+  })
+
+  notify(server, {
+    bucket: ctx.bucket, eventName: 'ObjectCreated:Put', key: ctx.key,
+    size: result.size, etag: result.etag, versionId: result.versionId,
+  })
+
+  sendEmpty(ctx, res, 200, {
+    ETag: result.etag,
+    ...checksumHeaders(result.checksums),
+    ...versionHeaders(result),
+    ...encryptionResponseHeaders(result.encryption),
+  })
+}
+
+export async function copyObject(ctx, res, { store, server }) {
+  const raw = String(ctx.headers['x-amz-copy-source'])
+  const [pathPart, queryPart] = raw.split('?')
+  const normalized = pathPart.startsWith('/') ? pathPart.slice(1) : pathPart
+  const slash = normalized.indexOf('/')
+  if (slash === -1) throw new S3Error('InvalidArgument', 'Invalid x-amz-copy-source')
+
+  let sourceBucket
+  let sourceKey
+  try {
+    sourceBucket = decodeURIComponent(normalized.slice(0, slash))
+    sourceKey = decodeURIComponent(normalized.slice(slash + 1))
+  } catch {
+    throw new S3Error('InvalidArgument', 'Invalid x-amz-copy-source encoding')
+  }
+  const sourceVersionId = queryPart
+    ? new URLSearchParams(queryPart).get('versionId')
+    : null
+
+  const metadataDirective = String(ctx.headers['x-amz-metadata-directive'] ?? 'COPY').toUpperCase()
+  const taggingDirective = String(ctx.headers['x-amz-tagging-directive'] ?? 'COPY').toUpperCase()
+
+  const result = await store.copyObject({
+    sourceBucket,
+    sourceKey,
+    sourceVersionId,
+    bucket: ctx.bucket,
+    key: ctx.key,
+    replaceMetadata: metadataDirective === 'REPLACE',
+    metadata: userMetadata(ctx.headers),
+    contentType: ctx.headers['content-type'],
+    replaceTags: taggingDirective === 'REPLACE',
+    tags: parseTaggingHeader(ctx.headers['x-amz-tagging']),
+    sourceEncryptionRequest: sseRequest(ctx, store, { copySource: true }),
+    encryptionRequest: sseRequest(ctx, store),
+  })
+
+  notify(server, {
+    bucket: ctx.bucket, eventName: 'ObjectCreated:Copy', key: ctx.key,
+    size: result.size, etag: result.etag, versionId: result.versionId,
+  })
+
+  sendXml(ctx, res, 200, document('CopyObjectResult',
+    text('LastModified', isoDate(result.lastModified)) + text('ETag', result.etag)),
+  {
+    ...versionHeaders(result),
+    ...encryptionResponseHeaders(result.encryption),
+    ...(sourceVersionId ? { 'x-amz-copy-source-version-id': sourceVersionId } : {}),
+  })
+}
+
+function objectResponseHeaders(ctx, record) {
+  const headers = {
+    ...baseHeaders(ctx),
+    'Content-Type': record.contentType ?? 'application/octet-stream',
+    ETag: record.etag,
+    'Last-Modified': httpDate(record.lastModified),
+    'Accept-Ranges': 'bytes',
+    ...checksumHeaders(record.checksums),
+    ...encryptionResponseHeaders(record.encryption),
+  }
+  if (record.versionId && record.versionId !== 'null') headers['x-amz-version-id'] = record.versionId
+  if (Object.keys(record.tags ?? {}).length) {
+    headers['x-amz-tagging-count'] = String(Object.keys(record.tags).length)
+  }
+  for (const [name, value] of Object.entries(record.metadata ?? {})) {
+    headers[`x-amz-meta-${name}`] = value
+  }
+  // Response header overrides for presigned download links.
+  const overrides = {
+    'response-content-type': 'Content-Type',
+    'response-content-disposition': 'Content-Disposition',
+    'response-content-encoding': 'Content-Encoding',
+    'response-content-language': 'Content-Language',
+    'response-cache-control': 'Cache-Control',
+    'response-expires': 'Expires',
+  }
+  for (const [param, header] of Object.entries(overrides)) {
+    const value = ctx.query.get(param)
+    if (value !== undefined) headers[header] = value
+  }
+  return headers
+}
+
+export async function getObject(ctx, res, { store }) {
+  const record = store.getObject(ctx.bucket, ctx.key, requestedVersionId(ctx))
+  const encryptionKey = store.resolveEncryptionKey(record, sseRequest(ctx, store))
+
+  if (evaluatePreconditions(ctx.headers, record) === 'not-modified') {
+    sendEmpty(ctx, res, 304, { ETag: record.etag, 'Last-Modified': httpDate(record.lastModified) })
+    return
+  }
+
+  const range = parseRange(ctx.headers.range, record.size)
+  const start = range ? range.start : 0
+  const end = range ? range.end : record.size - 1
+  const length = record.size === 0 ? 0 : end - start + 1
+
+  const headers = { ...objectResponseHeaders(ctx, record), 'Content-Length': length }
+  if (range) {
+    headers['Content-Range'] = `bytes ${start}-${end}/${record.size}`
+    // The stored checksum covers the whole object, not the slice being sent.
+    // Returning it makes SDK-side validation fail on every ranged read.
+    for (const name of Object.keys(headers)) {
+      if (name.startsWith('x-amz-checksum-')) delete headers[name]
+    }
+  }
+
+  res.writeHead(range ? 206 : 200, headers)
+  if (length === 0) {
+    res.end()
+    return
+  }
+  await pipeline(store.createObjectStream(record, start, end, { encryptionKey }), res)
+}
+
+export function headObject(ctx, res, { store }) {
+  const record = store.getObject(ctx.bucket, ctx.key, requestedVersionId(ctx))
+  store.resolveEncryptionKey(record, sseRequest(ctx, store))
+  if (evaluatePreconditions(ctx.headers, record) === 'not-modified') {
+    sendEmpty(ctx, res, 304, { ETag: record.etag })
+    return
+  }
+  res.writeHead(200, { ...objectResponseHeaders(ctx, record), 'Content-Length': record.size })
+  res.end()
+}
+
+export async function deleteObject(ctx, res, { store, server }) {
+  const result = await store.deleteObject(ctx.bucket, ctx.key, requestedVersionId(ctx))
+
+  if (result.deleted) {
+    notify(server, {
+      bucket: ctx.bucket,
+      eventName: result.deleteMarker ? 'ObjectRemoved:DeleteMarkerCreated' : 'ObjectRemoved:Delete',
+      key: ctx.key, size: 0, versionId: result.versionId,
+    })
+  }
+
+  const headers = {}
+  if (result.versionId && result.versionId !== 'null') headers['x-amz-version-id'] = result.versionId
+  if (result.deleteMarker) headers['x-amz-delete-marker'] = 'true'
+  // S3 deletes are idempotent: a missing key still reports success.
+  sendEmpty(ctx, res, 204, headers)
+}
+
+/* ------------------------------ tagging ------------------------------- */
+
+export function getObjectTagging(ctx, res, { store }) {
+  const versionId = requestedVersionId(ctx)
+  const tags = store.getObjectTags(ctx.bucket, ctx.key, versionId)
+  sendXml(ctx, res, 200, taggingXml(tags), versionId ? { 'x-amz-version-id': versionId } : {})
+}
+
+export async function putObjectTagging(ctx, res, { store }) {
+  const tags = parseTaggingXml(await collectBody(ctx.bodyStreams))
+  const versionId = store.setObjectTags(ctx.bucket, ctx.key, requestedVersionId(ctx), tags)
+  sendEmpty(ctx, res, 200, versionId !== 'null' ? { 'x-amz-version-id': versionId } : {})
+}
+
+export function deleteObjectTagging(ctx, res, { store }) {
+  const versionId = store.setObjectTags(ctx.bucket, ctx.key, requestedVersionId(ctx), {})
+  sendEmpty(ctx, res, 204, versionId !== 'null' ? { 'x-amz-version-id': versionId } : {})
+}

package/src/handlers/post.js

@@ -0,0 +1,106 @@
+import { S3Error } from '../errors.js'
+import { parseBoundary, parseFormData } from '../features/formdata.js'
+import { resolveKey, verifyPostPolicy } from '../features/postpolicy.js'
+import { baseHeaders, sendEmpty, sendXml } from '../http.js'
+import { document, text } from '../xml.js'
+import { notify } from './shared.js'
+
+/**
+ * Browser form upload: `POST /{bucket}` with multipart/form-data.
+ *
+ * Unlike every other route this one authenticates itself, because the
+ * credential and signature arrive as form fields rather than headers. The
+ * router therefore reaches it before the normal SigV4 path runs.
+ */
+export async function postObject(ctx, res, { store, server }) {
+  const contentType = String(ctx.headers['content-type'] ?? '')
+  if (!contentType.toLowerCase().startsWith('multipart/form-data')) {
+    throw new S3Error('MalformedPOSTRequest', 'POST uploads require multipart/form-data')
+  }
+  store.requireBucket(ctx.bucket)
+
+  const { fields, file } = await parseFormData(ctx.bodyStreams, {
+    boundary: parseBoundary(contentType),
+  })
+  if (!file) throw new S3Error('MalformedPOSTRequest', 'The POST request is missing a file field')
+
+  let verified
+  try {
+    verified = verifyPostPolicy({
+      fields,
+      bucket: ctx.bucket,
+      lookupCredential: server.credentials.lookup,
+    })
+  } catch (err) {
+    file.stream.destroy()
+    throw err
+  }
+
+  const key = resolveKey(fields.get('key'), file.filename)
+  try {
+    // The form told us who is uploading; a bucket policy still gets its say.
+    server.authorizePostUpload(ctx, key, verified.accessKeyId)
+  } catch (err) {
+    file.stream.destroy()
+    throw err
+  }
+
+  const metadata = {}
+  for (const [name, value] of fields) {
+    if (name.startsWith('x-amz-meta-')) metadata[name.slice('x-amz-meta-'.length)] = value
+  }
+
+  const result = await store.putObject({
+    bucket: ctx.bucket,
+    key,
+    body: [file.stream],
+    contentType: fields.get('content-type') ?? file.contentType,
+    metadata,
+  })
+
+  // content-length-range is only knowable once the body has been read.
+  if (verified.range) {
+    const { min, max } = verified.range
+    if (result.size < min || result.size > max) {
+      await store.deleteObject(ctx.bucket, key, result.versioned ? result.versionId : null)
+      throw new S3Error('EntityTooLarge',
+        `The uploaded body must be between ${min} and ${max} bytes`)
+    }
+  }
+
+  notify(server, {
+    bucket: ctx.bucket, eventName: 'ObjectCreated:Post', key,
+    size: result.size, etag: result.etag, versionId: result.versionId,
+  })
+
+  const location = `http://${ctx.headers.host ?? 'localhost'}/${ctx.bucket}/${encodeURIComponent(key)}`
+  const extraHeaders = {
+    ETag: result.etag,
+    ...(result.versioned && result.versionId ? { 'x-amz-version-id': result.versionId } : {}),
+  }
+
+  const redirect = fields.get('success_action_redirect') ?? fields.get('redirect')
+  if (redirect) {
+    let target
+    try {
+      target = new URL(redirect)
+    } catch {
+      throw new S3Error('MalformedPOSTRequest', 'success_action_redirect is not a valid URL')
+    }
+    target.searchParams.set('bucket', ctx.bucket)
+    target.searchParams.set('key', key)
+    target.searchParams.set('etag', result.etag)
+    res.writeHead(303, { ...baseHeaders(ctx), ...extraHeaders, Location: target.toString(), 'Content-Length': 0 })
+    res.end()
+    return
+  }
+
+  const status = Number.parseInt(fields.get('success_action_status') ?? '204', 10)
+  if (status === 201) {
+    sendXml(ctx, res, 201, document('PostResponse',
+      text('Location', location) + text('Bucket', ctx.bucket) +
+      text('Key', key) + text('ETag', result.etag)), extraHeaders)
+    return
+  }
+  sendEmpty(ctx, res, status === 200 ? 200 : 204, extraHeaders)
+}

package/src/handlers/service.js

@@ -0,0 +1,10 @@
+import { isoDate, sendXml } from '../http.js'
+import { document, text } from '../xml.js'
+import { ownerXml } from './shared.js'
+
+export function listBuckets(ctx, res, { store }) {
+  const buckets = store.listBuckets()
+    .map((bucket) => `<Bucket>${text('Name', bucket.name)}${text('CreationDate', isoDate(bucket.createdAt))}</Bucket>`)
+    .join('')
+  sendXml(ctx, res, 200, document('ListAllMyBucketsResult', `${ownerXml}<Buckets>${buckets}</Buckets>`))
+}

package/src/handlers/shared.js

@@ -0,0 +1,84 @@
+import { S3Error } from '../errors.js'
+import { CHECKSUM_ALGORITHMS } from '../util/hash.js'
+import { text } from '../xml.js'
+
+export const MAX_DELETE_KEYS = 1000
+export const OWNER_ID = 's3node'
+export const OWNER_DISPLAY_NAME = 's3node'
+
+export const ownerXml = `<Owner>${text('ID', OWNER_ID)}${text('DisplayName', OWNER_DISPLAY_NAME)}</Owner>`
+
+export function maybeEncode(value, encodingType) {
+  return encodingType === 'url' ? encodeURIComponent(value) : value
+}
+
+export function integerParam(query, name, fallback, { min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
+  const raw = query.get(name)
+  if (raw === undefined || raw === '') return fallback
+  const parsed = Number.parseInt(raw, 10)
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+    throw new S3Error('InvalidArgument', `Invalid value for ${name}`)
+  }
+  return parsed
+}
+
+/**
+ * Collects everything the request declared about body integrity: Content-MD5,
+ * the literal payload SHA-256 (when not streaming/unsigned) and the
+ * `x-amz-checksum-*` family, which modern SDKs send by default as a trailer
+ * (docs/plan.md section 4.2).
+ */
+export function integrityOptions(ctx) {
+  const headers = ctx.headers
+  const payloadHash = ctx.auth?.payloadHash
+  const literalSha256 = /^[0-9a-f]{64}$/.test(payloadHash ?? '') ? payloadHash : null
+
+  let checksumAlgorithm = null
+  let expectedChecksum = null
+  for (const algorithm of CHECKSUM_ALGORITHMS) {
+    const value = headers[`x-amz-checksum-${algorithm}`]
+    if (value !== undefined) {
+      checksumAlgorithm = algorithm
+      expectedChecksum = String(value)
+      break
+    }
+  }
+  if (!checksumAlgorithm) {
+    const declared = headers['x-amz-trailer'] ?? headers['x-amz-sdk-checksum-algorithm']
+    const match = /(crc32c|crc32|sha256|sha1)/i.exec(String(declared ?? ''))
+    if (match) checksumAlgorithm = match[1].toLowerCase()
+  }
+
+  return {
+    contentMd5: headers['content-md5'] ? String(headers['content-md5']) : null,
+    expectedSha256: literalSha256,
+    checksumAlgorithm,
+    expectedChecksum,
+    trailerProvider: ctx.trailers ? (name) => ctx.trailers[name] ?? null : null,
+  }
+}
+
+export function checksumHeaders(checksums) {
+  const headers = {}
+  for (const [algorithm, value] of Object.entries(checksums ?? {})) {
+    headers[`x-amz-checksum-${algorithm}`] = value
+  }
+  return headers
+}
+
+/** `x-amz-version-id` is only meaningful once the bucket has been versioned. */
+export function versionHeaders(result) {
+  return result?.versioned && result.versionId ? { 'x-amz-version-id': result.versionId } : {}
+}
+
+export function sseRequest(ctx, store, { copySource = false } = {}) {
+  const prefix = copySource
+    ? 'x-amz-copy-source-server-side-encryption'
+    : 'x-amz-server-side-encryption'
+  return store.encryption.parseRequest(ctx.headers, { prefix })
+}
+
+/** Fire-and-forget event delivery; never allowed to fail the request. */
+export function notify(server, event) {
+  server?.notifications?.dispatch(event)
+}