Send to zulip

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/browser-builder.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+var path = require('path');
+
+var AWS = require('../index');
+
+var license = [
+  '// AWS SDK for JavaScript v' + AWS.VERSION,
+  '// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.',
+  '// License at https://sdk.amazonaws.com/js/BUNDLE_LICENSE.txt'
+].join('\n') + '\n';
+
+function minify(code) {
+  var uglify = require('uglify-js');
+  var minified = uglify.minify(code, {fromString: true});
+  return minified.code;
+}
+
+function build(options, callback) {
+  if (arguments.length === 1) {
+    callback = options;
+    options = {};
+  }
+
+  var img = require('insert-module-globals');
+  img.vars.process = function() { return '{browser:true}'; };
+
+  if (options.services) process.env.AWS_SERVICES = options.services;
+
+  var browserify = require('browserify');
+  var brOpts = { basedir: path.resolve(__dirname, '..') };
+  browserify(brOpts).add('./').ignore('domain').bundle(function(err, data) {
+    if (err) return callback(err);
+
+    var code = (data || '').toString();
+    if (options.minify) code = minify(code);
+
+    code = license + code;
+    callback(null, code);
+  });
+}
+
+// run if we called this tool directly
+if (require.main === module) {
+  var opts = {
+    services: process.argv[2] || process.env.SERVICES,
+    minify: process.env.MINIFY ? true : false
+  };
+  build(opts, function(err, code) {
+    if (err) console.error(err.message);
+    else console.log(code);
+  });
+}
+
+build.license = license;
+module.exports = build;

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/client-creator.js

