@aws-amplify/graphql-model-transformer 1.3.4-agqlac.0 → 1.4.0-rds.0

package/rds-lambda/node_modules/mysql2/README.md

@@ -1,281 +0,0 @@
-## Node MySQL 2
-
-[![Greenkeeper badge](https://badges.greenkeeper.io/sidorares/node-mysql2.svg)](https://greenkeeper.io/)
-[![NPM Version][npm-image]][npm-url]
-[![NPM Downloads][downloads-image]][downloads-url]
-[![Node.js Version][node-version-image]][node-version-url]
-[![Linux Build][travis-image]][travis-url]
-[![Windows Build][appveyor-image]][appveyor-url]
-[![License][license-image]][license-url]
-
-> MySQL client for Node.js with focus on performance. Supports prepared statements, non-utf8 encodings, binary log protocol, compression, ssl [much more](https://github.com/sidorares/node-mysql2/tree/master/documentation)
-
-__Table of contents__
-
-  - [History and Why MySQL2](#history-and-why-mysql2)
-  - [Installation](#installation)
-  - [First Query](#first-query)
-  - [Using Prepared Statements](#using-prepared-statements)
-  - [Using connection pools](#using-connection-pools)
-  - [Using Promise Wrapper](#using-promise-wrapper)
-  - [API and Configuration](#api-and-configuration)
-  - [Documentation](#documentation)
-  - [Acknowledgements](#acknowledgements)
-  - [Contributing](#contributing)
-
-## History and Why MySQL2
-
-MySQL2 project is a continuation of [MySQL-Native][mysql-native]. Protocol parser code was rewritten from scratch and api changed to match popular [mysqljs/mysql][node-mysql]. MySQL2 team is working together with [mysqljs/mysql][node-mysql] team to factor out shared code and move it under [mysqljs][node-mysql] organisation.
-
-MySQL2 is mostly API compatible with [mysqljs][node-mysql] and supports majority of features. MySQL2 also offers these additional features
-
- - Faster / Better Performance
- - [Prepared Statements](https://github.com/sidorares/node-mysql2/tree/master/documentation/Prepared-Statements.md)
- - MySQL Binary Log Protocol
- - [MySQL Server](https://github.com/sidorares/node-mysql2/tree/master/documentation/MySQL-Server.md)
- - Extended support for Encoding and Collation
- - [Promise Wrapper](https://github.com/sidorares/node-mysql2/tree/master/documentation/Promise-Wrapper.md)
- - Compression
- - SSL and [Authentication Switch](https://github.com/sidorares/node-mysql2/tree/master/documentation/Authentication-Switch.md)
- - [Custom Streams](https://github.com/sidorares/node-mysql2/tree/master/documentation/Extras.md)
- - [Pooling](#using-connection-pools)
-
-## Installation
-
-MySQL2 is free from native bindings and can be installed on Linux, Mac OS or Windows without any issues.
-
-```bash
-npm install --save mysql2
-```
-
-## First Query
-
-```js
-// get the client
-const mysql = require('mysql2');
-
-// create the connection to database
-const connection = mysql.createConnection({
-  host: 'localhost',
-  user: 'root',
-  database: 'test'
-});
-
-// simple query
-connection.query(
-  'SELECT * FROM `table` WHERE `name` = "Page" AND `age` > 45',
-  function(err, results, fields) {
-    console.log(results); // results contains rows returned by server
-    console.log(fields); // fields contains extra meta data about results, if available
-  }
-);
-
-// with placeholder
-connection.query(
-  'SELECT * FROM `table` WHERE `name` = ? AND `age` > ?',
-  ['Page', 45],
-  function(err, results) {
-    console.log(results);
-  }
-);
-```
-
-## Using Prepared Statements
-
-With MySQL2 you also get the prepared statements. With prepared statements MySQL doesn't have to prepare plan for same query everytime, this results in better performance. If you don't know why they are important, please check these discussions
-
-- [How prepared statements can protect from SQL Injection attacks](http://stackoverflow.com/questions/8263371/how-can-prepared-statements-protect-from-sql-injection-attacks)
-
-MySQL provides `execute` helper which will prepare and query the statement. You can also manually prepare / unprepare statement with `prepare` / `unprepare` methods.
-
-```js
-// get the client
-const mysql = require('mysql2');
-
-// create the connection to database
-const connection = mysql.createConnection({
-  host: 'localhost',
-  user: 'root',
-  database: 'test'
-});
-
-// execute will internally call prepare and query
-connection.execute(
-  'SELECT * FROM `table` WHERE `name` = ? AND `age` > ?',
-  ['Rick C-137', 53],
-  function(err, results, fields) {
-    console.log(results); // results contains rows returned by server
-    console.log(fields); // fields contains extra meta data about results, if available
-
-    // If you execute same statement again, it will be picked from a LRU cache
-    // which will save query preparation time and give better performance
-  }
-);
-```
-
-## Using connection pools
-
-Connection pools help reduce the time spent connecting to the MySQL server by reusing a previous connection, leaving them open instead of closing when you are done with them.
-
-This improves the latency of queries as you avoid all of the overhead that comes with establishing a new connection.
-
-```js
-// get the client
-const mysql = require('mysql2');
-
-// Create the connection pool. The pool-specific settings are the defaults
-const pool = mysql.createPool({
-  host: 'localhost',
-  user: 'root',
-  database: 'test',
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0
-});
-```
-The pool does not create all connections upfront but creates them on demand until the connection limit is reached.
-
-You can use the pool in the same way as connections (using `pool.query()` and `pool.execute()`):
-```js
-// For pool initialization, see above
-pool.query("SELECT field FROM atable", function(err, rows, fields) {
-   // Connection is automatically released when query resolves
-})
-```
-
-Alternatively, there is also the possibility of manually acquiring a connection from the pool and returning it later:
-```js
-// For pool initialization, see above
-pool.getConnection(function(err, conn) {
-   // Do something with the connection
-   conn.query(/* ... */);
-   // Don't forget to release the connection when finished!
-   pool.releaseConnection(conn);
-})
-```
-
-## Using Promise Wrapper
-
-MySQL2 also support Promise API. Which works very well with ES7 async await.
-
-<!--eslint-disable-next-block-->
-```js
-async function main() {
-  // get the client
-  const mysql = require('mysql2/promise');
-  // create the connection
-  const connection = await mysql.createConnection({host:'localhost', user: 'root', database: 'test'});
-  // query database
-  const [rows, fields] = await connection.execute('SELECT * FROM `table` WHERE `name` = ? AND `age` > ?', ['Morty', 14]);
-}
-```
-
-MySQL2 use default `Promise` object available in scope. But you can choose which `Promise` implementation you want to use
-
-<!--eslint-disable-next-block-->
-```js
-// get the client
-const mysql = require('mysql2/promise');
-
-// get the promise implementation, we will use bluebird
-const bluebird = require('bluebird');
-
-// create the connection, specify bluebird as Promise
-const connection = await mysql.createConnection({host:'localhost', user: 'root', database: 'test', Promise: bluebird});
-
-// query database
-const [rows, fields] = await connection.execute('SELECT * FROM `table` WHERE `name` = ? AND `age` > ?', ['Morty', 14]);
-```
-
-MySQL2 also exposes a .promise() function on Pools, so you can create a promise/non-promise connections from the same pool
-```js
-async function main() {
-  // get the client
-  const mysql = require('mysql2');
-  // create the pool
-  const pool = mysql.createPool({host:'localhost', user: 'root', database: 'test'});
-  // now get a Promise wrapped instance of that pool
-  const promisePool = pool.promise();
-  // query database using promises
-  const [rows,fields] = await promisePool.query("SELECT 1");
-```
-
-MySQL2 exposes a .promise() function on Connections, to "upgrade" an existing non-promise connection to use promise
-```js
-// get the client
-const mysql = require('mysql2');
-// create the connection
-const con = mysql.createConnection(
-  {host:'localhost', user: 'root', database: 'test'}
-);
-con.promise().query("SELECT 1")
-  .then( ([rows,fields]) => {
-    console.log(rows);
-  })
-  .catch(console.log)
-  .then( () => con.end());
-```
-
-## Array results
-
-If you have two columns with the same name, you might want to get results as an array rather than an object to prevent them from clashing. This is a deviation from the [Node MySQL][node-mysql] library.
-
-For example: `select 1 as foo, 2 as foo`.
-
-You can enable this setting at either the connection level (applies to all queries), or at the query level (applies only to that specific query).
-
-### Connection Option
-```js
-const con = mysql.createConnection(
-  { host: 'localhost', database: 'test', user: 'root', rowsAsArray: true }
-);
-
-```
-
-### Query Option
-
-```js
-con.query({ sql: 'select 1 as foo, 2 as foo', rowsAsArray: true }, function(err, results, fields) {
-  console.log(results) // will be an array of arrays rather than an array of objects
-  console.log(fields) // these are unchanged
-});
-
-```
-
-## API and Configuration
-
-MySQL2 is mostly API compatible with [Node MySQL][node-mysql]. You should check their API documentation to see all available API options.
-
-If you find any incompatibility with [Node MySQL][node-mysql], Please report via Issue tracker. We will fix reported incompatibility on priority basis.
-
-## Documentation
-
-You can find more detailed documentation [here](https://github.com/sidorares/node-mysql2/tree/master/documentation). You should also check various code [examples](https://github.com/sidorares/node-mysql2/tree/master/examples) to understand advanced concepts.
-
-## Acknowledgements
-
-  - Internal protocol is written by @sidorares [MySQL-Native](https://github.com/sidorares/nodejs-mysql-native)
-  - Constants, SQL parameters interpolation, Pooling, `ConnectionConfig` class taken from [node-mysql](https://github.com/mysqljs/mysql)
-  - SSL upgrade code based on @TooTallNate [code](https://gist.github.com/TooTallNate/848444)
-  - Secure connection / compressed connection api flags compatible to [MariaSQL](https://github.com/mscdex/node-mariasql/) client.
-  - [Contributors](https://github.com/sidorares/node-mysql2/graphs/contributors)
-
-## Contributing
-
-Want to improve something in `node-mysql2`. Please check [Contributing.md](https://github.com/sidorares/node-mysql2/blob/master/Contributing.md) for detailed instruction on how to get started.
-
-
-[npm-image]: https://img.shields.io/npm/v/mysql2.svg
-[npm-url]: https://npmjs.org/package/mysql2
-[node-version-image]: http://img.shields.io/node/v/mysql2.svg
-[node-version-url]: http://nodejs.org/download/
-[travis-image]: https://img.shields.io/travis/sidorares/node-mysql2/master.svg?label=linux
-[travis-url]: https://travis-ci.org/sidorares/node-mysql2
-[appveyor-image]: https://img.shields.io/appveyor/ci/sidorares/node-mysql2/master.svg?label=windows
-[appveyor-url]: https://ci.appveyor.com/project/sidorares/node-mysql2
-[downloads-image]: https://img.shields.io/npm/dm/mysql2.svg
-[downloads-url]: https://npmjs.org/package/mysql2
-[license-url]: https://github.com/sidorares/node-mysql2/blob/master/License
-[license-image]: https://img.shields.io/npm/l/mysql2.svg?maxAge=2592000
-[node-mysql]: https://github.com/mysqljs/mysql
-[mysql-native]: https://github.com/sidorares/nodejs-mysql-native

package/rds-lambda/node_modules/mysql2/lib/auth_plugins/caching_sha2_password.md

@@ -1,18 +0,0 @@
-##
-
-https://mysqlserverteam.com/mysql-8-0-4-new-default-authentication-plugin-caching_sha2_password/
-
-```js
-const mysql = require('mysql');
-mysql.createConnection({
-  authPlugins: {
-    caching_sha2_password: mysql.authPlugins.caching_sha2_password({
-      onServerPublikKey: function(key) {
-        console.log(key);
-      },
-      serverPublicKey: 'xxxyyy',
-      overrideIsSecure: true //
-    })
-  }
-});
-```

package/rds-lambda/node_modules/mysql2/node_modules/lru-cache/README.md

@@ -1,166 +0,0 @@
-# lru cache
-
-A cache object that deletes the least-recently-used items.
-
-[![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache)
-
-## Installation:
-
-```javascript
-npm install lru-cache --save
-```
-
-## Usage:
-
-```javascript
-var LRU = require("lru-cache")
-  , options = { max: 500
-              , length: function (n, key) { return n * 2 + key.length }
-              , dispose: function (key, n) { n.close() }
-              , maxAge: 1000 * 60 * 60 }
-  , cache = new LRU(options)
-  , otherCache = new LRU(50) // sets just the max size
-
-cache.set("key", "value")
-cache.get("key") // "value"
-
-// non-string keys ARE fully supported
-// but note that it must be THE SAME object, not
-// just a JSON-equivalent object.
-var someObject = { a: 1 }
-cache.set(someObject, 'a value')
-// Object keys are not toString()-ed
-cache.set('[object Object]', 'a different value')
-assert.equal(cache.get(someObject), 'a value')
-// A similar object with same keys/values won't work,
-// because it's a different object identity
-assert.equal(cache.get({ a: 1 }), undefined)
-
-cache.reset()    // empty the cache
-```
-
-If you put more stuff in it, then items will fall out.
-
-If you try to put an oversized thing in it, then it'll fall out right
-away.
-
-## Options
-
-* `max` The maximum size of the cache, checked by applying the length
-  function to all values in the cache.  Not setting this is kind of
-  silly, since that's the whole purpose of this lib, but it defaults
-  to `Infinity`.  Setting it to a non-number or negative number will
-  throw a `TypeError`.  Setting it to 0 makes it be `Infinity`.
-* `maxAge` Maximum age in ms.  Items are not pro-actively pruned out
-  as they age, but if you try to get an item that is too old, it'll
-  drop it and return undefined instead of giving it to you.
-  Setting this to a negative value will make everything seem old!
-  Setting it to a non-number will throw a `TypeError`.
-* `length` Function that is used to calculate the length of stored
-  items.  If you're storing strings or buffers, then you probably want
-  to do something like `function(n, key){return n.length}`.  The default is
-  `function(){return 1}`, which is fine if you want to store `max`
-  like-sized things.  The item is passed as the first argument, and
-  the key is passed as the second argumnet.
-* `dispose` Function that is called on items when they are dropped
-  from the cache.  This can be handy if you want to close file
-  descriptors or do other cleanup tasks when items are no longer
-  accessible.  Called with `key, value`.  It's called *before*
-  actually removing the item from the internal cache, so if you want
-  to immediately put it back in, you'll have to do that in a
-  `nextTick` or `setTimeout` callback or it won't do anything.
-* `stale` By default, if you set a `maxAge`, it'll only actually pull
-  stale items out of the cache when you `get(key)`.  (That is, it's
-  not pre-emptively doing a `setTimeout` or anything.)  If you set
-  `stale:true`, it'll return the stale value before deleting it.  If
-  you don't set this, then it'll return `undefined` when you try to
-  get a stale entry, as if it had already been deleted.
-* `noDisposeOnSet` By default, if you set a `dispose()` method, then
-  it'll be called whenever a `set()` operation overwrites an existing
-  key.  If you set this option, `dispose()` will only be called when a
-  key falls out of the cache, not when it is overwritten.
-* `updateAgeOnGet` When using time-expiring entries with `maxAge`,
-  setting this to `true` will make each item's effective time update
-  to the current time whenever it is retrieved from cache, causing it
-  to not expire.  (It can still fall out of cache based on recency of
-  use, of course.)
-
-## API
-
-* `set(key, value, maxAge)`
-* `get(key) => value`
-
-    Both of these will update the "recently used"-ness of the key.
-    They do what you think. `maxAge` is optional and overrides the
-    cache `maxAge` option if provided.
-
-    If the key is not found, `get()` will return `undefined`.
-
-    The key and val can be any value.
-
-* `peek(key)`
-
-    Returns the key value (or `undefined` if not found) without
-    updating the "recently used"-ness of the key.
-
-    (If you find yourself using this a lot, you *might* be using the
-    wrong sort of data structure, but there are some use cases where
-    it's handy.)
-
-* `del(key)`
-
-    Deletes a key out of the cache.
-
-* `reset()`
-
-    Clear the cache entirely, throwing away all values.
-
-* `has(key)`
-
-    Check if a key is in the cache, without updating the recent-ness
-    or deleting it for being stale.
-
-* `forEach(function(value,key,cache), [thisp])`
-
-    Just like `Array.prototype.forEach`.  Iterates over all the keys
-    in the cache, in order of recent-ness.  (Ie, more recently used
-    items are iterated over first.)
-
-* `rforEach(function(value,key,cache), [thisp])`
-
-    The same as `cache.forEach(...)` but items are iterated over in
-    reverse order.  (ie, less recently used items are iterated over
-    first.)
-
-* `keys()`
-
-    Return an array of the keys in the cache.
-
-* `values()`
-
-    Return an array of the values in the cache.
-
-* `length`
-
-    Return total length of objects in cache taking into account
-    `length` options function.
-
-* `itemCount`
-
-    Return total quantity of objects currently in cache. Note, that
-    `stale` (see options) items are returned as part of this item
-    count.
-
-* `dump()`
-
-    Return an array of the cache entries ready for serialization and usage
-    with 'destinationCache.load(arr)`.
-
-* `load(cacheEntriesArray)`
-
-    Loads another cache entries array, obtained with `sourceCache.dump()`,
-    into the cache. The destination cache is reset before loading new entries
-
-* `prune()`
-
-    Manually iterates over the entire cache proactively pruning old entries

package/rds-lambda/node_modules/mysql2/node_modules/lru-cache/package.json

@@ -1,34 +0,0 @@
-{
-  "name": "lru-cache",
-  "description": "A cache object that deletes the least-recently-used items.",
-  "version": "6.0.0",
-  "author": "Isaac Z. Schlueter <i@izs.me>",
-  "keywords": [
-    "mru",
-    "lru",
-    "cache"
-  ],
-  "scripts": {
-    "test": "tap",
-    "snap": "tap",
-    "preversion": "npm test",
-    "postversion": "npm publish",
-    "prepublishOnly": "git push origin --follow-tags"
-  },
-  "main": "index.js",
-  "repository": "git://github.com/isaacs/node-lru-cache.git",
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "tap": "^14.10.7"
-  },
-  "license": "ISC",
-  "dependencies": {
-    "yallist": "^4.0.0"
-  },
-  "files": [
-    "index.js"
-  ],
-  "engines": {
-    "node": ">=10"
-  }
-}

package/rds-lambda/node_modules/mysql2/node_modules/yallist/README.md

@@ -1,204 +0,0 @@
-# yallist
-
-Yet Another Linked List
-
-There are many doubly-linked list implementations like it, but this
-one is mine.
-
-For when an array would be too big, and a Map can't be iterated in
-reverse order.
-
-
-[![Build Status](https://travis-ci.org/isaacs/yallist.svg?branch=master)](https://travis-ci.org/isaacs/yallist) [![Coverage Status](https://coveralls.io/repos/isaacs/yallist/badge.svg?service=github)](https://coveralls.io/github/isaacs/yallist)
-
-## basic usage
-
-```javascript
-var yallist = require('yallist')
-var myList = yallist.create([1, 2, 3])
-myList.push('foo')
-myList.unshift('bar')
-// of course pop() and shift() are there, too
-console.log(myList.toArray()) // ['bar', 1, 2, 3, 'foo']
-myList.forEach(function (k) {
-  // walk the list head to tail
-})
-myList.forEachReverse(function (k, index, list) {
-  // walk the list tail to head
-})
-var myDoubledList = myList.map(function (k) {
-  return k + k
-})
-// now myDoubledList contains ['barbar', 2, 4, 6, 'foofoo']
-// mapReverse is also a thing
-var myDoubledListReverse = myList.mapReverse(function (k) {
-  return k + k
-}) // ['foofoo', 6, 4, 2, 'barbar']
-
-var reduced = myList.reduce(function (set, entry) {
-  set += entry
-  return set
-}, 'start')
-console.log(reduced) // 'startfoo123bar'
-```
-
-## api
-
-The whole API is considered "public".
-
-Functions with the same name as an Array method work more or less the
-same way.
-
-There's reverse versions of most things because that's the point.
-
-### Yallist
-
-Default export, the class that holds and manages a list.
-
-Call it with either a forEach-able (like an array) or a set of
-arguments, to initialize the list.
-
-The Array-ish methods all act like you'd expect.  No magic length,
-though, so if you change that it won't automatically prune or add
-empty spots.
-
-### Yallist.create(..)
-
-Alias for Yallist function.  Some people like factories.
-
-#### yallist.head
-
-The first node in the list
-
-#### yallist.tail
-
-The last node in the list
-
-#### yallist.length
-
-The number of nodes in the list.  (Change this at your peril.  It is
-not magic like Array length.)
-
-#### yallist.toArray()
-
-Convert the list to an array.
-
-#### yallist.forEach(fn, [thisp])
-
-Call a function on each item in the list.
-
-#### yallist.forEachReverse(fn, [thisp])
-
-Call a function on each item in the list, in reverse order.
-
-#### yallist.get(n)
-
-Get the data at position `n` in the list.  If you use this a lot,
-probably better off just using an Array.
-
-#### yallist.getReverse(n)
-
-Get the data at position `n`, counting from the tail.
-
-#### yallist.map(fn, thisp)
-
-Create a new Yallist with the result of calling the function on each
-item.
-
-#### yallist.mapReverse(fn, thisp)
-
-Same as `map`, but in reverse.
-
-#### yallist.pop()
-
-Get the data from the list tail, and remove the tail from the list.
-
-#### yallist.push(item, ...)
-
-Insert one or more items to the tail of the list.
-
-#### yallist.reduce(fn, initialValue)
-
-Like Array.reduce.
-
-#### yallist.reduceReverse
-
-Like Array.reduce, but in reverse.
-
-#### yallist.reverse
-
-Reverse the list in place.
-
-#### yallist.shift()
-
-Get the data from the list head, and remove the head from the list.
-
-#### yallist.slice([from], [to])
-
-Just like Array.slice, but returns a new Yallist.
-
-#### yallist.sliceReverse([from], [to])
-
-Just like yallist.slice, but the result is returned in reverse.
-
-#### yallist.toArray()
-
-Create an array representation of the list.
-
-#### yallist.toArrayReverse()
-
-Create a reversed array representation of the list.
-
-#### yallist.unshift(item, ...)
-
-Insert one or more items to the head of the list.
-
-#### yallist.unshiftNode(node)
-
-Move a Node object to the front of the list.  (That is, pull it out of
-wherever it lives, and make it the new head.)
-
-If the node belongs to a different list, then that list will remove it
-first.
-
-#### yallist.pushNode(node)
-
-Move a Node object to the end of the list.  (That is, pull it out of
-wherever it lives, and make it the new tail.)
-
-If the node belongs to a list already, then that list will remove it
-first.
-
-#### yallist.removeNode(node)
-
-Remove a node from the list, preserving referential integrity of head
-and tail and other nodes.
-
-Will throw an error if you try to have a list remove a node that
-doesn't belong to it.
-
-### Yallist.Node
-
-The class that holds the data and is actually the list.
-
-Call with `var n = new Node(value, previousNode, nextNode)`
-
-Note that if you do direct operations on Nodes themselves, it's very
-easy to get into weird states where the list is broken.  Be careful :)
-
-#### node.next
-
-The next node in the list.
-
-#### node.prev
-
-The previous node in the list.
-
-#### node.value
-
-The data the node contains.
-
-#### node.list
-
-The list to which this node belongs.  (Null if it does not belong to
-any list.)