@hanzo/s3 0.6.3 → 8.0.7

package/src/internal/post-policy.ts

@@ -0,0 +1,99 @@
+// Build PostPolicy object that can be signed by presignedPostPolicy
+import * as errors from '../errors.ts'
+import { isObject, isValidBucketName, isValidObjectName, isValidPrefix } from './helper.ts'
+import type { ObjectMetaData } from './type.ts'
+
+export class PostPolicy {
+  public policy: { conditions: (string | number)[][]; expiration?: string } = {
+    conditions: [],
+  }
+  public formData: Record<string, string> = {}
+
+  // set expiration date
+  setExpires(date: Date) {
+    if (!date) {
+      throw new errors.InvalidDateError('Invalid date: cannot be null')
+    }
+    this.policy.expiration = date.toISOString()
+  }
+
+  // set object name
+  setKey(objectName: string) {
+    if (!isValidObjectName(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name : ${objectName}`)
+    }
+    this.policy.conditions.push(['eq', '$key', objectName])
+    this.formData.key = objectName
+  }
+
+  // set object name prefix, i.e policy allows any keys with this prefix
+  setKeyStartsWith(prefix: string) {
+    if (!isValidPrefix(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)
+    }
+    this.policy.conditions.push(['starts-with', '$key', prefix])
+    this.formData.key = prefix
+  }
+
+  // set bucket name
+  setBucket(bucketName: string) {
+    if (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)
+    }
+    this.policy.conditions.push(['eq', '$bucket', bucketName])
+    this.formData.bucket = bucketName
+  }
+
+  // set Content-Type
+  setContentType(type: string) {
+    if (!type) {
+      throw new Error('content-type cannot be null')
+    }
+    this.policy.conditions.push(['eq', '$Content-Type', type])
+    this.formData['Content-Type'] = type
+  }
+
+  // set Content-Type prefix, i.e image/ allows any image
+  setContentTypeStartsWith(prefix: string) {
+    if (!prefix) {
+      throw new Error('content-type cannot be null')
+    }
+    this.policy.conditions.push(['starts-with', '$Content-Type', prefix])
+    this.formData['Content-Type'] = prefix
+  }
+
+  // set Content-Disposition
+  setContentDisposition(value: string) {
+    if (!value) {
+      throw new Error('content-disposition cannot be null')
+    }
+    this.policy.conditions.push(['eq', '$Content-Disposition', value])
+    this.formData['Content-Disposition'] = value
+  }
+
+  // set minimum/maximum length of what Content-Length can be.
+  setContentLengthRange(min: number, max: number) {
+    if (min > max) {
+      throw new Error('min cannot be more than max')
+    }
+    if (min < 0) {
+      throw new Error('min should be > 0')
+    }
+    if (max < 0) {
+      throw new Error('max should be > 0')
+    }
+    this.policy.conditions.push(['content-length-range', min, max])
+  }
+
+  // set user defined metadata
+  setUserMetaData(metaData: ObjectMetaData) {
+    if (!isObject(metaData)) {
+      throw new TypeError('metadata should be of type "object"')
+    }
+    Object.entries(metaData).forEach(([key, value]) => {
+      const amzMetaDataKey = `x-amz-meta-${key}`
+      this.policy.conditions.push(['eq', `$${amzMetaDataKey}`, value])
+      this.formData[amzMetaDataKey] = value.toString()
+    })
+  }
+}

package/src/internal/request.ts

@@ -0,0 +1,102 @@
+import type * as http from 'node:http'
+import type * as https from 'node:https'
+import type * as stream from 'node:stream'
+import { pipeline } from 'node:stream'
+import { promisify } from 'node:util'
+
+import type { Transport } from './type.ts'
+
+const pipelineAsync = promisify(pipeline)
+
+export async function request(
+  transport: Transport,
+  opt: https.RequestOptions,
+  body: Buffer | string | stream.Readable | null = null,
+): Promise<http.IncomingMessage> {
+  return new Promise<http.IncomingMessage>((resolve, reject) => {
+    const requestObj = transport.request(opt, (response) => {
+      resolve(response)
+    })
+
+    requestObj.on('error', reject)
+
+    if (!body || Buffer.isBuffer(body) || typeof body === 'string') {
+      requestObj.end(body)
+    } else {
+      pipelineAsync(body, requestObj).catch(reject)
+    }
+  })
+}
+
+const MAX_RETRIES = 1
+const BASE_DELAY_MS = 100 // Base delay for exponential backoff
+const MAX_DELAY_MS = 60000 // Max delay for exponential backoff
+
+// Retryable error codes for HTTP (ref: Go SDK)
+export const retryHttpCodes: Record<string, boolean> = {
+  408: true,
+  429: true,
+  499: true,
+  500: true,
+  502: true,
+  503: true,
+  504: true,
+  520: true,
+}
+
+const isHttpRetryable = (httpResCode: number) => {
+  return retryHttpCodes[httpResCode] !== undefined
+}
+
+const sleep = (ms: number) => {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+const getExpBackOffDelay = (retryCount: number, baseDelayMs: number, maximumDelayMs: number) => {
+  const backOffBy = baseDelayMs * (1 << retryCount)
+  const additionalDelay = Math.random() * backOffBy
+  return Math.min(backOffBy + additionalDelay, maximumDelayMs)
+}
+
+export async function requestWithRetry(
+  transport: Transport,
+  opt: https.RequestOptions,
+  body: Buffer | string | stream.Readable | null = null,
+  maxRetries: number = MAX_RETRIES,
+  baseDelayMs: number = BASE_DELAY_MS,
+  maximumDelayMs: number = MAX_DELAY_MS,
+): Promise<http.IncomingMessage> {
+  let attempt = 0
+  let isRetryable = false
+  while (attempt <= maxRetries) {
+    try {
+      const response = await request(transport, opt, body)
+      // Check if the HTTP status code is retryable
+      if (isHttpRetryable(response.statusCode as number)) {
+        isRetryable = true
+        throw new Error(`Retryable HTTP status: ${response.statusCode}`) // trigger retry attempt with calculated delay
+      }
+
+      return response // Success, return the raw response
+    } catch (err: unknown) {
+      if (isRetryable) {
+        attempt++
+        isRetryable = false
+
+        if (attempt > maxRetries) {
+          throw new Error(`Request failed after ${maxRetries} retries: ${err}`)
+        }
+        const delay = getExpBackOffDelay(attempt, baseDelayMs, maximumDelayMs)
+        // eslint-disable-next-line no-console
+        console.warn(
+          `${new Date().toLocaleString()} Retrying request (attempt ${attempt}/${maxRetries}) after ${delay}ms due to: ${err}`,
+        )
+        await sleep(delay)
+      } else {
+        throw err // re-throw if any request, syntax errors
+      }
+    }
+  }
+
+  throw new Error(`${MAX_RETRIES} Retries exhausted, request failed.`)
+}

package/src/internal/response.ts

@@ -0,0 +1,26 @@
+import type http from 'node:http'
+import type stream from 'node:stream'
+
+export async function readAsBuffer(res: stream.Readable): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const body: Buffer[] = []
+    res
+      .on('data', (chunk: Buffer) => body.push(chunk))
+      .on('error', (e) => reject(e))
+      .on('end', () => resolve(Buffer.concat(body)))
+  })
+}
+
+export async function readAsString(res: http.IncomingMessage): Promise<string> {
+  const body = await readAsBuffer(res)
+  return body.toString()
+}
+
+export async function drainResponse(res: stream.Readable): Promise<void> {
+  return new Promise((resolve, reject) => {
+    res
+      .on('data', () => {})
+      .on('error', (e) => reject(e))
+      .on('end', () => resolve())
+  })
+}

package/src/internal/s3-endpoints.ts

@@ -0,0 +1,70 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 Hanzo AI, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { isString } from './helper.ts'
+
+// List of currently supported endpoints.
+const awsS3Endpoint = {
+  'af-south-1': 's3.af-south-1.amazonaws.com',
+  'ap-east-1': 's3.ap-east-1.amazonaws.com',
+  'ap-south-1': 's3.ap-south-1.amazonaws.com',
+  'ap-south-2': 's3.ap-south-2.amazonaws.com',
+  'ap-southeast-1': 's3.ap-southeast-1.amazonaws.com',
+  'ap-southeast-2': 's3.ap-southeast-2.amazonaws.com',
+  'ap-southeast-3': 's3.ap-southeast-3.amazonaws.com',
+  'ap-southeast-4': 's3.ap-southeast-4.amazonaws.com',
+  'ap-southeast-5': 's3.ap-southeast-5.amazonaws.com',
+  'ap-northeast-1': 's3.ap-northeast-1.amazonaws.com',
+  'ap-northeast-2': 's3.ap-northeast-2.amazonaws.com',
+  'ap-northeast-3': 's3.ap-northeast-3.amazonaws.com',
+  'ca-central-1': 's3.ca-central-1.amazonaws.com',
+  'ca-west-1': 's3.ca-west-1.amazonaws.com',
+  'cn-north-1': 's3.cn-north-1.amazonaws.com.cn',
+  'eu-central-1': 's3.eu-central-1.amazonaws.com',
+  'eu-central-2': 's3.eu-central-2.amazonaws.com',
+  'eu-north-1': 's3.eu-north-1.amazonaws.com',
+  'eu-south-1': 's3.eu-south-1.amazonaws.com',
+  'eu-south-2': 's3.eu-south-2.amazonaws.com',
+  'eu-west-1': 's3.eu-west-1.amazonaws.com',
+  'eu-west-2': 's3.eu-west-2.amazonaws.com',
+  'eu-west-3': 's3.eu-west-3.amazonaws.com',
+  'il-central-1': 's3.il-central-1.amazonaws.com',
+  'me-central-1': 's3.me-central-1.amazonaws.com',
+  'me-south-1': 's3.me-south-1.amazonaws.com',
+  'sa-east-1': 's3.sa-east-1.amazonaws.com',
+  'us-east-1': 's3.us-east-1.amazonaws.com',
+  'us-east-2': 's3.us-east-2.amazonaws.com',
+  'us-west-1': 's3.us-west-1.amazonaws.com',
+  'us-west-2': 's3.us-west-2.amazonaws.com',
+  'us-gov-east-1': 's3.us-gov-east-1.amazonaws.com',
+  'us-gov-west-1': 's3.us-gov-west-1.amazonaws.com',
+  // Add new endpoints here.
+}
+
+export type Region = keyof typeof awsS3Endpoint | string
+
+// getS3Endpoint get relevant endpoint for the region.
+export function getS3Endpoint(region: Region): string {
+  if (!isString(region)) {
+    throw new TypeError(`Invalid region: ${region}`)
+  }
+
+  const endpoint = (awsS3Endpoint as Record<string, string>)[region]
+  if (endpoint) {
+    return endpoint
+  }
+  return 's3.amazonaws.com'
+}