@@ -0,0 +1,235 @@
+var fs = require('fs');
+var path = require('path');
+
+/**
+ * Generate service clients
+ *
+ * Pass optional path to target directory.
+ * The directory must include the apis/ folder and service customizations at
+ * `lib/services`. Clients will be generated in `clients/`.
+ *
+ * If parameter is not passed the repository root will be used.
+ */
+function ClientCreator(basePath) {
+  basePath = basePath || path.join(__dirname, '..');
+  this._metadataPath = path.join(basePath, 'apis', 'metadata.json');
+  this._apisFolderPath = path.join(basePath, 'apis');
+  this._clientFolderPath = path.join(basePath, 'clients');
+  this._serviceCustomizationsFolderPath = path.join(basePath, 'lib', 'services');
+  this._packageJsonPath = path.join(basePath, 'package.json');
+  // Lazy loading values on usage to avoid side-effects in constructor
+  this._apiFileNames = null;
+  this._metadata = null;
+}
+
+ClientCreator.prototype.loadMetadata = function loadMetadata() {
+    if (this._metadata) {
+      return this._metadata;
+    }
+
+    var metadataFile = fs.readFileSync(this._metadataPath);
+    this.metadata = JSON.parse(metadataFile);
+    return this.metadata;
+};
+
+ClientCreator.prototype.getAllApiFilenames = function getAllApiFilenames() {
+    if (this._apiFileNames) {
+        return this._apiFileNames;
+    }
+    var apiFileNames = fs.readdirSync(this._apisFolderPath);
+    // filter out metadata
+    this._apiFileNames = apiFileNames.filter(function(name) {
+        return name !== 'metadata.json';
+    });
+    return this._apiFileNames;
+};
+
+ClientCreator.prototype.getAllApiFilenamesForService = function getAllApiFilenamesForService(modelName) {
+    var serviceRegex = new RegExp('(^' + modelName + '-([\\d]{4}-[\\d]{2}-[\\d]{2})\\.([\\w]+))\\.json$');
+    var modelRegex = /(([\d]{4}-[\d]{2}-[\d]{2})\.([\w]+))\.json$/;
+
+    var models = {};
+    var versions = {};
+    this.getAllApiFilenames().filter(function(name) {
+        return name.search(serviceRegex) === 0;
+    }).forEach(function(name) {
+        var matches = name.match(serviceRegex);
+        if (!matches) {
+            return;
+        }
+        var model = matches[1];
+        var version = matches[2];
+        var modelType = matches[3];
+        if (!versions.hasOwnProperty(version)) {
+            versions[version] = {};
+        }
+        var versionInfo = versions[version];
+        switch (modelType) {
+            case 'min':
+                versionInfo.api = model;
+                break;
+            case 'paginators':
+                versionInfo.paginators = model;
+                break;
+            case 'waiters2':
+                versionInfo.waiters = model;
+                break;
+            default:
+                return;
+        }
+    });
+    models.versions = versions;
+    return models;
+};
+
+ClientCreator.prototype.customizationsExist = function customizationsExist(serviceName) {
+    var customizationsFolder = this._serviceCustomizationsFolderPath;
+    return fs.existsSync(path.join(customizationsFolder, serviceName + '.js'));
+};
+
+ClientCreator.prototype.generateClientFileSource = function generateClientFileSource(serviceMetadata, specifiedVersion) {
+  var clientFolderPath = this._clientFolderPath;
+  var className = serviceMetadata.name;
+  var serviceName = className.toLowerCase();
+  var modelName = serviceMetadata.prefix || serviceName;
+  specifiedVersion = specifiedVersion || '*';
+
+  // get models for the service
+  var models = this.getAllApiFilenamesForService(modelName);
+
+  var modelVersions = models && models.versions;
+  if (!modelVersions) {
+      throw new Error('Unable to get models for ' + modelName);
+  }
+  var obsoleteVersions = serviceMetadata.versions || [];
+  var versionNumbers = Object.keys(modelVersions);
+  var tab = '  ';
+  var code = '';
+  code += 'require(\'../lib/node_loader\');\n';
+  code += 'var AWS = require(\'../lib/core\');\n';
+  code += 'var Service = AWS.Service;\n';
+  code += 'var apiLoader = AWS.apiLoader;\n\n';
+  code += 'apiLoader.services[\'' + serviceName +'\'] = {};\n';
+  code += 'AWS.' + className + ' = Service.defineService(\'' + serviceName + '\', [\'' + [].concat(obsoleteVersions, versionNumbers).sort().join('\', \'') + '\']);\n';
+  // pull in service customizations
+  if (this.customizationsExist(serviceName)) {
+    code += 'require(\'../lib/services/' + serviceName + '\');\n';
+  }
+  versionNumbers.forEach(function(version) {
+    // check version
+    if (specifiedVersion !== '*' && specifiedVersion !== version) {
+        return;
+    }
+    var versionInfo = modelVersions[version];
+    if (!versionInfo.hasOwnProperty('api')) {
+        throw new Error('No API model for ' + serviceName + '-' + version);
+    }
+    code += 'Object.defineProperty(apiLoader.services[\'' + serviceName +'\'], \'' + version + '\', {\n';
+    code += tab + 'get: function get() {\n';
+    code += tab + tab + 'var model = require(\'../apis/' + versionInfo.api + '.json\');\n';
+    if (versionInfo.hasOwnProperty('paginators')) {
+        code += tab + tab + 'model.paginators = require(\'../apis/' + versionInfo.paginators + '.json\').pagination;\n';
+    }
+    if (versionInfo.hasOwnProperty('waiters')) {
+        code += tab + tab + 'model.waiters = require(\'../apis/' + versionInfo.waiters + '.json\').waiters;\n';
+    }
+    code += tab + tab + 'return model;\n';
+    code += tab + '},\n';
+    code += tab + 'enumerable: true,\n';
+    code += tab + 'configurable: true\n';
+    code += '});\n';
+  });
+
+  code += '\n';
+  code += 'module.exports = AWS.' + className + ';\n';
+  return {
+      code: code,
+      path: path.join(clientFolderPath, serviceName + '.js'),
+      service: serviceName,
+  };
+};
+
+ClientCreator.prototype.tabs = function tabs(count) {
+  var tab = '';
+  for (var i = 0; i < count; i++) {
+      tab += '  ';
+  }
+  return tab;
+};
+
+ClientCreator.prototype.generateDefinePropertySource = function generateDefinePropertySource(objName, serviceName, className) {
+  var tabs = this.tabs;
+  var code = '';
+  code += 'var ' + serviceName + ' = null;\n';
+  code += 'Object.defineProperty(' + objName + ', \'' + className + '\', {\n';
+  code += tabs(1) + 'get: function get() {\n';
+  code += tabs(2) + 'return ' + serviceName + ' || require(\'./' + serviceName + '\');\n';
+  code += tabs(1) + '},\n';
+  code += tabs(1) + 'set: function set(svc) {\n';
+  code += tabs(2) + serviceName + ' = svc;\n';
+  code += tabs(1) + '},\n';
+  code += tabs(1) + 'enumerable: true,\n';
+  code += tabs(1) + 'configurable: true\n';
+  code += '});\n';
+
+  return code;
+};
+
+ClientCreator.prototype.generateAllServicesSource = function generateAllServicesSource(services, fileName) {
+  var metadata = this.loadMetadata();
+  var self = this;
+  var code = '';
+  code += 'require(\'../lib/node_loader\');\n';
+  code += 'module.exports = {\n';
+
+  services.forEach(function(service, idx) {
+    var className = metadata[service].name;
+    var tab = '  ';
+    var isLast = idx === services.length - 1;
+    code += self.tabs(1) + className + ': require(\'./' + service + '\')' + (isLast ? '' : ',') + '\n';
+  });
+  code += '};';
+  return {
+    code: code,
+    path: path.join(this._clientFolderPath, fileName + '.js'),
+    service: fileName
+  };
+};
+
+ClientCreator.prototype.getDefaultServices = function getDefaultServices() {
+  var metadata = this.loadMetadata();
+  var services = [];
+  for (var key in metadata) {
+    if (!metadata.hasOwnProperty(key)) {
+      continue;
+    }
+    var className = metadata[key].name;
+    var serviceName = className.toLowerCase();
+    services.push(serviceName);
+  }
+  return services;
+};
+
+ClientCreator.prototype.writeClientServices = function writeClientServices() {
+  var metadata = this.loadMetadata();
+  var services = [];
+  var corsServices = [];
+  for (var key in metadata) {
+    if (!metadata.hasOwnProperty(key)) {
+      continue;
+    }
+    var clientInfo = this.generateClientFileSource(metadata[key]);
+    fs.writeFileSync(clientInfo.path, clientInfo.code);
+    services.push(clientInfo.service);
+    // check if service supports CORS
+    if (metadata[key].cors === true) {
+      corsServices.push(clientInfo.service);
+    }
+  }
+  var allClientInfo = this.generateAllServicesSource(services, 'all');
+  fs.writeFileSync(allClientInfo.path, allClientInfo.code);
+  var browserClientInfo = this.generateAllServicesSource(corsServices, 'browser_default');
+  fs.writeFileSync(browserClientInfo.path, browserClientInfo.code);
+};
+
+module.exports = ClientCreator;

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/create-all-services.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+var path = require('path');
+
+/*
+ * Pass optional path to target directory as command line argument.
+ *
+ * The directory must include the apis/ folder and service customizations at
+ * `lib/services`. Clients will be generated in `clients/`.
+ *
+ * If parameter is not passed the repository root will be used.
+ */
+
+var ClientCreator = require('./client-creator');
+
+var cc = new ClientCreator(process.argv[2] || path.join(__dirname, '..'));
+
+cc.writeClientServices();
+console.log('Finished updating services.');

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/service-collector.js

