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

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

@@ -1,205 +0,0 @@
-# sqlstring
-
-[![NPM Version][npm-version-image]][npm-url]
-[![NPM Downloads][npm-downloads-image]][npm-url]
-[![Node.js Version][node-image]][node-url]
-[![Build Status][github-actions-ci-image]][github-actions-ci-url]
-[![Coverage Status][coveralls-image]][coveralls-url]
-
-Simple SQL escape and format for MySQL
-
-## Install
-
-```sh
-$ npm install sqlstring
-```
-
-## Usage
-
-
-```js
-var SqlString = require('sqlstring');
-```
-
-### Escaping query values
-
-**Caution** These methods of escaping values only works when the
-[NO_BACKSLASH_ESCAPES](https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_backslash_escapes)
-SQL mode is disabled (which is the default state for MySQL servers).
-
-In order to avoid SQL Injection attacks, you should always escape any user
-provided data before using it inside a SQL query. You can do so using the
-`SqlString.escape()` method:
-
-```js
-var userId = 'some user provided value';
-var sql    = 'SELECT * FROM users WHERE id = ' + SqlString.escape(userId);
-console.log(sql); // SELECT * FROM users WHERE id = 'some user provided value'
-```
-
-Alternatively, you can use `?` characters as placeholders for values you would
-like to have escaped like this:
-
-```js
-var userId = 1;
-var sql    = SqlString.format('SELECT * FROM users WHERE id = ?', [userId]);
-console.log(sql); // SELECT * FROM users WHERE id = 1
-```
-
-Multiple placeholders are mapped to values in the same order as passed. For example,
-in the following query `foo` equals `a`, `bar` equals `b`, `baz` equals `c`, and
-`id` will be `userId`:
-
-```js
-var userId = 1;
-var sql    = SqlString.format('UPDATE users SET foo = ?, bar = ?, baz = ? WHERE id = ?',
-  ['a', 'b', 'c', userId]);
-console.log(sql); // UPDATE users SET foo = 'a', bar = 'b', baz = 'c' WHERE id = 1
-```
-
-This looks similar to prepared statements in MySQL, however it really just uses
-the same `SqlString.escape()` method internally.
-
-**Caution** This also differs from prepared statements in that all `?` are
-replaced, even those contained in comments and strings.
-
-Different value types are escaped differently, here is how:
-
-* Numbers are left untouched
-* Booleans are converted to `true` / `false`
-* Date objects are converted to `'YYYY-mm-dd HH:ii:ss'` strings
-* Buffers are converted to hex strings, e.g. `X'0fa5'`
-* Strings are safely escaped
-* Arrays are turned into list, e.g. `['a', 'b']` turns into `'a', 'b'`
-* Nested arrays are turned into grouped lists (for bulk inserts), e.g. `[['a',
-  'b'], ['c', 'd']]` turns into `('a', 'b'), ('c', 'd')`
-* Objects that have a `toSqlString` method will have `.toSqlString()` called
-  and the returned value is used as the raw SQL.
-* Objects are turned into `key = 'val'` pairs for each enumerable property on
-  the object. If the property's value is a function, it is skipped; if the
-  property's value is an object, toString() is called on it and the returned
-  value is used.
-* `undefined` / `null` are converted to `NULL`
-* `NaN` / `Infinity` are left as-is. MySQL does not support these, and trying
-  to insert them as values will trigger MySQL errors until they implement
-  support.
-
-You may have noticed that this escaping allows you to do neat things like this:
-
-```js
-var post  = {id: 1, title: 'Hello MySQL'};
-var sql = SqlString.format('INSERT INTO posts SET ?', post);
-console.log(sql); // INSERT INTO posts SET `id` = 1, `title` = 'Hello MySQL'
-```
-
-And the `toSqlString` method allows you to form complex queries with functions:
-
-```js
-var CURRENT_TIMESTAMP = { toSqlString: function() { return 'CURRENT_TIMESTAMP()'; } };
-var sql = SqlString.format('UPDATE posts SET modified = ? WHERE id = ?', [CURRENT_TIMESTAMP, 42]);
-console.log(sql); // UPDATE posts SET modified = CURRENT_TIMESTAMP() WHERE id = 42
-```
-
-To generate objects with a `toSqlString` method, the `SqlString.raw()` method can
-be used. This creates an object that will be left un-touched when using in a `?`
-placeholder, useful for using functions as dynamic values:
-
-**Caution** The string provided to `SqlString.raw()` will skip all escaping
-functions when used, so be careful when passing in unvalidated input.
-
-```js
-var CURRENT_TIMESTAMP = SqlString.raw('CURRENT_TIMESTAMP()');
-var sql = SqlString.format('UPDATE posts SET modified = ? WHERE id = ?', [CURRENT_TIMESTAMP, 42]);
-console.log(sql); // UPDATE posts SET modified = CURRENT_TIMESTAMP() WHERE id = 42
-```
-
-If you feel the need to escape queries by yourself, you can also use the escaping
-function directly:
-
-```js
-var sql = 'SELECT * FROM posts WHERE title=' + SqlString.escape('Hello MySQL');
-console.log(sql); // SELECT * FROM posts WHERE title='Hello MySQL'
-```
-
-### Escaping query identifiers
-
-If you can't trust an SQL identifier (database / table / column name) because it is
-provided by a user, you should escape it with `SqlString.escapeId(identifier)` like this:
-
-```js
-var sorter = 'date';
-var sql    = 'SELECT * FROM posts ORDER BY ' + SqlString.escapeId(sorter);
-console.log(sql); // SELECT * FROM posts ORDER BY `date`
-```
-
-It also supports adding qualified identifiers. It will escape both parts.
-
-```js
-var sorter = 'date';
-var sql    = 'SELECT * FROM posts ORDER BY ' + SqlString.escapeId('posts.' + sorter);
-console.log(sql); // SELECT * FROM posts ORDER BY `posts`.`date`
-```
-
-If you do not want to treat `.` as qualified identifiers, you can set the second
-argument to `true` in order to keep the string as a literal identifier:
-
-```js
-var sorter = 'date.2';
-var sql    = 'SELECT * FROM posts ORDER BY ' + SqlString.escapeId(sorter, true);
-console.log(sql); // SELECT * FROM posts ORDER BY `date.2`
-```
-
-Alternatively, you can use `??` characters as placeholders for identifiers you would
-like to have escaped like this:
-
-```js
-var userId = 1;
-var columns = ['username', 'email'];
-var sql     = SqlString.format('SELECT ?? FROM ?? WHERE id = ?', [columns, 'users', userId]);
-console.log(sql); // SELECT `username`, `email` FROM `users` WHERE id = 1
-```
-**Please note that this last character sequence is experimental and syntax might change**
-
-When you pass an Object to `.escape()` or `.format()`, `.escapeId()` is used to avoid SQL injection in object keys.
-
-### Formatting queries
-
-You can use `SqlString.format` to prepare a query with multiple insertion points,
-utilizing the proper escaping for ids and values. A simple example of this follows:
-
-```js
-var userId  = 1;
-var inserts = ['users', 'id', userId];
-var sql     = SqlString.format('SELECT * FROM ?? WHERE ?? = ?', inserts);
-console.log(sql); // SELECT * FROM `users` WHERE `id` = 1
-```
-
-Following this you then have a valid, escaped query that you can then send to the database safely.
-This is useful if you are looking to prepare the query before actually sending it to the database.
-You also have the option (but are not required) to pass in `stringifyObject` and `timeZone`,
-allowing you provide a custom means of turning objects into strings, as well as a
-location-specific/timezone-aware `Date`.
-
-This can be further combined with the `SqlString.raw()` helper to generate SQL
-that includes MySQL functions as dynamic vales:
-
-```js
-var userId = 1;
-var data   = { email: 'foobar@example.com', modified: SqlString.raw('NOW()') };
-var sql    = SqlString.format('UPDATE ?? SET ? WHERE `id` = ?', ['users', data, userId]);
-console.log(sql); // UPDATE `users` SET `email` = 'foobar@example.com', `modified` = NOW() WHERE `id` = 1
-```
-
-## License
-
-[MIT](LICENSE)
-
-[npm-version-image]: https://img.shields.io/npm/v/sqlstring.svg
-[npm-downloads-image]: https://img.shields.io/npm/dm/sqlstring.svg
-[npm-url]: https://npmjs.org/package/sqlstring
-[coveralls-image]: https://img.shields.io/coveralls/mysqljs/sqlstring/master.svg
-[coveralls-url]: https://coveralls.io/r/mysqljs/sqlstring?branch=master
-[github-actions-ci-image]: https://img.shields.io/github/workflow/status/mysqljs/sqlstring/ci/master?label=build
-[github-actions-ci-url]: https://github.com/mysqljs/sqlstring/actions/workflows/ci.yml
-[node-image]: https://img.shields.io/node/v/sqlstring.svg
-[node-url]: https://nodejs.org/en/download

