@hanzo/s3 0.6.3 → 8.0.7

package/src/notification.ts

@@ -0,0 +1,254 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 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 { EventEmitter } from 'eventemitter3'
+import jsonLineParser from 'stream-json/jsonl/Parser.js'
+
+import { DEFAULT_REGION } from './helpers.ts'
+import type { TypedClient } from './internal/client.ts'
+import { pipesetup, uriEscape } from './internal/helper.ts'
+
+// TODO: type this
+
+type Event = unknown
+
+// Base class for three supported configs.
+export class TargetConfig {
+  private Filter?: { S3Key: { FilterRule: { Name: string; Value: string }[] } }
+  private Event?: Event[]
+  private Id: unknown
+
+  setId(id: unknown) {
+    this.Id = id
+  }
+
+  addEvent(newevent: Event) {
+    if (!this.Event) {
+      this.Event = []
+    }
+    this.Event.push(newevent)
+  }
+
+  addFilterSuffix(suffix: string) {
+    if (!this.Filter) {
+      this.Filter = { S3Key: { FilterRule: [] } }
+    }
+    this.Filter.S3Key.FilterRule.push({ Name: 'suffix', Value: suffix })
+  }
+
+  addFilterPrefix(prefix: string) {
+    if (!this.Filter) {
+      this.Filter = { S3Key: { FilterRule: [] } }
+    }
+    this.Filter.S3Key.FilterRule.push({ Name: 'prefix', Value: prefix })
+  }
+}
+
+// 1. Topic (simple notification service)
+export class TopicConfig extends TargetConfig {
+  private Topic: string
+
+  constructor(arn: string) {
+    super()
+    this.Topic = arn
+  }
+}
+
+// 2. Queue (simple queue service)
+export class QueueConfig extends TargetConfig {
+  private Queue: string
+
+  constructor(arn: string) {
+    super()
+    this.Queue = arn
+  }
+}
+
+// 3. CloudFront (lambda function)
+export class CloudFunctionConfig extends TargetConfig {
+  private CloudFunction: string
+
+  constructor(arn: string) {
+    super()
+    this.CloudFunction = arn
+  }
+}
+
+// Notification config - array of target configs.
+// Target configs can be
+// 1. Topic (simple notification service)
+// 2. Queue (simple queue service)
+// 3. CloudFront (lambda function)
+export class NotificationConfig {
+  private TopicConfiguration?: TargetConfig[]
+  private CloudFunctionConfiguration?: TargetConfig[]
+  private QueueConfiguration?: TargetConfig[]
+
+  add(target: TargetConfig) {
+    let instance: TargetConfig[] | undefined
+    if (target instanceof TopicConfig) {
+      instance = this.TopicConfiguration ??= []
+    }
+    if (target instanceof QueueConfig) {
+      instance = this.QueueConfiguration ??= []
+    }
+    if (target instanceof CloudFunctionConfig) {
+      instance = this.CloudFunctionConfiguration ??= []
+    }
+    if (instance) {
+      instance.push(target)
+    }
+  }
+}
+
+export const buildARN = (partition: string, service: string, region: string, accountId: string, resource: string) => {
+  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource
+}
+export const ObjectCreatedAll = 's3:ObjectCreated:*'
+export const ObjectCreatedPut = 's3:ObjectCreated:Put'
+export const ObjectCreatedPost = 's3:ObjectCreated:Post'
+export const ObjectCreatedCopy = 's3:ObjectCreated:Copy'
+export const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload'
+export const ObjectRemovedAll = 's3:ObjectRemoved:*'
+export const ObjectRemovedDelete = 's3:ObjectRemoved:Delete'
+export const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated'
+export const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject'
+export type NotificationEvent =
+  | 's3:ObjectCreated:*'
+  | 's3:ObjectCreated:Put'
+  | 's3:ObjectCreated:Post'
+  | 's3:ObjectCreated:Copy'
+  | 's3:ObjectCreated:CompleteMultipartUpload'
+  | 's3:ObjectRemoved:*'
+  | 's3:ObjectRemoved:Delete'
+  | 's3:ObjectRemoved:DeleteMarkerCreated'
+  | 's3:ReducedRedundancyLostObject'
+  | 's3:TestEvent'
+  | 's3:ObjectRestore:Post'
+  | 's3:ObjectRestore:Completed'
+  | 's3:Replication:OperationFailedReplication'
+  | 's3:Replication:OperationMissedThreshold'
+  | 's3:Replication:OperationReplicatedAfterThreshold'
+  | 's3:Replication:OperationNotTracked'
+  | string // put string at least so auto-complete could work
+
+// TODO: type this
+export type NotificationRecord = unknown
+// Poll for notifications, used in #listenBucketNotification.
+// Listening constitutes repeatedly requesting s3 whether or not any
+// changes have occurred.
+export class NotificationPoller extends EventEmitter<{
+  notification: (event: NotificationRecord) => void
+  error: (error: unknown) => void
+}> {
+  private client: TypedClient
+  private bucketName: string
+  private prefix: string
+  private suffix: string
+  private events: NotificationEvent[]
+  private ending: boolean
+
+  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]) {
+    super()
+
+    this.client = client
+    this.bucketName = bucketName
+    this.prefix = prefix
+    this.suffix = suffix
+    this.events = events
+
+    this.ending = false
+  }
+
+  // Starts the polling.
+  start() {
+    this.ending = false
+
+    process.nextTick(() => {
+      this.checkForChanges()
+    })
+  }
+
+  // Stops the polling.
+  stop() {
+    this.ending = true
+  }
+
+  checkForChanges() {
+    // Don't continue if we're looping again but are cancelled.
+    if (this.ending) {
+      return
+    }
+
+    const method = 'GET'
+    const queries = []
+    if (this.prefix) {
+      const prefix = uriEscape(this.prefix)
+      queries.push(`prefix=${prefix}`)
+    }
+    if (this.suffix) {
+      const suffix = uriEscape(this.suffix)
+      queries.push(`suffix=${suffix}`)
+    }
+    if (this.events) {
+      this.events.forEach((s3event) => queries.push('events=' + uriEscape(s3event)))
+    }
+    queries.sort()
+
+    let query = ''
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`
+    }
+    const region = this.client.region || DEFAULT_REGION
+
+    this.client.makeRequestAsync({ method, bucketName: this.bucketName, query }, '', [200], region).then(
+      (response) => {
+        const asm = jsonLineParser.make()
+
+        pipesetup(response, asm)
+          .on('data', (data) => {
+            // Data is flushed periodically (every 5 seconds), so we should
+            // handle it after flushing from the JSON parser.
+            let records = data.value.Records
+            // If null (= no records), change to an empty array.
+            if (!records) {
+              records = []
+            }
+
+            // Iterate over the notifications and emit them individually.
+            records.forEach((record: NotificationRecord) => {
+              this.emit('notification', record)
+            })
+
+            // If we're done, stop.
+            if (this.ending) {
+              response?.destroy()
+            }
+          })
+          .on('error', (e) => this.emit('error', e))
+          .on('end', () => {
+            // Do it again, if we haven't cancelled yet.
+            process.nextTick(() => {
+              this.checkForChanges()
+            })
+          })
+      },
+      (e) => {
+        return this.emit('error', e)
+      },
+    )
+  }
+}

package/src/s3.ts

@@ -0,0 +1,155 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 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 type { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './helpers.ts'
+import { callbackify } from './internal/callbackify.ts'
+import { TypedClient } from './internal/client.ts'
+import { CopyConditions } from './internal/copy-conditions.ts'
+import { PostPolicy } from './internal/post-policy.ts'
+
+export * from './errors.ts'
+export * from './helpers.ts'
+export * from './notification.ts'
+export { CopyConditions, PostPolicy }
+export { IamAwsProvider } from './IamAwsProvider.ts'
+export type { MakeBucketOpt } from './internal/client.ts'
+export type { ClientOptions, NoResultCallback, RemoveOptions } from './internal/client.ts'
+export type { Region } from './internal/s3-endpoints.ts'
+export type {
+  BucketItem,
+  BucketItemCopy,
+  BucketItemFromList,
+  BucketItemStat,
+  BucketItemWithMetadata,
+  BucketStream,
+  EmptyObject,
+  ExistingObjectReplication,
+  GetObjectLegalHoldOptions,
+  IncompleteUploadedBucketItem,
+  InputSerialization,
+  IsoDate,
+  ItemBucketMetadata,
+  ItemBucketMetadataList,
+  LegalHoldStatus,
+  LifecycleConfig,
+  LifecycleRule,
+  MetadataItem,
+  ObjectLockInfo,
+  OutputSerialization,
+  PostPolicyResult,
+  PutObjectLegalHoldOptions,
+  ReplicaModifications,
+  ReplicationConfig,
+  ReplicationConfigOpts,
+  ReplicationRule,
+  ReplicationRuleAnd,
+  ReplicationRuleDestination,
+  ReplicationRuleFilter,
+  ReplicationRuleStatus,
+  Retention,
+  RetentionOptions,
+  ScanRange,
+  SelectOptions,
+  SelectProgress,
+  SourceSelectionCriteria,
+  Tag,
+} from './internal/type.ts'
+
+/**
+ * @deprecated keep for backward compatible, use `RETENTION_MODES` instead
+ */
+export type Mode = RETENTION_MODES
+
+/**
+ * @deprecated keep for backward compatible
+ */
+export type LockUnit = RETENTION_VALIDITY_UNITS
+
+export type VersioningConfig = Record<string | number | symbol, unknown>
+export type TagList = Record<string, string>
+
+export interface LockConfig {
+  mode: RETENTION_MODES
+  unit: RETENTION_VALIDITY_UNITS
+  validity: number
+}
+
+export interface LegalHoldOptions {
+  versionId: string
+  status: LEGAL_HOLD_STATUS
+}
+
+export interface SourceObjectStats {
+  size: number
+  metaData: string
+  lastModicied: Date
+  versionId: string
+  etag: string
+}
+
+export class Client extends TypedClient {}
+
+// refactored API use promise internally
+Client.prototype.makeBucket = callbackify(Client.prototype.makeBucket)
+Client.prototype.bucketExists = callbackify(Client.prototype.bucketExists)
+Client.prototype.removeBucket = callbackify(Client.prototype.removeBucket)
+Client.prototype.listBuckets = callbackify(Client.prototype.listBuckets)
+
+Client.prototype.getObject = callbackify(Client.prototype.getObject)
+Client.prototype.fGetObject = callbackify(Client.prototype.fGetObject)
+Client.prototype.getPartialObject = callbackify(Client.prototype.getPartialObject)
+Client.prototype.statObject = callbackify(Client.prototype.statObject)
+Client.prototype.putObjectRetention = callbackify(Client.prototype.putObjectRetention)
+Client.prototype.putObject = callbackify(Client.prototype.putObject)
+Client.prototype.fPutObject = callbackify(Client.prototype.fPutObject)
+Client.prototype.removeObject = callbackify(Client.prototype.removeObject)
+
+Client.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication)
+Client.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication)
+Client.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication)
+Client.prototype.getObjectLegalHold = callbackify(Client.prototype.getObjectLegalHold)
+Client.prototype.setObjectLegalHold = callbackify(Client.prototype.setObjectLegalHold)
+Client.prototype.setObjectLockConfig = callbackify(Client.prototype.setObjectLockConfig)
+Client.prototype.getObjectLockConfig = callbackify(Client.prototype.getObjectLockConfig)
+Client.prototype.getBucketPolicy = callbackify(Client.prototype.getBucketPolicy)
+Client.prototype.setBucketPolicy = callbackify(Client.prototype.setBucketPolicy)
+Client.prototype.getBucketTagging = callbackify(Client.prototype.getBucketTagging)
+Client.prototype.getObjectTagging = callbackify(Client.prototype.getObjectTagging)
+Client.prototype.setBucketTagging = callbackify(Client.prototype.setBucketTagging)
+Client.prototype.removeBucketTagging = callbackify(Client.prototype.removeBucketTagging)
+Client.prototype.setObjectTagging = callbackify(Client.prototype.setObjectTagging)
+Client.prototype.removeObjectTagging = callbackify(Client.prototype.removeObjectTagging)
+Client.prototype.getBucketVersioning = callbackify(Client.prototype.getBucketVersioning)
+Client.prototype.setBucketVersioning = callbackify(Client.prototype.setBucketVersioning)
+Client.prototype.selectObjectContent = callbackify(Client.prototype.selectObjectContent)
+Client.prototype.setBucketLifecycle = callbackify(Client.prototype.setBucketLifecycle)
+Client.prototype.getBucketLifecycle = callbackify(Client.prototype.getBucketLifecycle)
+Client.prototype.removeBucketLifecycle = callbackify(Client.prototype.removeBucketLifecycle)
+Client.prototype.setBucketEncryption = callbackify(Client.prototype.setBucketEncryption)
+Client.prototype.getBucketEncryption = callbackify(Client.prototype.getBucketEncryption)
+Client.prototype.removeBucketEncryption = callbackify(Client.prototype.removeBucketEncryption)
+Client.prototype.getObjectRetention = callbackify(Client.prototype.getObjectRetention)
+Client.prototype.removeObjects = callbackify(Client.prototype.removeObjects)
+Client.prototype.removeIncompleteUpload = callbackify(Client.prototype.removeIncompleteUpload)
+Client.prototype.copyObject = callbackify(Client.prototype.copyObject)
+Client.prototype.composeObject = callbackify(Client.prototype.composeObject)
+Client.prototype.presignedUrl = callbackify(Client.prototype.presignedUrl)
+Client.prototype.presignedGetObject = callbackify(Client.prototype.presignedGetObject)
+Client.prototype.presignedPutObject = callbackify(Client.prototype.presignedPutObject)
+Client.prototype.presignedPostPolicy = callbackify(Client.prototype.presignedPostPolicy)
+Client.prototype.setBucketNotification = callbackify(Client.prototype.setBucketNotification)
+Client.prototype.getBucketNotification = callbackify(Client.prototype.getBucketNotification)
+Client.prototype.removeAllBucketNotification = callbackify(Client.prototype.removeAllBucketNotification)