cdk-rds-sql
Version:
A CDK construct that allows creating roles or users and databases on Aurora Serverless PostgreSQL or MySQL/MariaDB clusters, as well as AWS DSQL clusters.
1,596 lines (1,575 loc) • 1.59 MB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/exponential-backoff/dist/options.js
var require_options = __commonJS({
"node_modules/exponential-backoff/dist/options.js"(exports2) {
"use strict";
var __assign = exports2 && exports2.__assign || function() {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports2, "__esModule", { value: true });
var defaultOptions = {
delayFirstAttempt: false,
jitter: "none",
maxDelay: Infinity,
numOfAttempts: 10,
retry: function() {
return true;
},
startingDelay: 100,
timeMultiple: 2
};
function getSanitizedOptions(options) {
var sanitized = __assign(__assign({}, defaultOptions), options);
if (sanitized.numOfAttempts < 1) {
sanitized.numOfAttempts = 1;
}
return sanitized;
}
exports2.getSanitizedOptions = getSanitizedOptions;
}
});
// node_modules/exponential-backoff/dist/jitter/full/full.jitter.js
var require_full_jitter = __commonJS({
"node_modules/exponential-backoff/dist/jitter/full/full.jitter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
function fullJitter(delay) {
var jitteredDelay = Math.random() * delay;
return Math.round(jitteredDelay);
}
exports2.fullJitter = fullJitter;
}
});
// node_modules/exponential-backoff/dist/jitter/no/no.jitter.js
var require_no_jitter = __commonJS({
"node_modules/exponential-backoff/dist/jitter/no/no.jitter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
function noJitter(delay) {
return delay;
}
exports2.noJitter = noJitter;
}
});
// node_modules/exponential-backoff/dist/jitter/jitter.factory.js
var require_jitter_factory = __commonJS({
"node_modules/exponential-backoff/dist/jitter/jitter.factory.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var full_jitter_1 = require_full_jitter();
var no_jitter_1 = require_no_jitter();
function JitterFactory(options) {
switch (options.jitter) {
case "full":
return full_jitter_1.fullJitter;
case "none":
default:
return no_jitter_1.noJitter;
}
}
exports2.JitterFactory = JitterFactory;
}
});
// node_modules/exponential-backoff/dist/delay/delay.base.js
var require_delay_base = __commonJS({
"node_modules/exponential-backoff/dist/delay/delay.base.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var jitter_factory_1 = require_jitter_factory();
var Delay = (
/** @class */
(function() {
function Delay2(options) {
this.options = options;
this.attempt = 0;
}
Delay2.prototype.apply = function() {
var _this = this;
return new Promise(function(resolve) {
return setTimeout(resolve, _this.jitteredDelay);
});
};
Delay2.prototype.setAttemptNumber = function(attempt) {
this.attempt = attempt;
};
Object.defineProperty(Delay2.prototype, "jitteredDelay", {
get: function() {
var jitter = jitter_factory_1.JitterFactory(this.options);
return jitter(this.delay);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Delay2.prototype, "delay", {
get: function() {
var constant = this.options.startingDelay;
var base = this.options.timeMultiple;
var power = this.numOfDelayedAttempts;
var delay = constant * Math.pow(base, power);
return Math.min(delay, this.options.maxDelay);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Delay2.prototype, "numOfDelayedAttempts", {
get: function() {
return this.attempt;
},
enumerable: true,
configurable: true
});
return Delay2;
})()
);
exports2.Delay = Delay;
}
});
// node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js
var require_skip_first_delay = __commonJS({
"node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js"(exports2) {
"use strict";
var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = exports2 && exports2.__generator || function(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1) throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports2, "__esModule", { value: true });
var delay_base_1 = require_delay_base();
var SkipFirstDelay = (
/** @class */
(function(_super) {
__extends(SkipFirstDelay2, _super);
function SkipFirstDelay2() {
return _super !== null && _super.apply(this, arguments) || this;
}
SkipFirstDelay2.prototype.apply = function() {
return __awaiter(this, void 0, void 0, function() {
return __generator(this, function(_a) {
return [2, this.isFirstAttempt ? true : _super.prototype.apply.call(this)];
});
});
};
Object.defineProperty(SkipFirstDelay2.prototype, "isFirstAttempt", {
get: function() {
return this.attempt === 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(SkipFirstDelay2.prototype, "numOfDelayedAttempts", {
get: function() {
return this.attempt - 1;
},
enumerable: true,
configurable: true
});
return SkipFirstDelay2;
})(delay_base_1.Delay)
);
exports2.SkipFirstDelay = SkipFirstDelay;
}
});
// node_modules/exponential-backoff/dist/delay/always/always.delay.js
var require_always_delay = __commonJS({
"node_modules/exponential-backoff/dist/delay/always/always.delay.js"(exports2) {
"use strict";
var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports2, "__esModule", { value: true });
var delay_base_1 = require_delay_base();
var AlwaysDelay = (
/** @class */
(function(_super) {
__extends(AlwaysDelay2, _super);
function AlwaysDelay2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return AlwaysDelay2;
})(delay_base_1.Delay)
);
exports2.AlwaysDelay = AlwaysDelay;
}
});
// node_modules/exponential-backoff/dist/delay/delay.factory.js
var require_delay_factory = __commonJS({
"node_modules/exponential-backoff/dist/delay/delay.factory.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var skip_first_delay_1 = require_skip_first_delay();
var always_delay_1 = require_always_delay();
function DelayFactory(options, attempt) {
var delay = initDelayClass(options);
delay.setAttemptNumber(attempt);
return delay;
}
exports2.DelayFactory = DelayFactory;
function initDelayClass(options) {
if (!options.delayFirstAttempt) {
return new skip_first_delay_1.SkipFirstDelay(options);
}
return new always_delay_1.AlwaysDelay(options);
}
}
});
// node_modules/exponential-backoff/dist/backoff.js
var require_backoff = __commonJS({
"node_modules/exponential-backoff/dist/backoff.js"(exports2) {
"use strict";
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = exports2 && exports2.__generator || function(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1) throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports2, "__esModule", { value: true });
var options_1 = require_options();
var delay_factory_1 = require_delay_factory();
function backOff2(request, options) {
if (options === void 0) {
options = {};
}
return __awaiter(this, void 0, void 0, function() {
var sanitizedOptions, backOff3;
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
sanitizedOptions = options_1.getSanitizedOptions(options);
backOff3 = new BackOff(request, sanitizedOptions);
return [4, backOff3.execute()];
case 1:
return [2, _a.sent()];
}
});
});
}
exports2.backOff = backOff2;
var BackOff = (
/** @class */
(function() {
function BackOff2(request, options) {
this.request = request;
this.options = options;
this.attemptNumber = 0;
}
BackOff2.prototype.execute = function() {
return __awaiter(this, void 0, void 0, function() {
var e_1, shouldRetry;
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
if (!!this.attemptLimitReached) return [3, 7];
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 6]);
return [4, this.applyDelay()];
case 2:
_a.sent();
return [4, this.request()];
case 3:
return [2, _a.sent()];
case 4:
e_1 = _a.sent();
this.attemptNumber++;
return [4, this.options.retry(e_1, this.attemptNumber)];
case 5:
shouldRetry = _a.sent();
if (!shouldRetry || this.attemptLimitReached) {
throw e_1;
}
return [3, 6];
case 6:
return [3, 0];
case 7:
throw new Error("Something went wrong.");
}
});
});
};
Object.defineProperty(BackOff2.prototype, "attemptLimitReached", {
get: function() {
return this.attemptNumber >= this.options.numOfAttempts;
},
enumerable: true,
configurable: true
});
BackOff2.prototype.applyDelay = function() {
return __awaiter(this, void 0, void 0, function() {
var delay;
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
delay = delay_factory_1.DelayFactory(this.options, this.attemptNumber);
return [4, delay.apply()];
case 1:
_a.sent();
return [
2
/*return*/
];
}
});
});
};
return BackOff2;
})()
);
}
});
// node_modules/node-pg-format/lib/reserved.js
var require_reserved = __commonJS({
"node_modules/node-pg-format/lib/reserved.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.default = {
"AES128": true,
"AES256": true,
"ALL": true,
"ALLOWOVERWRITE": true,
"ANALYSE": true,
"ANALYZE": true,
"AND": true,
"ANY": true,
"ARRAY": true,
"AS": true,
"ASC": true,
"ASYMMETRIC": true,
"AUTHORIZATION": true,
"BACKUP": true,
"BETWEEN": true,
"BINARY": true,
"BLANKSASNULL": true,
"BOTH": true,
"BYTEDICT": true,
"CASE": true,
"CAST": true,
"CHECK": true,
"COLLATE": true,
"COLUMN": true,
"CONSTRAINT": true,
"CREATE": true,
"CREDENTIALS": true,
"CROSS": true,
"CURRENT_CATALOG": true,
"CURRENT_DATE": true,
"CURRENT_ROLE": true,
"CURRENT_TIME": true,
"CURRENT_TIMESTAMP": true,
"CURRENT_USER": true,
"CURRENT_USER_ID": true,
"DEFAULT": true,
"DEFERRABLE": true,
"DEFLATE": true,
"DEFRAG": true,
"DELTA": true,
"DELTA32K": true,
"DESC": true,
"DISABLE": true,
"DISTINCT": true,
"DO": true,
"ELSE": true,
"EMPTYASNULL": true,
"ENABLE": true,
"ENCODE": true,
"ENCRYPT": true,
"ENCRYPTION": true,
"END": true,
"EXCEPT": true,
"EXPLICIT": true,
"FALSE": true,
"FETCH": true,
"FOR": true,
"FOREIGN": true,
"FREEZE": true,
"FROM": true,
"FULL": true,
"GLOBALDICT256": true,
"GLOBALDICT64K": true,
"GRANT": true,
"GROUP": true,
"GZIP": true,
"HAVING": true,
"IDENTITY": true,
"IGNORE": true,
"ILIKE": true,
"IN": true,
"INITIALLY": true,
"INNER": true,
"INTERSECT": true,
"INTO": true,
"IS": true,
"ISNULL": true,
"JOIN": true,
"LATERAL": true,
"LEADING": true,
"LEFT": true,
"LIKE": true,
"LIMIT": true,
"LOCALTIME": true,
"LOCALTIMESTAMP": true,
"LUN": true,
"LUNS": true,
"LZO": true,
"LZOP": true,
"MINUS": true,
"MOSTLY13": true,
"MOSTLY32": true,
"MOSTLY8": true,
"NATURAL": true,
"NEW": true,
"NOT": true,
"NOTNULL": true,
"NULL": true,
"NULLS": true,
"OFF": true,
"OFFLINE": true,
"OFFSET": true,
"OLD": true,
"ON": true,
"ONLY": true,
"OPEN": true,
"OR": true,
"ORDER": true,
"OUTER": true,
"OVERLAPS": true,
"PARALLEL": true,
"PARTITION": true,
"PERCENT": true,
"PLACING": true,
"PRIMARY": true,
"RAW": true,
"READRATIO": true,
"RECOVER": true,
"REFERENCES": true,
"REJECTLOG": true,
"RESORT": true,
"RESTORE": true,
"RETURNING": true,
"RIGHT": true,
"SELECT": true,
"SESSION_USER": true,
"SIMILAR": true,
"SOME": true,
"SYMMETRIC": true,
"SYSDATE": true,
"SYSTEM": true,
"TABLE": true,
"TAG": true,
"TDES": true,
"TEXT255": true,
"TEXT32K": true,
"THEN": true,
"TO": true,
"TOP": true,
"TRAILING": true,
"TRUE": true,
"TRUNCATECOLUMNS": true,
"UNION": true,
"UNIQUE": true,
"USER": true,
"USING": true,
"VARIADIC": true,
"VERBOSE": true,
"WALLET": true,
"WHEN": true,
"WHERE": true,
"WINDOW": true,
"WITH": true,
"WITHOUT": true
};
}
});
// node_modules/node-pg-format/lib/index.js
var require_lib = __commonJS({
"node_modules/node-pg-format/lib/index.js"(exports2) {
"use strict";
var __importDefault = exports2 && exports2.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.format = exports2.formatWithArray = exports2.config = exports2.quoteString = exports2.quoteLiteral = exports2.quoteIdent = void 0;
var reserved_1 = __importDefault(require_reserved());
var fmtPattern = {
ident: "I",
literal: "L",
string: "s"
};
function formatDate(date) {
date = date.replace("T", " ");
date = date.replace("Z", "+00");
return date;
}
function isReserved(value) {
if (reserved_1.default[value.toUpperCase()]) {
return true;
}
return false;
}
function arrayToList(useSpace, array, formatter) {
let sql = "";
sql += useSpace ? " (" : "(";
for (let i = 0; i < array.length; i++) {
sql += (i === 0 ? "" : ", ") + formatter(array[i]);
}
sql += ")";
return sql;
}
function quoteIdent(value) {
if (value === void 0 || value === null) {
throw new Error("SQL identifier cannot be null or undefined");
} else if (value === false) {
return '"f"';
} else if (value === true) {
return '"t"';
} else if (value instanceof Date) {
return '"' + formatDate(value.toISOString()) + '"';
} else if (value instanceof Buffer) {
throw new Error("SQL identifier cannot be a buffer");
} else if (Array.isArray(value) === true) {
const temp = [];
for (let i = 0; i < value.length; i++) {
if (Array.isArray(value[i]) === true) {
throw new Error("Nested array to grouped list conversion is not supported for SQL identifier");
} else {
temp.push(quoteIdent(value[i]));
}
}
return temp.toString();
} else if (value === Object(value)) {
throw new Error("SQL identifier cannot be an object");
}
const ident = value.toString().slice(0);
if (/^[a-z_][a-z0-9_$.]*$/.test(ident) === true && isReserved(ident) === false) {
return ident;
}
let quoted = '"';
for (let i = 0; i < ident.length; i++) {
const c = ident[i];
if (c === '"') {
quoted += c + c;
} else {
quoted += c;
}
}
quoted += '"';
return quoted;
}
exports2.quoteIdent = quoteIdent;
function quoteLiteral(value) {
let literal = "";
let explicitCast = null;
if (value === void 0 || value === null) {
return "NULL";
} else if (typeof value === "bigint") {
return BigInt(value).toString();
} else if (value === Number.POSITIVE_INFINITY) {
return "'Infinity'";
} else if (value === Number.NEGATIVE_INFINITY) {
return "'-Infinity'";
} else if (Number.isNaN(value)) {
return "'NaN'";
} else if (typeof value === "number") {
return Number(value).toString();
} else if (value === false) {
return "'f'";
} else if (value === true) {
return "'t'";
} else if (value instanceof Date) {
return "'" + formatDate(value.toISOString()) + "'";
} else if (value instanceof Buffer) {
return "E'\\\\x" + value.toString("hex") + "'";
} else if (Array.isArray(value) === true) {
const temp = [];
for (let i = 0; i < value.length; i++) {
if (Array.isArray(value[i]) === true) {
temp.push(arrayToList(i !== 0, value[i], quoteLiteral));
} else {
temp.push(quoteLiteral(value[i]));
}
}
return temp.toString();
} else if (value === Object(value)) {
explicitCast = "jsonb";
literal = JSON.stringify(value);
} else {
literal = value.toString().slice(0);
}
let hasBackslash = false;
let quoted = "'";
for (let i = 0; i < literal.length; i++) {
const c = literal[i];
if (c === "'") {
quoted += c + c;
} else if (c === "\\") {
quoted += c + c;
hasBackslash = true;
} else {
quoted += c;
}
}
quoted += "'";
if (hasBackslash === true) {
quoted = "E" + quoted;
}
if (explicitCast) {
quoted += "::" + explicitCast;
}
return quoted;
}
exports2.quoteLiteral = quoteLiteral;
function quoteString(value) {
if (value === void 0 || value === null) {
return "";
} else if (value === false) {
return "f";
} else if (value === true) {
return "t";
} else if (value instanceof Date) {
return formatDate(value.toISOString());
} else if (value instanceof Buffer) {
return "\\x" + value.toString("hex");
} else if (Array.isArray(value) === true) {
const temp = [];
for (let i = 0; i < value.length; i++) {
if (value[i] !== null && value[i] !== void 0) {
if (Array.isArray(value[i]) === true) {
temp.push(arrayToList(i !== 0, value[i], quoteString));
} else {
temp.push(quoteString(value[i]));
}
}
}
return temp.toString();
} else if (value === Object(value)) {
return JSON.stringify(value);
}
return value.toString().slice(0);
}
exports2.quoteString = quoteString;
function config(cfg) {
fmtPattern.ident = "I";
fmtPattern.literal = "L";
fmtPattern.string = "s";
if (cfg && cfg.pattern) {
if (cfg.pattern.ident) {
fmtPattern.ident = cfg.pattern.ident;
}
if (cfg.pattern.literal) {
fmtPattern.literal = cfg.pattern.literal;
}
if (cfg.pattern.string) {
fmtPattern.string = cfg.pattern.string;
}
}
}
exports2.config = config;
function formatWithArray(fmt, parameters) {
let index = 0;
let params = parameters;
let reText = "%(%|(\\d+\\$)?[";
reText += fmtPattern.ident;
reText += fmtPattern.literal;
reText += fmtPattern.string;
reText += "])";
const re = new RegExp(reText, "g");
return fmt.replace(re, function(_, type) {
if (type === "%") {
return "%";
}
let position = index;
const tokens = type.split("$");
if (tokens.length > 1) {
position = parseInt(tokens[0]) - 1;
type = tokens[1];
}
if (position < 0) {
throw new Error("specified argument 0 but arguments start at 1");
} else if (position > params.length - 1) {
throw new Error("too few arguments");
}
index = position + 1;
if (type === fmtPattern.ident) {
return quoteIdent(params[position]);
} else if (type === fmtPattern.literal) {
return quoteLiteral(params[position]);
} else if (type === fmtPattern.string) {
return quoteString(params[position]);
}
});
}
exports2.formatWithArray = formatWithArray;
function format(fmt, ...args) {
return formatWithArray(fmt, args);
}
exports2.format = format;
}
});
// node_modules/postgres-array/index.js
var require_postgres_array = __commonJS({
"node_modules/postgres-array/index.js"(exports2) {
"use strict";
exports2.parse = function(source, transform) {
return new ArrayParser(source, transform).parse();
};
var ArrayParser = class _ArrayParser {
constructor(source, transform) {
this.source = source;
this.transform = transform || identity;
this.position = 0;
this.entries = [];
this.recorded = [];
this.dimension = 0;
}
isEof() {
return this.position >= this.source.length;
}
nextCharacter() {
var character = this.source[this.position++];
if (character === "\\") {
return {
value: this.source[this.position++],
escaped: true
};
}
return {
value: character,
escaped: false
};
}
record(character) {
this.recorded.push(character);
}
newEntry(includeEmpty) {
var entry;
if (this.recorded.length > 0 || includeEmpty) {
entry = this.recorded.join("");
if (entry === "NULL" && !includeEmpty) {
entry = null;
}
if (entry !== null) entry = this.transform(entry);
this.entries.push(entry);
this.recorded = [];
}
}
consumeDimensions() {
if (this.source[0] === "[") {
while (!this.isEof()) {
var char = this.nextCharacter();
if (char.value === "=") break;
}
}
}
parse(nested) {
var character, parser, quote;
this.consumeDimensions();
while (!this.isEof()) {
character = this.nextCharacter();
if (character.value === "{" && !quote) {
this.dimension++;
if (this.dimension > 1) {
parser = new _ArrayParser(this.source.substr(this.position - 1), this.transform);
this.entries.push(parser.parse(true));
this.position += parser.position - 2;
}
} else if (character.value === "}" && !quote) {
this.dimension--;
if (!this.dimension) {
this.newEntry();
if (nested) return this.entries;
}
} else if (character.value === '"' && !character.escaped) {
if (quote) this.newEntry(true);
quote = !quote;
} else if (character.value === "," && !quote) {
this.newEntry();
} else {
this.record(character.value);
}
}
if (this.dimension !== 0) {
throw new Error("array dimension not balanced");
}
return this.entries;
}
};
function identity(value) {
return value;
}
}
});
// node_modules/pg-types/lib/arrayParser.js
var require_arrayParser = __commonJS({
"node_modules/pg-types/lib/arrayParser.js"(exports2, module2) {
var array = require_postgres_array();
module2.exports = {
create: function(source, transform) {
return {
parse: function() {
return array.parse(source, transform);
}
};
}
};
}
});
// node_modules/postgres-date/index.js
var require_postgres_date = __commonJS({
"node_modules/postgres-date/index.js"(exports2, module2) {
"use strict";
var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/;
var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/;
var TIME_ZONE = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/;
var INFINITY = /^-?infinity$/;
module2.exports = function parseDate(isoDate) {
if (INFINITY.test(isoDate)) {
return Number(isoDate.replace("i", "I"));
}
var matches = DATE_TIME.exec(isoDate);
if (!matches) {
return getDate(isoDate) || null;
}
var isBC = !!matches[8];
var year = parseInt(matches[1], 10);
if (isBC) {
year = bcYearToNegativeYear(year);
}
var month = parseInt(matches[2], 10) - 1;
var day = matches[3];
var hour = parseInt(matches[4], 10);
var minute = parseInt(matches[5], 10);
var second = parseInt(matches[6], 10);
var ms = matches[7];
ms = ms ? 1e3 * parseFloat(ms) : 0;
var date;
var offset = timeZoneOffset(isoDate);
if (offset != null) {
date = new Date(Date.UTC(year, month, day, hour, minute, second, ms));
if (is0To99(year)) {
date.setUTCFullYear(year);
}
if (offset !== 0) {
date.setTime(date.getTime() - offset);
}
} else {
date = new Date(year, month, day, hour, minute, second, ms);
if (is0To99(year)) {
date.setFullYear(year);
}
}
return date;
};
function getDate(isoDate) {
var matches = DATE.exec(isoDate);
if (!matches) {
return;
}
var year = parseInt(matches[1], 10);
var isBC = !!matches[4];
if (isBC) {
year = bcYearToNegativeYear(year);
}
var month = parseInt(matches[2], 10) - 1;
var day = matches[3];
var date = new Date(year, month, day);
if (is0To99(year)) {
date.setFullYear(year);
}
return date;
}
function timeZoneOffset(isoDate) {
if (isoDate.endsWith("+00")) {
return 0;
}
var zone = TIME_ZONE.exec(isoDate.split(" ")[1]);
if (!zone) return;
var type = zone[1];
if (type === "Z") {
return 0;
}
var sign = type === "-" ? -1 : 1;
var offset = parseInt(zone[2], 10) * 3600 + parseInt(zone[3] || 0, 10) * 60 + parseInt(zone[4] || 0, 10);
return offset * sign * 1e3;
}
function bcYearToNegativeYear(year) {
return -(year - 1);
}
function is0To99(num) {
return num >= 0 && num < 100;
}
}
});
// node_modules/xtend/mutable.js
var require_mutable = __commonJS({
"node_modules/xtend/mutable.js"(exports2, module2) {
module2.exports = extend;
var hasOwnProperty = Object.prototype.hasOwnProperty;
function extend(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
}
}
});
// node_modules/postgres-interval/index.js
var require_postgres_interval = __commonJS({
"node_modules/postgres-interval/index.js"(exports2, module2) {
"use strict";
var extend = require_mutable();
module2.exports = PostgresInterval;
function PostgresInterval(raw) {
if (!(this instanceof PostgresInterval)) {
return new PostgresInterval(raw);
}
extend(this, parse(raw));
}
var properties = ["seconds", "minutes", "hours", "days", "months", "years"];
PostgresInterval.prototype.toPostgres = function() {
var filtered = properties.filter(this.hasOwnProperty, this);
if (this.milliseconds && filtered.indexOf("seconds") < 0) {
filtered.push("seconds");
}
if (filtered.length === 0) return "0";
return filtered.map(function(property) {
var value = this[property] || 0;
if (property === "seconds" && this.milliseconds) {
value = (value + this.milliseconds / 1e3).toFixed(6).replace(/\.?0+$/, "");
}
return value + " " + property;
}, this).join(" ");
};
var propertiesISOEquivalent = {
years: "Y",
months: "M",
days: "D",
hours: "H",
minutes: "M",
seconds: "S"
};
var dateProperties = ["years", "months", "days"];
var timeProperties = ["hours", "minutes", "seconds"];
PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = function() {
var datePart = dateProperties.map(buildProperty, this).join("");
var timePart = timeProperties.map(buildProperty, this).join("");
return "P" + datePart + "T" + timePart;
function buildProperty(property) {
var value = this[property] || 0;
if (property === "seconds" && this.milliseconds) {
value = (value + this.milliseconds / 1e3).toFixed(6).replace(/0+$/, "");
}
return value + propertiesISOEquivalent[property];
}
};
var NUMBER = "([+-]?\\d+)";
var YEAR = NUMBER + "\\s+years?";
var MONTH = NUMBER + "\\s+mons?";
var DAY = NUMBER + "\\s+days?";
var TIME = "([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?";
var INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function(regexString) {
return "(" + regexString + ")?";
}).join("\\s*"));
var positions = {
years: 2,
months: 4,
days: 6,
hours: 9,
minutes: 10,
seconds: 11,
milliseconds: 12
};
var negatives = ["hours", "minutes", "seconds", "milliseconds"];
function parseMilliseconds(fraction) {
var microseconds = fraction + "000000".slice(fraction.length);
return parseInt(microseconds, 10) / 1e3;
}
function parse(interval) {
if (!interval) return {};
var matches = INTERVAL.exec(interval);
var isNegative = matches[8] === "-";
return Object.keys(positions).reduce(function(parsed, property) {
var position = positions[property];
var value = matches[position];
if (!value) return parsed;
value = property === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10);
if (!value) return parsed;
if (isNegative && ~negatives.indexOf(property)) {
value *= -1;
}
parsed[property] = value;
return parsed;
}, {});
}
}
});
// node_modules/postgres-bytea/index.js
var require_postgres_bytea = __commonJS({
"node_modules/postgres-bytea/index.js"(exports2, module2) {
"use strict";
module2.exports = function parseBytea(input) {
if (/^\\x/.test(input)) {
return new Buffer(input.substr(2), "hex");
}
var output = "";
var i = 0;
while (i < input.length) {
if (input[i] !== "\\") {
output += input[i];
++i;
} else {
if (/[0-7]{3}/.test(input.substr(i + 1, 3))) {
output += String.fromCharCode(parseInt(input.substr(i + 1, 3), 8));
i += 4;
} else {
var backslashes = 1;
while (i + backslashes < input.length && input[i + backslashes] === "\\") {
backslashes++;
}
for (var k = 0; k < Math.floor(backslashes / 2); ++k) {
output += "\\";
}
i += Math.floor(backslashes / 2) * 2;
}
}
}
return new Buffer(output, "binary");
};
}
});
// node_modules/pg-types/lib/textParsers.js
var require_textParsers = __commonJS({
"node_modules/pg-types/lib/textParsers.js"(exports2, module2) {
var array = require_postgres_array();
var arrayParser = require_arrayParser();
var parseDate = require_postgres_date();
var parseInterval = require_postgres_interval();
var parseByteA = require_postgres_bytea();
function allowNull(fn) {
return function nullAllowed(value) {
if (value === null) return value;
return fn(value);
};
}
function parseBool(value) {
if (value === null) return value;
return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1";
}
function parseBoolArray(value) {
if (!value) return null;
return array.parse(value, parseBool);
}
function parseBaseTenInt(string) {
return parseInt(string, 10);
}
function parseIntegerArray(value) {
if (!value) return null;
return array.parse(value, allowNull(parseBaseTenInt));
}
function parseBigIntegerArray(value) {
if (!value) return null;
return array.parse(value, allowNull(function(entry) {
return parseBigInteger(entry).trim();
}));
}
var parsePointArray = function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parsePoint(entry);
}
return entry;
});
return p.parse();
};
var parseFloatArray = function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parseFloat(entry);
}
return entry;
});
return p.parse();
};
var parseStringArray = function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value);
return p.parse();
};
var parseDateArray = function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parseDate(entry);
}
return entry;
});
return p.parse();
};
var parseIntervalArray = function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parseInterval(entry);
}
return entry;
});
return p.parse();
};
var parseByteAArray = function(value) {
if (!value) {
return null;
}
return array.parse(value, allowNull(parseByteA));
};
var parseInteger = function(value) {
return parseInt(value, 10);
};
var parseBigInteger = function(value) {
var valStr = String(value);
if (/^\d+$/.test(valStr)) {
return valStr;
}
return value;
};
var parseJsonArray = function(value) {
if (!value) {
return null;
}
return array.parse(value, allowNull(JSON.parse));
};
var parsePoint = function(value) {
if (value[0] !== "(") {
return null;
}
value = value.substring(1, value.length - 1).split(",");
return {
x: parseFloat(value[0]),
y: parseFloat(value[1])
};
};
var parseCircle = function(value) {
if (value[0] !== "<" && value[1] !== "(") {
return null;
}
var point = "(";
var radius = "";
var pointParsed = false;
for (var i = 2; i < value.length - 1; i++) {
if (!pointParsed) {
point += value[i];
}
if (value[i] === ")") {
pointParsed = true;
continue;
} else if (!pointParsed) {
continue;
}
if (value[i] === ",") {
continue;
}
radius += value[i];
}
var result = parsePoint(point);
result.radius = parseFloat(radius);
return result;
};
var init = function(register) {
register(20, parseBigInteger);
register(21, parseInteger);
register(23, parseInteger);
register(26, parseInteger);
register(700, parseFloat);
register(701, parseFloat);
register(16, parseBool);
register(1082, parseDate);
register(1114, parseDate);
register(1184, parseDate);
register(600, parsePoint);
register(651, parseStringArray);
register(718, parseCircle);
register(1e3, parseBoolArray);
register(1001, parseByteAArray);
register(1005, parseIntegerArray);
register(1007, parseIntegerArray);
register(1028, parseIntegerArray);
register(1016, parseBigIntegerArray);
register(1017, parsePointArray);
register(1021, parseFloatArray);
register(1022, parseFloatArray);
register(1231, parseFloatArray);
register(1014, parseStringArray);
register(1015, parseStringArray);
register(1008, parseStringArray);
register(1009, parseStringArray);
register(1040, parseStringArray);
register(1041, parseStringArray);
register(1115, parseDateArray);
register(1182, parseDateArray);
register(1185, parseDateArray);
register(1186, parseInterval);
register(1187, parseIntervalArray);
register(17, parseByteA);
register(114, JSON.parse.bind(JSON));
register(3802, JSON.parse.bind(JSON));
register(199, parseJsonArray);
register(3807, parseJsonArray);
register(3907, parseStringArray);
register(2951, parseStringArray);
register(791, parseStringArray);
register(1183, parseStringArray);
register(1270, parseStringArray);
};
module2.exports = {
init
};
}
});
// node_modules/pg-int8/index.js
var require_pg_int8 = __commonJS({
"node_modules/pg-int8/index.js"(exports2, module2) {
"use strict";
var BASE = 1e6;
function readInt8(buffer) {
var high = buffer.readInt32BE(0);
var low = buffer.readUInt32BE(4);
var sign = "";
if (high < 0) {
high = ~high + (low === 0);
low = ~low + 1 >>> 0;
sign = "-";
}
var result = "";
var carry;
var t;
var digits;
var pad;
var l;
var i;
{
carry = high % BASE;
high = high / BASE >>> 0;
t = 4294967296 * carry + low;
low = t / BASE >>> 0;
digits = "" + (t - BASE * low);
if (low === 0 && high === 0) {
return sign + digits + result;
}
pad = "";
l = 6 - digits.length;
for (i = 0; i < l; i++) {
pad += "0";
}
result = pad + digits + result;
}
{
carry = high % BASE;
high = high / BASE >>> 0;
t = 4294967296 * carry + low;
low = t / BASE >>> 0;
digits = "" + (t - BASE * low);
if (low === 0 && high === 0) {
return sign + digits + result;
}
pad = "";
l = 6 - digits.length;
for (i = 0; i < l; i++) {
pad += "0";
}
result = pad + digits + result;
}
{
carry = high % BASE;
high = high / BASE >>> 0;
t = 4294967296 * carry + low;
low = t / BASE >>> 0;
digits = "" + (t - BASE * low);
if (low === 0 && high === 0) {
return sign + digits + result;
}
pad = "";
l = 6 - digits.length;
for (i = 0; i < l; i++) {
pad += "0";
}
result = pad + digits + result;
}
{
carry = high % BASE;
t = 4294967296 * carry + low;
digits = "" + t % BASE;
return sign + digits + result;
}
}
module2.exports = readInt8;
}
});
// node_modules/pg-types/lib/binaryParsers.js
var require_binaryParsers = __commonJS({
"node_modules/pg-types/lib/binaryParsers.js"(exports2, module2) {
var parseInt64 = require_pg_int8();
var parseBits = function(data, bits, offset, invert, callback) {