knowledge/node_modules/minio/dist/esm/notification.mjs

/*
 * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, 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.mjs";
import { pipesetup, uriEscape } from "./internal/helper.mjs";

// TODO: type this

// Base class for three supported configs.
export class TargetConfig {
  setId(id) {
    this.Id = id;
  }
  addEvent(newevent) {
    if (!this.Event) {
      this.Event = [];
    }
    this.Event.push(newevent);
  }
  addFilterSuffix(suffix) {
    if (!this.Filter) {
      this.Filter = {
        S3Key: {
          FilterRule: []
        }
      };
    }
    this.Filter.S3Key.FilterRule.push({
      Name: 'suffix',
      Value: suffix
    });
  }
  addFilterPrefix(prefix) {
    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 {
  constructor(arn) {
    super();
    this.Topic = arn;
  }
}

// 2. Queue (simple queue service)
export class QueueConfig extends TargetConfig {
  constructor(arn) {
    super();
    this.Queue = arn;
  }
}

// 3. CloudFront (lambda function)
export class CloudFunctionConfig extends TargetConfig {
  constructor(arn) {
    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 {
  add(target) {
    let instance;
    if (target instanceof TopicConfig) {
      instance = this.TopicConfiguration ?? (this.TopicConfiguration = []);
    }
    if (target instanceof QueueConfig) {
      instance = this.QueueConfiguration ?? (this.QueueConfiguration = []);
    }
    if (target instanceof CloudFunctionConfig) {
      instance = this.CloudFunctionConfiguration ?? (this.CloudFunctionConfiguration = []);
    }
    if (instance) {
      instance.push(target);
    }
  }
}
export const buildARN = (partition, service, region, accountId, resource) => {
  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';

// put string at least so auto-complete could work
// TODO: type this
// Poll for notifications, used in #listenBucketNotification.
// Listening constitutes repeatedly requesting s3 whether or not any
// changes have occurred.
export class NotificationPoller extends EventEmitter {
  constructor(client, bucketName, prefix, suffix, events) {
    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 => {
          this.emit('notification', record);
        });

        // If we're done, stop.
        if (this.ending) {
          response === null || response === void 0 ? void 0 : 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);
    });
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["EventEmitter","jsonLineParser","DEFAULT_REGION","pipesetup","uriEscape","TargetConfig","setId","id","Id","addEvent","newevent","Event","push","addFilterSuffix","suffix","Filter","S3Key","FilterRule","Name","Value","addFilterPrefix","prefix","TopicConfig","constructor","arn","Topic","QueueConfig","Queue","CloudFunctionConfig","CloudFunction","NotificationConfig","add","target","instance","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","buildARN","partition","service","region","accountId","resource","ObjectCreatedAll","ObjectCreatedPut","ObjectCreatedPost","ObjectCreatedCopy","ObjectCreatedCompleteMultipartUpload","ObjectRemovedAll","ObjectRemovedDelete","ObjectRemovedDeleteMarkerCreated","ObjectReducedRedundancyLostObject","NotificationPoller","client","bucketName","events","ending","start","process","nextTick","checkForChanges","stop","method","queries","forEach","s3event","sort","query","length","join","makeRequestAsync","then","response","asm","make","on","data","records","value","Records","record","emit","destroy","e"],"sources":["notification.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter } from 'eventemitter3'\nimport jsonLineParser from 'stream-json/jsonl/Parser.js'\n\nimport { DEFAULT_REGION } from './helpers.ts'\nimport type { TypedClient } from './internal/client.ts'\nimport { pipesetup, uriEscape } from './internal/helper.ts'\n\n// TODO: type this\n\ntype Event = unknown\n\n// Base class for three supported configs.\nexport class TargetConfig {\n  private Filter?: { S3Key: { FilterRule: { Name: string; Value: string }[] } }\n  private Event?: Event[]\n  private Id: unknown\n\n  setId(id: unknown) {\n    this.Id = id\n  }\n\n  addEvent(newevent: Event) {\n    if (!this.Event) {\n      this.Event = []\n    }\n    this.Event.push(newevent)\n  }\n\n  addFilterSuffix(suffix: string) {\n    if (!this.Filter) {\n      this.Filter = { S3Key: { FilterRule: [] } }\n    }\n    this.Filter.S3Key.FilterRule.push({ Name: 'suffix', Value: suffix })\n  }\n\n  addFilterPrefix(prefix: string) {\n    if (!this.Filter) {\n      this.Filter = { S3Key: { FilterRule: [] } }\n    }\n    this.Filter.S3Key.FilterRule.push({ Name: 'prefix', Value: prefix })\n  }\n}\n\n// 1. Topic (simple notification service)\nexport class TopicConfig extends TargetConfig {\n  private Topic: string\n\n  constructor(arn: string) {\n    super()\n    this.Topic = arn\n  }\n}\n\n// 2. Queue (simple queue service)\nexport class QueueConfig extends TargetConfig {\n  private Queue: string\n\n  constructor(arn: string) {\n    super()\n    this.Queue = arn\n  }\n}\n\n// 3. CloudFront (lambda function)\nexport class CloudFunctionConfig extends TargetConfig {\n  private CloudFunction: string\n\n  constructor(arn: string) {\n    super()\n    this.CloudFunction = arn\n  }\n}\n\n// Notification config - array of target configs.\n// Target configs can be\n// 1. Topic (simple notification service)\n// 2. Queue (simple queue service)\n// 3. CloudFront (lambda function)\nexport class NotificationConfig {\n  private TopicConfiguration?: TargetConfig[]\n  private CloudFunctionConfiguration?: TargetConfig[]\n  private QueueConfiguration?: TargetConfig[]\n\n  add(target: TargetConfig) {\n    let instance: TargetConfig[] | undefined\n    if (target instanceof TopicConfig) {\n      instance = this.TopicConfiguration ??= []\n    }\n    if (target instanceof QueueConfig) {\n      instance = this.QueueConfiguration ??= []\n    }\n    if (target instanceof CloudFunctionConfig) {\n      instance = this.CloudFunctionConfiguration ??= []\n    }\n    if (instance) {\n      instance.push(target)\n    }\n  }\n}\n\nexport const buildARN = (partition: string, service: string, region: string, accountId: string, resource: string) => {\n  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource\n}\nexport const ObjectCreatedAll = 's3:ObjectCreated:*'\nexport const ObjectCreatedPut = 's3:ObjectCreated:Put'\nexport const ObjectCreatedPost = 's3:ObjectCreated:Post'\nexport const ObjectCreatedCopy = 's3:ObjectCreated:Copy'\nexport const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload'\nexport const ObjectRemovedAll = 's3:ObjectRemoved:*'\nexport const ObjectRemovedDelete = 's3:ObjectRemoved:Delete'\nexport const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated'\nexport const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject'\nexport type NotificationEvent =\n  | 's3:ObjectCreated:*'\n  | 's3:ObjectCreated:Put'\n  | 's3:ObjectCreated:Post'\n  | 's3:ObjectCreated:Copy'\n  | 's3:ObjectCreated:CompleteMultipartUpload'\n  | 's3:ObjectRemoved:*'\n  | 's3:ObjectRemoved:Delete'\n  | 's3:ObjectRemoved:DeleteMarkerCreated'\n  | 's3:ReducedRedundancyLostObject'\n  | 's3:TestEvent'\n  | 's3:ObjectRestore:Post'\n  | 's3:ObjectRestore:Completed'\n  | 's3:Replication:OperationFailedReplication'\n  | 's3:Replication:OperationMissedThreshold'\n  | 's3:Replication:OperationReplicatedAfterThreshold'\n  | 's3:Replication:OperationNotTracked'\n  | string // put string at least so auto-complete could work\n\n// TODO: type this\nexport type NotificationRecord = unknown\n// Poll for notifications, used in #listenBucketNotification.\n// Listening constitutes repeatedly requesting s3 whether or not any\n// changes have occurred.\nexport class NotificationPoller extends EventEmitter<{\n  notification: (event: NotificationRecord) => void\n  error: (error: unknown) => void\n}> {\n  private client: TypedClient\n  private bucketName: string\n  private prefix: string\n  private suffix: string\n  private events: NotificationEvent[]\n  private ending: boolean\n\n  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]) {\n    super()\n\n    this.client = client\n    this.bucketName = bucketName\n    this.prefix = prefix\n    this.suffix = suffix\n    this.events = events\n\n    this.ending = false\n  }\n\n  // Starts the polling.\n  start() {\n    this.ending = false\n\n    process.nextTick(() => {\n      this.checkForChanges()\n    })\n  }\n\n  // Stops the polling.\n  stop() {\n    this.ending = true\n  }\n\n  checkForChanges() {\n    // Don't continue if we're looping again but are cancelled.\n    if (this.ending) {\n      return\n    }\n\n    const method = 'GET'\n    const queries = []\n    if (this.prefix) {\n      const prefix = uriEscape(this.prefix)\n      queries.push(`prefix=${prefix}`)\n    }\n    if (this.suffix) {\n      const suffix = uriEscape(this.suffix)\n      queries.push(`suffix=${suffix}`)\n    }\n    if (this.events) {\n      this.events.forEach((s3event) => queries.push('events=' + uriEscape(s3event)))\n    }\n    queries.sort()\n\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    const region = this.client.region || DEFAULT_REGION\n\n    this.client.makeRequestAsync({ method, bucketName: this.bucketName, query }, '', [200], region).then(\n      (response) => {\n        const asm = jsonLineParser.make()\n\n        pipesetup(response, asm)\n          .on('data', (data) => {\n            // Data is flushed periodically (every 5 seconds), so we should\n            // handle it after flushing from the JSON parser.\n            let records = data.value.Records\n            // If null (= no records), change to an empty array.\n            if (!records) {\n              records = []\n            }\n\n            // Iterate over the notifications and emit them individually.\n            records.forEach((record: NotificationRecord) => {\n              this.emit('notification', record)\n            })\n\n            // If we're done, stop.\n            if (this.ending) {\n              response?.destroy()\n            }\n          })\n          .on('error', (e) => this.emit('error', e))\n          .on('end', () => {\n            // Do it again, if we haven't cancelled yet.\n            process.nextTick(() => {\n              this.checkForChanges()\n            })\n          })\n      },\n      (e) => {\n        return this.emit('error', e)\n      },\n    )\n  }\n}\n"],"mappings":"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"}