@juit/pgproxy-types 1.0.0

package/dist/serializers/date.mjs

@@ -0,0 +1,21 @@
+// serializers/date.ts
+function pad(number, digits) {
+  return number.toString().padStart(digits, "0");
+}
+function serializeDateUTC(date) {
+  if (isNaN(date.getTime()))
+    throw new TypeError("Attempted to serialize invalid date");
+  let year = date.getUTCFullYear();
+  const isBCYear = year < 1;
+  if (isBCYear)
+    year = Math.abs(year) + 1;
+  let ret = pad(year, 4) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + "T" + pad(date.getUTCHours(), 2) + ":" + pad(date.getUTCMinutes(), 2) + ":" + pad(date.getUTCSeconds(), 2) + "." + pad(date.getUTCMilliseconds(), 3);
+  ret += "+00:00";
+  if (isBCYear)
+    ret += " BC";
+  return ret;
+}
+export {
+  serializeDateUTC
+};
+//# sourceMappingURL=date.mjs.map

package/dist/serializers/date.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/serializers/date.ts"],
+  "mappings": ";AACA,SAAS,IAAI,QAAgB,QAAwB;AACnD,SAAO,OAAO,SAAS,EAAE,SAAS,QAAQ,GAAG;AAC/C;AAwCO,SAAS,iBAAiB,MAAoB;AACnD,MAAI,MAAM,KAAK,QAAQ,CAAC;AAAG,UAAM,IAAI,UAAU,qCAAqC;AAEpF,MAAI,OAAO,KAAK,eAAe;AAC/B,QAAM,WAAW,OAAO;AACxB,MAAI;AAAU,WAAO,KAAK,IAAI,IAAI,IAAI;AAEtC,MAAI,MACF,IAAI,MAAM,CAAC,IAAI,MACf,IAAI,KAAK,YAAY,IAAI,GAAG,CAAC,IAAI,MACjC,IAAI,KAAK,WAAW,GAAG,CAAC,IAAI,MAC5B,IAAI,KAAK,YAAY,GAAG,CAAC,IAAI,MAC7B,IAAI,KAAK,cAAc,GAAG,CAAC,IAAI,MAC/B,IAAI,KAAK,cAAc,GAAG,CAAC,IAAI,MAC/B,IAAI,KAAK,mBAAmB,GAAG,CAAC;AAElC,SAAO;AACP,MAAI;AAAU,WAAO;AACrB,SAAO;AACT;",
+  "names": []
+}

