s3mini 0.3.0 → 0.5.0

package/src/consts.ts

@@ -13,11 +13,12 @@ export const DEFAULT_REQUEST_SIZE_IN_BYTES = 8 * 1024 * 1024;
 
 // Headers
 export const HEADER_AMZ_CONTENT_SHA256 = 'x-amz-content-sha256';
+export const HEADER_AMZ_CHECKSUM_SHA256 = 'x-amz-checksum-sha256';
 export const HEADER_AMZ_DATE = 'x-amz-date';
 export const HEADER_HOST = 'host';
-export const HEADER_AUTHORIZATION = 'Authorization';
-export const HEADER_CONTENT_TYPE = 'Content-Type';
-export const HEADER_CONTENT_LENGTH = 'Content-Length';
+export const HEADER_AUTHORIZATION = 'authorization';
+export const HEADER_CONTENT_TYPE = 'content-type';
+export const HEADER_CONTENT_LENGTH = 'content-length';
 export const HEADER_ETAG = 'etag';
 export const HEADER_LAST_MODIFIED = 'last-modified';
 
@@ -32,7 +33,6 @@ export const ERROR_UPLOAD_ID_REQUIRED = `${ERROR_PREFIX}uploadId must be a non-e
 export const ERROR_PARTS_REQUIRED = `${ERROR_PREFIX}parts must be a non-empty array`;
 export const ERROR_INVALID_PART = `${ERROR_PREFIX}Each part must have a partNumber (number) and ETag (string)`;
 export const ERROR_DATA_BUFFER_REQUIRED = `${ERROR_PREFIX}data must be a Buffer or string`;
-// const ERROR_PATH_REQUIRED = `${ERROR_PREFIX}path must be a string`;
 export const ERROR_PREFIX_TYPE = `${ERROR_PREFIX}prefix must be a string`;
 export const ERROR_MAX_KEYS_TYPE = `${ERROR_PREFIX}maxKeys must be a positive integer`;
 export const ERROR_DELIMITER_REQUIRED = `${ERROR_PREFIX}delimiter must be a string`;

package/src/index.ts

@@ -1,11 +1,11 @@
 'use strict';
 
-import { s3mini } from './S3.js';
+import { S3mini } from './S3.js';
 import { sanitizeETag, runInBatches } from './utils.js';
 
 // Export the S3 class as default export and named export
-export { s3mini, sanitizeETag, runInBatches };
-export default s3mini;
+export { S3mini, sanitizeETag, runInBatches };
+export default S3mini;
 
 // Re-export types
 export type {

package/src/types.ts

@@ -8,18 +8,14 @@ export interface S3Config {
   logger?: Logger;
 }
 
-export interface Crypto {
-  createHmac: (
-    algorithm: string,
-    key: Buffer | string,
-  ) => {
-    update: (data: Buffer | string) => { digest: (encoding?: string) => string | Buffer };
-    digest: (encoding?: string) => string | Buffer;
-  };
-  createHash: (algorithm: string) => {
-    update: (data: Buffer | string) => { digest: (encoding?: string) => string | Buffer };
-    digest: (encoding?: string) => string | Buffer;
-  };
+export interface SSECHeaders {
+  'x-amz-server-side-encryption-customer-algorithm': string;
+  'x-amz-server-side-encryption-customer-key': string;
+  'x-amz-server-side-encryption-customer-key-md5': string;
+}
+
+export interface AWSHeaders {
+  [k: `x-amz-${string}`]: string;
 }
 
 export interface Logger {
@@ -33,6 +29,14 @@ export interface UploadPart {
   etag: string;
 }
 
+export interface ListObject {
+  Key: string;
+  Size: number;
+  LastModified: Date;
+  ETag: string;
+  StorageClass: string;
+}
+
 export interface CompleteMultipartUploadResult {
   location: string;
   bucket: string;
@@ -58,7 +62,7 @@ export interface ListMultipartUploadSuccess {
     key: string;
     uploadId: string;
     size?: number;
-    mtime?: Date | undefined;
+    mtime?: Date;
     etag?: string;
     eTag?: string; // for backward compatibility
     parts: UploadPart[];
@@ -93,3 +97,62 @@ export interface XmlMap {
   [key: string]: XmlValue | XmlValue[]; // one or many children
   [key: number]: XmlValue | XmlValue[]; // allow numeric keys
 }
+
+export interface CopyObjectOptions {
+  /**
+   * Specifies whether the metadata is copied from the source object or replaced with metadata provided in the request.
+   * Valid values: 'COPY' | 'REPLACE'
+   * Default: 'COPY'
+   */
+  metadataDirective?: 'COPY' | 'REPLACE';
+
+  /**
+   * Metadata to be set on the destination object when metadataDirective is 'REPLACE'.
+   * Keys can be provided with or without 'x-amz-meta-' prefix.
+   */
+  metadata?: Record<string, string>;
+  contentType?: string;
+
+  /**
+   * Storage class for the destination object.
+   * Valid values: 'STANDARD' | 'REDUCED_REDUNDANCY' | 'STANDARD_IA' | 'ONEZONE_IA' | 'INTELLIGENT_TIERING' | 'GLACIER' | 'DEEP_ARCHIVE' | 'GLACIER_IR'
+   */
+  storageClass?: string;
+
+  /**
+   * Specifies whether the object tag-set is copied from the source object or replaced with tag-set provided in the request.
+   * Valid values: 'COPY' | 'REPLACE'
+   */
+  taggingDirective?: 'COPY' | 'REPLACE';
+
+  /**
+   * If the bucket is configured as a website, redirects requests for this object to another object or URL.
+   */
+  websiteRedirectLocation?: string;
+
+  /**
+   * Server-Side Encryption with Customer-Provided Keys headers for the source object.
+   * Should include:
+   * - x-amz-copy-source-server-side-encryption-customer-algorithm
+   * - x-amz-copy-source-server-side-encryption-customer-key
+   * - x-amz-copy-source-server-side-encryption-customer-key-MD5
+   */
+  sourceSSECHeaders?: Record<string, string | number>;
+  destinationSSECHeaders?: SSECHeaders;
+  additionalHeaders?: Record<string, string | number>;
+}
+
+export interface CopyObjectResult {
+  etag: string;
+  lastModified?: Date;
+}
+
+/**
+ * Where Buffer is available, e.g. when @types/node is loaded, we want to use it.
+ * But it should be excluded in other environments (e.g. Cloudflare).
+ */
+export type MaybeBuffer = typeof globalThis extends { Buffer?: infer B }
+  ? B extends new (...a: unknown[]) => unknown
+    ? InstanceType<B>
+    : ArrayBuffer | Uint8Array
+  : ArrayBuffer | Uint8Array;

package/src/utils.ts

@@ -1,36 +1,80 @@
 'use strict';
+import type { XmlValue, XmlMap, ListBucketResponse, ErrorWithCode } from './types.js';
 
-import type { Crypto, XmlValue, XmlMap, ListBucketResponse, ErrorWithCode } from './types.js';
-declare const crypto: Crypto;
+const ENCODR = new TextEncoder();
+const chunkSize = 0x8000; // 32KB chunks
+const HEXS = '0123456789abcdef';
 
-// Initialize crypto functions - this is needed for environments where `crypto` is not available globally
-// e.g., in Cloudflare Workers or other non-Node.js environments with nodejs_flags enabled.
-const _createHmac: Crypto['createHmac'] = crypto.createHmac || (await import('node:crypto')).createHmac;
-const _createHash: Crypto['createHash'] = crypto.createHash || (await import('node:crypto')).createHash;
+export const getByteSize = (data: unknown): number => {
+  if (typeof data === 'string') {
+    return ENCODR.encode(data).byteLength;
+  }
+  if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+    return data.byteLength;
+  }
+  if (data instanceof Blob) {
+    return data.size;
+  }
+  throw new Error('Unsupported data type');
+};
+
+/**
+ * Turn a raw ArrayBuffer into its hexadecimal representation.
+ * @param {ArrayBuffer} buffer The raw bytes.
+ * @returns {string} Hexadecimal string
+ */
+export const hexFromBuffer = (buffer: ArrayBuffer): string => {
+  const bytes = new Uint8Array(buffer);
+  let hex = '';
+  for (const byte of bytes) {
+    hex += HEXS[byte >> 4]! + HEXS[byte & 0x0f]!;
+  }
+  return hex;
+};
 
 /**
- * Hash content using SHA-256
- * @param {string|Buffer} content  – data to hash
- * @returns {string} Hex encoded hash
+ * Turn a raw ArrayBuffer into its base64 representation.
+ * @param {ArrayBuffer} buffer The raw bytes.
+ * @returns {string} Base64 string
  */
-export const hash = (content: string | Buffer): string => {
-  return _createHash('sha256').update(content).digest('hex') as string;
+export const base64FromBuffer = (buffer: ArrayBuffer): string => {
+  const bytes = new Uint8Array(buffer);
+  let result = '';
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    result += btoa(String.fromCharCode.apply(null, chunk as unknown as number[]));
+  }
+  return result;
 };
 
-export const md5base64 = (data: string | Buffer): string => {
-  return _createHash('md5').update(data).digest('base64') as string;
+/**
+ * Compute SHA-256 hash of arbitrary string data.
+ * @param {string} content The content to be hashed.
+ * @returns {ArrayBuffer} The raw hash
+ */
+export const sha256 = async (content: string): Promise<ArrayBuffer> => {
+  const data = ENCODR.encode(content);
+
+  return await globalThis.crypto.subtle.digest('SHA-256', data);
 };
 
 /**
- * Compute HMAC-SHA-256 of arbitrary data and return a hex string.
- * @param {string|Buffer} key      – secret key
- * @param {string|Buffer} content  – data to authenticate
- * @param {BufferEncoding} [encoding='hex'] – hex | base64 | …
- * @returns {string | Buffer} hex encoded HMAC
+ * Compute HMAC-SHA-256 of arbitrary data.
+ * @param {string|ArrayBuffer} key The key used to sign the content.
+ * @param {string} content The content to be signed.
+ * @returns {ArrayBuffer} The raw signature
  */
-export const hmac = (key: string | Buffer, content: string | Buffer, encoding?: 'hex' | 'base64'): string | Buffer => {
-  const mac = _createHmac('sha256', key).update(content);
-  return encoding ? mac.digest(encoding) : mac.digest();
+export const hmac = async (key: string | ArrayBuffer, content: string): Promise<ArrayBuffer> => {
+  const secret = await globalThis.crypto.subtle.importKey(
+    'raw',
+    typeof key === 'string' ? ENCODR.encode(key) : key,
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign'],
+  );
+  const data = ENCODR.encode(content);
+
+  return await globalThis.crypto.subtle.sign('HMAC', secret, data);
 };
 
 /**
@@ -46,7 +90,7 @@ export const sanitizeETag = (etag: string): string => {
     '&QUOT;': '',
     '&#x00022': '',
   };
-  return etag.replace(/^("|&quot;|&#34;)|("|&quot;|&#34;)$/g, m => replaceChars[m] as string);
+  return etag.replace(/(^("|&quot;|&#34;))|(("|&quot;|&#34;)$)/g, m => replaceChars[m] as string);
 };
 
 const entityMap = {