@@ -0,0 +1,166 @@
+var fs = require('fs');
+var util = require('util');
+var path = require('path');
+
+var AWS = require('../');
+var apis = require('../lib/api_loader');
+var metadata = require('../apis/metadata');
+var ClientCreator = require('./client-creator');
+
+var clientCreator = new ClientCreator();
+var defaultServices = clientCreator.getDefaultServices().join(',');
+var sanitizeRegex = /[^a-zA-Z0-9,-]/;
+
+var serviceClasses = {};
+Object.keys(AWS).forEach(function(name) {
+  if (AWS[name].serviceIdentifier) {
+    serviceClasses[AWS[name].serviceIdentifier] = AWS[name];
+  }
+});
+
+function getServiceHeader(service) {
+  if (service === 'all') {
+    return Object.keys(serviceClasses).map(function(name) {
+      return getServiceHeader(name);
+    }).join('\n');
+  }
+
+  if (!serviceClasses[service]) return null;
+  var versions = serviceClasses[service].apiVersions.map(function(version) {
+    return version.indexOf('*') >= 0 ? null : version;
+  }).filter(function(c) { return c !== null; });
+
+  var file = util.format(
+    'if (!Object.prototype.hasOwnProperty.call(AWS, \'' + metadata[service].name + '\')) {\n' +
+    '  AWS.apiLoader.services[\'%s\'] = {};\n' +
+    '  AWS.%s = AWS.Service.defineService(\'%s\', %s);\n',
+    service, metadata[service].name, service, util.inspect(versions));
+  var svcPath = path.join(__dirname, '..', 'lib', 'services', service + '.js');
+  if (fs.existsSync(svcPath)) {
+    file += '  require(\'./services/' + service + '\');\n';
+  }
+  file += '}\n';
+
+  return file;
+}
+
+function getService(service, version) {
+  if (service === 'all') {
+    return Object.keys(serviceClasses).map(function(name) {
+      var out = serviceClasses[name].apiVersions.map(function(svcVersion) {
+        if (svcVersion.indexOf('*') >= 0) return null;
+        return getService(name, svcVersion);
+      }).filter(function(c) { return c !== null; }).join('\n');
+
+      return out;
+    }).join('\n');
+  }
+
+  var svc, api;
+  if (!serviceClasses[service]) {
+    return null;
+  }
+
+  try {
+    var ClassName = serviceClasses[service];
+    svc = new ClassName({apiVersion: version, endpoint: 'localhost'});
+    api = svc.api;
+  } catch (e) {
+    return null;
+  }
+
+  var serviceFileName = metadata[service].prefix || service;
+  var lines = [];
+  var line = util.format(
+    'AWS.apiLoader.services[\'%s\'][\'%s\'] = %s;\n',
+    service, svc.api.apiVersion, 'require(\'../apis/' + serviceFileName + '-' + svc.api.apiVersion + '.min\')');
+  lines.push(line);
+  if (Object.prototype.hasOwnProperty.call(api, 'paginators') && Object.keys(api.paginators).length) {
+    line = util.format(
+      'AWS.apiLoader.services[\'%s\'][\'%s\'].paginators = %s;\n',
+      service, svc.api.apiVersion, 'require(\'../apis/' + serviceFileName + '-' + svc.api.apiVersion + '.paginators\').pagination');
+    lines.push(line);
+  }
+  if (Object.prototype.hasOwnProperty.call(api, 'waiters') && Object.keys(api.waiters).length) {
+    line = util.format(
+      'AWS.apiLoader.services[\'%s\'][\'%s\'].waiters = %s;\n',
+      service, svc.api.apiVersion, 'require(\'../apis/' + serviceFileName + '-' + svc.api.apiVersion + '.waiters2\').waiters');
+    lines.push(line);
+  }
+  return lines.join('');
+}
+
+function ServiceCollector(services) {
+  var builtServices = {};
+
+  function buildService(name, usingDefaultServices) {
+    var match = name.match(/^(.+?)(?:-(.+?))?$/);
+    var service = match[1], version = match[2] || 'latest';
+    var contents = [];
+    var lines, err;
+
+    if (!builtServices[service]) {
+      builtServices[service] = {};
+
+      lines = getServiceHeader(service);
+      if (lines === null) {
+        if (!usingDefaultServices) {
+          err = new Error('Invalid module: ' + service);
+          err.name = 'InvalidModuleError';
+          throw err;
+        }
+      } else {
+        contents.push(lines);
+      }
+    }
+
+    if (!builtServices[service][version]) {
+      builtServices[service][version] = true;
+
+      lines = getService(service, version);
+      if (lines === null) {
+        if (!usingDefaultServices) {
+          err = new Error('Invalid module: ' + service + '-' + version);
+          err.name = 'InvalidModuleError';
+          throw err;
+        }
+      } else {
+        contents.push(lines);
+      }
+    }
+
+    return contents.join('');
+  }
+
+  var serviceCode = '';
+  var usingDefaultServicesToggle = false;
+  if (!services) {
+    usingDefaultServicesToggle = true;
+    services = defaultServices;
+  }
+  if (services.match(sanitizeRegex)) {
+    throw new Error('Incorrectly formatted service names');
+  }
+
+  var invalidModules = [];
+  services.split(',').sort().forEach(function(name) {
+    if (['cognitoidentity', 'sts'].indexOf(name) >= 0) {
+      // these service has been included via browser credentials already
+      return;
+    }
+    try {
+      serviceCode += buildService(name, usingDefaultServicesToggle) + '\n';
+    } catch (e) {
+      if (e.name === 'InvalidModuleError') invalidModules.push(name);
+      else throw e;
+    }
+  });
+
+  if (invalidModules.length > 0) {
+    throw new Error('Missing modules: ' + invalidModules.join(', '));
+  }
+
+  return serviceCode;
+}
+
+module.exports = ServiceCollector;

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/transform.js