package/rds-lambda/node_modules/sqlstring/package.json

@@ -1,47 +0,0 @@
-{
-  "name": "sqlstring",
-  "description": "Simple SQL escape and format for MySQL",
-  "version": "2.3.3",
-  "contributors": [
-    "Adri Van Houdt <adri.van.houdt@gmail.com>",
-    "Douglas Christopher Wilson <doug@somethingdoug.com>",
-    "fengmk2 <fengmk2@gmail.com> (http://fengmk2.github.com)",
-    "Kevin Jose Martin <kevin@tiliq.com>",
-    "Nathan Woltman <nwoltman@outlook.com>",
-    "Sergej Sintschilin <seregpie@gmail.com>"
-  ],
-  "license": "MIT",
-  "keywords": [
-    "sqlstring",
-    "sql",
-    "escape",
-    "sql escape"
-  ],
-  "repository": "mysqljs/sqlstring",
-  "devDependencies": {
-    "beautify-benchmark": "0.2.4",
-    "benchmark": "2.1.4",
-    "eslint": "7.32.0",
-    "eslint-plugin-markdown": "2.2.1",
-    "nyc": "15.1.0",
-    "urun": "0.0.8",
-    "utest": "0.0.8"
-  },
-  "files": [
-    "lib/",
-    "HISTORY.md",
-    "LICENSE",
-    "README.md",
-    "index.js"
-  ],
-  "engines": {
-    "node": ">= 0.6"
-  },
-  "scripts": {
-    "bench": "node benchmark/index.js",
-    "lint": "eslint .",
-    "test": "node test/run.js",
-    "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
-    "test-cov": "nyc --reporter=html --reporter=text npm test"
-  }
-}