package/dist/serializers.cjs

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// serializers.ts
+var serializers_exports = {};
+__export(serializers_exports, {
+  serialize: () => serialize,
+  serializeByteA: () => import_bytea2.serializeByteA,
+  serializeDateUTC: () => import_date2.serializeDateUTC
+});
+module.exports = __toCommonJS(serializers_exports);
+var import_bytea = require("./serializers/bytea.cjs");
+var import_date = require("./serializers/date.cjs");
+var import_bytea2 = require("./serializers/bytea.cjs");
+var import_date2 = require("./serializers/date.cjs");
+var serializationCache = /* @__PURE__ */ new WeakMap();
+function quote(string) {
+  return `"${string.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function serializeArray(value, stack) {
+  const result = new Array(value.length);
+  for (let i = 0; i < value.length; i++) {
+    const member = value[i];
+    const type = typeof member;
+    if (member === null || member === void 0) {
+      result[i] = "NULL";
+    } else if (type === "boolean") {
+      result[i] = member ? "t" : "f";
+    } else if (type === "bigint" || type === "number") {
+      result[i] = `${member}`;
+    } else if (Array.isArray(member)) {
+      const cached = serializationCache.get(member);
+      if (cached) {
+        result[i] = cached;
+      } else {
+        if (stack.has(member))
+          throw new TypeError("Circularity detected serializing");
+        stack.add(member);
+        result[i] = serializeArray(member, stack);
+        serializationCache.set(member, result[i]);
+        stack.delete(member);
+      }
+    } else if (ArrayBuffer.isView(member)) {
+      result[i] = `"\\${(0, import_bytea.serializeByteA)(member)}"`;
+    } else {
+      result[i] = quote(serializeValue(member, stack));
+    }
+  }
+  return `{${result.join(",")}}`;
+}
+function serializeValue(value, stack) {
+  if (value === null)
+    throw new TypeError('Can not serialize "null"');
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "boolean":
+      return value ? "t" : "f";
+    case "bigint":
+    case "number":
+      return value.toString();
+    case "object":
+      break;
+    case "function":
+    case "symbol":
+    case "undefined":
+    default:
+      throw new TypeError(`Can not serialize "${typeof value}"`);
+  }
+  const cached = serializationCache.get(value);
+  if (cached !== void 0)
+    return cached;
+  if (stack.has(value))
+    throw new TypeError("Circularity detected serializing");
+  stack.add(value);
+  const subserialize = (v) => serializeValue(v, stack);
+  let string;
+  if (isPGSerializable(value)) {
+    string = value.toPostgres(subserialize);
+  } else if (ArrayBuffer.isView(value)) {
+    string = (0, import_bytea.serializeByteA)(value);
+  } else if (Array.isArray(value)) {
+    string = serializeArray(value, stack);
+  } else if (value instanceof Date) {
+    string = (0, import_date.serializeDateUTC)(value);
+  } else {
+    string = JSON.stringify(value);
+  }
+  serializationCache.set(value, string);
+  stack.delete(value);
+  return string;
+}
+function isPGSerializable(value) {
+  return value && typeof value["toPostgres"] === "function";
+}
+var serialize = (value) => serializeValue(value, /* @__PURE__ */ new WeakSet());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serialize,
+  serializeByteA,
+  serializeDateUTC
+});
+//# sourceMappingURL=serializers.cjs.map

package/dist/serializers.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/serializers.ts"],
+  "mappings": "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",
+  "names": ["import_bytea", "import_date"]
+}

package/dist/serializers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Defines an object that can be serialized to a _string_ comprehensible by
+ * PostgreSQL.
+ *
+ * The `serialize` parameter is a serialization function which can be used
+ * to serialize _members_ of the {@link PGSerializable} itself (e.g. boundaries
+ * of a {@link PGRange}, members of an _array_, ...).
+ */
+export interface PGSerializable {
+    toPostgres(serialize: PGSerialize): string;
+}
+/** An interface describing our {@link serialize} function. */
+export interface PGSerialize {
+    (value?: null | undefined): never;
+    (value: any): string;
+}
+/** Serialize a value to _string_ comprehensible by PostgreSQL. */
+export declare const serialize: PGSerialize;
+export { serializeByteA } from './serializers/bytea';
+export { serializeDateUTC } from './serializers/date';

package/dist/serializers.mjs

@@ -0,0 +1,92 @@
+// serializers.ts
+import { serializeByteA } from "./serializers/bytea.mjs";
+import { serializeDateUTC } from "./serializers/date.mjs";
+import { serializeByteA as serializeByteA2 } from "./serializers/bytea.mjs";
+import { serializeDateUTC as serializeDateUTC2 } from "./serializers/date.mjs";
+var serializationCache = /* @__PURE__ */ new WeakMap();
+function quote(string) {
+  return `"${string.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function serializeArray(value, stack) {
+  const result = new Array(value.length);
+  for (let i = 0; i < value.length; i++) {
+    const member = value[i];
+    const type = typeof member;
+    if (member === null || member === void 0) {
+      result[i] = "NULL";
+    } else if (type === "boolean") {
+      result[i] = member ? "t" : "f";
+    } else if (type === "bigint" || type === "number") {
+      result[i] = `${member}`;
+    } else if (Array.isArray(member)) {
+      const cached = serializationCache.get(member);
+      if (cached) {
+        result[i] = cached;
+      } else {
+        if (stack.has(member))
+          throw new TypeError("Circularity detected serializing");
+        stack.add(member);
+        result[i] = serializeArray(member, stack);
+        serializationCache.set(member, result[i]);
+        stack.delete(member);
+      }
+    } else if (ArrayBuffer.isView(member)) {
+      result[i] = `"\\${serializeByteA(member)}"`;
+    } else {
+      result[i] = quote(serializeValue(member, stack));
+    }
+  }
+  return `{${result.join(",")}}`;
+}
+function serializeValue(value, stack) {
+  if (value === null)
+    throw new TypeError('Can not serialize "null"');
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "boolean":
+      return value ? "t" : "f";
+    case "bigint":
+    case "number":
+      return value.toString();
+    case "object":
+      break;
+    case "function":
+    case "symbol":
+    case "undefined":
+    default:
+      throw new TypeError(`Can not serialize "${typeof value}"`);
+  }
+  const cached = serializationCache.get(value);
+  if (cached !== void 0)
+    return cached;
+  if (stack.has(value))
+    throw new TypeError("Circularity detected serializing");
+  stack.add(value);
+  const subserialize = (v) => serializeValue(v, stack);
+  let string;
+  if (isPGSerializable(value)) {
+    string = value.toPostgres(subserialize);
+  } else if (ArrayBuffer.isView(value)) {
+    string = serializeByteA(value);
+  } else if (Array.isArray(value)) {
+    string = serializeArray(value, stack);
+  } else if (value instanceof Date) {
+    string = serializeDateUTC(value);
+  } else {
+    string = JSON.stringify(value);
+  }
+  serializationCache.set(value, string);
+  stack.delete(value);
+  return string;
+}
+function isPGSerializable(value) {
+  return value && typeof value["toPostgres"] === "function";
+}
+var serialize = (value) => serializeValue(value, /* @__PURE__ */ new WeakSet());
+export {
+  serialize,
+  serializeByteA2 as serializeByteA,
+  serializeDateUTC2 as serializeDateUTC
+};
+//# sourceMappingURL=serializers.mjs.map