@@ -0,0 +1,43 @@
+var Transform = require('stream').Transform;
+var collector = require('./service-collector');
+var license = require('./browser-builder').license;
+
+module.exports = function(file) {
+  var stream = new Transform();
+
+  var didDefineServices = !!process.env.AWS_SERVICES;
+
+  var isEntryPoint = !!file.match(/[\/\\]lib[\/\\]browser\.js$/);
+
+  stream._transform = function(data, encoding, callback) {
+    callback(null, data);
+  };
+
+  if (isEntryPoint) {
+    if (didDefineServices) {
+      // We need to strip out the default requires statement
+      stream._transform = function(data, encoding, callback) {
+        var code = data.toString();
+        code = code.trim();
+        var lines = code.split('\n');
+        lines = lines.filter(function(line) {
+          return !line.match(/^require\(.+browser_default['"]\);$/);
+        });
+
+        code = lines.join('\n');
+        data = Buffer.from(code);
+        callback(null, data);
+      };
+
+      var src = collector(process.env.AWS_SERVICES);
+      stream._flush = function(callback) {
+        stream.push(src);
+        callback();
+      };
+    }
+
+    stream.push(license);
+  }
+
+  return stream;
+};

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/webpack.config.rn-core.js

@@ -0,0 +1,32 @@
+// import path for resolving file paths
+var path = require('path');
+module.exports = {
+    // Specify the entry point for our app.
+    entry: [
+        path.join(__dirname, '..', 'lib', 'core.js'),
+    ],
+    // Specify the output file containing our bundled code
+    output: {
+        path: path.join(__dirname, '..', 'dist'),
+        filename: 'aws-sdk-core-react-native.js',
+        libraryTarget: 'umd',
+        library: 'AWS'
+    },
+    resolve: {},
+    module: {
+        /**
+         * Tell webpack how to load 'json' files.
+         * By default, webpack only knows how to handle
+         * JavaScript files.
+         * When webpack comes across a 'require()' statement
+         * where a json file is being imported, it will use
+         * the json-loader.
+         */
+        loaders: [
+            {
+                test: /\.json$/,
+                loaders: ['json']
+            }
+        ]
+    }
+};

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/webpack.config.rn-dep.js

@@ -0,0 +1,31 @@
+// import path for resolving file paths
+var path = require('path');
+module.exports = {
+    // Specify the entry point for our app.
+    entry: [
+        'xml2js'
+    ],
+    // Specify the output file containing our bundled code
+    output: {
+        path: path.join(__dirname, '..', 'dist'),
+        filename: 'xml2js.js',
+        libraryTarget: 'commonjs2',
+    },
+    resolve: {},
+    module: {
+        /**
+         * Tell webpack how to load 'json' files.
+         * By default, webpack only knows how to handle
+         * JavaScript files.
+         * When webpack comes across a 'require()' statement
+         * where a json file is being imported, it will use
+         * the json-loader.
+         */
+        loaders: [
+            {
+                test: /\.json$/,
+                loaders: ['json']
+            }
+        ]
+    }
+};

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/dist-tools/webpack.config.rn.js

@@ -0,0 +1,34 @@
+// import path for resolving file paths
+var path = require('path');
+module.exports = {
+    // Specify the entry point for our app.
+    entry: [
+        path.join(__dirname, '..', 'react-native.js')
+    ],
+    // Specify the output file containing our bundled code
+    output: {
+        path: path.join(__dirname, '..', 'dist'),
+        filename: 'aws-sdk-react-native.js',
+        libraryTarget: 'umd',
+        library: 'AWS'
+    },
+    resolve: {
+      packageAlias: 'react-native'
+    },
+    module: {
+        /**
+         * Tell webpack how to load 'json' files.
+         * By default, webpack only knows how to handle
+         * JavaScript files.
+         * When webpack comes across a 'require()' statement
+         * where a json file is being imported, it will use
+         * the json-loader.
+         */
+        loaders: [
+            {
+                test: /\.json$/,
+                loaders: ['json']
+            }
+        ]
+    }
+};