Files
S. EsmaeiliandClaude Haiku 5.5 10e453e4be build: ship pre-built API bundle; images copy output instead of installing
- API: `pnpm build` bundles dist/ into apps/api/.output (esbuild), with
  Linux musl native packages for sharp and argon2 kept alongside
- docker/api.Dockerfile copies that output; no pnpm install on the server
- add dist/migrate.js (prisma migrate deploy equivalent, same
  _prisma_migrations table and lock) so the Prisma CLI is not needed at runtime
- pnpm-workspace: supportedArchitectures for linux/x64/musl
- admin: apps/admin/.env.production sets VITE_SITE_URL for the production build
- drop NPM_REGISTRY / SITE_URL build args from compose and .env.example
- gitignore: anchor node_modules rules so pre-built node_modules are committed
- README: describe the pre-built deploy flow

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-24 14:41:31 +03:30

5495 lines
190 KiB
JavaScript

import { createRequire as __bundleCreateRequire } from "node:module"; const require = __bundleCreateRequire(import.meta.url);
import {
__commonJS,
__name,
__require,
__toESM
} from "./chunk-T6GW54FI.js";
// ../../node_modules/.pnpm/postgres-array@2.0.0/node_modules/postgres-array/index.js
var require_postgres_array = __commonJS({
"../../node_modules/.pnpm/postgres-array@2.0.0/node_modules/postgres-array/index.js"(exports) {
"use strict";
exports.parse = function(source, transform) {
return new ArrayParser(source, transform).parse();
};
var ArrayParser = class _ArrayParser {
static {
__name(this, "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;
}
__name(identity, "identity");
}
});
// ../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/arrayParser.js
var require_arrayParser = __commonJS({
"../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/arrayParser.js"(exports, module) {
var array = require_postgres_array();
module.exports = {
create: /* @__PURE__ */ __name(function(source, transform) {
return {
parse: /* @__PURE__ */ __name(function() {
return array.parse(source, transform);
}, "parse")
};
}, "create")
};
}
});
// ../../node_modules/.pnpm/postgres-date@1.0.7/node_modules/postgres-date/index.js
var require_postgres_date = __commonJS({
"../../node_modules/.pnpm/postgres-date@1.0.7/node_modules/postgres-date/index.js"(exports, module) {
"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$/;
module.exports = /* @__PURE__ */ __name(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;
}, "parseDate");
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;
}
__name(getDate, "getDate");
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;
}
__name(timeZoneOffset, "timeZoneOffset");
function bcYearToNegativeYear(year) {
return -(year - 1);
}
__name(bcYearToNegativeYear, "bcYearToNegativeYear");
function is0To99(num) {
return num >= 0 && num < 100;
}
__name(is0To99, "is0To99");
}
});
// ../../node_modules/.pnpm/xtend@4.0.2/node_modules/xtend/mutable.js
var require_mutable = __commonJS({
"../../node_modules/.pnpm/xtend@4.0.2/node_modules/xtend/mutable.js"(exports, module) {
module.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;
}
__name(extend, "extend");
}
});
// ../../node_modules/.pnpm/postgres-interval@1.2.0/node_modules/postgres-interval/index.js
var require_postgres_interval = __commonJS({
"../../node_modules/.pnpm/postgres-interval@1.2.0/node_modules/postgres-interval/index.js"(exports, module) {
"use strict";
var extend = require_mutable();
module.exports = PostgresInterval;
function PostgresInterval(raw) {
if (!(this instanceof PostgresInterval)) {
return new PostgresInterval(raw);
}
extend(this, parse(raw));
}
__name(PostgresInterval, "PostgresInterval");
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];
}
__name(buildProperty, "buildProperty");
};
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;
}
__name(parseMilliseconds, "parseMilliseconds");
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;
}, {});
}
__name(parse, "parse");
}
});
// ../../node_modules/.pnpm/postgres-bytea@1.0.1/node_modules/postgres-bytea/index.js
var require_postgres_bytea = __commonJS({
"../../node_modules/.pnpm/postgres-bytea@1.0.1/node_modules/postgres-bytea/index.js"(exports, module) {
"use strict";
var bufferFrom = Buffer.from || Buffer;
module.exports = /* @__PURE__ */ __name(function parseBytea(input) {
if (/^\\x/.test(input)) {
return bufferFrom(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 bufferFrom(output, "binary");
}, "parseBytea");
}
});
// ../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js
var require_textParsers = __commonJS({
"../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js"(exports, module) {
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 /* @__PURE__ */ __name(function nullAllowed(value) {
if (value === null) return value;
return fn(value);
}, "nullAllowed");
}
__name(allowNull, "allowNull");
function parseBool(value) {
if (value === null) return value;
return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1";
}
__name(parseBool, "parseBool");
function parseBoolArray(value) {
if (!value) return null;
return array.parse(value, parseBool);
}
__name(parseBoolArray, "parseBoolArray");
function parseBaseTenInt(string) {
return parseInt(string, 10);
}
__name(parseBaseTenInt, "parseBaseTenInt");
function parseIntegerArray(value) {
if (!value) return null;
return array.parse(value, allowNull(parseBaseTenInt));
}
__name(parseIntegerArray, "parseIntegerArray");
function parseBigIntegerArray(value) {
if (!value) return null;
return array.parse(value, allowNull(function(entry) {
return parseBigInteger(entry).trim();
}));
}
__name(parseBigIntegerArray, "parseBigIntegerArray");
var parsePointArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parsePoint(entry);
}
return entry;
});
return p.parse();
}, "parsePointArray");
var parseFloatArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parseFloat(entry);
}
return entry;
});
return p.parse();
}, "parseFloatArray");
var parseStringArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value);
return p.parse();
}, "parseStringArray");
var parseDateArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parseDate(entry);
}
return entry;
});
return p.parse();
}, "parseDateArray");
var parseIntervalArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
var p = arrayParser.create(value, function(entry) {
if (entry !== null) {
entry = parseInterval(entry);
}
return entry;
});
return p.parse();
}, "parseIntervalArray");
var parseByteAArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
return array.parse(value, allowNull(parseByteA));
}, "parseByteAArray");
var parseInteger = /* @__PURE__ */ __name(function(value) {
return parseInt(value, 10);
}, "parseInteger");
var parseBigInteger = /* @__PURE__ */ __name(function(value) {
var valStr = String(value);
if (/^\d+$/.test(valStr)) {
return valStr;
}
return value;
}, "parseBigInteger");
var parseJsonArray = /* @__PURE__ */ __name(function(value) {
if (!value) {
return null;
}
return array.parse(value, allowNull(JSON.parse));
}, "parseJsonArray");
var parsePoint = /* @__PURE__ */ __name(function(value) {
if (value[0] !== "(") {
return null;
}
value = value.substring(1, value.length - 1).split(",");
return {
x: parseFloat(value[0]),
y: parseFloat(value[1])
};
}, "parsePoint");
var parseCircle = /* @__PURE__ */ __name(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;
}, "parseCircle");
var init = /* @__PURE__ */ __name(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);
}, "init");
module.exports = {
init
};
}
});
// ../../node_modules/.pnpm/pg-int8@1.0.1/node_modules/pg-int8/index.js
var require_pg_int8 = __commonJS({
"../../node_modules/.pnpm/pg-int8@1.0.1/node_modules/pg-int8/index.js"(exports, module) {
"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;
}
}
__name(readInt8, "readInt8");
module.exports = readInt8;
}
});
// ../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/binaryParsers.js
var require_binaryParsers = __commonJS({
"../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/binaryParsers.js"(exports, module) {
var parseInt64 = require_pg_int8();
var parseBits = /* @__PURE__ */ __name(function(data, bits, offset, invert, callback) {
offset = offset || 0;
invert = invert || false;
callback = callback || function(lastValue, newValue, bits2) {
return lastValue * Math.pow(2, bits2) + newValue;
};
var offsetBytes = offset >> 3;
var inv = /* @__PURE__ */ __name(function(value) {
if (invert) {
return ~value & 255;
}
return value;
}, "inv");
var mask = 255;
var firstBits = 8 - offset % 8;
if (bits < firstBits) {
mask = 255 << 8 - bits & 255;
firstBits = bits;
}
if (offset) {
mask = mask >> offset % 8;
}
var result = 0;
if (offset % 8 + bits >= 8) {
result = callback(0, inv(data[offsetBytes]) & mask, firstBits);
}
var bytes = bits + offset >> 3;
for (var i = offsetBytes + 1; i < bytes; i++) {
result = callback(result, inv(data[i]), 8);
}
var lastBits = (bits + offset) % 8;
if (lastBits > 0) {
result = callback(result, inv(data[bytes]) >> 8 - lastBits, lastBits);
}
return result;
}, "parseBits");
var parseFloatFromBits = /* @__PURE__ */ __name(function(data, precisionBits, exponentBits) {
var bias = Math.pow(2, exponentBits - 1) - 1;
var sign = parseBits(data, 1);
var exponent = parseBits(data, exponentBits, 1);
if (exponent === 0) {
return 0;
}
var precisionBitsCounter = 1;
var parsePrecisionBits = /* @__PURE__ */ __name(function(lastValue, newValue, bits) {
if (lastValue === 0) {
lastValue = 1;
}
for (var i = 1; i <= bits; i++) {
precisionBitsCounter /= 2;
if ((newValue & 1 << bits - i) > 0) {
lastValue += precisionBitsCounter;
}
}
return lastValue;
}, "parsePrecisionBits");
var mantissa = parseBits(data, precisionBits, exponentBits + 1, false, parsePrecisionBits);
if (exponent == Math.pow(2, exponentBits + 1) - 1) {
if (mantissa === 0) {
return sign === 0 ? Infinity : -Infinity;
}
return NaN;
}
return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - bias) * mantissa;
}, "parseFloatFromBits");
var parseInt16 = /* @__PURE__ */ __name(function(value) {
if (parseBits(value, 1) == 1) {
return -1 * (parseBits(value, 15, 1, true) + 1);
}
return parseBits(value, 15, 1);
}, "parseInt16");
var parseInt32 = /* @__PURE__ */ __name(function(value) {
if (parseBits(value, 1) == 1) {
return -1 * (parseBits(value, 31, 1, true) + 1);
}
return parseBits(value, 31, 1);
}, "parseInt32");
var parseFloat32 = /* @__PURE__ */ __name(function(value) {
return parseFloatFromBits(value, 23, 8);
}, "parseFloat32");
var parseFloat64 = /* @__PURE__ */ __name(function(value) {
return parseFloatFromBits(value, 52, 11);
}, "parseFloat64");
var parseNumeric = /* @__PURE__ */ __name(function(value) {
var sign = parseBits(value, 16, 32);
if (sign == 49152) {
return NaN;
}
var weight = Math.pow(1e4, parseBits(value, 16, 16));
var result = 0;
var digits = [];
var ndigits = parseBits(value, 16);
for (var i = 0; i < ndigits; i++) {
result += parseBits(value, 16, 64 + 16 * i) * weight;
weight /= 1e4;
}
var scale = Math.pow(10, parseBits(value, 16, 48));
return (sign === 0 ? 1 : -1) * Math.round(result * scale) / scale;
}, "parseNumeric");
var parseDate = /* @__PURE__ */ __name(function(isUTC, value) {
var sign = parseBits(value, 1);
var rawValue = parseBits(value, 63, 1);
var result = new Date((sign === 0 ? 1 : -1) * rawValue / 1e3 + 9466848e5);
if (!isUTC) {
result.setTime(result.getTime() + result.getTimezoneOffset() * 6e4);
}
result.usec = rawValue % 1e3;
result.getMicroSeconds = function() {
return this.usec;
};
result.setMicroSeconds = function(value2) {
this.usec = value2;
};
result.getUTCMicroSeconds = function() {
return this.usec;
};
return result;
}, "parseDate");
var parseArray = /* @__PURE__ */ __name(function(value) {
var dim = parseBits(value, 32);
var flags = parseBits(value, 32, 32);
var elementType = parseBits(value, 32, 64);
var offset = 96;
var dims = [];
for (var i = 0; i < dim; i++) {
dims[i] = parseBits(value, 32, offset);
offset += 32;
offset += 32;
}
var parseElement = /* @__PURE__ */ __name(function(elementType2) {
var length = parseBits(value, 32, offset);
offset += 32;
if (length == 4294967295) {
return null;
}
var result;
if (elementType2 == 23 || elementType2 == 20) {
result = parseBits(value, length * 8, offset);
offset += length * 8;
return result;
} else if (elementType2 == 25) {
result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3);
return result;
} else {
console.log("ERROR: ElementType not implemented: " + elementType2);
}
}, "parseElement");
var parse = /* @__PURE__ */ __name(function(dimension, elementType2) {
var array = [];
var i2;
if (dimension.length > 1) {
var count = dimension.shift();
for (i2 = 0; i2 < count; i2++) {
array[i2] = parse(dimension, elementType2);
}
dimension.unshift(count);
} else {
for (i2 = 0; i2 < dimension[0]; i2++) {
array[i2] = parseElement(elementType2);
}
}
return array;
}, "parse");
return parse(dims, elementType);
}, "parseArray");
var parseText = /* @__PURE__ */ __name(function(value) {
return value.toString("utf8");
}, "parseText");
var parseBool = /* @__PURE__ */ __name(function(value) {
if (value === null) return null;
return parseBits(value, 8) > 0;
}, "parseBool");
var init = /* @__PURE__ */ __name(function(register) {
register(20, parseInt64);
register(21, parseInt16);
register(23, parseInt32);
register(26, parseInt32);
register(1700, parseNumeric);
register(700, parseFloat32);
register(701, parseFloat64);
register(16, parseBool);
register(1114, parseDate.bind(null, false));
register(1184, parseDate.bind(null, true));
register(1e3, parseArray);
register(1007, parseArray);
register(1016, parseArray);
register(1008, parseArray);
register(1009, parseArray);
register(25, parseText);
}, "init");
module.exports = {
init
};
}
});
// ../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/builtins.js
var require_builtins = __commonJS({
"../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/builtins.js"(exports, module) {
module.exports = {
BOOL: 16,
BYTEA: 17,
CHAR: 18,
INT8: 20,
INT2: 21,
INT4: 23,
REGPROC: 24,
TEXT: 25,
OID: 26,
TID: 27,
XID: 28,
CID: 29,
JSON: 114,
XML: 142,
PG_NODE_TREE: 194,
SMGR: 210,
PATH: 602,
POLYGON: 604,
CIDR: 650,
FLOAT4: 700,
FLOAT8: 701,
ABSTIME: 702,
RELTIME: 703,
TINTERVAL: 704,
CIRCLE: 718,
MACADDR8: 774,
MONEY: 790,
MACADDR: 829,
INET: 869,
ACLITEM: 1033,
BPCHAR: 1042,
VARCHAR: 1043,
DATE: 1082,
TIME: 1083,
TIMESTAMP: 1114,
TIMESTAMPTZ: 1184,
INTERVAL: 1186,
TIMETZ: 1266,
BIT: 1560,
VARBIT: 1562,
NUMERIC: 1700,
REFCURSOR: 1790,
REGPROCEDURE: 2202,
REGOPER: 2203,
REGOPERATOR: 2204,
REGCLASS: 2205,
REGTYPE: 2206,
UUID: 2950,
TXID_SNAPSHOT: 2970,
PG_LSN: 3220,
PG_NDISTINCT: 3361,
PG_DEPENDENCIES: 3402,
TSVECTOR: 3614,
TSQUERY: 3615,
GTSVECTOR: 3642,
REGCONFIG: 3734,
REGDICTIONARY: 3769,
JSONB: 3802,
REGNAMESPACE: 4089,
REGROLE: 4096
};
}
});
// ../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/index.js
var require_pg_types = __commonJS({
"../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/index.js"(exports) {
var textParsers = require_textParsers();
var binaryParsers = require_binaryParsers();
var arrayParser = require_arrayParser();
var builtinTypes = require_builtins();
exports.getTypeParser = getTypeParser;
exports.setTypeParser = setTypeParser;
exports.arrayParser = arrayParser;
exports.builtins = builtinTypes;
var typeParsers = {
text: {},
binary: {}
};
function noParse(val) {
return String(val);
}
__name(noParse, "noParse");
function getTypeParser(oid, format) {
format = format || "text";
if (!typeParsers[format]) {
return noParse;
}
return typeParsers[format][oid] || noParse;
}
__name(getTypeParser, "getTypeParser");
function setTypeParser(oid, format, parseFn) {
if (typeof format == "function") {
parseFn = format;
format = "text";
}
typeParsers[format][oid] = parseFn;
}
__name(setTypeParser, "setTypeParser");
textParsers.init(function(oid, converter) {
typeParsers.text[oid] = converter;
});
binaryParsers.init(function(oid, converter) {
typeParsers.binary[oid] = converter;
});
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/defaults.js
var require_defaults = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/defaults.js"(exports, module) {
"use strict";
var user;
try {
user = process.platform === "win32" ? process.env.USERNAME : process.env.USER;
} catch {
}
module.exports = {
// database host. defaults to localhost
host: "localhost",
// database user's name
user,
// name of database to connect
database: void 0,
// database user's password
password: null,
// a Postgres connection string to be used instead of setting individual connection items
// NOTE: Setting this value will cause it to override any other value (such as database or user) defined
// in the defaults object.
connectionString: void 0,
// database port
port: 5432,
// number of rows to return at a time from a prepared statement's
// portal. 0 will return all rows at once
rows: 0,
// binary result mode
binary: false,
// Connection pool options - see https://github.com/brianc/node-pg-pool
// number of connections to use in connection pool
// 0 will disable connection pooling
max: 10,
// max milliseconds a client can go unused before it is removed
// from the pool and destroyed
idleTimeoutMillis: 3e4,
client_encoding: "",
ssl: false,
// SSL negotiation style: 'postgres' (traditional SSLRequest) or 'direct'
sslnegotiation: void 0,
application_name: void 0,
fallback_application_name: void 0,
options: void 0,
parseInputDatesAsUTC: false,
// max milliseconds any query using this connection will execute for before timing out in error.
// false=unlimited
statement_timeout: false,
// Abort any statement that waits longer than the specified duration in milliseconds while attempting to acquire a lock.
// false=unlimited
lock_timeout: false,
// Terminate any session with an open transaction that has been idle for longer than the specified duration in milliseconds
// false=unlimited
idle_in_transaction_session_timeout: false,
// max milliseconds to wait for query to complete (client side)
query_timeout: false,
connect_timeout: 0,
keepalives: 1,
keepalives_idle: 0
};
var pgTypes = require_pg_types();
var parseBigInteger = pgTypes.getTypeParser(20, "text");
var parseBigIntegerArray = pgTypes.getTypeParser(1016, "text");
module.exports.__defineSetter__("parseInt8", function(val) {
pgTypes.setTypeParser(20, "text", val ? pgTypes.getTypeParser(23, "text") : parseBigInteger);
pgTypes.setTypeParser(1016, "text", val ? pgTypes.getTypeParser(1007, "text") : parseBigIntegerArray);
});
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/utils.js
var require_utils = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/utils.js"(exports, module) {
"use strict";
var defaults2 = require_defaults();
var nodeUtils = __require("util");
var { isDate } = __require("util/types");
var invalidDateDeprecationNotice = nodeUtils.deprecate(
() => {
},
"Sending an invalid date to Postgres is deprecated and will throw an error in the next major version of pg. Ensure any Date object passed as a query parameter is valid.",
"PG_INVALID_DATE"
);
function escapeElement(elementRepresentation) {
const escaped = elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
return '"' + escaped + '"';
}
__name(escapeElement, "escapeElement");
function arrayString(val) {
let result = "{";
for (let i = 0; i < val.length; i++) {
if (i > 0) {
result += ",";
}
let item = val[i];
if (item == null) {
result += "NULL";
} else if (Array.isArray(item)) {
result += arrayString(item);
} else if (ArrayBuffer.isView(item)) {
if (!(item instanceof Buffer)) {
item = Buffer.from(item.buffer, item.byteOffset, item.byteLength);
}
result += "\\\\x" + item.toString("hex");
} else {
result += escapeElement(prepareValue(item));
}
}
result += "}";
return result;
}
__name(arrayString, "arrayString");
var prepareValue = /* @__PURE__ */ __name(function(val, seen) {
if (val == null) {
return null;
}
if (typeof val === "object") {
if (val instanceof Buffer) {
return val;
}
if (ArrayBuffer.isView(val)) {
return Buffer.from(val.buffer, val.byteOffset, val.byteLength);
}
if (isDate(val)) {
if (isNaN(val.getTime())) {
invalidDateDeprecationNotice();
}
if (defaults2.parseInputDatesAsUTC) {
return dateToStringUTC(val);
} else {
return dateToString(val);
}
}
if (Array.isArray(val)) {
return arrayString(val);
}
return prepareObject(val, seen);
}
return val.toString();
}, "prepareValue");
function prepareObject(val, seen) {
if (val && typeof val.toPostgres === "function") {
seen = seen || [];
if (seen.indexOf(val) !== -1) {
throw new Error('circular reference detected while preparing "' + val + '" for query');
}
seen.push(val);
return prepareValue(val.toPostgres(prepareValue), seen);
}
return JSON.stringify(val);
}
__name(prepareObject, "prepareObject");
function dateToString(date) {
let offset = -date.getTimezoneOffset();
let year = date.getFullYear();
const isBCYear = year < 1;
if (isBCYear) year = Math.abs(year) + 1;
let ret = String(year).padStart(4, "0") + "-" + String(date.getMonth() + 1).padStart(2, "0") + "-" + String(date.getDate()).padStart(2, "0") + "T" + String(date.getHours()).padStart(2, "0") + ":" + String(date.getMinutes()).padStart(2, "0") + ":" + String(date.getSeconds()).padStart(2, "0") + "." + String(date.getMilliseconds()).padStart(3, "0");
if (offset < 0) {
ret += "-";
offset *= -1;
} else {
ret += "+";
}
ret += String(Math.floor(offset / 60)).padStart(2, "0") + ":" + String(offset % 60).padStart(2, "0");
if (isBCYear) ret += " BC";
return ret;
}
__name(dateToString, "dateToString");
function dateToStringUTC(date) {
let year = date.getUTCFullYear();
const isBCYear = year < 1;
if (isBCYear) year = Math.abs(year) + 1;
let ret = String(year).padStart(4, "0") + "-" + String(date.getUTCMonth() + 1).padStart(2, "0") + "-" + String(date.getUTCDate()).padStart(2, "0") + "T" + String(date.getUTCHours()).padStart(2, "0") + ":" + String(date.getUTCMinutes()).padStart(2, "0") + ":" + String(date.getUTCSeconds()).padStart(2, "0") + "." + String(date.getUTCMilliseconds()).padStart(3, "0");
ret += "+00:00";
if (isBCYear) ret += " BC";
return ret;
}
__name(dateToStringUTC, "dateToStringUTC");
function normalizeQueryConfig(config, values, callback) {
config = typeof config === "string" ? { text: config } : cloneQueryConfig(config);
if (values) {
if (typeof values === "function") {
config.callback = values;
} else {
config.values = values;
}
}
if (callback) {
config.callback = callback;
}
return config;
}
__name(normalizeQueryConfig, "normalizeQueryConfig");
function cloneQueryConfig(config) {
if (config == null) {
return config;
}
return Object.defineProperties(Object.create(Object.getPrototypeOf(config)), Object.getOwnPropertyDescriptors(config));
}
__name(cloneQueryConfig, "cloneQueryConfig");
var escapeIdentifier2 = /* @__PURE__ */ __name(function(str) {
return '"' + str.replace(/"/g, '""') + '"';
}, "escapeIdentifier");
var escapeLiteral2 = /* @__PURE__ */ __name(function(str) {
let hasBackslash = false;
let escaped = "'";
if (str == null) {
return "''";
}
if (typeof str !== "string") {
return "''";
}
for (let i = 0; i < str.length; i++) {
const c = str[i];
if (c === "'") {
escaped += c + c;
} else if (c === "\\") {
escaped += c + c;
hasBackslash = true;
} else {
escaped += c;
}
}
escaped += "'";
if (hasBackslash === true) {
escaped = " E" + escaped;
}
return escaped;
}, "escapeLiteral");
module.exports = {
prepareValue: /* @__PURE__ */ __name(function prepareValueWrapper(value) {
return prepareValue(value);
}, "prepareValueWrapper"),
normalizeQueryConfig,
escapeIdentifier: escapeIdentifier2,
escapeLiteral: escapeLiteral2
};
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/crypto/utils.js
var require_utils2 = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/crypto/utils.js"(exports, module) {
var nodeCrypto = __require("crypto");
module.exports = {
postgresMd5PasswordHash,
randomBytes,
deriveKey,
sha256,
hashByName,
hmacSha256,
md5
};
var webCrypto = nodeCrypto.webcrypto || globalThis.crypto;
var subtleCrypto = webCrypto.subtle;
var textEncoder = new TextEncoder();
function randomBytes(length) {
return webCrypto.getRandomValues(Buffer.alloc(length));
}
__name(randomBytes, "randomBytes");
async function md5(string) {
try {
return nodeCrypto.createHash("md5").update(string, "utf-8").digest("hex");
} catch (e) {
const data = typeof string === "string" ? textEncoder.encode(string) : string;
const hash = await subtleCrypto.digest("MD5", data);
return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
}
}
__name(md5, "md5");
async function postgresMd5PasswordHash(user, password, salt) {
const inner = await md5(password + user);
const outer = await md5(Buffer.concat([Buffer.from(inner), salt]));
return "md5" + outer;
}
__name(postgresMd5PasswordHash, "postgresMd5PasswordHash");
async function sha256(text) {
return await subtleCrypto.digest("SHA-256", text);
}
__name(sha256, "sha256");
async function hashByName(hashName, text) {
return await subtleCrypto.digest(hashName, text);
}
__name(hashByName, "hashByName");
async function hmacSha256(keyBuffer, msg) {
const key = await subtleCrypto.importKey("raw", keyBuffer, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
return await subtleCrypto.sign("HMAC", key, textEncoder.encode(msg));
}
__name(hmacSha256, "hmacSha256");
async function deriveKey(password, salt, iterations) {
const key = await subtleCrypto.importKey("raw", textEncoder.encode(password), "PBKDF2", false, ["deriveBits"]);
const params = { name: "PBKDF2", hash: "SHA-256", salt, iterations };
return await subtleCrypto.deriveBits(params, key, 32 * 8, ["deriveBits"]);
}
__name(deriveKey, "deriveKey");
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/crypto/cert-signatures.js
var require_cert_signatures = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/crypto/cert-signatures.js"(exports, module) {
function x509Error(msg, cert) {
return new Error("SASL channel binding: " + msg + " when parsing public certificate " + cert.toString("base64"));
}
__name(x509Error, "x509Error");
function readASN1Length(data, index) {
let length = data[index++];
if (length < 128) return { length, index };
const lengthBytes = length & 127;
if (lengthBytes > 4) throw x509Error("bad length", data);
length = 0;
for (let i = 0; i < lengthBytes; i++) {
length = length << 8 | data[index++];
}
return { length, index };
}
__name(readASN1Length, "readASN1Length");
function readASN1OID(data, index) {
if (data[index++] !== 6) throw x509Error("non-OID data", data);
const { length: OIDLength, index: indexAfterOIDLength } = readASN1Length(data, index);
index = indexAfterOIDLength;
const lastIndex = index + OIDLength;
const byte1 = data[index++];
let oid = (byte1 / 40 >> 0) + "." + byte1 % 40;
while (index < lastIndex) {
let value = 0;
while (index < lastIndex) {
const nextByte = data[index++];
value = value << 7 | nextByte & 127;
if (nextByte < 128) break;
}
oid += "." + value;
}
return { oid, index };
}
__name(readASN1OID, "readASN1OID");
function expectASN1Seq(data, index) {
if (data[index++] !== 48) throw x509Error("non-sequence data", data);
return readASN1Length(data, index);
}
__name(expectASN1Seq, "expectASN1Seq");
function signatureAlgorithmHashFromCertificate(data, index) {
if (index === void 0) index = 0;
index = expectASN1Seq(data, index).index;
const { length: certInfoLength, index: indexAfterCertInfoLength } = expectASN1Seq(data, index);
index = indexAfterCertInfoLength + certInfoLength;
index = expectASN1Seq(data, index).index;
const { oid, index: indexAfterOID } = readASN1OID(data, index);
switch (oid) {
// RSA
case "1.2.840.113549.1.1.4":
return "MD5";
case "1.2.840.113549.1.1.5":
return "SHA-1";
case "1.2.840.113549.1.1.11":
return "SHA-256";
case "1.2.840.113549.1.1.12":
return "SHA-384";
case "1.2.840.113549.1.1.13":
return "SHA-512";
case "1.2.840.113549.1.1.14":
return "SHA-224";
case "1.2.840.113549.1.1.15":
return "SHA512-224";
case "1.2.840.113549.1.1.16":
return "SHA512-256";
// ECDSA
case "1.2.840.10045.4.1":
return "SHA-1";
case "1.2.840.10045.4.3.1":
return "SHA-224";
case "1.2.840.10045.4.3.2":
return "SHA-256";
case "1.2.840.10045.4.3.3":
return "SHA-384";
case "1.2.840.10045.4.3.4":
return "SHA-512";
// RSASSA-PSS: hash is indicated separately
case "1.2.840.113549.1.1.10": {
index = indexAfterOID;
index = expectASN1Seq(data, index).index;
if (data[index++] !== 160) throw x509Error("non-tag data", data);
index = readASN1Length(data, index).index;
index = expectASN1Seq(data, index).index;
const { oid: hashOID } = readASN1OID(data, index);
switch (hashOID) {
// standalone hash OIDs
case "1.2.840.113549.2.5":
return "MD5";
case "1.3.14.3.2.26":
return "SHA-1";
case "2.16.840.1.101.3.4.2.1":
return "SHA-256";
case "2.16.840.1.101.3.4.2.2":
return "SHA-384";
case "2.16.840.1.101.3.4.2.3":
return "SHA-512";
}
throw x509Error("unknown hash OID " + hashOID, data);
}
// Ed25519 -- see https://github.com/openssl/openssl/issues/15477
case "1.3.101.110":
case "1.3.101.112":
return "SHA-512";
// Ed448 -- still not in pg 17.2 (if supported, digest would be SHAKE256 x 64 bytes)
case "1.3.101.111":
case "1.3.101.113":
throw x509Error("Ed448 certificate channel binding is not currently supported by Postgres");
}
throw x509Error("unknown OID " + oid, data);
}
__name(signatureAlgorithmHashFromCertificate, "signatureAlgorithmHashFromCertificate");
module.exports = { signatureAlgorithmHashFromCertificate };
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/crypto/sasl.js
var require_sasl = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/crypto/sasl.js"(exports, module) {
"use strict";
var crypto = require_utils2();
var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
function saslprep(password) {
const nonAsciiSpace = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
const mappedToNothing = /[\u00AD\u034F\u1806\u180B\u180C\u180D\u200C\u200D\u2060\uFE00-\uFE0F\uFEFF]/g;
return password.replace(nonAsciiSpace, " ").replace(mappedToNothing, "").normalize("NFKC");
}
__name(saslprep, "saslprep");
var DEFAULT_MAX_SCRAM_ITERATIONS = 1e5;
function startSession(mechanisms, stream, scramMaxIterations = DEFAULT_MAX_SCRAM_ITERATIONS) {
const candidates = ["SCRAM-SHA-256"];
if (stream) candidates.unshift("SCRAM-SHA-256-PLUS");
const mechanism = candidates.find((candidate) => mechanisms.includes(candidate));
if (!mechanism) {
throw new Error("SASL: Only mechanism(s) " + candidates.join(" and ") + " are supported");
}
if (mechanism === "SCRAM-SHA-256-PLUS" && typeof stream.getPeerCertificate !== "function") {
throw new Error("SASL: Mechanism SCRAM-SHA-256-PLUS requires a certificate");
}
const clientNonce = crypto.randomBytes(18).toString("base64");
const gs2Header = mechanism === "SCRAM-SHA-256-PLUS" ? "p=tls-server-end-point" : stream ? "y" : "n";
return {
mechanism,
clientNonce,
response: gs2Header + ",,n=*,r=" + clientNonce,
message: "SASLInitialResponse",
scramMaxIterations
};
}
__name(startSession, "startSession");
async function continueSession(session, password, serverData, stream) {
if (session.message !== "SASLInitialResponse") {
throw new Error("SASL: Last message was not SASLInitialResponse");
}
if (typeof password !== "string") {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string");
}
if (password === "") {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a non-empty string");
}
if (typeof serverData !== "string") {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string");
}
const sv = parseServerFirstMessage(serverData);
if (!sv.nonce.startsWith(session.clientNonce)) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce");
} else if (sv.nonce.length === session.clientNonce.length) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
}
const scramMaxIterations = typeof session.scramMaxIterations === "number" ? session.scramMaxIterations : DEFAULT_MAX_SCRAM_ITERATIONS;
if (scramMaxIterations !== 0 && sv.iteration > scramMaxIterations) {
throw new Error(
"SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration count " + sv.iteration + " exceeds scramMaxIterations of " + scramMaxIterations
);
}
const clientFirstMessageBare = "n=*,r=" + session.clientNonce;
const serverFirstMessage = "r=" + sv.nonce + ",s=" + sv.salt + ",i=" + sv.iteration;
let channelBinding = stream ? "eSws" : "biws";
if (session.mechanism === "SCRAM-SHA-256-PLUS") {
const peerCert = stream.getPeerCertificate().raw;
let hashName = signatureAlgorithmHashFromCertificate(peerCert);
if (hashName === "MD5" || hashName === "SHA-1") hashName = "SHA-256";
const certHash = await crypto.hashByName(hashName, peerCert);
const bindingData = Buffer.concat([Buffer.from("p=tls-server-end-point,,"), Buffer.from(certHash)]);
channelBinding = bindingData.toString("base64");
}
const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce;
const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof;
const saltBytes = Buffer.from(sv.salt, "base64");
const saltedPassword = await crypto.deriveKey(saslprep(password), saltBytes, sv.iteration);
const clientKey = await crypto.hmacSha256(saltedPassword, "Client Key");
const storedKey = await crypto.sha256(clientKey);
const clientSignature = await crypto.hmacSha256(storedKey, authMessage);
const clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString("base64");
const serverKey = await crypto.hmacSha256(saltedPassword, "Server Key");
const serverSignatureBytes = await crypto.hmacSha256(serverKey, authMessage);
session.message = "SASLResponse";
session.serverSignature = Buffer.from(serverSignatureBytes).toString("base64");
session.response = clientFinalMessageWithoutProof + ",p=" + clientProof;
}
__name(continueSession, "continueSession");
function finalizeSession(session, serverData) {
if (session.message !== "SASLResponse") {
throw new Error("SASL: Last message was not SASLResponse");
}
if (typeof serverData !== "string") {
throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string");
}
const { serverSignature } = parseServerFinalMessage(serverData);
if (serverSignature !== session.serverSignature) {
throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match");
}
}
__name(finalizeSession, "finalizeSession");
function isPrintableChars(text) {
if (typeof text !== "string") {
throw new TypeError("SASL: text must be a string");
}
return text.split("").map((_, i) => text.charCodeAt(i)).every((c) => c >= 33 && c <= 43 || c >= 45 && c <= 126);
}
__name(isPrintableChars, "isPrintableChars");
function isBase64(text) {
return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(text);
}
__name(isBase64, "isBase64");
function parseAttributePairs(text) {
if (typeof text !== "string") {
throw new TypeError("SASL: attribute pairs text must be a string");
}
return new Map(
text.split(",").map((attrValue) => {
if (!/^.=/.test(attrValue)) {
throw new Error("SASL: Invalid attribute pair entry");
}
const name = attrValue[0];
const value = attrValue.substring(2);
return [name, value];
})
);
}
__name(parseAttributePairs, "parseAttributePairs");
function parseServerFirstMessage(data) {
const attrPairs = parseAttributePairs(data);
const nonce = attrPairs.get("r");
if (!nonce) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
} else if (!isPrintableChars(nonce)) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
}
const salt = attrPairs.get("s");
if (!salt) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing");
} else if (!isBase64(salt)) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64");
}
const iterationText = attrPairs.get("i");
if (!iterationText) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing");
} else if (!/^[1-9][0-9]*$/.test(iterationText)) {
throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count");
}
const iteration = parseInt(iterationText, 10);
return {
nonce,
salt,
iteration
};
}
__name(parseServerFirstMessage, "parseServerFirstMessage");
function parseServerFinalMessage(serverData) {
const attrPairs = parseAttributePairs(serverData);
const error = attrPairs.get("e");
const serverSignature = attrPairs.get("v");
if (error) {
throw new Error(`SASL: SCRAM-SERVER-FINAL-MESSAGE: server returned error: "${error}"`);
}
if (!serverSignature) {
throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing");
} else if (!isBase64(serverSignature)) {
throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
}
return {
serverSignature
};
}
__name(parseServerFinalMessage, "parseServerFinalMessage");
function xorBuffers(a, b) {
if (!Buffer.isBuffer(a)) {
throw new TypeError("first argument must be a Buffer");
}
if (!Buffer.isBuffer(b)) {
throw new TypeError("second argument must be a Buffer");
}
if (a.length !== b.length) {
throw new Error("Buffer lengths must match");
}
if (a.length === 0) {
throw new Error("Buffers cannot be empty");
}
return Buffer.from(a.map((_, i) => a[i] ^ b[i]));
}
__name(xorBuffers, "xorBuffers");
module.exports = {
startSession,
continueSession,
finalizeSession,
DEFAULT_MAX_SCRAM_ITERATIONS
};
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/type-overrides.js
var require_type_overrides = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/type-overrides.js"(exports, module) {
"use strict";
var types2 = require_pg_types();
function TypeOverrides2(userTypes) {
this._types = userTypes || types2;
this.text = {};
this.binary = {};
}
__name(TypeOverrides2, "TypeOverrides");
TypeOverrides2.prototype.getOverrides = function(format) {
switch (format) {
case "text":
return this.text;
case "binary":
return this.binary;
default:
return {};
}
};
TypeOverrides2.prototype.setTypeParser = function(oid, format, parseFn) {
if (typeof format === "function") {
parseFn = format;
format = "text";
}
this.getOverrides(format)[oid] = parseFn;
};
TypeOverrides2.prototype.getTypeParser = function(oid, format) {
format = format || "text";
return this.getOverrides(format)[oid] || this._types.getTypeParser(oid, format);
};
module.exports = TypeOverrides2;
}
});
// ../../node_modules/.pnpm/pg-connection-string@2.14.1/node_modules/pg-connection-string/index.js
var require_pg_connection_string = __commonJS({
"../../node_modules/.pnpm/pg-connection-string@2.14.1/node_modules/pg-connection-string/index.js"(exports, module) {
"use strict";
function parse(str, options = {}) {
if (str.charAt(0) === "/") {
const config2 = str.split(" ");
return { host: config2[0], database: config2[1] };
}
const config = /* @__PURE__ */ Object.create(null);
let result;
let dummyHost = false;
if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
str = encodeURI(str).replace(/%25(\d\d)/g, "%$1");
}
try {
try {
result = new URL(str, "postgres://base");
} catch (e) {
result = new URL(str.replace("@/", "@___DUMMY___/"), "postgres://base");
dummyHost = true;
}
} catch (err) {
err.input && (err.input = "*****REDACTED*****");
throw err;
}
for (const entry of result.searchParams.entries()) {
config[entry[0]] = entry[1];
}
config.user = config.user || decodeURIComponent(result.username);
config.password = config.password || decodeURIComponent(result.password);
if (result.protocol == "socket:") {
config.host = decodeURI(result.pathname);
config.database = result.searchParams.get("db");
config.client_encoding = result.searchParams.get("encoding");
return config;
}
const hostname = (dummyHost ? "" : result.hostname).replace(/^\[(.+)\]$/, "$1");
if (!config.host) {
config.host = decodeURIComponent(hostname);
} else if (hostname && /^%2f/i.test(hostname)) {
result.pathname = hostname + result.pathname;
}
if (!config.port) {
config.port = result.port;
}
const pathname = result.pathname.slice(1) || null;
config.database = pathname ? decodeURI(pathname) : null;
if (config.ssl === "true" || config.ssl === "1") {
config.ssl = true;
}
if (config.ssl === "0") {
config.ssl = false;
}
if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) {
config.ssl = {};
}
if (config.sslnegotiation === "direct" && config.ssl === void 0) {
config.ssl = true;
}
const fs = config.sslcert || config.sslkey || config.sslrootcert ? __require("fs") : null;
if (config.sslcert) {
config.ssl.cert = fs.readFileSync(config.sslcert).toString();
}
if (config.sslkey) {
config.ssl.key = fs.readFileSync(config.sslkey).toString();
}
if (config.sslrootcert) {
config.ssl.ca = fs.readFileSync(config.sslrootcert).toString();
}
if (options.useLibpqCompat && config.uselibpqcompat) {
throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
}
if (config.uselibpqcompat === "true" || options.useLibpqCompat) {
switch (config.sslmode) {
case "disable": {
config.ssl = false;
break;
}
case "prefer": {
config.ssl.rejectUnauthorized = false;
break;
}
case "require": {
if (config.sslrootcert) {
config.ssl.checkServerIdentity = function() {
};
} else {
config.ssl.rejectUnauthorized = false;
}
break;
}
case "verify-ca": {
if (!config.ssl.ca) {
throw new Error(
"SECURITY WARNING: Using sslmode=verify-ca requires specifying a CA with sslrootcert. If a public CA is used, verify-ca allows connections to a server that somebody else may have registered with the CA, making you vulnerable to Man-in-the-Middle attacks. Either specify a custom CA certificate with sslrootcert parameter or use sslmode=verify-full for proper security."
);
}
config.ssl.checkServerIdentity = function() {
};
break;
}
case "verify-full": {
break;
}
}
} else {
switch (config.sslmode) {
case "disable": {
config.ssl = false;
break;
}
case "prefer":
case "require":
case "verify-ca":
case "verify-full": {
if (config.sslmode !== "verify-full") {
deprecatedSslModeWarning(config.sslmode);
}
break;
}
case "no-verify": {
config.ssl.rejectUnauthorized = false;
break;
}
}
}
return config;
}
__name(parse, "parse");
function toConnectionOptions(sslConfig) {
const connectionOptions = Object.entries(sslConfig).reduce((c, [key, value]) => {
if (value !== void 0 && value !== null) {
c[key] = value;
}
return c;
}, /* @__PURE__ */ Object.create(null));
return connectionOptions;
}
__name(toConnectionOptions, "toConnectionOptions");
function toClientConfig(config) {
const poolConfig = Object.entries(config).reduce((c, [key, value]) => {
if (key === "ssl") {
const sslConfig = value;
if (typeof sslConfig === "boolean") {
c[key] = sslConfig;
}
if (typeof sslConfig === "object") {
c[key] = toConnectionOptions(sslConfig);
}
} else if (value !== void 0 && value !== null) {
if (key === "port") {
if (value !== "") {
const v = parseInt(value, 10);
if (isNaN(v)) {
throw new Error(`Invalid ${key}: ${value}`);
}
c[key] = v;
}
} else {
c[key] = value;
}
}
return c;
}, /* @__PURE__ */ Object.create(null));
return poolConfig;
}
__name(toClientConfig, "toClientConfig");
function parseIntoClientConfig(str) {
return toClientConfig(parse(str));
}
__name(parseIntoClientConfig, "parseIntoClientConfig");
function deprecatedSslModeWarning(sslmode) {
if (!deprecatedSslModeWarning.warned && typeof process !== "undefined" && process.emitWarning) {
deprecatedSslModeWarning.warned = true;
process.emitWarning(`SECURITY WARNING: The SSL modes 'prefer', 'require', and 'verify-ca' are treated as aliases for 'verify-full'.
In the next major version (pg-connection-string v3.0.0 and pg v9.0.0), these modes will adopt standard libpq semantics, which have weaker security guarantees.
To prepare for this change:
- If you want the current behavior, explicitly use 'sslmode=verify-full'
- If you want libpq compatibility now, use 'uselibpqcompat=true&sslmode=${sslmode}'
See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode definitions.`);
}
}
__name(deprecatedSslModeWarning, "deprecatedSslModeWarning");
module.exports = parse;
parse.parse = parse;
parse.toClientConfig = toClientConfig;
parse.parseIntoClientConfig = parseIntoClientConfig;
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/connection-parameters.js
var require_connection_parameters = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/connection-parameters.js"(exports, module) {
"use strict";
var dns = __require("dns");
var defaults2 = require_defaults();
var parse = require_pg_connection_string().parse;
var val = /* @__PURE__ */ __name(function(key, config, envVar) {
if (config[key]) {
return config[key];
}
if (envVar === void 0) {
envVar = process.env["PG" + key.toUpperCase()];
} else if (envVar === false) {
} else {
envVar = process.env[envVar];
}
return envVar || defaults2[key];
}, "val");
var readSSLConfigFromEnvironment = /* @__PURE__ */ __name(function() {
switch (process.env.PGSSLMODE) {
case "disable":
return false;
case "prefer":
case "require":
case "verify-ca":
case "verify-full":
return true;
case "no-verify":
return { rejectUnauthorized: false };
}
return defaults2.ssl;
}, "readSSLConfigFromEnvironment");
var quoteParamValue = /* @__PURE__ */ __name(function(value) {
return "'" + ("" + value).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
}, "quoteParamValue");
var add = /* @__PURE__ */ __name(function(params, config, paramName) {
const value = config[paramName];
if (value !== void 0 && value !== null) {
params.push(paramName + "=" + quoteParamValue(value));
}
}, "add");
var ConnectionParameters = class {
static {
__name(this, "ConnectionParameters");
}
constructor(config) {
config = typeof config === "string" ? parse(config) : config || {};
if (config.connectionString) {
config = Object.assign({}, config, parse(config.connectionString));
}
this.user = val("user", config);
this.database = val("database", config);
if (this.database === void 0) {
this.database = this.user;
}
this.port = parseInt(val("port", config), 10);
this.host = val("host", config);
Object.defineProperty(this, "password", {
configurable: true,
enumerable: false,
writable: true,
value: val("password", config)
});
this.binary = val("binary", config);
this.options = val("options", config);
this.ssl = typeof config.ssl === "undefined" ? readSSLConfigFromEnvironment() : config.ssl;
if (typeof this.ssl === "string") {
if (this.ssl === "true") {
this.ssl = true;
}
}
if (this.ssl === "no-verify") {
this.ssl = { rejectUnauthorized: false };
}
if (this.ssl && this.ssl.key) {
Object.defineProperty(this.ssl, "key", {
enumerable: false
});
}
this.sslnegotiation = val("sslnegotiation", config, "PGSSLNEGOTIATION");
if (this.sslnegotiation !== void 0 && this.sslnegotiation !== "postgres" && this.sslnegotiation !== "direct") {
throw new Error(
`Invalid sslnegotiation value: "${this.sslnegotiation}". Valid values are "postgres" and "direct".`
);
}
if (this.sslnegotiation === "direct" && !this.ssl) {
throw new Error("sslnegotiation=direct requires SSL to be enabled");
}
this.client_encoding = val("client_encoding", config);
this.replication = val("replication", config);
this.isDomainSocket = !(this.host || "").indexOf("/");
this.application_name = val("application_name", config, "PGAPPNAME");
this.fallback_application_name = val("fallback_application_name", config, false);
this.statement_timeout = val("statement_timeout", config, false);
this.lock_timeout = val("lock_timeout", config, false);
this.idle_in_transaction_session_timeout = val("idle_in_transaction_session_timeout", config, false);
this.query_timeout = val("query_timeout", config, false);
if (config.connectionTimeoutMillis === void 0) {
this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0;
} else {
this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1e3);
}
if (config.keepAlive === false) {
this.keepalives = 0;
} else if (config.keepAlive === true) {
this.keepalives = 1;
}
if (typeof config.keepAliveInitialDelayMillis === "number") {
this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1e3);
}
}
getLibpqConnectionString(cb) {
const params = [];
add(params, this, "user");
add(params, this, "password");
add(params, this, "port");
add(params, this, "application_name");
add(params, this, "fallback_application_name");
add(params, this, "connect_timeout");
add(params, this, "options");
const ssl = typeof this.ssl === "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {};
add(params, ssl, "sslmode");
add(params, ssl, "sslca");
add(params, ssl, "sslkey");
add(params, ssl, "sslcert");
add(params, ssl, "sslrootcert");
add(params, this, "sslnegotiation");
if (this.database) {
params.push("dbname=" + quoteParamValue(this.database));
}
if (this.replication) {
params.push("replication=" + quoteParamValue(this.replication));
}
if (this.host) {
params.push("host=" + quoteParamValue(this.host));
}
if (this.isDomainSocket) {
return cb(null, params.join(" "));
}
if (this.client_encoding) {
params.push("client_encoding=" + quoteParamValue(this.client_encoding));
}
dns.lookup(this.host, function(err, address) {
if (err) return cb(err, null);
params.push("hostaddr=" + quoteParamValue(address));
return cb(null, params.join(" "));
});
}
};
module.exports = ConnectionParameters;
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/result.js
var require_result = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/result.js"(exports, module) {
"use strict";
var types2 = require_pg_types();
var matchRegexp = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/;
var Result2 = class {
static {
__name(this, "Result");
}
constructor(rowMode, types3) {
this.command = null;
this.rowCount = null;
this.oid = null;
this.rows = [];
this.fields = [];
this._parsers = void 0;
this._types = types3;
this.RowCtor = null;
this.rowAsArray = rowMode === "array";
if (this.rowAsArray) {
this.parseRow = this._parseRowAsArray;
}
this._prebuiltEmptyResultObject = null;
}
// adds a command complete message
addCommandComplete(msg) {
let match;
if (msg.text) {
match = matchRegexp.exec(msg.text);
} else {
match = matchRegexp.exec(msg.command);
}
if (match) {
this.command = match[1];
if (match[3]) {
this.oid = parseInt(match[2], 10);
this.rowCount = parseInt(match[3], 10);
} else if (match[2]) {
this.rowCount = parseInt(match[2], 10);
}
}
}
_parseRowAsArray(rowData) {
const row = new Array(rowData.length);
for (let i = 0, len = rowData.length; i < len; i++) {
const rawValue = rowData[i];
if (rawValue !== null) {
row[i] = this._parsers[i](rawValue);
} else {
row[i] = null;
}
}
return row;
}
parseRow(rowData) {
const row = { ...this._prebuiltEmptyResultObject };
for (let i = 0, len = rowData.length; i < len; i++) {
const rawValue = rowData[i];
const field = this.fields[i].name;
if (rawValue !== null) {
const v = this.fields[i].format === "binary" ? Buffer.from(rawValue) : rawValue;
row[field] = this._parsers[i](v);
} else {
row[field] = null;
}
}
return row;
}
addRow(row) {
this.rows.push(row);
}
addFields(fieldDescriptions) {
this.fields = fieldDescriptions;
if (this.fields.length) {
this._parsers = new Array(fieldDescriptions.length);
}
const row = /* @__PURE__ */ Object.create(null);
for (let i = 0; i < fieldDescriptions.length; i++) {
const desc = fieldDescriptions[i];
row[desc.name] = null;
if (this._types) {
this._parsers[i] = this._types.getTypeParser(desc.dataTypeID, desc.format || "text");
} else {
this._parsers[i] = types2.getTypeParser(desc.dataTypeID, desc.format || "text");
}
}
this._prebuiltEmptyResultObject = { ...row };
}
};
module.exports = Result2;
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/query.js
var require_query = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/query.js"(exports, module) {
"use strict";
var { EventEmitter } = __require("events");
var Result2 = require_result();
var utils = require_utils();
var Query2 = class extends EventEmitter {
static {
__name(this, "Query");
}
constructor(config, values, callback) {
super();
config = utils.normalizeQueryConfig(config, values, callback);
this.text = config.text;
this.values = config.values;
this.rows = config.rows;
this.types = config.types;
this.name = config.name;
this.queryMode = config.queryMode;
this.binary = config.binary;
this.portal = config.portal || "";
this.callback = config.callback;
this._rowMode = config.rowMode;
if (process.domain && config.callback) {
this.callback = process.domain.bind(config.callback);
}
this._result = new Result2(this._rowMode, this.types);
this._results = this._result;
this._canceledDueToError = false;
}
requiresPreparation() {
if (this.queryMode === "extended") {
return true;
}
if (this.name) {
return true;
}
if (this.rows) {
return true;
}
if (!this.text) {
return false;
}
if (!this.values) {
return false;
}
return this.values.length > 0;
}
_checkForMultirow() {
if (this._result.command) {
if (!Array.isArray(this._results)) {
this._results = [this._result];
}
this._result = new Result2(this._rowMode, this._result._types);
this._results.push(this._result);
}
}
// associates row metadata from the supplied
// message with this query object
// metadata used when parsing row results
handleRowDescription(msg) {
this._checkForMultirow();
this._result.addFields(msg.fields);
this._accumulateRows = this.callback || !this.listeners("row").length;
}
handleDataRow(msg) {
let row;
if (this._canceledDueToError) {
return;
}
try {
row = this._result.parseRow(msg.fields);
} catch (err) {
this._canceledDueToError = err;
return;
}
this.emit("row", row, this._result);
if (this._accumulateRows) {
this._result.addRow(row);
}
}
handleCommandComplete(msg, connection) {
this._checkForMultirow();
this._result.addCommandComplete(msg);
if (this.rows) {
connection.sync();
}
}
// if a named prepared statement is created with empty query text
// the backend will send an emptyQuery message but *not* a command complete message
// since we pipeline sync immediately after execute we don't need to do anything here
// unless we have rows specified, in which case we did not pipeline the initial sync call
handleEmptyQuery(connection) {
if (this.rows) {
connection.sync();
}
}
handleError(err, connection) {
if (this._canceledDueToError) {
err = this._canceledDueToError;
this._canceledDueToError = false;
}
if (this.callback) {
return this.callback(err);
}
this.emit("error", err);
}
handleReadyForQuery(con) {
if (this._canceledDueToError) {
return this.handleError(this._canceledDueToError, con);
}
if (this.callback) {
try {
this.callback(null, this._results);
} catch (err) {
process.nextTick(() => {
throw err;
});
}
}
this.emit("end", this._results);
}
submit(connection) {
if (typeof this.text !== "string" && typeof this.name !== "string") {
return new Error("A query must have either text or a name. Supplying neither is unsupported.");
}
const previous = connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name];
if (this.text && previous && this.text !== previous) {
return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
}
if (this.values && !Array.isArray(this.values)) {
return new Error("Query values must be an array");
}
if (this.requiresPreparation()) {
connection.stream.cork && connection.stream.cork();
try {
this.prepare(connection);
} finally {
connection.stream.uncork && connection.stream.uncork();
}
} else {
connection.query(this.text);
}
return null;
}
hasBeenParsed(connection) {
return this.name && (connection.parsedStatements[this.name] !== void 0 || connection.submittedNamedStatements[this.name] !== void 0);
}
handlePortalSuspended(connection) {
this._getRows(connection, this.rows);
}
_getRows(connection, rows) {
connection.execute({
portal: this.portal,
rows
});
if (!rows) {
connection.sync();
} else {
connection.flush();
}
}
// http://developer.postgresql.org/pgdocs/postgres/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY
prepare(connection) {
if (!this.hasBeenParsed(connection)) {
connection.parse({
text: this.text,
name: this.name,
types: this.types
});
if (this.name) {
connection.submittedNamedStatements[this.name] = this.text;
}
}
try {
connection.bind({
portal: this.portal,
statement: this.name,
values: this.values,
binary: this.binary,
valueMapper: utils.prepareValue
});
} catch (err) {
connection.close({ type: "S", name: this.name });
connection.sync();
this.handleError(err, connection);
return;
}
connection.describe({
type: "P",
name: this.portal || ""
});
this._getRows(connection, this.rows);
}
handleCopyInResponse(connection) {
connection.sendCopyFail("No source stream defined");
}
handleCopyData(msg, connection) {
}
};
module.exports = Query2;
}
});
// ../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/messages.js
var require_messages = __commonJS({
"../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/messages.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoticeMessage = exports.DataRowMessage = exports.CommandCompleteMessage = exports.ReadyForQueryMessage = exports.NotificationResponseMessage = exports.BackendKeyDataMessage = exports.AuthenticationMD5Password = exports.ParameterStatusMessage = exports.ParameterDescriptionMessage = exports.RowDescriptionMessage = exports.Field = exports.CopyResponse = exports.CopyDataMessage = exports.DatabaseError = exports.copyDone = exports.emptyQuery = exports.replicationStart = exports.portalSuspended = exports.noData = exports.closeComplete = exports.bindComplete = exports.parseComplete = void 0;
exports.parseComplete = {
name: "parseComplete",
length: 5
};
exports.bindComplete = {
name: "bindComplete",
length: 5
};
exports.closeComplete = {
name: "closeComplete",
length: 5
};
exports.noData = {
name: "noData",
length: 5
};
exports.portalSuspended = {
name: "portalSuspended",
length: 5
};
exports.replicationStart = {
name: "replicationStart",
length: 4
};
exports.emptyQuery = {
name: "emptyQuery",
length: 4
};
exports.copyDone = {
name: "copyDone",
length: 4
};
var DatabaseError2 = class extends Error {
static {
__name(this, "DatabaseError");
}
constructor(message, length, name) {
super(message);
this.length = length;
this.name = name;
}
};
exports.DatabaseError = DatabaseError2;
var CopyDataMessage = class {
static {
__name(this, "CopyDataMessage");
}
constructor(length, chunk) {
this.length = length;
this.chunk = chunk;
this.name = "copyData";
}
};
exports.CopyDataMessage = CopyDataMessage;
var CopyResponse = class {
static {
__name(this, "CopyResponse");
}
constructor(length, name, binary, columnCount) {
this.length = length;
this.name = name;
this.binary = binary;
this.columnTypes = new Array(columnCount);
}
};
exports.CopyResponse = CopyResponse;
var Field = class {
static {
__name(this, "Field");
}
constructor(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, format) {
this.name = name;
this.tableID = tableID;
this.columnID = columnID;
this.dataTypeID = dataTypeID;
this.dataTypeSize = dataTypeSize;
this.dataTypeModifier = dataTypeModifier;
this.format = format;
}
};
exports.Field = Field;
var RowDescriptionMessage = class {
static {
__name(this, "RowDescriptionMessage");
}
constructor(length, fieldCount) {
this.length = length;
this.fieldCount = fieldCount;
this.name = "rowDescription";
this.fields = new Array(this.fieldCount);
}
};
exports.RowDescriptionMessage = RowDescriptionMessage;
var ParameterDescriptionMessage = class {
static {
__name(this, "ParameterDescriptionMessage");
}
constructor(length, parameterCount) {
this.length = length;
this.parameterCount = parameterCount;
this.name = "parameterDescription";
this.dataTypeIDs = new Array(this.parameterCount);
}
};
exports.ParameterDescriptionMessage = ParameterDescriptionMessage;
var ParameterStatusMessage = class {
static {
__name(this, "ParameterStatusMessage");
}
constructor(length, parameterName, parameterValue) {
this.length = length;
this.parameterName = parameterName;
this.parameterValue = parameterValue;
this.name = "parameterStatus";
}
};
exports.ParameterStatusMessage = ParameterStatusMessage;
var AuthenticationMD5Password = class {
static {
__name(this, "AuthenticationMD5Password");
}
constructor(length, salt) {
this.length = length;
this.salt = salt;
this.name = "authenticationMD5Password";
}
};
exports.AuthenticationMD5Password = AuthenticationMD5Password;
var BackendKeyDataMessage = class {
static {
__name(this, "BackendKeyDataMessage");
}
constructor(length, processID, secretKey) {
this.length = length;
this.processID = processID;
this.secretKey = secretKey;
this.name = "backendKeyData";
}
};
exports.BackendKeyDataMessage = BackendKeyDataMessage;
var NotificationResponseMessage = class {
static {
__name(this, "NotificationResponseMessage");
}
constructor(length, processId, channel, payload) {
this.length = length;
this.processId = processId;
this.channel = channel;
this.payload = payload;
this.name = "notification";
}
};
exports.NotificationResponseMessage = NotificationResponseMessage;
var ReadyForQueryMessage = class {
static {
__name(this, "ReadyForQueryMessage");
}
constructor(length, status) {
this.length = length;
this.status = status;
this.name = "readyForQuery";
}
};
exports.ReadyForQueryMessage = ReadyForQueryMessage;
var CommandCompleteMessage = class {
static {
__name(this, "CommandCompleteMessage");
}
constructor(length, text) {
this.length = length;
this.text = text;
this.name = "commandComplete";
}
};
exports.CommandCompleteMessage = CommandCompleteMessage;
var DataRowMessage = class {
static {
__name(this, "DataRowMessage");
}
constructor(length, fields) {
this.length = length;
this.fields = fields;
this.name = "dataRow";
this.fieldCount = fields.length;
}
};
exports.DataRowMessage = DataRowMessage;
var NoticeMessage = class {
static {
__name(this, "NoticeMessage");
}
constructor(length, message) {
this.length = length;
this.message = message;
this.name = "notice";
}
};
exports.NoticeMessage = NoticeMessage;
}
});
// ../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/buffer-writer.js
var require_buffer_writer = __commonJS({
"../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/buffer-writer.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Writer = void 0;
var Writer = class {
static {
__name(this, "Writer");
}
constructor(size = 256) {
this.size = size;
this.offset = 5;
this.headerPosition = 0;
this.buffer = Buffer.allocUnsafe(size);
}
ensure(size) {
const remaining = this.buffer.length - this.offset;
if (remaining < size) {
const oldBuffer = this.buffer;
const newSize = oldBuffer.length + (oldBuffer.length >> 1) + size;
this.buffer = Buffer.allocUnsafe(newSize);
oldBuffer.copy(this.buffer, 0, 0, this.offset);
}
}
addInt32(num) {
this.ensure(4);
this.buffer[this.offset++] = num >>> 24 & 255;
this.buffer[this.offset++] = num >>> 16 & 255;
this.buffer[this.offset++] = num >>> 8 & 255;
this.buffer[this.offset++] = num >>> 0 & 255;
return this;
}
addInt16(num) {
this.ensure(2);
this.buffer[this.offset++] = num >>> 8 & 255;
this.buffer[this.offset++] = num >>> 0 & 255;
return this;
}
addCString(string) {
if (!string) {
this.ensure(1);
} else {
const len = Buffer.byteLength(string);
this.ensure(len + 1);
this.buffer.write(string, this.offset, "utf-8");
this.offset += len;
}
this.buffer[this.offset++] = 0;
return this;
}
addString(string = "") {
const len = Buffer.byteLength(string);
this.ensure(len);
this.buffer.write(string, this.offset);
this.offset += len;
return this;
}
// Write an Int32 byte-length prefix immediately followed by the string's UTF-8
// bytes. Postgres' Bind wire format prefixes every parameter with its length,
// and doing it in one method computes Buffer.byteLength ONCE — the previous
// `addInt32(Buffer.byteLength(s)).addString(s)` pairing scanned the string
// three times (byteLength for the prefix, byteLength again inside addString,
// then the encode), which is costly for large text parameters.
addInt32PrefixedString(string) {
const len = Buffer.byteLength(string);
this.ensure(4 + len);
const buffer = this.buffer;
let offset = this.offset;
buffer[offset++] = len >>> 24 & 255;
buffer[offset++] = len >>> 16 & 255;
buffer[offset++] = len >>> 8 & 255;
buffer[offset++] = len >>> 0 & 255;
buffer.write(string, offset, "utf-8");
this.offset = offset + len;
return this;
}
add(otherBuffer) {
this.ensure(otherBuffer.length);
otherBuffer.copy(this.buffer, this.offset);
this.offset += otherBuffer.length;
return this;
}
/**
* Appends an uninitialized block of {@link size} bytes to the buffer and returns its offset.
*/
reserveUnsafe(size) {
const offset = this.offset;
this.ensure(size);
this.offset += size;
return offset;
}
join(code) {
if (code) {
this.buffer[this.headerPosition] = code;
const length = this.offset - (this.headerPosition + 1);
this.buffer.writeInt32BE(length, this.headerPosition + 1);
}
return this.buffer.slice(code ? 0 : 5, this.offset);
}
flush(code) {
const result = this.join(code);
this.offset = 5;
this.headerPosition = 0;
this.buffer = Buffer.allocUnsafe(this.size);
return result;
}
clear() {
this.offset = 5;
this.headerPosition = 0;
}
};
exports.Writer = Writer;
}
});
// ../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/serializer.js
var require_serializer = __commonJS({
"../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/serializer.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.serialize = void 0;
var buffer_writer_1 = require_buffer_writer();
var writer = new buffer_writer_1.Writer();
var startup = /* @__PURE__ */ __name((opts) => {
writer.addInt16(3).addInt16(0);
for (const key of Object.keys(opts)) {
writer.addCString(key).addCString(opts[key]);
}
writer.addCString("client_encoding").addCString("UTF8");
const bodyBuffer = writer.addCString("").flush();
const length = bodyBuffer.length + 4;
return new buffer_writer_1.Writer().addInt32(length).add(bodyBuffer).flush();
}, "startup");
var requestSsl = /* @__PURE__ */ __name(() => {
const response = Buffer.allocUnsafe(8);
response.writeInt32BE(8, 0);
response.writeInt32BE(80877103, 4);
return response;
}, "requestSsl");
var password = /* @__PURE__ */ __name((password2) => {
return writer.addCString(password2).flush(
112
/* code.startup */
);
}, "password");
var sendSASLInitialResponseMessage = /* @__PURE__ */ __name(function(mechanism, initialResponse) {
writer.addCString(mechanism).addInt32PrefixedString(initialResponse);
return writer.flush(
112
/* code.startup */
);
}, "sendSASLInitialResponseMessage");
var sendSCRAMClientFinalMessage = /* @__PURE__ */ __name(function(additionalData) {
return writer.addString(additionalData).flush(
112
/* code.startup */
);
}, "sendSCRAMClientFinalMessage");
var query = /* @__PURE__ */ __name((text) => {
return writer.addCString(text).flush(
81
/* code.query */
);
}, "query");
var emptyArray = [];
var parse = /* @__PURE__ */ __name((query2) => {
const name = query2.name || "";
if (name.length > 63) {
console.error("Warning! Postgres only supports 63 characters for query names.");
console.error("You supplied %s (%s)", name, name.length);
console.error("This can cause conflicts and silent errors executing queries");
}
const types2 = query2.types || emptyArray;
const len = types2.length;
const buffer = writer.addCString(name).addCString(query2.text).addInt16(len);
for (let i = 0; i < len; i++) {
buffer.addInt32(types2[i]);
}
return writer.flush(
80
/* code.parse */
);
}, "parse");
var writeValues = /* @__PURE__ */ __name(function(values, valueMapper, formatsOffset) {
const len = values.length;
for (let i = 0; i < len; i++) {
const mappedVal = valueMapper ? valueMapper(values[i], i) : values[i];
let formatByte = 0;
if (mappedVal == null) {
writer.addInt32(-1);
} else if (mappedVal instanceof Buffer) {
formatByte = 1;
writer.addInt32(mappedVal.length);
writer.add(mappedVal);
} else {
writer.addInt32PrefixedString(mappedVal);
}
const buf = writer.buffer;
buf[formatsOffset++] = 0;
buf[formatsOffset++] = formatByte;
}
}, "writeValues");
var bind = /* @__PURE__ */ __name((config = {}) => {
const portal = config.portal || "";
const statement = config.statement || "";
const binary = config.binary || false;
const values = config.values || emptyArray;
const len = values.length;
writer.addCString(portal).addCString(statement);
writer.addInt16(len);
const formatsOffset = writer.reserveUnsafe(len * 2);
writer.addInt16(len);
try {
writeValues(values, config.valueMapper, formatsOffset);
} catch (err) {
writer.clear();
throw err;
}
writer.addInt16(1);
writer.addInt16(
binary ? 1 : 0
/* ParamType.STRING */
);
return writer.flush(
66
/* code.bind */
);
}, "bind");
var emptyExecute = Buffer.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]);
var execute = /* @__PURE__ */ __name((config) => {
if (!config || !config.portal && !config.rows) {
return emptyExecute;
}
const portal = config.portal || "";
const rows = config.rows || 0;
const portalLength = Buffer.byteLength(portal);
const len = 4 + portalLength + 1 + 4;
const buff = Buffer.allocUnsafe(1 + len);
buff[0] = 69;
buff.writeInt32BE(len, 1);
buff.write(portal, 5, "utf-8");
buff[portalLength + 5] = 0;
buff.writeUInt32BE(rows, buff.length - 4);
return buff;
}, "execute");
var cancel = /* @__PURE__ */ __name((processID, secretKey) => {
const buffer = Buffer.allocUnsafe(16);
buffer.writeInt32BE(16, 0);
buffer.writeInt16BE(1234, 4);
buffer.writeInt16BE(5678, 6);
buffer.writeInt32BE(processID, 8);
buffer.writeInt32BE(secretKey, 12);
return buffer;
}, "cancel");
var cstringMessage = /* @__PURE__ */ __name((code, string) => {
const stringLen = Buffer.byteLength(string);
const len = 4 + stringLen + 1;
const buffer = Buffer.allocUnsafe(1 + len);
buffer[0] = code;
buffer.writeInt32BE(len, 1);
buffer.write(string, 5, "utf-8");
buffer[len] = 0;
return buffer;
}, "cstringMessage");
var emptyDescribePortal = writer.addCString("P").flush(
68
/* code.describe */
);
var emptyDescribeStatement = writer.addCString("S").flush(
68
/* code.describe */
);
var describe = /* @__PURE__ */ __name((msg) => {
return msg.name ? cstringMessage(68, `${msg.type}${msg.name || ""}`) : msg.type === "P" ? emptyDescribePortal : emptyDescribeStatement;
}, "describe");
var close = /* @__PURE__ */ __name((msg) => {
const text = `${msg.type}${msg.name || ""}`;
return cstringMessage(67, text);
}, "close");
var copyData = /* @__PURE__ */ __name((chunk) => {
return writer.add(chunk).flush(
100
/* code.copyFromChunk */
);
}, "copyData");
var copyFail = /* @__PURE__ */ __name((message) => {
return cstringMessage(102, message);
}, "copyFail");
var codeOnlyBuffer = /* @__PURE__ */ __name((code) => Buffer.from([code, 0, 0, 0, 4]), "codeOnlyBuffer");
var flushBuffer = codeOnlyBuffer(
72
/* code.flush */
);
var syncBuffer = codeOnlyBuffer(
83
/* code.sync */
);
var endBuffer = codeOnlyBuffer(
88
/* code.end */
);
var copyDoneBuffer = codeOnlyBuffer(
99
/* code.copyDone */
);
var serialize = {
startup,
password,
requestSsl,
sendSASLInitialResponseMessage,
sendSCRAMClientFinalMessage,
query,
parse,
bind,
execute,
describe,
close,
flush: /* @__PURE__ */ __name(() => flushBuffer, "flush"),
sync: /* @__PURE__ */ __name(() => syncBuffer, "sync"),
end: /* @__PURE__ */ __name(() => endBuffer, "end"),
copyData,
copyDone: /* @__PURE__ */ __name(() => copyDoneBuffer, "copyDone"),
copyFail,
cancel
};
exports.serialize = serialize;
}
});
// ../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/buffer-reader.js
var require_buffer_reader = __commonJS({
"../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/buffer-reader.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BufferReader = void 0;
var BufferReader = class {
static {
__name(this, "BufferReader");
}
constructor(offset = 0) {
this.offset = offset;
this.buffer = Buffer.allocUnsafe(0);
this.encoding = "utf-8";
}
setBuffer(offset, buffer) {
this.offset = offset;
this.buffer = buffer;
}
int16() {
const result = this.buffer.readInt16BE(this.offset);
this.offset += 2;
return result;
}
byte() {
const result = this.buffer[this.offset];
this.offset++;
return result;
}
int32() {
const result = this.buffer.readInt32BE(this.offset);
this.offset += 4;
return result;
}
uint32() {
const result = this.buffer.readUInt32BE(this.offset);
this.offset += 4;
return result;
}
string(length) {
const result = this.buffer.toString(this.encoding, this.offset, this.offset + length);
this.offset += length;
return result;
}
cstring() {
const start = this.offset;
let end = start;
while (this.buffer[end++]) {
}
this.offset = end;
return this.buffer.toString(this.encoding, start, end - 1);
}
bytes(length) {
const result = this.buffer.slice(this.offset, this.offset + length);
this.offset += length;
return result;
}
};
exports.BufferReader = BufferReader;
}
});
// ../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/parser.js
var require_parser = __commonJS({
"../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/parser.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Parser = void 0;
var messages_1 = require_messages();
var buffer_reader_1 = require_buffer_reader();
var CODE_LENGTH = 1;
var LEN_LENGTH = 4;
var HEADER_LENGTH = CODE_LENGTH + LEN_LENGTH;
var LATEINIT_LENGTH = -1;
var emptyBuffer = Buffer.allocUnsafe(0);
var Parser = class {
static {
__name(this, "Parser");
}
constructor(opts) {
this.buffer = emptyBuffer;
this.bufferLength = 0;
this.bufferOffset = 0;
this.reader = new buffer_reader_1.BufferReader();
if ((opts === null || opts === void 0 ? void 0 : opts.mode) === "binary") {
throw new Error("Binary mode not supported yet");
}
this.mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || "text";
}
parse(buffer, callback) {
this.mergeBuffer(buffer);
const bufferFullLength = this.bufferOffset + this.bufferLength;
let offset = this.bufferOffset;
while (offset + HEADER_LENGTH <= bufferFullLength) {
const code = this.buffer[offset];
const length = this.buffer.readUInt32BE(offset + CODE_LENGTH);
const fullMessageLength = CODE_LENGTH + length;
if (fullMessageLength + offset <= bufferFullLength) {
const message = this.handlePacket(offset + HEADER_LENGTH, code, length, this.buffer);
callback(message);
offset += fullMessageLength;
} else {
break;
}
}
if (offset === bufferFullLength) {
this.buffer = emptyBuffer;
this.bufferLength = 0;
this.bufferOffset = 0;
} else {
this.bufferLength = bufferFullLength - offset;
this.bufferOffset = offset;
}
}
mergeBuffer(buffer) {
if (this.bufferLength > 0) {
const newLength = this.bufferLength + buffer.byteLength;
const newFullLength = newLength + this.bufferOffset;
if (newFullLength > this.buffer.byteLength) {
let newBuffer;
if (newLength <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) {
newBuffer = this.buffer;
} else {
let newBufferLength = this.buffer.byteLength * 2;
while (newLength >= newBufferLength) {
newBufferLength *= 2;
}
newBuffer = Buffer.allocUnsafe(newBufferLength);
}
this.buffer.copy(newBuffer, 0, this.bufferOffset, this.bufferOffset + this.bufferLength);
this.buffer = newBuffer;
this.bufferOffset = 0;
}
buffer.copy(this.buffer, this.bufferOffset + this.bufferLength);
this.bufferLength = newLength;
} else {
this.buffer = buffer;
this.bufferOffset = 0;
this.bufferLength = buffer.byteLength;
}
}
handlePacket(offset, code, length, bytes) {
const { reader } = this;
reader.setBuffer(offset, bytes);
let message;
switch (code) {
case 50:
message = messages_1.bindComplete;
break;
case 49:
message = messages_1.parseComplete;
break;
case 51:
message = messages_1.closeComplete;
break;
case 110:
message = messages_1.noData;
break;
case 115:
message = messages_1.portalSuspended;
break;
case 99:
message = messages_1.copyDone;
break;
case 87:
message = messages_1.replicationStart;
break;
case 73:
message = messages_1.emptyQuery;
break;
case 68:
message = parseDataRowMessage(reader);
break;
case 67:
message = parseCommandCompleteMessage(reader);
break;
case 90:
message = parseReadyForQueryMessage(reader);
break;
case 65:
message = parseNotificationMessage(reader);
break;
case 82:
message = parseAuthenticationResponse(reader, length);
break;
case 83:
message = parseParameterStatusMessage(reader);
break;
case 75:
message = parseBackendKeyData(reader);
break;
case 69:
message = parseErrorMessage(reader, "error");
break;
case 78:
message = parseErrorMessage(reader, "notice");
break;
case 84:
message = parseRowDescriptionMessage(reader);
break;
case 116:
message = parseParameterDescriptionMessage(reader);
break;
case 71:
message = parseCopyInMessage(reader);
break;
case 72:
message = parseCopyOutMessage(reader);
break;
case 100:
message = parseCopyData(reader, length);
break;
default:
return new messages_1.DatabaseError("received invalid response: " + code.toString(16), length, "error");
}
reader.setBuffer(0, emptyBuffer);
message.length = length;
return message;
}
};
exports.Parser = Parser;
var parseReadyForQueryMessage = /* @__PURE__ */ __name((reader) => {
const status = reader.string(1);
return new messages_1.ReadyForQueryMessage(LATEINIT_LENGTH, status);
}, "parseReadyForQueryMessage");
var parseCommandCompleteMessage = /* @__PURE__ */ __name((reader) => {
const text = reader.cstring();
return new messages_1.CommandCompleteMessage(LATEINIT_LENGTH, text);
}, "parseCommandCompleteMessage");
var parseCopyData = /* @__PURE__ */ __name((reader, length) => {
const chunk = reader.bytes(length - 4);
return new messages_1.CopyDataMessage(LATEINIT_LENGTH, chunk);
}, "parseCopyData");
var parseCopyInMessage = /* @__PURE__ */ __name((reader) => parseCopyMessage(reader, "copyInResponse"), "parseCopyInMessage");
var parseCopyOutMessage = /* @__PURE__ */ __name((reader) => parseCopyMessage(reader, "copyOutResponse"), "parseCopyOutMessage");
var parseCopyMessage = /* @__PURE__ */ __name((reader, messageName) => {
const isBinary = reader.byte() !== 0;
const columnCount = reader.int16();
const message = new messages_1.CopyResponse(LATEINIT_LENGTH, messageName, isBinary, columnCount);
for (let i = 0; i < columnCount; i++) {
message.columnTypes[i] = reader.int16();
}
return message;
}, "parseCopyMessage");
var parseNotificationMessage = /* @__PURE__ */ __name((reader) => {
const processId = reader.int32();
const channel = reader.cstring();
const payload = reader.cstring();
return new messages_1.NotificationResponseMessage(LATEINIT_LENGTH, processId, channel, payload);
}, "parseNotificationMessage");
var parseRowDescriptionMessage = /* @__PURE__ */ __name((reader) => {
const fieldCount = reader.int16();
const message = new messages_1.RowDescriptionMessage(LATEINIT_LENGTH, fieldCount);
for (let i = 0; i < fieldCount; i++) {
message.fields[i] = parseField(reader);
}
return message;
}, "parseRowDescriptionMessage");
var parseField = /* @__PURE__ */ __name((reader) => {
const name = reader.cstring();
const tableID = reader.uint32();
const columnID = reader.int16();
const dataTypeID = reader.uint32();
const dataTypeSize = reader.int16();
const dataTypeModifier = reader.int32();
const mode = reader.int16() === 0 ? "text" : "binary";
return new messages_1.Field(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, mode);
}, "parseField");
var parseParameterDescriptionMessage = /* @__PURE__ */ __name((reader) => {
const parameterCount = reader.int16();
const message = new messages_1.ParameterDescriptionMessage(LATEINIT_LENGTH, parameterCount);
for (let i = 0; i < parameterCount; i++) {
message.dataTypeIDs[i] = reader.uint32();
}
return message;
}, "parseParameterDescriptionMessage");
var parseDataRowMessage = /* @__PURE__ */ __name((reader) => {
const fieldCount = reader.int16();
const fields = new Array(fieldCount);
for (let i = 0; i < fieldCount; i++) {
const len = reader.int32();
fields[i] = len === -1 ? null : reader.string(len);
}
return new messages_1.DataRowMessage(LATEINIT_LENGTH, fields);
}, "parseDataRowMessage");
var parseParameterStatusMessage = /* @__PURE__ */ __name((reader) => {
const name = reader.cstring();
const value = reader.cstring();
return new messages_1.ParameterStatusMessage(LATEINIT_LENGTH, name, value);
}, "parseParameterStatusMessage");
var parseBackendKeyData = /* @__PURE__ */ __name((reader) => {
const processID = reader.int32();
const secretKey = reader.int32();
return new messages_1.BackendKeyDataMessage(LATEINIT_LENGTH, processID, secretKey);
}, "parseBackendKeyData");
var parseAuthenticationResponse = /* @__PURE__ */ __name((reader, length) => {
const code = reader.int32();
const message = {
name: "authenticationOk",
length
};
switch (code) {
case 0:
break;
case 3:
if (message.length === 8) {
message.name = "authenticationCleartextPassword";
}
break;
case 5:
if (message.length === 12) {
message.name = "authenticationMD5Password";
const salt = reader.bytes(4);
return new messages_1.AuthenticationMD5Password(LATEINIT_LENGTH, salt);
}
break;
case 10:
{
message.name = "authenticationSASL";
message.mechanisms = [];
let mechanism;
do {
mechanism = reader.cstring();
if (mechanism) {
message.mechanisms.push(mechanism);
}
} while (mechanism);
}
break;
case 11:
message.name = "authenticationSASLContinue";
message.data = reader.string(length - 8);
break;
case 12:
message.name = "authenticationSASLFinal";
message.data = reader.string(length - 8);
break;
default:
throw new Error("Unknown authenticationOk message type " + code);
}
return message;
}, "parseAuthenticationResponse");
var parseErrorMessage = /* @__PURE__ */ __name((reader, name) => {
const fields = {};
let fieldType = reader.string(1);
while (fieldType !== "\0") {
fields[fieldType] = reader.cstring();
fieldType = reader.string(1);
}
const messageValue = fields.M;
const message = name === "notice" ? new messages_1.NoticeMessage(LATEINIT_LENGTH, messageValue) : new messages_1.DatabaseError(messageValue, LATEINIT_LENGTH, name);
message.severity = fields.S;
message.code = fields.C;
message.detail = fields.D;
message.hint = fields.H;
message.position = fields.P;
message.internalPosition = fields.p;
message.internalQuery = fields.q;
message.where = fields.W;
message.schema = fields.s;
message.table = fields.t;
message.column = fields.c;
message.dataType = fields.d;
message.constraint = fields.n;
message.file = fields.F;
message.line = fields.L;
message.routine = fields.R;
return message;
}, "parseErrorMessage");
}
});
// ../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/index.js
var require_dist = __commonJS({
"../../node_modules/.pnpm/pg-protocol@1.16.1/node_modules/pg-protocol/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatabaseError = exports.serialize = void 0;
exports.parse = parse;
var messages_1 = require_messages();
Object.defineProperty(exports, "DatabaseError", { enumerable: true, get: /* @__PURE__ */ __name(function() {
return messages_1.DatabaseError;
}, "get") });
var serializer_1 = require_serializer();
Object.defineProperty(exports, "serialize", { enumerable: true, get: /* @__PURE__ */ __name(function() {
return serializer_1.serialize;
}, "get") });
var parser_1 = require_parser();
function parse(stream, callback) {
const parser = new parser_1.Parser();
stream.on("data", (buffer) => parser.parse(buffer, callback));
return new Promise((resolve) => stream.on("end", () => resolve()));
}
__name(parse, "parse");
}
});
// ../../node_modules/.pnpm/pg-cloudflare@1.4.1/node_modules/pg-cloudflare/dist/empty.js
var require_empty = __commonJS({
"../../node_modules/.pnpm/pg-cloudflare@1.4.1/node_modules/pg-cloudflare/dist/empty.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = {};
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/stream.js
var require_stream = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/stream.js"(exports, module) {
var { getStream, getSecureStream } = getStreamFuncs();
module.exports = {
/**
* Get a socket stream compatible with the current runtime environment.
* @returns {Duplex}
*/
getStream,
/**
* Get a TLS secured socket, compatible with the current environment,
* using the socket and other settings given in `options`.
* @returns {Duplex}
*/
getSecureStream
};
function getNodejsStreamFuncs() {
function getStream2(ssl) {
const net = __require("net");
return new net.Socket();
}
__name(getStream2, "getStream");
function getSecureStream2(options) {
const tls = __require("tls");
return tls.connect(options);
}
__name(getSecureStream2, "getSecureStream");
return {
getStream: getStream2,
getSecureStream: getSecureStream2
};
}
__name(getNodejsStreamFuncs, "getNodejsStreamFuncs");
function getCloudflareStreamFuncs() {
function getStream2(ssl) {
const { CloudflareSocket } = require_empty();
return new CloudflareSocket(ssl);
}
__name(getStream2, "getStream");
function getSecureStream2(options) {
options.socket.startTls(options);
return options.socket;
}
__name(getSecureStream2, "getSecureStream");
return {
getStream: getStream2,
getSecureStream: getSecureStream2
};
}
__name(getCloudflareStreamFuncs, "getCloudflareStreamFuncs");
function isCloudflareRuntime() {
if (typeof navigator === "object" && navigator !== null && typeof navigator.userAgent === "string") {
return navigator.userAgent === "Cloudflare-Workers";
}
if (typeof Response === "function") {
const resp = new Response(null, { cf: { thing: true } });
if (typeof resp.cf === "object" && resp.cf !== null && resp.cf.thing) {
return true;
}
}
return false;
}
__name(isCloudflareRuntime, "isCloudflareRuntime");
function getStreamFuncs() {
if (isCloudflareRuntime()) {
return getCloudflareStreamFuncs();
}
return getNodejsStreamFuncs();
}
__name(getStreamFuncs, "getStreamFuncs");
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/connection.js
var require_connection = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/connection.js"(exports, module) {
"use strict";
var EventEmitter = __require("events").EventEmitter;
var { parse, serialize } = require_dist();
var stream = require_stream();
var { getStream } = stream;
var flushBuffer = serialize.flush();
var syncBuffer = serialize.sync();
var endBuffer = serialize.end();
var Connection2 = class extends EventEmitter {
static {
__name(this, "Connection");
}
constructor(config) {
super();
config = config || {};
this.stream = config.stream || getStream(config.ssl);
if (typeof this.stream === "function") {
this.stream = this.stream(config);
}
this._keepAlive = config.keepAlive;
this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis;
this.parsedStatements = {};
this.submittedNamedStatements = {};
this.ssl = config.ssl || false;
this.sslNegotiation = config.sslNegotiation || "postgres";
this._ending = false;
this._emitMessage = false;
const self = this;
this.on("newListener", function(eventName) {
if (eventName === "message") {
self._emitMessage = true;
}
});
}
connect(port, host) {
const self = this;
this._connecting = true;
this.stream.setNoDelay(true);
this.stream.connect(port, host);
this.stream.once("connect", function() {
if (self._keepAlive) {
self.stream.setKeepAlive(true, self._keepAliveInitialDelayMillis);
}
self.emit("connect");
});
const reportStreamError = /* @__PURE__ */ __name(function(error) {
if (self._ending && (error.code === "ECONNRESET" || error.code === "EPIPE")) {
return;
}
self.emit("error", error);
}, "reportStreamError");
this.stream.on("error", reportStreamError);
this.stream.on("close", function() {
self.emit("end");
});
if (!this.ssl) {
return this.attachListeners(this.stream);
}
if (this.sslNegotiation === "direct") {
return this.stream.once("connect", function() {
self.upgradeToSSL(host, reportStreamError);
});
}
this.stream.once("data", function(buffer) {
const responseCode = buffer.toString("utf8");
switch (responseCode) {
case "S":
break;
case "N":
self.stream.end();
return self.emit("error", new Error("The server does not support SSL connections"));
default:
self.stream.end();
return self.emit("error", new Error("There was an error establishing an SSL connection"));
}
self.upgradeToSSL(host, reportStreamError);
});
}
upgradeToSSL(host, reportStreamError) {
const self = this;
const options = {
socket: self.stream,
// tls.connect checks the server identity against `servername`, falling
// back to `host` and then to 'localhost'. `servername` must stay unset
// for IP addresses (see below), so `host` is needed to keep certificate
// validation working when connecting to an IP address.
host
};
if (self.ssl !== true) {
Object.assign(options, self.ssl);
if ("key" in self.ssl) {
options.key = self.ssl.key;
}
}
if (self.sslNegotiation === "direct") {
options.ALPNProtocols = ["postgresql"];
}
const net = __require("net");
if (net.isIP && net.isIP(host) === 0) {
options.servername = host;
}
try {
self.stream = stream.getSecureStream(options);
} catch (err) {
return self.emit("error", err);
}
self.attachListeners(self.stream);
self.stream.on("error", reportStreamError);
self.emit("sslconnect");
}
attachListeners(stream2) {
parse(stream2, (msg) => {
const eventName = msg.name === "error" ? "errorMessage" : msg.name;
if (this._emitMessage) {
this.emit("message", msg);
}
this.emit(eventName, msg);
});
}
requestSsl() {
this.stream.write(serialize.requestSsl());
}
startup(config) {
this.stream.write(serialize.startup(config));
}
cancel(processID, secretKey) {
this._send(serialize.cancel(processID, secretKey));
}
password(password) {
this._send(serialize.password(password));
}
sendSASLInitialResponseMessage(mechanism, initialResponse) {
this._send(serialize.sendSASLInitialResponseMessage(mechanism, initialResponse));
}
sendSCRAMClientFinalMessage(additionalData) {
this._send(serialize.sendSCRAMClientFinalMessage(additionalData));
}
_send(buffer) {
if (!this.stream.writable) {
return false;
}
return this.stream.write(buffer);
}
query(text) {
this._send(serialize.query(text));
}
// send parse message
parse(query) {
this._send(serialize.parse(query));
}
// send bind message
bind(config) {
this._send(serialize.bind(config));
}
// send execute message
execute(config) {
this._send(serialize.execute(config));
}
flush() {
if (this.stream.writable) {
this.stream.write(flushBuffer);
}
}
sync() {
this._send(syncBuffer);
}
ref() {
this.stream.ref();
}
unref() {
this.stream.unref();
}
end() {
this._ending = true;
if (!this._connecting || !this.stream.writable) {
this.stream.end();
return;
}
return this.stream.write(endBuffer, () => {
this.stream.end();
});
}
close(msg) {
this._send(serialize.close(msg));
}
describe(msg) {
this._send(serialize.describe(msg));
}
sendCopyFromChunk(chunk) {
this._send(serialize.copyData(chunk));
}
endCopyFrom() {
this._send(serialize.copyDone());
}
sendCopyFail(msg) {
this._send(serialize.copyFail(msg));
}
};
module.exports = Connection2;
}
});
// ../../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js
var require_split2 = __commonJS({
"../../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js"(exports, module) {
"use strict";
var { Transform } = __require("stream");
var { StringDecoder } = __require("string_decoder");
var kLast = /* @__PURE__ */ Symbol("last");
var kDecoder = /* @__PURE__ */ Symbol("decoder");
function transform(chunk, enc, cb) {
let list;
if (this.overflow) {
const buf = this[kDecoder].write(chunk);
list = buf.split(this.matcher);
if (list.length === 1) return cb();
list.shift();
this.overflow = false;
} else {
this[kLast] += this[kDecoder].write(chunk);
list = this[kLast].split(this.matcher);
}
this[kLast] = list.pop();
for (let i = 0; i < list.length; i++) {
try {
push(this, this.mapper(list[i]));
} catch (error) {
return cb(error);
}
}
this.overflow = this[kLast].length > this.maxLength;
if (this.overflow && !this.skipOverflow) {
cb(new Error("maximum buffer reached"));
return;
}
cb();
}
__name(transform, "transform");
function flush(cb) {
this[kLast] += this[kDecoder].end();
if (this[kLast]) {
try {
push(this, this.mapper(this[kLast]));
} catch (error) {
return cb(error);
}
}
cb();
}
__name(flush, "flush");
function push(self, val) {
if (val !== void 0) {
self.push(val);
}
}
__name(push, "push");
function noop(incoming) {
return incoming;
}
__name(noop, "noop");
function split(matcher, mapper, options) {
matcher = matcher || /\r?\n/;
mapper = mapper || noop;
options = options || {};
switch (arguments.length) {
case 1:
if (typeof matcher === "function") {
mapper = matcher;
matcher = /\r?\n/;
} else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
options = matcher;
matcher = /\r?\n/;
}
break;
case 2:
if (typeof matcher === "function") {
options = mapper;
mapper = matcher;
matcher = /\r?\n/;
} else if (typeof mapper === "object") {
options = mapper;
mapper = noop;
}
}
options = Object.assign({}, options);
options.autoDestroy = true;
options.transform = transform;
options.flush = flush;
options.readableObjectMode = true;
const stream = new Transform(options);
stream[kLast] = "";
stream[kDecoder] = new StringDecoder("utf8");
stream.matcher = matcher;
stream.mapper = mapper;
stream.maxLength = options.maxLength;
stream.skipOverflow = options.skipOverflow || false;
stream.overflow = false;
stream._destroy = function(err, cb) {
this._writableState.errorEmitted = false;
cb(err);
};
return stream;
}
__name(split, "split");
module.exports = split;
}
});
// ../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/helper.js
var require_helper = __commonJS({
"../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/helper.js"(exports, module) {
"use strict";
var path = __require("path");
var Stream = __require("stream").Stream;
var split = require_split2();
var util = __require("util");
var defaultPort = 5432;
var isWin = process.platform === "win32";
var warnStream = process.stderr;
var S_IRWXG = 56;
var S_IRWXO = 7;
var S_IFMT = 61440;
var S_IFREG = 32768;
function isRegFile(mode) {
return (mode & S_IFMT) == S_IFREG;
}
__name(isRegFile, "isRegFile");
var fieldNames = ["host", "port", "database", "user", "password"];
var nrOfFields = fieldNames.length;
var passKey = fieldNames[nrOfFields - 1];
function warn() {
var isWritable = warnStream instanceof Stream && true === warnStream.writable;
if (isWritable) {
var args = Array.prototype.slice.call(arguments).concat("\n");
warnStream.write(util.format.apply(util, args));
}
}
__name(warn, "warn");
Object.defineProperty(module.exports, "isWin", {
get: /* @__PURE__ */ __name(function() {
return isWin;
}, "get"),
set: /* @__PURE__ */ __name(function(val) {
isWin = val;
}, "set")
});
module.exports.warnTo = function(stream) {
var old = warnStream;
warnStream = stream;
return old;
};
module.exports.getFileName = function(rawEnv) {
var env = rawEnv || process.env;
var file = env.PGPASSFILE || (isWin ? path.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path.join(env.HOME || "./", ".pgpass"));
return file;
};
module.exports.usePgPass = function(stats, fname) {
if (Object.prototype.hasOwnProperty.call(process.env, "PGPASSWORD")) {
return false;
}
if (isWin) {
return true;
}
fname = fname || "<unkn>";
if (!isRegFile(stats.mode)) {
warn('WARNING: password file "%s" is not a plain file', fname);
return false;
}
if (stats.mode & (S_IRWXG | S_IRWXO)) {
warn('WARNING: password file "%s" has group or world access; permissions should be u=rw (0600) or less', fname);
return false;
}
return true;
};
var matcher = module.exports.match = function(connInfo, entry) {
return fieldNames.slice(0, -1).reduce(function(prev, field, idx) {
if (idx == 1) {
if (Number(connInfo[field] || defaultPort) === Number(entry[field])) {
return prev && true;
}
}
return prev && (entry[field] === "*" || entry[field] === connInfo[field]);
}, true);
};
module.exports.getPassword = function(connInfo, stream, cb) {
var pass;
var lineStream = stream.pipe(split());
function onLine(line) {
var entry = parseLine(line);
if (entry && isValidEntry(entry) && matcher(connInfo, entry)) {
pass = entry[passKey];
lineStream.end();
}
}
__name(onLine, "onLine");
var onEnd = /* @__PURE__ */ __name(function() {
stream.destroy();
cb(pass);
}, "onEnd");
var onErr = /* @__PURE__ */ __name(function(err) {
stream.destroy();
warn("WARNING: error on reading file: %s", err);
cb(void 0);
}, "onErr");
stream.on("error", onErr);
lineStream.on("data", onLine).on("end", onEnd).on("error", onErr);
};
var parseLine = module.exports.parseLine = function(line) {
if (line.length < 11 || line.match(/^\s+#/)) {
return null;
}
var curChar = "";
var prevChar = "";
var fieldIdx = 0;
var startIdx = 0;
var endIdx = 0;
var obj = {};
var isLastField = false;
var addToObj = /* @__PURE__ */ __name(function(idx, i0, i1) {
var field = line.substring(i0, i1);
if (!Object.hasOwnProperty.call(process.env, "PGPASS_NO_DEESCAPE")) {
field = field.replace(/\\([:\\])/g, "$1");
}
obj[fieldNames[idx]] = field;
}, "addToObj");
for (var i = 0; i < line.length - 1; i += 1) {
curChar = line.charAt(i + 1);
prevChar = line.charAt(i);
isLastField = fieldIdx == nrOfFields - 1;
if (isLastField) {
addToObj(fieldIdx, startIdx);
break;
}
if (i >= 0 && curChar == ":" && prevChar !== "\\") {
addToObj(fieldIdx, startIdx, i + 1);
startIdx = i + 2;
fieldIdx += 1;
}
}
obj = Object.keys(obj).length === nrOfFields ? obj : null;
return obj;
};
var isValidEntry = module.exports.isValidEntry = function(entry) {
var rules = {
// host
0: function(x) {
return x.length > 0;
},
// port
1: function(x) {
if (x === "*") {
return true;
}
x = Number(x);
return isFinite(x) && x > 0 && x < 9007199254740992 && Math.floor(x) === x;
},
// database
2: function(x) {
return x.length > 0;
},
// username
3: function(x) {
return x.length > 0;
},
// password
4: function(x) {
return x.length > 0;
}
};
for (var idx = 0; idx < fieldNames.length; idx += 1) {
var rule = rules[idx];
var value = entry[fieldNames[idx]] || "";
var res = rule(value);
if (!res) {
return false;
}
}
return true;
};
}
});
// ../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/index.js
var require_lib = __commonJS({
"../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/index.js"(exports, module) {
"use strict";
var path = __require("path");
var fs = __require("fs");
var helper = require_helper();
module.exports = function(connInfo, cb) {
var file = helper.getFileName();
fs.stat(file, function(err, stat) {
if (err || !helper.usePgPass(stat, file)) {
return cb(void 0);
}
var st = fs.createReadStream(file);
helper.getPassword(connInfo, st, cb);
});
};
module.exports.warnTo = helper.warnTo;
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/client.js
var require_client = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/client.js"(exports, module) {
var EventEmitter = __require("events").EventEmitter;
var utils = require_utils();
var nodeUtils = __require("util");
var sasl = require_sasl();
var TypeOverrides2 = require_type_overrides();
var ConnectionParameters = require_connection_parameters();
var Query2 = require_query();
var defaults2 = require_defaults();
var Connection2 = require_connection();
var crypto = require_utils2();
var activeQueryDeprecationNotice = nodeUtils.deprecate(
() => {
},
"Client.activeQuery is deprecated and will be removed in pg@9.0"
);
var queryQueueDeprecationNotice = nodeUtils.deprecate(
() => {
},
"Client.queryQueue is deprecated and will be removed in pg@9.0."
);
var pgPassDeprecationNotice = nodeUtils.deprecate(
() => {
},
"pgpass support is deprecated and will be removed in pg@9.0. You can provide an async function as the password property to the Client/Pool constructor that returns a password instead. Within this function you can call the pgpass module in your own code."
);
var byoPromiseDeprecationNotice = nodeUtils.deprecate(
() => {
},
"Passing a custom Promise implementation to the Client/Pool constructor is deprecated and will be removed in pg@9.0."
);
var queryQueueLengthDeprecationNotice = nodeUtils.deprecate(
() => {
},
"Calling client.query() when the client is already executing a query is deprecated and will be removed in pg@9.0. Use async/await or an external async flow control mechanism instead."
);
function coerceNumberOrDefault(value, defaultValue) {
if (typeof value === "number") {
return Number.isFinite(value) ? value : defaultValue;
}
if (typeof value === "string" && value.trim() !== "") {
const n = Number(value);
return Number.isFinite(n) ? n : defaultValue;
}
return defaultValue;
}
__name(coerceNumberOrDefault, "coerceNumberOrDefault");
var Client2 = class extends EventEmitter {
static {
__name(this, "Client");
}
constructor(config) {
super();
this.connectionParameters = new ConnectionParameters(config);
this.user = this.connectionParameters.user;
this.database = this.connectionParameters.database;
this.port = this.connectionParameters.port;
this.host = this.connectionParameters.host;
Object.defineProperty(this, "password", {
configurable: true,
enumerable: false,
writable: true,
value: this.connectionParameters.password
});
this.replication = this.connectionParameters.replication;
const c = config || {};
if (c.Promise) {
byoPromiseDeprecationNotice();
}
this._Promise = c.Promise || global.Promise;
this._types = new TypeOverrides2(c.types);
this._ending = false;
this._ended = false;
this._connecting = false;
this._connected = false;
this._connectionError = false;
this._queryable = true;
this._activeQuery = null;
this._txStatus = null;
this.enableChannelBinding = Boolean(c.enableChannelBinding);
this.scramMaxIterations = coerceNumberOrDefault(c.scramMaxIterations, sasl.DEFAULT_MAX_SCRAM_ITERATIONS);
this.connection = c.connection || new Connection2({
stream: c.stream,
ssl: this.connectionParameters.ssl,
sslNegotiation: this.connectionParameters.sslnegotiation,
keepAlive: c.keepAlive || false,
keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
encoding: this.connectionParameters.client_encoding || "utf8"
});
this._queryQueue = [];
this._sentQueryQueue = [];
this.pipeline = Boolean(c.pipeline);
this.binary = c.binary || defaults2.binary;
this.processID = null;
this.secretKey = null;
this.ssl = this.connectionParameters.ssl || false;
this.sslNegotiation = this.connectionParameters.sslnegotiation || "postgres";
if (this.ssl && this.ssl.key) {
Object.defineProperty(this.ssl, "key", {
enumerable: false
});
}
this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0;
}
get activeQuery() {
activeQueryDeprecationNotice();
return this._activeQuery;
}
set activeQuery(val) {
activeQueryDeprecationNotice();
this._activeQuery = val;
}
_getActiveQuery() {
return this._activeQuery;
}
_errorAllQueries(err) {
const enqueueError = /* @__PURE__ */ __name((query) => {
process.nextTick(() => {
query.handleError(err, this.connection);
});
}, "enqueueError");
const activeQuery = this._getActiveQuery();
if (activeQuery) {
enqueueError(activeQuery);
this._activeQuery = null;
}
this._sentQueryQueue.forEach(enqueueError);
this._sentQueryQueue.length = 0;
this._queryQueue.forEach(enqueueError);
this._queryQueue.length = 0;
}
_connect(callback) {
const self = this;
const con = this.connection;
this._connectionCallback = callback;
if (this._connecting || this._connected) {
const err = new Error("Client has already been connected. You cannot reuse a client.");
process.nextTick(() => {
callback(err);
});
return;
}
this._connecting = true;
if (this._connectionTimeoutMillis > 0) {
this.connectionTimeoutHandle = setTimeout(() => {
con._ending = true;
con.stream.destroy(new Error("timeout expired"));
}, this._connectionTimeoutMillis);
if (this.connectionTimeoutHandle.unref) {
this.connectionTimeoutHandle.unref();
}
}
if (this.host && this.host.indexOf("/") === 0) {
con.connect(this.host + "/.s.PGSQL." + this.port);
} else {
con.connect(this.port, this.host);
}
con.on("connect", function() {
if (self.ssl) {
if (self.sslNegotiation !== "direct") {
con.requestSsl();
}
} else {
con.startup(self.getStartupConf());
}
});
con.on("sslconnect", function() {
con.startup(self.getStartupConf());
});
this._attachListeners(con);
con.once("end", () => {
const error = this._ending ? new Error("Connection terminated") : new Error("Connection terminated unexpectedly");
clearTimeout(this.connectionTimeoutHandle);
this._errorAllQueries(error);
this._ended = true;
if (!this._ending) {
if (this._connecting && !this._connectionError) {
if (this._connectionCallback) {
this._connectionCallback(error);
} else {
this._handleErrorEvent(error);
}
} else if (!this._connectionError) {
this._handleErrorEvent(error);
}
}
process.nextTick(() => {
this.emit("end");
});
});
}
connect(callback) {
if (callback) {
this._connect(callback);
return;
}
return new this._Promise((resolve, reject) => {
this._connect((error) => {
if (error) {
reject(error);
} else {
resolve(this);
}
});
});
}
_attachListeners(con) {
con.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this));
con.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this));
con.on("authenticationSASL", this._handleAuthSASL.bind(this));
con.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this));
con.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this));
con.on("backendKeyData", this._handleBackendKeyData.bind(this));
con.on("error", this._handleErrorEvent.bind(this));
con.on("errorMessage", this._handleErrorMessage.bind(this));
con.on("readyForQuery", this._handleReadyForQuery.bind(this));
con.on("notice", this._handleNotice.bind(this));
con.on("rowDescription", this._handleRowDescription.bind(this));
con.on("dataRow", this._handleDataRow.bind(this));
con.on("portalSuspended", this._handlePortalSuspended.bind(this));
con.on("emptyQuery", this._handleEmptyQuery.bind(this));
con.on("commandComplete", this._handleCommandComplete.bind(this));
con.on("parseComplete", this._handleParseComplete.bind(this));
con.on("copyInResponse", this._handleCopyInResponse.bind(this));
con.on("copyData", this._handleCopyData.bind(this));
con.on("notification", this._handleNotification.bind(this));
}
_getPassword(cb) {
const con = this.connection;
if (typeof this.password === "function") {
this._Promise.resolve().then(() => this.password(this.connectionParameters)).then((pass) => {
if (pass !== void 0) {
if (typeof pass !== "string") {
con.emit("error", new TypeError("Password must be a string"));
return;
}
this.connectionParameters.password = this.password = pass;
} else {
this.connectionParameters.password = this.password = null;
}
cb();
}).catch((err) => {
con.emit("error", err);
});
} else if (this.password !== null) {
cb();
} else {
try {
const pgPass = require_lib();
pgPass(this.connectionParameters, (pass) => {
if (void 0 !== pass) {
pgPassDeprecationNotice();
this.connectionParameters.password = this.password = pass;
}
cb();
});
} catch (e) {
this.emit("error", e);
}
}
}
_handleAuthCleartextPassword(msg) {
this._getPassword(() => {
this.connection.password(this.password);
});
}
_handleAuthMD5Password(msg) {
this._getPassword(async () => {
try {
const hashedPassword = await crypto.postgresMd5PasswordHash(this.user, this.password, msg.salt);
this.connection.password(hashedPassword);
} catch (e) {
this.emit("error", e);
}
});
}
_handleAuthSASL(msg) {
this._getPassword(() => {
try {
this.saslSession = sasl.startSession(
msg.mechanisms,
this.enableChannelBinding && this.connection.stream,
this.scramMaxIterations
);
this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response);
} catch (err) {
this.connection.emit("error", err);
}
});
}
async _handleAuthSASLContinue(msg) {
try {
await sasl.continueSession(
this.saslSession,
this.password,
msg.data,
this.enableChannelBinding && this.connection.stream
);
this.connection.sendSCRAMClientFinalMessage(this.saslSession.response);
} catch (err) {
this.connection.emit("error", err);
}
}
_handleAuthSASLFinal(msg) {
try {
sasl.finalizeSession(this.saslSession, msg.data);
this.saslSession = null;
} catch (err) {
this.connection.emit("error", err);
}
}
_handleBackendKeyData(msg) {
this.processID = msg.processID;
this.secretKey = msg.secretKey;
}
_handleReadyForQuery(msg) {
if (this._connecting) {
this._connecting = false;
this._connected = true;
clearTimeout(this.connectionTimeoutHandle);
if (this._connectionCallback) {
this._connectionCallback(null, this);
this._connectionCallback = null;
}
this.emit("connect");
}
const activeQuery = this._getActiveQuery();
this._activeQuery = null;
this._txStatus = msg?.status ?? null;
this.readyForQuery = true;
if (activeQuery) {
activeQuery.handleReadyForQuery(this.connection);
}
this._pulseQueryQueue();
}
// if we receive an error event or error message
// during the connection process we handle it here
_handleErrorWhileConnecting(err) {
if (this._connectionError) {
return;
}
this._connectionError = true;
clearTimeout(this.connectionTimeoutHandle);
if (this._connectionCallback) {
return this._connectionCallback(err);
}
this.emit("error", err);
}
// if we're connected and we receive an error event from the connection
// this means the socket is dead - do a hard abort of all queries and emit
// the socket error on the client as well
_handleErrorEvent(err) {
if (this._connecting) {
return this._handleErrorWhileConnecting(err);
}
this._queryable = false;
this._errorAllQueries(err);
this.emit("error", err);
}
// handle error messages from the postgres backend
_handleErrorMessage(msg) {
if (this._connecting) {
return this._handleErrorWhileConnecting(msg);
}
const activeQuery = this._getActiveQuery();
if (!activeQuery) {
this._handleErrorEvent(msg);
return;
}
this._activeQuery = null;
if (activeQuery.name) {
delete this.connection.submittedNamedStatements[activeQuery.name];
}
activeQuery.handleError(msg, this.connection);
}
_handleRowDescription(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected rowDescription message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handleRowDescription(msg);
}
_handleDataRow(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected dataRow message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handleDataRow(msg);
}
_handlePortalSuspended(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected portalSuspended message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handlePortalSuspended(this.connection);
}
_handleEmptyQuery(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected emptyQuery message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handleEmptyQuery(this.connection);
}
_handleCommandComplete(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected commandComplete message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handleCommandComplete(msg, this.connection);
}
_handleParseComplete() {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected parseComplete message from backend.");
this._handleErrorEvent(error);
return;
}
if (activeQuery.name) {
this.connection.parsedStatements[activeQuery.name] = activeQuery.text;
delete this.connection.submittedNamedStatements[activeQuery.name];
}
}
_handleCopyInResponse(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected copyInResponse message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handleCopyInResponse(this.connection);
}
_handleCopyData(msg) {
const activeQuery = this._getActiveQuery();
if (activeQuery == null) {
const error = new Error("Received unexpected copyData message from backend.");
this._handleErrorEvent(error);
return;
}
activeQuery.handleCopyData(msg, this.connection);
}
_handleNotification(msg) {
this.emit("notification", msg);
}
_handleNotice(msg) {
this.emit("notice", msg);
}
getStartupConf() {
const params = this.connectionParameters;
const data = {
user: params.user,
database: params.database
};
const appName = params.application_name || params.fallback_application_name;
if (appName) {
data.application_name = appName;
}
if (params.replication) {
data.replication = "" + params.replication;
}
if (params.statement_timeout) {
data.statement_timeout = String(parseInt(params.statement_timeout, 10));
}
if (params.lock_timeout) {
data.lock_timeout = String(parseInt(params.lock_timeout, 10));
}
if (params.idle_in_transaction_session_timeout) {
data.idle_in_transaction_session_timeout = String(parseInt(params.idle_in_transaction_session_timeout, 10));
}
if (params.options) {
data.options = params.options;
}
return data;
}
cancel(client, query) {
if (client.activeQuery === query) {
const con = this.connection;
if (this.host && this.host.indexOf("/") === 0) {
con.connect(this.host + "/.s.PGSQL." + this.port);
} else {
con.connect(this.port, this.host);
}
con.on("connect", function() {
con.cancel(client.processID, client.secretKey);
});
} else if (client._queryQueue.indexOf(query) !== -1) {
client._queryQueue.splice(client._queryQueue.indexOf(query), 1);
} else if (client._sentQueryQueue.indexOf(query) !== -1) {
query.callback = () => {
};
}
}
setTypeParser(oid, format, parseFn) {
return this._types.setTypeParser(oid, format, parseFn);
}
getTypeParser(oid, format) {
return this._types.getTypeParser(oid, format);
}
// escapeIdentifier and escapeLiteral moved to utility functions & exported
// on PG
// re-exported here for backwards compatibility
escapeIdentifier(str) {
return utils.escapeIdentifier(str);
}
escapeLiteral(str) {
return utils.escapeLiteral(str);
}
_pulseQueryQueue() {
if (this.pipeline) {
this._pulsePipelinedQueryQueue();
return;
}
if (this.readyForQuery === true) {
this._activeQuery = this._queryQueue.shift();
const activeQuery = this._getActiveQuery();
if (activeQuery) {
this.readyForQuery = false;
this.hasExecuted = true;
const queryError = activeQuery.submit(this.connection);
if (queryError) {
process.nextTick(() => {
activeQuery.handleError(queryError, this.connection);
this.readyForQuery = true;
this._pulseQueryQueue();
});
}
} else if (this.hasExecuted) {
this._activeQuery = null;
this.emit("drain");
}
}
}
_pulsePipelinedQueryQueue() {
if (!this._connected || !this._queryable) {
return;
}
while (this._queryQueue.length > 0) {
const query = this._queryQueue.shift();
this.hasExecuted = true;
const queryError = query.submit(this.connection);
if (queryError) {
process.nextTick(() => {
query.handleError(queryError, this.connection);
});
continue;
}
this._sentQueryQueue.push(query);
}
if (this.readyForQuery && !this._activeQuery && this._sentQueryQueue.length > 0) {
this._activeQuery = this._sentQueryQueue.shift();
this.readyForQuery = false;
}
if (!this._activeQuery && this._sentQueryQueue.length === 0 && this._queryQueue.length === 0 && this.hasExecuted) {
this.emit("drain");
}
}
query(config, values, callback) {
let query;
let result;
if (config == null) {
throw new TypeError("Client was passed a null or undefined query");
}
if (typeof config.submit === "function") {
result = query = config;
if (!query.callback) {
if (typeof values === "function") {
query.callback = values;
} else if (callback) {
query.callback = callback;
}
}
} else {
query = new Query2(config, values, callback);
if (!query.callback) {
result = new this._Promise((resolve, reject) => {
query.callback = (err, res) => err ? reject(err) : resolve(res);
}).catch((err) => {
Error.captureStackTrace(err);
throw err;
});
} else if (typeof query.callback !== "function") {
throw new TypeError("callback is not a function");
}
}
const readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
if (readTimeout) {
const queryCallback = query.callback || (() => {
});
const readTimeoutTimer = setTimeout(() => {
const error = new Error("Query read timeout");
process.nextTick(() => {
query.handleError(error, this.connection);
});
queryCallback(error);
query.callback = () => {
};
const index = this._queryQueue.indexOf(query);
if (index > -1) {
this._queryQueue.splice(index, 1);
} else if (this.pipeline) {
this.connection.stream.destroy();
return;
}
this._pulseQueryQueue();
}, readTimeout);
query.callback = (err, res) => {
clearTimeout(readTimeoutTimer);
queryCallback(err, res);
};
}
if (this.binary && !query.binary) {
query.binary = true;
}
if (query._result && !query._result._types) {
query._result._types = this._types;
}
if (this.pipeline) {
const portalQuery = typeof config.submit === "function" && !(query instanceof Query2) ? "Custom query classes such as pg-cursor and pg-query-stream are" : query.rows ? "The `rows` option is" : null;
if (portalQuery) {
process.nextTick(() => {
query.handleError(new Error(`${portalQuery} not supported in pipeline mode`), this.connection);
});
return result;
}
}
if (!this._queryable) {
process.nextTick(() => {
query.handleError(new Error("Client has encountered a connection error and is not queryable"), this.connection);
});
return result;
}
if (this._ending) {
process.nextTick(() => {
query.handleError(new Error("Client was closed and is not queryable"), this.connection);
});
return result;
}
if (this._queryQueue.length > 0 && !this.pipeline) {
queryQueueLengthDeprecationNotice();
}
this._queryQueue.push(query);
this._pulseQueryQueue();
return result;
}
ref() {
this.connection.ref();
}
unref() {
this.connection.unref();
}
getTransactionStatus() {
return this._txStatus;
}
end(cb) {
this._ending = true;
if (!this.connection._connecting || this._ended) {
if (cb) {
cb();
return;
} else {
return this._Promise.resolve();
}
}
if (!this._queryable) {
this.connection.stream.destroy();
} else if (this.pipeline && (this._getActiveQuery() || this._sentQueryQueue.length > 0 || this._queryQueue.length > 0)) {
this.once("drain", () => this.connection.end());
} else if (this._getActiveQuery()) {
this.connection.stream.destroy();
} else {
this.connection.end();
}
if (cb) {
this.connection.once("end", cb);
} else {
return new this._Promise((resolve) => {
this.connection.once("end", resolve);
});
}
}
get queryQueue() {
queryQueueDeprecationNotice();
return this._queryQueue;
}
};
Client2.Query = Query2;
module.exports = Client2;
}
});
// ../../node_modules/.pnpm/pg-pool@3.14.0_pg@8.23.1/node_modules/pg-pool/index.js
var require_pg_pool = __commonJS({
"../../node_modules/.pnpm/pg-pool@3.14.0_pg@8.23.1/node_modules/pg-pool/index.js"(exports, module) {
"use strict";
var EventEmitter = __require("events").EventEmitter;
var NOOP = /* @__PURE__ */ __name(function() {
}, "NOOP");
var removeWhere = /* @__PURE__ */ __name((list, predicate) => {
const i = list.findIndex(predicate);
return i === -1 ? void 0 : list.splice(i, 1)[0];
}, "removeWhere");
var IdleItem = class {
static {
__name(this, "IdleItem");
}
constructor(client, idleListener, timeoutId) {
this.client = client;
this.idleListener = idleListener;
this.timeoutId = timeoutId;
}
};
var PendingItem = class {
static {
__name(this, "PendingItem");
}
constructor(callback) {
this.callback = callback;
}
};
function throwOnDoubleRelease() {
throw new Error("Release called on client which has already been released to the pool.");
}
__name(throwOnDoubleRelease, "throwOnDoubleRelease");
function promisify(Promise2, callback) {
if (callback) {
return { callback, result: void 0 };
}
let rej;
let res;
const cb = /* @__PURE__ */ __name(function(err, client) {
err ? rej(err) : res(client);
}, "cb");
const result = new Promise2(function(resolve, reject) {
res = resolve;
rej = reject;
}).catch((err) => {
Error.captureStackTrace(err);
throw err;
});
return { callback: cb, result };
}
__name(promisify, "promisify");
function makeIdleListener(pool, client) {
return /* @__PURE__ */ __name(function idleListener(err) {
err.client = client;
client.removeListener("error", idleListener);
client.on("error", () => {
pool.log("additional client error after disconnection due to error", err);
});
pool._remove(client);
pool.emit("error", err, client);
}, "idleListener");
}
__name(makeIdleListener, "makeIdleListener");
var Pool2 = class extends EventEmitter {
static {
__name(this, "Pool");
}
constructor(options, Client2) {
super();
this.options = Object.assign({}, options);
if (options != null && "password" in options) {
Object.defineProperty(this.options, "password", {
configurable: true,
enumerable: false,
writable: true,
value: options.password
});
}
if (options != null && options.ssl && options.ssl.key) {
Object.defineProperty(this.options.ssl, "key", {
enumerable: false
});
}
this.options.max = this.options.max || this.options.poolSize || 10;
this.options.min = this.options.min || 0;
this.options.maxUses = this.options.maxUses || Infinity;
this.options.allowExitOnIdle = this.options.allowExitOnIdle || false;
this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0;
this.log = this.options.log || function() {
};
this.Client = this.options.Client || Client2 || require_lib2().Client;
this.Promise = this.options.Promise || global.Promise;
if (typeof this.options.idleTimeoutMillis === "undefined") {
this.options.idleTimeoutMillis = 1e4;
}
this._clients = [];
this._idle = [];
this._expired = /* @__PURE__ */ new WeakSet();
this._pendingQueue = [];
this._endCallback = void 0;
this.ending = false;
this.ended = false;
}
_promiseTry(f) {
const Promise2 = this.Promise;
if (typeof Promise2.try === "function") {
return Promise2.try(f);
}
return new Promise2((resolve) => resolve(f()));
}
_isFull() {
return this._clients.length >= this.options.max;
}
_isAboveMin() {
return this._clients.length > this.options.min;
}
_pulseQueue() {
this.log("pulse queue");
if (this.ended) {
this.log("pulse queue ended");
return;
}
if (this.ending) {
this.log("pulse queue on ending");
if (this._idle.length) {
this._idle.slice().map((item) => {
this._remove(item.client);
});
}
if (!this._clients.length) {
this.ended = true;
this._endCallback();
}
return;
}
if (!this._pendingQueue.length) {
this.log("no queued requests");
return;
}
if (!this._idle.length && this._isFull()) {
return;
}
const pendingItem = this._pendingQueue.shift();
if (this._idle.length) {
const idleItem = this._idle.pop();
clearTimeout(idleItem.timeoutId);
const client = idleItem.client;
client.ref && client.ref();
const idleListener = idleItem.idleListener;
return this._acquireClient(client, pendingItem, idleListener, false);
}
if (!this._isFull()) {
return this.newClient(pendingItem);
}
throw new Error("unexpected condition");
}
_remove(client, callback) {
const removed = removeWhere(this._idle, (item) => item.client === client);
if (removed !== void 0) {
clearTimeout(removed.timeoutId);
}
this._clients = this._clients.filter((c) => c !== client);
const context = this;
client.end(() => {
context.emit("remove", client);
if (typeof callback === "function") {
callback();
}
});
}
connect(cb) {
if (this.ending) {
const err = new Error("Cannot use a pool after calling end on the pool");
return cb ? cb(err) : this.Promise.reject(err);
}
const response = promisify(this.Promise, cb);
const result = response.result;
if (this._isFull() || this._idle.length) {
if (this._idle.length) {
process.nextTick(() => this._pulseQueue());
}
if (!this.options.connectionTimeoutMillis) {
this._pendingQueue.push(new PendingItem(response.callback));
return result;
}
const queueCallback = /* @__PURE__ */ __name((err, res, done) => {
clearTimeout(tid);
response.callback(err, res, done);
}, "queueCallback");
const pendingItem = new PendingItem(queueCallback);
const tid = setTimeout(() => {
removeWhere(this._pendingQueue, (i) => i.callback === queueCallback);
pendingItem.timedOut = true;
response.callback(new Error("timeout exceeded when trying to connect"));
}, this.options.connectionTimeoutMillis);
if (tid.unref) {
tid.unref();
}
this._pendingQueue.push(pendingItem);
return result;
}
this.newClient(new PendingItem(response.callback));
return result;
}
newClient(pendingItem) {
const client = new this.Client(this.options);
this._clients.push(client);
const idleListener = makeIdleListener(this, client);
this.log("checking client timeout");
let tid;
let timeoutHit = false;
if (this.options.connectionTimeoutMillis) {
tid = setTimeout(() => {
if (client.connection) {
this.log("ending client due to timeout");
timeoutHit = true;
client.connection.stream.destroy();
} else if (!client.isConnected()) {
this.log("ending client due to timeout");
timeoutHit = true;
client.end();
}
}, this.options.connectionTimeoutMillis);
}
this.log("connecting new client");
client.connect((err) => {
if (tid) {
clearTimeout(tid);
}
client.on("error", idleListener);
if (err) {
this.log("client failed to connect", err);
this._clients = this._clients.filter((c) => c !== client);
if (timeoutHit) {
err = new Error("Connection terminated due to connection timeout", { cause: err });
}
this._pulseQueue();
if (!pendingItem.timedOut) {
pendingItem.callback(err, void 0, NOOP);
}
} else {
this.log("new client connected");
if (this.options.onConnect) {
this._promiseTry(() => this.options.onConnect(client)).then(
() => {
this._afterConnect(client, pendingItem, idleListener);
},
(hookErr) => {
this._clients = this._clients.filter((c) => c !== client);
client.end(() => {
this._pulseQueue();
if (!pendingItem.timedOut) {
pendingItem.callback(hookErr, void 0, NOOP);
}
});
}
);
return;
}
return this._afterConnect(client, pendingItem, idleListener);
}
});
}
_afterConnect(client, pendingItem, idleListener) {
if (this.options.maxLifetimeSeconds !== 0) {
const maxLifetimeTimeout = setTimeout(() => {
this.log("ending client due to expired lifetime");
this._expired.add(client);
const idleIndex = this._idle.findIndex((idleItem) => idleItem.client === client);
if (idleIndex !== -1) {
this._acquireClient(
client,
new PendingItem((err, client2, clientRelease) => clientRelease()),
idleListener,
false
);
}
}, this.options.maxLifetimeSeconds * 1e3);
maxLifetimeTimeout.unref();
client.once("end", () => clearTimeout(maxLifetimeTimeout));
}
return this._acquireClient(client, pendingItem, idleListener, true);
}
// acquire a client for a pending work item
_acquireClient(client, pendingItem, idleListener, isNew) {
if (isNew) {
this.emit("connect", client);
}
this.emit("acquire", client);
client.release = this._releaseOnce(client, idleListener);
client.removeListener("error", idleListener);
if (!pendingItem.timedOut) {
if (isNew && this.options.verify) {
this.options.verify(client, (err) => {
if (err) {
client.release(err);
return pendingItem.callback(err, void 0, NOOP);
}
pendingItem.callback(void 0, client, client.release);
});
} else {
pendingItem.callback(void 0, client, client.release);
}
} else {
if (isNew && this.options.verify) {
this.options.verify(client, client.release);
} else {
client.release();
}
}
}
// returns a function that wraps _release and throws if called more than once
_releaseOnce(client, idleListener) {
let released = false;
return (err) => {
if (released) {
throwOnDoubleRelease();
}
released = true;
this._release(client, idleListener, err);
};
}
// release a client back to the poll, include an error
// to remove it from the pool
_release(client, idleListener, err) {
client.on("error", idleListener);
client._poolUseCount = (client._poolUseCount || 0) + 1;
this.emit("release", err, client);
if (err || this.ending || !client._queryable || client._ending || client._poolUseCount >= this.options.maxUses) {
if (client._poolUseCount >= this.options.maxUses) {
this.log("remove expended client");
}
return this._remove(client, this._pulseQueue.bind(this));
}
const isExpired = this._expired.has(client);
if (isExpired) {
this.log("remove expired client");
this._expired.delete(client);
return this._remove(client, this._pulseQueue.bind(this));
}
let tid;
if (this.options.idleTimeoutMillis && this._isAboveMin()) {
tid = setTimeout(() => {
if (this._isAboveMin()) {
this.log("remove idle client");
this._remove(client, this._pulseQueue.bind(this));
}
}, this.options.idleTimeoutMillis);
if (this.options.allowExitOnIdle) {
tid.unref();
}
}
if (this.options.allowExitOnIdle) {
client.unref();
}
this._idle.push(new IdleItem(client, idleListener, tid));
this._pulseQueue();
}
query(text, values, cb) {
if (typeof text === "function") {
const response2 = promisify(this.Promise, text);
setImmediate(function() {
return response2.callback(new Error("Passing a function as the first parameter to pool.query is not supported"));
});
return response2.result;
}
if (typeof values === "function") {
cb = values;
values = void 0;
}
const response = promisify(this.Promise, cb);
cb = response.callback;
this.connect((err, client) => {
if (err) {
return cb(err);
}
let clientReleased = false;
const onError = /* @__PURE__ */ __name((err2) => {
if (clientReleased) {
return;
}
clientReleased = true;
client.release(err2);
cb(err2);
}, "onError");
client.once("error", onError);
this.log("dispatching query");
try {
client.query(text, values, (err2, res) => {
this.log("query dispatched");
client.removeListener("error", onError);
if (clientReleased) {
return;
}
clientReleased = true;
client.release(err2);
if (err2) {
return cb(err2);
}
return cb(void 0, res);
});
} catch (err2) {
client.release(err2);
return cb(err2);
}
});
return response.result;
}
end(cb) {
this.log("ending");
if (this.ending) {
const err = new Error("Called end on pool more than once");
return cb ? cb(err) : this.Promise.reject(err);
}
this.ending = true;
const promised = promisify(this.Promise, cb);
this._endCallback = promised.callback;
this._pulseQueue();
return promised.result;
}
get waitingCount() {
return this._pendingQueue.length;
}
get idleCount() {
return this._idle.length;
}
get expiredCount() {
return this._clients.reduce((acc, client) => acc + (this._expired.has(client) ? 1 : 0), 0);
}
get totalCount() {
return this._clients.length;
}
};
module.exports = Pool2;
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/native/query.js
var require_query2 = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/native/query.js"(exports, module) {
"use strict";
var EventEmitter = __require("events").EventEmitter;
var util = __require("util");
var utils = require_utils();
var NativeQuery = module.exports = function(config, values, callback) {
EventEmitter.call(this);
config = utils.normalizeQueryConfig(config, values, callback);
this.text = config.text;
this.values = config.values;
this.name = config.name;
this.queryMode = config.queryMode;
this.callback = config.callback;
this.state = "new";
this._arrayMode = config.rowMode === "array";
this._emitRowEvents = false;
this.on(
"newListener",
function(event) {
if (event === "row") this._emitRowEvents = true;
}.bind(this)
);
};
util.inherits(NativeQuery, EventEmitter);
var errorFieldMap = {
sqlState: "code",
statementPosition: "position",
messagePrimary: "message",
messageDetail: "detail",
messageHint: "hint",
context: "where",
schemaName: "schema",
tableName: "table",
columnName: "column",
dataTypeName: "dataType",
constraintName: "constraint",
sourceFile: "file",
sourceLine: "line",
sourceFunction: "routine"
};
NativeQuery.prototype.handleError = function(err) {
const fields = this.native && this.native.pq.resultErrorFields();
if (fields) {
for (const key in fields) {
const normalizedFieldName = errorFieldMap[key] || key;
err[normalizedFieldName] = fields[key];
}
}
if (this.callback) {
this.callback(err);
} else {
this.emit("error", err);
}
this.state = "error";
};
NativeQuery.prototype.then = function(onSuccess, onFailure) {
return this._getPromise().then(onSuccess, onFailure);
};
NativeQuery.prototype.catch = function(callback) {
return this._getPromise().catch(callback);
};
NativeQuery.prototype._getPromise = function() {
if (this._promise) return this._promise;
this._promise = new Promise(
function(resolve, reject) {
this._once("end", resolve);
this._once("error", reject);
}.bind(this)
);
return this._promise;
};
NativeQuery.prototype.submit = function(client) {
this.state = "running";
const self = this;
this.native = client.native;
client.native.arrayMode = this._arrayMode;
let after = /* @__PURE__ */ __name(function(err, rows, results) {
client.native.arrayMode = false;
setImmediate(function() {
self.emit("_done");
});
if (err) {
return self.handleError(err);
}
if (self._emitRowEvents) {
if (results.length > 1) {
rows.forEach((rowOfRows, i) => {
rowOfRows.forEach((row) => {
self.emit("row", row, results[i]);
});
});
} else {
rows.forEach(function(row) {
self.emit("row", row, results);
});
}
}
self.state = "end";
self.emit("end", results);
if (self.callback) {
self.callback(null, results);
}
}, "after");
if (process.domain) {
after = process.domain.bind(after);
}
if (this.name) {
if (this.name.length > 63) {
console.error("Warning! Postgres only supports 63 characters for query names.");
console.error("You supplied %s (%s)", this.name, this.name.length);
console.error("This can cause conflicts and silent errors executing queries");
}
const values = (this.values || []).map(utils.prepareValue);
if (client.namedQueries[this.name] !== void 0) {
if (this.text && client.namedQueries[this.name] !== this.text) {
const err = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
return after(err);
}
return client.native.execute(this.name, values, after);
}
return client.native.prepare(this.name, this.text, values.length, function(err) {
if (err) return after(err);
client.namedQueries[self.name] = self.text;
return self.native.execute(self.name, values, after);
});
} else if (this.values) {
if (!Array.isArray(this.values)) {
const err = new Error("Query values must be an array");
return after(err);
}
const vals = this.values.map(utils.prepareValue);
client.native.query(this.text, vals, after);
} else if (this.queryMode === "extended") {
client.native.query(this.text, [], after);
} else {
client.native.query(this.text, after);
}
};
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/native/client.js
var require_client2 = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/native/client.js"(exports, module) {
var nodeUtils = __require("util");
var Native;
try {
Native = __require("pg-native");
} catch (e) {
throw e;
}
var TypeOverrides2 = require_type_overrides();
var EventEmitter = __require("events").EventEmitter;
var util = __require("util");
var ConnectionParameters = require_connection_parameters();
var NativeQuery = require_query2();
var queryQueueLengthDeprecationNotice = nodeUtils.deprecate(
() => {
},
"Calling client.query() when the client is already executing a query is deprecated and will be removed in pg@9.0. Use async/await or an external async flow control mechanism instead."
);
var Client2 = module.exports = function(config) {
EventEmitter.call(this);
config = config || {};
this._Promise = config.Promise || global.Promise;
this._types = new TypeOverrides2(config.types);
this.native = new Native({
types: this._types
});
this._queryQueue = [];
this._ending = false;
this._connecting = false;
this._connected = false;
this._queryable = true;
this.pipeline = Boolean(config.pipeline);
this._pipelineInFlight = false;
const cp = this.connectionParameters = new ConnectionParameters(config);
if (config.nativeConnectionString) cp.nativeConnectionString = config.nativeConnectionString;
this.user = cp.user;
Object.defineProperty(this, "password", {
configurable: true,
enumerable: false,
writable: true,
value: cp.password
});
this.database = cp.database;
this.host = cp.host;
this.port = cp.port;
this.namedQueries = {};
};
Client2.Query = NativeQuery;
util.inherits(Client2, EventEmitter);
Client2.prototype._errorAllQueries = function(err) {
const enqueueError = /* @__PURE__ */ __name((query) => {
process.nextTick(() => {
query.native = this.native;
query.handleError(err);
});
}, "enqueueError");
if (this._hasActiveQuery()) {
enqueueError(this._activeQuery);
this._activeQuery = null;
}
this._queryQueue.forEach(enqueueError);
this._queryQueue.length = 0;
};
Client2.prototype._connect = function(cb) {
const self = this;
if (this._connecting) {
process.nextTick(() => cb(new Error("Client has already been connected. You cannot reuse a client.")));
return;
}
this._connecting = true;
this.connectionParameters.getLibpqConnectionString(function(err, conString) {
if (self.connectionParameters.nativeConnectionString) conString = self.connectionParameters.nativeConnectionString;
if (err) return cb(err);
self.native.connect(conString, function(err2) {
if (err2) {
self.native.end();
return cb(err2);
}
self._connected = true;
self.native.on("error", function(err3) {
self._queryable = false;
self._errorAllQueries(err3);
self.emit("error", err3);
});
self.native.on("notification", function(msg) {
self.emit("notification", {
channel: msg.relname,
payload: msg.extra
});
});
self.emit("connect");
self._pulseQueryQueue(true);
cb(null, this);
});
});
};
Client2.prototype.connect = function(callback) {
if (callback) {
this._connect(callback);
return;
}
return new this._Promise((resolve, reject) => {
this._connect((error) => {
if (error) {
reject(error);
} else {
resolve(this);
}
});
});
};
Client2.prototype.query = function(config, values, callback) {
let query;
let result;
let readTimeout;
let readTimeoutTimer;
let queryCallback;
if (config === null || config === void 0) {
throw new TypeError("Client was passed a null or undefined query");
} else if (typeof config.submit === "function") {
readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
result = query = config;
if (typeof values === "function") {
config.callback = values;
}
} else {
readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
query = new NativeQuery(config, values, callback);
if (!query.callback) {
let resolveOut, rejectOut;
result = new this._Promise((resolve, reject) => {
resolveOut = resolve;
rejectOut = reject;
}).catch((err) => {
Error.captureStackTrace(err);
throw err;
});
query.callback = (err, res) => err ? rejectOut(err) : resolveOut(res);
}
}
if (readTimeout) {
queryCallback = query.callback || (() => {
});
readTimeoutTimer = setTimeout(() => {
const error = new Error("Query read timeout");
process.nextTick(() => {
query.handleError(error, this.connection);
});
queryCallback(error);
query.callback = () => {
};
const index = this._queryQueue.indexOf(query);
if (index > -1) {
this._queryQueue.splice(index, 1);
}
this._pulseQueryQueue();
}, readTimeout);
query.callback = (err, res) => {
clearTimeout(readTimeoutTimer);
queryCallback(err, res);
};
}
if (!this._queryable) {
query.native = this.native;
process.nextTick(() => {
query.handleError(new Error("Client has encountered a connection error and is not queryable"));
});
return result;
}
if (this._ending) {
query.native = this.native;
process.nextTick(() => {
query.handleError(new Error("Client was closed and is not queryable"));
});
return result;
}
if (this._queryQueue.length > 0 && !this.pipeline) {
queryQueueLengthDeprecationNotice();
}
this._queryQueue.push(query);
this._pulseQueryQueue();
return result;
};
Client2.prototype.end = function(cb) {
const self = this;
this._ending = true;
if (this._connecting && !this._connected) {
this.once("connect", () => {
this.end(() => {
});
});
}
let result;
if (!cb) {
result = new this._Promise(function(resolve, reject) {
cb = /* @__PURE__ */ __name((err) => err ? reject(err) : resolve(), "cb");
});
}
const doEnd = /* @__PURE__ */ __name(function() {
self.native.end(function() {
self._connected = false;
self._errorAllQueries(new Error("Connection terminated"));
process.nextTick(() => {
self.emit("end");
if (cb) cb();
});
});
}, "doEnd");
if (this.pipeline && (this._pipelineInFlight || this._queryQueue.length > 0)) {
this.once("drain", doEnd);
} else {
doEnd();
}
return result;
};
Client2.prototype._hasActiveQuery = function() {
return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end";
};
Client2.prototype._pulseQueryQueue = function(initialConnection) {
if (!this._connected) {
return;
}
if (this.pipeline && !initialConnection) {
return this._pulsePipelinedQueryQueue();
}
if (this._hasActiveQuery()) {
return;
}
const query = this._queryQueue.shift();
if (!query) {
if (!initialConnection) {
this.emit("drain");
}
return;
}
this._activeQuery = query;
query.submit(this);
const self = this;
query.once("_done", function() {
self._pulseQueryQueue();
});
};
Client2.prototype._pulsePipelinedQueryQueue = function() {
if (!this._connected || this._pipelineInFlight) {
return;
}
if (this._queryQueue.length === 0) {
if (this.hasExecuted) {
this.emit("drain");
}
return;
}
this._pipelineInFlight = true;
const self = this;
const queries = [];
const nativeQueries = [];
const utils = require_utils();
while (this._queryQueue.length > 0) {
const query = this._queryQueue.shift();
this.hasExecuted = true;
nativeQueries.push(query);
const values = query.values ? query.values.map(utils.prepareValue) : null;
const pipelineEntry = { text: query.text, name: query.name, arrayMode: query._arrayMode };
if (values) {
pipelineEntry.values = values;
}
if (query.name && this.namedQueries[query.name]) {
pipelineEntry._alreadyPrepared = true;
}
queries.push(pipelineEntry);
}
this.native.pipeline(queries, function(err, results) {
self._pipelineInFlight = false;
if (err) {
self._connected = false;
self._queryable = false;
for (let i = 0; i < nativeQueries.length; i++) {
const q = nativeQueries[i];
q.native = self.native;
q.handleError(err);
}
self._errorAllQueries(err);
self.emit("error", err);
self.emit("end");
return;
}
for (let i = 0; i < nativeQueries.length; i++) {
const q = nativeQueries[i];
const r = results[i];
q.native = self.native;
if (r.err) {
q.handleError(r.err);
} else {
if (q.name) {
self.namedQueries[q.name] = q.text;
}
q.state = "end";
q.emit("end", r.result);
if (q.callback) {
q.callback(null, r.result);
}
}
setImmediate(function() {
q.emit("_done");
});
}
self._pulsePipelinedQueryQueue();
});
};
Client2.prototype.cancel = function(query) {
if (this._activeQuery === query) {
this.native.cancel(function() {
});
} else if (this._queryQueue.indexOf(query) !== -1) {
this._queryQueue.splice(this._queryQueue.indexOf(query), 1);
}
};
Client2.prototype.ref = function() {
};
Client2.prototype.unref = function() {
};
Client2.prototype.setTypeParser = function(oid, format, parseFn) {
return this._types.setTypeParser(oid, format, parseFn);
};
Client2.prototype.getTypeParser = function(oid, format) {
return this._types.getTypeParser(oid, format);
};
Client2.prototype.isConnected = function() {
return this._connected;
};
Client2.prototype.getTransactionStatus = function() {
return this.native.getTransactionStatus();
};
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/native/index.js
var require_native = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/native/index.js"(exports, module) {
"use strict";
module.exports = require_client2();
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/index.js
var require_lib2 = __commonJS({
"../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/lib/index.js"(exports, module) {
"use strict";
var Client2 = require_client();
var defaults2 = require_defaults();
var Connection2 = require_connection();
var Result2 = require_result();
var utils = require_utils();
var Pool2 = require_pg_pool();
var TypeOverrides2 = require_type_overrides();
var { DatabaseError: DatabaseError2 } = require_dist();
var { escapeIdentifier: escapeIdentifier2, escapeLiteral: escapeLiteral2 } = require_utils();
var poolFactory = /* @__PURE__ */ __name((Client3) => {
return class BoundPool extends Pool2 {
static {
__name(this, "BoundPool");
}
constructor(options) {
super(options, Client3);
}
};
}, "poolFactory");
var PG = /* @__PURE__ */ __name(function(clientConstructor2) {
this.defaults = defaults2;
this.Client = clientConstructor2;
this.Query = this.Client.Query;
this.Pool = poolFactory(this.Client);
this._pools = [];
this.Connection = Connection2;
this.types = require_pg_types();
this.DatabaseError = DatabaseError2;
this.TypeOverrides = TypeOverrides2;
this.escapeIdentifier = escapeIdentifier2;
this.escapeLiteral = escapeLiteral2;
this.Result = Result2;
this.utils = utils;
}, "PG");
var clientConstructor = Client2;
var forceNative = false;
try {
forceNative = !!process.env.NODE_PG_FORCE_NATIVE;
} catch {
}
if (forceNative) {
clientConstructor = require_native();
}
module.exports = new PG(clientConstructor);
Object.defineProperty(module.exports, "native", {
configurable: true,
enumerable: false,
get() {
let native = null;
try {
native = new PG(require_native());
} catch (err) {
if (err.code !== "MODULE_NOT_FOUND") {
throw err;
}
}
Object.defineProperty(module.exports, "native", {
value: native
});
return native;
}
});
}
});
// ../../node_modules/.pnpm/pg@8.23.1/node_modules/pg/esm/index.mjs
var import_lib = __toESM(require_lib2(), 1);
var Client = import_lib.default.Client;
var Pool = import_lib.default.Pool;
var Connection = import_lib.default.Connection;
var types = import_lib.default.types;
var Query = import_lib.default.Query;
var DatabaseError = import_lib.default.DatabaseError;
var escapeIdentifier = import_lib.default.escapeIdentifier;
var escapeLiteral = import_lib.default.escapeLiteral;
var Result = import_lib.default.Result;
var TypeOverrides = import_lib.default.TypeOverrides;
var defaults = import_lib.default.defaults;
var esm_default = import_lib.default;
export {
esm_default
};