package/dist/serializers.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/serializers.ts"],
+  "mappings": ";AAAA,SAAS,sBAAsB;AAC/B,SAAS,wBAAwB;AAkKjC,SAAS,kBAAAA,uBAAsB;AAC/B,SAAS,oBAAAC,yBAAwB;AAhKjC,IAAM,qBAAqB,oBAAI,QAAwB;AAGvD,SAAS,MAAM,QAAwB;AACrC,SAAO,IAAI,OAAO,QAAQ,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAK,CAAC;AAC/D;AAGA,SAAS,eAAe,OAAc,OAAgC;AACpE,QAAM,SAAS,IAAI,MAAc,MAAM,MAAM;AAE7C,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAM;AACtC,UAAM,SAAS,MAAM,CAAC;AACtB,UAAM,OAAO,OAAO;AAGpB,QAAK,WAAW,QAAU,WAAW,QAAY;AAC/C,aAAO,CAAC,IAAI;AAAA,IAGd,WAAW,SAAS,WAAW;AAC7B,aAAO,CAAC,IAAI,SAAS,MAAM;AAAA,IAG7B,WAAY,SAAS,YAAc,SAAS,UAAW;AACrD,aAAO,CAAC,IAAI,GAAG,MAAM;AAAA,IAKvB,WAAW,MAAM,QAAQ,MAAM,GAAG;AAChC,YAAM,SAAS,mBAAmB,IAAI,MAAM;AAC5C,UAAI,QAAQ;AACV,eAAO,CAAC,IAAI;AAAA,MACd,OAAO;AACL,YAAI,MAAM,IAAI,MAAM;AAAG,gBAAM,IAAI,UAAU,kCAAkC;AAC7E,cAAM,IAAI,MAAM;AAChB,eAAO,CAAC,IAAI,eAAe,QAAQ,KAAK;AACxC,2BAAmB,IAAI,QAAQ,OAAO,CAAC,CAAE;AACzC,cAAM,OAAO,MAAM;AAAA,MACrB;AAAA,IAKF,WAAW,YAAY,OAAO,MAAM,GAAG;AACrC,aAAO,CAAC,IAAI,MAAM,eAAe,MAAM,CAAC;AAAA,IAG1C,OAAO;AACL,aAAO,CAAC,IAAI,MAAM,eAAe,QAAQ,KAAK,CAAC;AAAA,IACjD;AAAA,EACF;AAEA,SAAO,IAAI,OAAO,KAAK,GAAG,CAAC;AAC7B;AAGA,SAAS,eAAe,OAAY,OAAgC;AAElE,MAAI,UAAU;AAAM,UAAM,IAAI,UAAU,0BAA0B;AAGlE,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK;AACH,aAAO;AAAA,IAET,KAAK;AACH,aAAO,QAAQ,MAAM;AAAA,IAEvB,KAAK;AAAA,IACL,KAAK;AACH,aAAO,MAAM,SAAS;AAAA,IAExB,KAAK;AACH;AAAA,IAEF,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL;AACE,YAAM,IAAI,UAAU,sBAAsB,OAAO,KAAK,GAAG;AAAA,EAC7D;AAKA,QAAM,SAAS,mBAAmB,IAAI,KAAK;AAC3C,MAAI,WAAW;AAAW,WAAO;AAGjC,MAAI,MAAM,IAAI,KAAK;AAAG,UAAM,IAAI,UAAU,kCAAkC;AAC5E,QAAM,IAAI,KAAK;AAGf,QAAM,eAAgB,CAAC,MAAW,eAAe,GAAG,KAAK;AAGzD,MAAI;AAGJ,MAAI,iBAAiB,KAAK,GAAG;AAC3B,aAAS,MAAM,WAAW,YAAY;AAAA,EAGxC,WAAW,YAAY,OAAO,KAAK,GAAG;AACpC,aAAS,eAAe,KAAK;AAAA,EAG/B,WAAW,MAAM,QAAQ,KAAK,GAAG;AAC/B,aAAS,eAAe,OAAO,KAAK;AAAA,EAGtC,WAAW,iBAAiB,MAAM;AAChC,aAAS,iBAAiB,KAAK;AAAA,EAGjC,OAAO;AACL,aAAS,KAAK,UAAU,KAAK;AAAA,EAC/B;AAGA,qBAAmB,IAAI,OAAO,MAAM;AACpC,QAAM,OAAO,KAAK;AAClB,SAAO;AACT;AAGA,SAAS,iBAAiB,OAAqC;AAC7D,SAAO,SAAU,OAAO,MAAM,YAAY,MAAM;AAClD;AAyBO,IAAM,YACV,CAAC,UAAe,eAAe,OAAO,oBAAI,QAAQ,CAAC;",
+  "names": ["serializeByteA", "serializeDateUTC"]
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@juit/pgproxy-types",
+  "version": "1.0.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "author": "Juit Developers <developers@juit.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/juitnow/juit-pgproxy.git"
+  },
+  "keywords": [
+    "database",
+    "pg",
+    "pool",
+    "postgres",
+    "proxy"
+  ],
+  "bugs": {
+    "url": "https://github.com/juitnow/juit-pgproxy/issues"
+  },
+  "homepage": "https://github.com/juitnow/juit-pgproxy#readme",
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "*.md",
+    "dist/",
+    "src/"
+  ],
+  "dependencies": {
+    "postgres-date": "^2.1.0",
+    "postgres-interval": "^4.0.1",
+    "postgres-range": "^1.1.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from './oids'
+export * from './parsers'
+export * from './registry'
+export * from './serializers'
+
+/* Re-export our classes and constructors */
+export type { PGArray } from './parsers/array'
+
+export { PGCircle, PGPoint } from './parsers/geometric'
+export { PGInterval } from './parsers/interval'
+export { PGRange } from './parsers/range'
+
+export type { PGCircleConstructor, PGPointConstructor } from './parsers/geometric'

package/src/oids.ts

@@ -0,0 +1,90 @@
+/**
+ * Relevant OIDS.
+ *
+ * See the `pg_catalog.pg_type` table, or the values listed in the sources at:
+ * https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_type.dat
+ */
+export const PGOIDs = {
+  /* Basic known types                                |_oid__|_typname______| */
+  bool: 16, /*                                        |   16 | bool         | */
+  bytea: 17, /*                                       |   17 | bytea        | */
+  int8: 20, /*                                        |   20 | int8         | */
+  int2: 21, /*                                        |   21 | int2         | */
+  int4: 23, /*                                        |   23 | int4         | */
+  oid: 26, /*                                         |   26 | oid          | */
+  json: 114, /*                                       |  114 | json         | */
+  point: 600, /*                                      |  600 | point        | */
+  float4: 700, /*                                     |  700 | float4       | */
+  float8: 701, /*                                     |  701 | float8       | */
+  circle: 718, /*                                     |  718 | circle       | */
+  varchar: 1043, /*                                   | 1043 | varchar      | */
+  timestamp: 1114, /*                                 | 1114 | timestamp    | */
+  timestamptz: 1184, /*                               | 1184 | timestamptz  | */
+  interval: 1186, /*                                  | 1186 | interval     | */
+  numeric: 1700, /*                                   | 1700 | numeric      | */
+  jsonb: 3802, /*                                     | 3802 | jsonb        | */
+
+  /* Native array types of the above                  |_oid__|_typname______|_base_| */
+  _bool: 1000, /*                                     | 1000 | _bool        |   16 | */
+  _bytea: 1001, /*                                    | 1001 | _bytea       |   17 | */
+  _int8: 1016, /*                                     | 1016 | _int8        |   20 | */
+  _int2: 1005, /*                                     | 1005 | _int2        |   21 | */
+  _int4: 1007, /*                                     | 1007 | _int4        |   23 | */
+  _oid: 1028, /*                                      | 1028 | _oid         |   26 | */
+  _json: 199, /*                                      |  199 | _json        |  114 | */
+  _point: 1017, /*                                    | 1017 | _point       |  600 | */
+  _float4: 1021, /*                                   | 1021 | _float4      |  700 | */
+  _float8: 1022, /*                                   | 1022 | _float8      |  701 | */
+  _circle: 719, /*                                    |  719 | _circle      |  718 | */
+  _timestamp: 1115, /*                                | 1115 | _timestamp   | 1114 | */
+  _timestamptz: 1185, /*                              | 1185 | _timestamptz | 1184 | */
+  _interval: 1187, /*                                 | 1187 | _interval    | 1186 | */
+  _numeric: 1231, /*                                  | 1231 | _numeric     | */
+  _jsonb: 3807, /*                                    | 3807 | _jsonb       | 3802 | */
+
+  /* Other known array types                          |_oid__|_typname______| */
+  _cidr: 651, /*                                      |  651 | _cidr        | */
+  _money: 791, /*                                     |  791 | _money       | */
+  _regproc: 1008, /*                                  | 1008 | _regproc     | */
+  _text: 1009, /*                                     | 1009 | _text        | */
+  _bpchar: 1014, /*                                   | 1014 | _bpchar      | */
+  _varchar: 1015, /*                                  | 1015 | _varchar     | */
+  _macaddr: 1040, /*                                  | 1040 | _macaddr     | */
+  _inet: 1041, /*                                     | 1041 | _inet        | */
+  _date: 1182, /*                                     | 1182 | _date        | */
+  _time: 1183, /*                                     | 1183 | _time        | */
+  _timetz: 1270, /*                                   | 1270 | _timetz      | */
+  _uuid: 2951, /*                                     | 2951 | _uuid        | */
+
+  /* Range types                                      |_oid__|_typname______| */
+  int4range: 3904, /*                                 | 3904 | int4range    | */
+  numrange: 3906, /*                                  | 3906 | numrange     | */
+  tsrange: 3908, /*                                   | 3908 | tsrange      | */
+  tstzrange: 3910, /*                                 | 3910 | tstzrange    | */
+  daterange: 3912, /*                                 | 3912 | daterange    | */
+  int8range: 3926, /*                                 | 3926 | int8range    | */
+
+  /* Array of range types                             |_oid__|_typname______|_base_| */
+  _int4range: 3905, /*                                | 3905 | _int4range   | 3904 | */
+  _numrange: 3907, /*                                 | 3907 | _numrange    | 3906 | */
+  _tsrange: 3909, /*                                  | 3909 | _tsrange     | 3908 | */
+  _tstzrange: 3911, /*                                | 3911 | _tstzrange   | 3910 | */
+  _daterange: 3913, /*                                | 3913 | _daterange   | 3912 | */
+  _int8range: 3927, /*                                | 3927 | _int8range   | 3926 | */
+
+  /* Special types                                    |_oid__|_typname______| */
+  void: 2278, /* function returns no value.           | 2278 | void         | */
+  xid: 28, /*    transaction id (int4)                |   28 | xid          | */
+  xid8: 5069, /* transaction id (int8)                | 5069 | xid8         | */
+  _xid: 1011, /* array of transaction ids (_int4)     | 1011 | _xid         | */
+  _xid8: 271, /* array of transaction ids (_int8)     |  271 | _xid8        | */
+
+} as const
+
+Object.freeze(PGOIDs)
+
+/** Supported PostgreSQL OIDs */
+export type PGOIDs = typeof PGOIDs
+
+/** Supported type _names_ as defined in the `pg_catalog.pg_type` table */
+export type PGTypeName = keyof PGOIDs

package/src/parsers/array.ts

@@ -0,0 +1,176 @@
+// Verbatim from https://github.com/bendrucker/postgres-array (MIT license)
+
+import {
+  parseBigint,
+  parseBool,
+  parseJson,
+  parseString,
+  parseTimestamp,
+  parseTimestampTz,
+} from './basic'
+import { parseByteA } from './bytea'
+import { parseCircle, parsePoint } from './geometric'
+import { parseInterval } from './interval'
+
+import type { PGParser } from '../parsers'
+import type { PGCircle, PGPoint } from './geometric'
+import type { PGInterval } from './interval'
+
+/** A parsed PostgreSQL `array` */
+export type PGArray<T = string> = (T | null)[]
+
+/** Parse a PostgreSQL array of string values */
+export function parseArray(source: string): PGArray
+/** Parse a PostgreSQL array using the specified parser for its elements */
+export function parseArray<T>(source: string, parser: PGParser<T>): PGArray<T>
+/* overloaded implementation */
+export function parseArray(
+    source: string,
+    parser = parseString,
+): PGArray {
+  return parseInternal(source, parser, false)
+}
+
+/* ========================================================================== */
+
+/** Parse a PostgreSQL array of _bigint_ values */
+export const parseBigintArray: PGParser<PGArray<bigint>> =
+  (value: string) => parseArray(value, parseBigint)
+
+/** Parse a PostgreSQL array of _boolean_ values */
+export const parseBoolArray: PGParser<PGArray<boolean>> =
+  (value: string) => parseArray(value, parseBool)
+
+/** Parse a PostgreSQL array of _binary_ values */
+export const parseByteAArray: PGParser<PGArray<Uint8Array>> =
+  (value: string) => parseArray(value, parseByteA)
+
+/** Parse a PostgreSQL array of {@link PGCircle} values */
+export const parseCircleArray: PGParser<PGArray<PGCircle>> =
+  (value: string) => parseArray(value, parseCircle)
+
+/** Parse a PostgreSQL array of _float_ values */
+export const parseFloatArray: PGParser<PGArray<number>> =
+  (value: string) => parseArray(value, parseFloat)
+
+/** Parse a PostgreSQL array of _number_ values */
+export const parseIntArray: PGParser<PGArray<number>> =
+  (value: string) => parseArray(value, parseInt)
+
+/** Parse a PostgreSQL array of {@link PGInterval} values */
+export const parseIntervalArray: PGParser<PGArray<PGInterval>> =
+  (value: string) => parseArray(value, parseInterval)
+
+/** Parse a PostgreSQL array of _JSON_ values */
+export const parseJsonArray: PGParser<PGArray<any[]>> =
+  (value: string) => parseArray(value, parseJson)
+
+/** Parse a PostgreSQL array of {@link PGPoint} values */
+export const parsePointArray: PGParser<PGArray<PGPoint>> =
+  (value: string) => parseArray(value, parsePoint)
+
+/** Parse a PostgreSQL array of _timestamp without time zone_ values */
+export const parseTimestampArray: PGParser<PGArray<Date>> =
+  (value: string) => parseArray(value, parseTimestamp)
+
+/** Parse a PostgreSQL array of _timestamp with time zone_ values */
+export const parseTimestampTzArray: PGParser<PGArray<Date>> =
+  (value: string) => parseArray(value, parseTimestampTz)
+
+/* ========================================================================== *
+ * INTERNALS                                                                  *
+ * ========================================================================== */
+
+/** Result from parsing a nested sub-array */
+interface SubArrayResult {
+  entries: any,
+  position: number,
+}
+
+function parseInternal(source: string, parser: PGParser<any>, nested: false): any[]
+function parseInternal(source: string, parser: PGParser<any>, nested: true): SubArrayResult
+function parseInternal(source: string, parser: PGParser<any>, nested: boolean): any[] | SubArrayResult {
+  const entries = []
+  let character = ''
+  let quote = false
+  let position = 0
+  let dimension = 0
+  let recorded = ''
+
+  const newEntry = (includeEmpty?: boolean): void => {
+    let entry: string | null = recorded
+
+    if (entry.length > 0 || includeEmpty) {
+      if (entry === 'NULL' && !includeEmpty) {
+        entry = null
+      }
+
+      if (entry !== null) {
+        entries.push(parser(entry))
+      } else {
+        entries.push(null)
+      }
+
+      recorded = ''
+    }
+  }
+
+  if (source[0] === '[') {
+    while (position < source.length) {
+      const char = source[position++]
+
+      if (char === '=') {
+        break
+      }
+    }
+  }
+
+  while (position < source.length) {
+    let escaped = false
+    character = source[position++]!
+
+    if (character === '\\') {
+      character = source[position++]!
+      escaped = true
+    }
+
+    if (character === '{' && !quote) {
+      dimension++
+
+      if (dimension > 1) {
+        const result = parseInternal(source.substring(position - 1), parser, true)
+        entries.push(result.entries)
+        position += result.position - 2
+      }
+    } else if (character === '}' && !quote) {
+      dimension--
+
+      if (!dimension) {
+        newEntry()
+
+        if (nested) {
+          return {
+            entries,
+            position,
+          }
+        }
+      }
+    } else if (character === '"' && !escaped) {
+      if (quote) {
+        newEntry(true)
+      }
+
+      quote = !quote
+    } else if (character === ',' && !quote) {
+      newEntry()
+    } else {
+      recorded += character
+    }
+  }
+
+  if (dimension !== 0) {
+    throw new Error('array dimension not balanced')
+  }
+
+  return entries
+}

package/src/parsers/basic.ts

@@ -0,0 +1,55 @@
+/* ========================================================================== *
+ * PARSE BASIC TYPES                                                          *
+ * ========================================================================== */
+
+import postgresDate from 'postgres-date'
+
+import type { PGParser } from '../parsers'
+
+/* ===== INVALID CONSTANTS ================================================== */
+
+const INVALID_DATE = new Date(NaN)
+
+/* ===== BASIC PARSERS ====================================================== */
+
+// parseInt and parseFloat are from JS
+
+/** Parse a `bigint` */
+export const parseBigint: PGParser<bigint> = BigInt
+
+/** Parse some JSON */
+export const parseJson: PGParser<any> = JSON.parse
+
+/** Parse a `boolean` */
+export const parseBool: PGParser<boolean> = (value: string): boolean => {
+  return value === 'TRUE' ||
+         value === 't' ||
+         value === 'true' ||
+         value === 'y' ||
+         value === 'yes' ||
+         value === 'on' ||
+         value === '1'
+}
+
+/** Parse a `string` (identity transformation) */
+export const parseString: PGParser<string> = (value: string): string => value
+
+/** Parse anything into `null` (normally used only for `void` types) */
+export const parseVoid: PGParser<null> = (): null => null
+
+/* ===== WRAP POSTGRES-DATE ================================================= */
+
+/** Parse a PostgreSQL timestamp _without_ time zone */
+export const parseTimestamp: PGParser<Date> = (value: string): Date => {
+  const utc = value.endsWith(' BC') ?
+    value.slice(0, -3) + 'Z BC' :
+    value + 'Z'
+
+  return parseTimestampTz(utc)
+}
+
+/** Parse a PostgreSQL timestamp _with_ time zone */
+export const parseTimestampTz: PGParser<Date> = (value: string): Date => {
+  const date = postgresDate(value)
+  return date instanceof Date ? date : INVALID_DATE
+}