package/rds-lambda/node_modules/xtend/.jshintrc

@@ -1,30 +0,0 @@
-{
-    "maxdepth": 4,
-    "maxstatements": 200,
-    "maxcomplexity": 12,
-    "maxlen": 80,
-    "maxparams": 5,
-
-    "curly": true,
-    "eqeqeq": true,
-    "immed": true,
-    "latedef": false,
-    "noarg": true,
-    "noempty": true,
-    "nonew": true,
-    "undef": true,
-    "unused": "vars",
-    "trailing": true,
-
-    "quotmark": true,
-    "expr": true,
-    "asi": true,
-
-    "browser": false,
-    "esnext": true,
-    "devel": false,
-    "node": false,
-    "nonstandard": false,
-
-    "predef": ["require", "module", "__dirname", "__filename"]
-}

package/rds-lambda/node_modules/xtend/LICENSE

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-Copyright (c) 2012-2014 Raynos.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

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

@@ -1,32 +0,0 @@
-# xtend
-
-[![browser support][3]][4]
-
-[![locked](http://badges.github.io/stability-badges/dist/locked.svg)](http://github.com/badges/stability-badges)
-
-Extend like a boss
-
-xtend is a basic utility library which allows you to extend an object by appending all of the properties from each object in a list. When there are identical properties, the right-most property takes precedence.
-
-## Examples
-
-```js
-var extend = require("xtend")
-
-// extend returns a new object. Does not mutate arguments
-var combination = extend({
-    a: "a",
-    b: "c"
-}, {
-    b: "b"
-})
-// { a: "a", b: "b" }
-```
-
-## Stability status: Locked
-
-## MIT Licensed 
-
-
-  [3]: http://ci.testling.com/Raynos/xtend.png
-  [4]: http://ci.testling.com/Raynos/xtend

package/rds-lambda/node_modules/xtend/package.json

@@ -1,55 +0,0 @@
-{
-  "name": "xtend",
-  "version": "4.0.2",
-  "description": "extend like a boss",
-  "keywords": [
-    "extend",
-    "merge",
-    "options",
-    "opts",
-    "object",
-    "array"
-  ],
-  "author": "Raynos <raynos2@gmail.com>",
-  "repository": "git://github.com/Raynos/xtend.git",
-  "main": "immutable",
-  "scripts": {
-    "test": "node test"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "tape": "~1.1.0"
-  },
-  "homepage": "https://github.com/Raynos/xtend",
-  "contributors": [
-    {
-      "name": "Jake Verbaten"
-    },
-    {
-      "name": "Matt Esch"
-    }
-  ],
-  "bugs": {
-    "url": "https://github.com/Raynos/xtend/issues",
-    "email": "raynos2@gmail.com"
-  },
-  "license": "MIT",
-  "testling": {
-    "files": "test.js",
-    "browsers": [
-      "ie/7..latest",
-      "firefox/16..latest",
-      "firefox/nightly",
-      "chrome/22..latest",
-      "chrome/canary",
-      "opera/12..latest",
-      "opera/next",
-      "safari/5.1..latest",
-      "ipad/6.0..latest",
-      "iphone/6.0..latest"
-    ]
-  },
-  "engines": {
-    "node": ">=0.4"
-  }
-}

package/rds-lambda/utils/rds_utils.ts

@@ -1,145 +0,0 @@
-export type RDSQueryFilter = {
-  rawSql: string;
-  queryParams?: any[];
-}
-
-/**
- * Util method to convert any GraphQL input filter argument to an AWS RDS query expression
- * @param filter The filter used on a given type, following generated format in AppSync
- */
-export const toRDSQueryExpression = (filter: any): RDSQueryFilter => {
-  let rdsExpression = '';
-  let isAndAppended = false;
-  const queryParameters = new Array<any>();
-  Object.entries(filter).forEach(([key, value]: any, index) => {
-    if (index !== 0) {
-      rdsExpression += ' AND ';
-      isAndAppended = true;
-    }
-    switch (key) {
-      case 'and':
-      case 'or':
-        rdsExpression += value.map((subValue: any) => {
-          const { rawSql, queryParams } = toRDSQueryExpression(subValue);
-          if (queryParams) {
-            queryParameters.push(...queryParams);
-          }
-          return rawSql;
-        }).join(` ${key.toUpperCase()} `);
-        break;
-      case 'not':
-        // eslint-disable-next-line no-case-declarations
-        const { rawSql, queryParams } = toRDSQueryExpression(value);
-        rdsExpression += `NOT ${rawSql}`;
-        if (queryParams) {
-          queryParameters.push(...queryParams);
-        }
-        break;
-      default:
-        Object.entries(value).forEach(([operator, operand]: any, secondIndex) => {
-          if (secondIndex !== 0) {
-            rdsExpression += ' AND ';
-          }
-          switch (operator) {
-            case 'attributeExists':
-              rdsExpression += `${key} IS NOT NULL`;
-              break;
-            case 'beginsWith':
-              rdsExpression += `${key} LIKE '?%'`;
-              queryParameters.push(operand);
-              break;
-            case 'between':
-              if (!Array.isArray(operand) || operand.length !== 2) {
-                throw new Error(`between condition must have two values, but got: ${operand?.length ? operand.length : 'not an array'}`);
-              }
-              rdsExpression += `${key} BETWEEN ? AND ?`;
-              queryParameters.push(...operand);
-              break;
-            case 'contains':
-              rdsExpression += `${key} LIKE '%?%'`;
-              queryParameters.push(operand);
-              break;
-            case 'eq':
-              rdsExpression += `${key} = ?`;
-              queryParameters.push(operand);
-              break;
-            case 'ge':
-              rdsExpression += `${key} >= ?`;
-              queryParameters.push(operand);
-              break;
-            case 'gt':
-              rdsExpression += `${key} > ?`;
-              queryParameters.push(operand);
-              break;
-            case 'le':
-              rdsExpression += `${key} <= ?`;
-              queryParameters.push(operand);
-              break;
-            case 'lt':
-              rdsExpression += `${key} < ?`;
-              queryParameters.push(operand);
-              break;
-            case 'ne':
-              rdsExpression += `${key} != ?`;
-              queryParameters.push(operand);
-              break;
-            case 'notContains':
-              // key : name , operand : 'a' , operator : notContains
-              rdsExpression += `${key} NOT LIKE '%?%'`;
-              queryParameters.push(operand);
-              break;
-            case 'size':
-              // size has nested operators:- between, eq, ge, gt, le, lt, ne
-              Object.entries(operand).forEach(([sizeOperator, sizeOperand]: any) => {
-                if (index !== 0 && !isAndAppended) {
-                  rdsExpression += ' AND ';
-                  isAndAppended = true;
-                }
-                switch (sizeOperator) {
-                  case 'between':
-                    if (!Array.isArray(sizeOperand) || sizeOperand.length !== 2) {
-                      throw new Error(`between condition must have two values, but got: ${sizeOperand}.length`);
-                    }
-                    rdsExpression += `LENGTH (${key}) BETWEEN ? AND ?`;
-                    queryParameters.push(...sizeOperand);
-                    break;
-                  case 'eq':
-                    rdsExpression += `LENGTH (${key}) = ?`;
-                    queryParameters.push(sizeOperand);
-                    break;
-                  case 'ge':
-                    rdsExpression += `LENGTH (${key}) >= ?`;
-                    queryParameters.push(sizeOperand);
-                    break;
-                  case 'gt':
-                    rdsExpression += `LENGTH (${key}) > ?`;
-                    queryParameters.push(sizeOperand);
-                    break;
-                  case 'le':
-                    rdsExpression += `LENGTH (${key}) <= ?`;
-                    queryParameters.push(sizeOperand);
-                    break;
-                  case 'lt':
-                    rdsExpression += `LENGTH (${key}) < ?`;
-                    queryParameters.push(sizeOperand);
-                    break;
-                  case 'ne':
-                    rdsExpression += `LENGTH (${key}) != ?`;
-                    queryParameters.push(sizeOperand);
-                    break;
-                  default:
-                    throw new Error(`Unsupported operator: ${sizeOperator}`);
-                }
-              });
-              break;
-            default:
-              throw new Error(`Unsupported operator: ${operator}`);
-          }
-        });
-    }
-  });
-  return {
-    rawSql: `(${rdsExpression})`,
-    queryParams: queryParameters,
-  };
-};