@typesql/pg 0.2.7 → 0.2.9

package/src/introspect/emit.ts

@@ -5,33 +5,19 @@ import type {
 } from "./introspect.js";
 
 export interface GenerateOptions {
-	/** Name of the exported schema interface. Default `"DB"`. */
 	readonly typeName?: string;
-	/** Module the column helpers are imported from. Default `"@typesql/core"`. */
 	readonly importFrom?: string;
-	/** Extra lines after the helper import, e.g. `import type { HistoryItem } from "./json.js";`. */
 	readonly imports?: readonly string[];
-	/**
-	 * TypeScript types of `json` / `jsonb` columns: a map keyed `"table.column"` (public) or
-	 * `"schema.table.column"`, or a function returning the TS type source for a column (or
-	 * `undefined`). Such a column is declared as `Json<T>`: still jsonb to the SQL, read as `T`,
-	 * written with `sql.json(value)`. Other columns are an error (use `column` for those).
-	 */
 	readonly columnTypes?:
 		| Readonly<Record<string, string>>
 		| ((
 				column: IntrospectedColumn,
 				relation: IntrospectedRelation,
 		  ) => string | undefined);
-	/**
-	 * Full control over one column: return the TypeScript source of its descriptor
-	 * (`Col<"jsonb">`, a helper of your own, ...) or `undefined` to keep the default.
-	 */
 	readonly column?: (
 		column: IntrospectedColumn,
 		relation: IntrospectedRelation,
 	) => string | undefined;
-	/** Emit table and column comments and notes as JSDoc. Default `true`. */
 	readonly comments?: boolean;
 }
 
@@ -76,11 +62,6 @@ function columnNotes(c: IntrospectedColumn): string[] {
 	return notes;
 }
 
-/**
- * TypeScript source declaring the TypeSQL schema of an introspected database: `public`
- * relations at the top level, other schemas nested (`DB["auth"]["sessions"]`), views and
- * materialized views as `View<…>`, enums under `$types`.
- */
 export function generateSource(
 	db: IntrospectedDatabase,
 	options: GenerateOptions = {},
@@ -91,7 +72,6 @@ export function generateSource(
 	const used = new Set<string>();
 	const usedKeys = new Set<string>();
 
-	/** The TS type `columnTypes` gives a column, if any. */
 	const customType = (
 		rel: IntrospectedRelation,
 		col: IntrospectedColumn,
@@ -101,7 +81,6 @@ export function generateSource(
 		let ts: string | undefined;
 		if (typeof columnTypes === "function") ts = columnTypes(col, rel);
 		else {
-			// The keys contain a dot, so no key is a property every object has.
 			const k =
 				rel.schema === "public" && !(qualified in columnTypes)
 					? short
@@ -117,7 +96,6 @@ export function generateSource(
 		return ts;
 	};
 
-	/** `Json<T>`, `Json<T, { nullable: true }>`, `Json<T, {}, "json">`, … */
 	const jsonDescriptor = (col: IntrospectedColumn, ts: string): string => {
 		const flags = [
 			...(col.nullable ? ["nullable: true"] : []),
@@ -185,8 +163,6 @@ export function generateSource(
 	}
 
 	if (db.enums.length > 0) {
-		// TypeSQL's enum registry is flat (`Col<"mood">`, schema qualifiers are dropped), so enums
-		// of the same name in different schemas share an entry.
 		const byName = new Map<
 			string,
 			{ values: Set<string>; schemas: string[] }
@@ -237,7 +213,6 @@ export function generateSource(
 		"}",
 		"",
 	];
-	// A function has no keys of its own.
 	const unknownKeys = Object.keys(columnTypes).filter((k) => !usedKeys.has(k));
 	if (unknownKeys.length > 0 && options.column === undefined) {
 		throw new Error(

package/src/introspect/introspect.ts

@@ -10,23 +10,13 @@ export type RelationKind =
 
 export interface IntrospectedColumn {
 	readonly name: string;
-	/**
-	 * Canonical Postgres type name as TypeSQL spells it: `int4`, `timestamptz`, `varchar`, an enum
-	 * name, `${T}[]` for arrays. Domains are replaced by their base type; `citext` is `text`.
-	 */
 	readonly type: string;
-	/** The column's type as Postgres prints it (`character varying(40)`, a domain name, ...). */
 	readonly declaredType: string;
-	/** The domain the column is declared with, if any (`public.positive`). */
 	readonly domain: string | null;
 	readonly nullable: boolean;
-	/** Optional on INSERT: a DEFAULT, serial, identity or generated column. Always false for views. */
 	readonly hasDefault: boolean;
-	/** `GENERATED ALWAYS AS IDENTITY` / `GENERATED BY DEFAULT AS IDENTITY`. */
 	readonly identity: "always" | "by default" | null;
-	/** The expression of a `GENERATED ALWAYS AS (…) STORED` column. */
 	readonly generated: string | null;
-	/** The DEFAULT expression. */
 	readonly default: string | null;
 	readonly comment: string | null;
 }
@@ -42,32 +32,19 @@ export interface IntrospectedRelation {
 export interface IntrospectedEnum {
 	readonly schema: string;
 	readonly name: string;
-	/** Labels in sort order. */
 	readonly values: readonly string[];
 }
 
 export interface IntrospectedDatabase {
-	/** `server_version`, e.g. `17.2`. */
 	readonly version: string;
-	/** Schemas that were read, in order. */
 	readonly schemas: readonly string[];
 	readonly relations: readonly IntrospectedRelation[];
-	/** Enums of the read schemas and enums their columns use. */
 	readonly enums: readonly IntrospectedEnum[];
 }
 
 export interface IntrospectOptions {
-	/** Schemas to read. Default: every schema except `pg_catalog`, `information_schema` and `pg_*`. */
 	readonly schemas?: readonly string[];
-	/**
-	 * Relations to leave out: names (`kysely_migration`) or `schema.name`, with `*` matching any
-	 * run of characters (`kysely_migration*`, `audit.*`).
-	 */
 	readonly exclude?: readonly string[];
-	/**
-	 * View columns to treat as NOT NULL when the analysis cannot prove it, called with the view's
-	 * name and the column's name.
-	 */
 	readonly viewNotNull?: NullabilityOptions["notNull"];
 }
 
@@ -87,7 +64,6 @@ const KINDS: Readonly<Record<string, RelationKind>> = {
 	f: "foreign table",
 };
 
-/** Postgres type names TypeSQL spells differently. */
 const TYPE_ALIASES: Readonly<Record<string, string>> = { citext: "text" };
 
 interface TypeRow {
@@ -104,7 +80,6 @@ interface TypeRow {
 interface ResolvedType {
 	readonly type: string;
 	readonly notnull: boolean;
-	/** The type under the domains and arrays: the enum the column uses, if it is one. */
 	readonly scalarOid: string;
 	readonly domain: string | null;
 }
@@ -112,7 +87,6 @@ interface ResolvedType {
 function resolver(types: ReadonlyMap<string, TypeRow>) {
 	const resolve = (oid: string): ResolvedType => {
 		const t = types.get(oid);
-		// A type created after the types were read (a concurrent CREATE TYPE and CREATE TABLE)
 		if (!t)
 			return { type: "unknown", notnull: false, scalarOid: oid, domain: null };
 		if (t.typtype === "d") {
@@ -123,8 +97,6 @@ function resolver(types: ReadonlyMap<string, TypeRow>) {
 				domain: `${t.schema}.${t.name}`,
 			};
 		}
-		// `typelem` is "0" (no type) for scalars; fixed-length types like `point` have one but are
-		// not its array type.
 		const elem = types.get(t.elem);
 		if (elem && elem.array === t.oid) {
 			const inner = resolve(elem.oid);
@@ -145,13 +117,8 @@ function resolver(types: ReadonlyMap<string, TypeRow>) {
 	return resolve;
 }
 
-/** Default schema filter: everything but the system schemas. */
 const USER_SCHEMAS = `n.nspname NOT IN ('pg_catalog', 'information_schema') AND n.nspname NOT LIKE 'pg\\_%'`;
 
-/**
- * Read tables, views, materialized views, foreign tables and enums of a live database through
- * any node-postgres-style client (`Client`, `Pool`, `PoolClient`).
- */
 export async function introspect(
 	client: PgQueryable,
 	options: IntrospectOptions = {},
@@ -244,7 +211,6 @@ export async function introspect(
 			...(options.viewNotNull && { notNull: options.viewNotNull }),
 		},
 	);
-	/** Types the columns use: their enums are read even outside `schemas`. */
 	const usedTypes = new Set<string>();
 	const relations: IntrospectedRelation[] = [];
 	for (const rel of relRows) {
@@ -268,7 +234,6 @@ export async function introspect(
 					declaredType: c.declared,
 					domain: t.domain,
 					nullable: viewNotNull ? !viewNotNull[i] : !(c.notnull || t.notnull),
-					// A generated column's expression is its `default` row in pg_attrdef.
 					hasDefault: !isView && (c.default !== null || identity !== null),
 					identity,
 					generated,

package/src/introspect/nullability.ts

@@ -1,45 +1,20 @@
-/**
- * Nullability of view columns, derived from the view's query tree.
- *
- * Postgres records no NOT NULL information for view (or materialized view) columns. Its rewrite
- * rule (`pg_rewrite.ev_action`, the `_RETURN` rule) holds the parsed query, though, and from
- * PostgreSQL 16 every column reference in it carries `varnullingrels`, the outer joins that can
- * null it. A view column is NOT NULL here only when its expression provably cannot be NULL: a
- * NOT NULL table column that no outer join nulls, a non-NULL constant, a cast or a strict
- * operator over such values, a CASE whose every branch is NOT NULL, `count(*)`, ... Anything
- * else (function calls outside a short list, scalar subqueries, set-returning function columns)
- * is nullable. On PostgreSQL 15 and older every column reference counts as nullable.
- *
- * This module has no imports so that scripts/pg-catalog-from-pg.ts can load it with Node's
- * type stripping.
- */
-
-/** Runs a query: node-postgres' `client.query(text, values)` fits. */
 export type QueryFn = (
 	text: string,
 	values?: unknown[],
 ) => Promise<{ readonly rows: readonly any[] }>;
 
 export interface NullabilityOptions {
-	/**
-	 * Columns known never to be NULL that the analysis cannot prove (typically columns of a
-	 * set-returning function). Called with the view's name and the column's name.
-	 */
 	readonly notNull?: (view: string, column: string) => boolean;
 }
 
-/** A node of a parsed `pg_node_tree`: `{ _: "VAR", varno: "1", … }`. */
 export interface Node {
 	readonly _: string;
 	readonly [field: string]: NodeValue;
 }
 export type NodeValue = Node | readonly NodeValue[] | string | null;
 
-// ───────────────────────────── pg_node_tree reader ─────────────────────────────
-
 type Token = string | { readonly str: string };
 
-/** Tokens of the text form of a node tree (`outfuncs.c`). `[ … ]` datum bytes are skipped. */
 function tokenize(s: string): Token[] {
 	const out: Token[] = [];
 	let i = 0;
@@ -79,7 +54,6 @@ function tokenize(s: string): Token[] {
 	return out;
 }
 
-/** Parse a node tree into plain values: nodes as objects, lists as arrays, `<>` as null. */
 export function parseNodeTree(text: string): NodeValue {
 	const toks = tokenize(text);
 	let p = 0;
@@ -91,7 +65,7 @@ export function parseNodeTree(text: string): NodeValue {
 			const node: Record<string, NodeValue> = { _: toks[p++] as string };
 			while (p < toks.length && toks[p] !== "}") {
 				const label = toks[p++];
-				if (!isLabel(label)) continue; // a datum's length before its skipped bytes
+				if (!isLabel(label)) continue;
 				if (toks[p] === "}" || isLabel(toks[p])) {
 					node[(label as string).slice(1)] = null;
 					continue;
@@ -120,9 +94,6 @@ const node = (x: NodeValue | undefined): Node | null =>
 const str = (x: NodeValue | undefined): string | null =>
 	typeof x === "string" ? x : null;
 
-// ───────────────────────────── function knowledge ─────────────────────────────
-
-/** `pg_catalog` functions that return a non-NULL value for non-NULL arguments. */
 const NON_NULL_FUNCTIONS = new Set([
 	"current_database",
 	"current_user",
@@ -167,7 +138,6 @@ const NON_NULL_FUNCTIONS = new Set([
 	"age",
 ]);
 
-/** `pg_stat_get_*` accessors returning a number report 0 when no statistics exist, except these. */
 const NULLABLE_STAT_FUNCTIONS = new Set([
 	"pg_stat_get_db_checksum_failures",
 	"pg_stat_get_backend_pid",
@@ -179,9 +149,7 @@ const isNonNullStatFunction = (name: string, ret: string): boolean =>
 	(ret === "int8" || ret === "int4" || ret === "float8") &&
 	!NULLABLE_STAT_FUNCTIONS.has(name);
 
-/** Aggregates that never return NULL. */
 const NON_NULL_AGGREGATES = new Set(["count"]);
-/** Window functions that never return NULL. */
 const NON_NULL_WINDOW_FUNCTIONS = new Set([
 	"count",
 	"row_number",
@@ -191,12 +159,6 @@ const NON_NULL_WINDOW_FUNCTIONS = new Set([
 	"cume_dist",
 ]);
 
-/**
- * Set-returning functions in FROM and their output columns (1-based) that are never NULL. A
- * strict set-returning function returns no rows for NULL arguments, so the arguments do not
- * matter. `jsonb_each` values are `jsonb` (a JSON null is `'null'::jsonb`, not SQL NULL);
- * the `_text` variants turn a JSON null into SQL NULL.
- */
 const NON_NULL_SRF_COLUMNS: Readonly<Record<string, readonly number[]>> = {
 	generate_series: [1],
 	generate_subscripts: [1],
@@ -212,11 +174,6 @@ const NON_NULL_SRF_COLUMNS: Readonly<Record<string, readonly number[]>> = {
 	regexp_split_to_table: [1],
 };
 
-/**
- * `pg_catalog` operators that can return NULL for non-NULL operands: JSON field and path access
- * (a missing key) and jsonpath matches (an unknown result). Other built-in operators are strict
- * and return a value for non-NULL operands; operators outside `pg_catalog` count as nullable.
- */
 const NULLABLE_OPERATORS = new Set(["->", "->>", "#>", "#>>", "@@", "@?"]);
 
 interface Proc {
@@ -230,9 +187,6 @@ interface Att {
 	readonly relkind: string;
 }
 
-// ───────────────────────────── analysis ─────────────────────────────
-
-/** Per-column NOT NULL of views and materialized views; caches what it reads. */
 export class ViewNullability {
 	private readonly query: QueryFn;
 	private readonly options: NullabilityOptions;
@@ -247,11 +201,8 @@ export class ViewNullability {
 		this.options = options;
 	}
 
-	/** NOT NULL flags of the view's columns, in column order. `relid` is the view's `pg_class.oid`. */
 	notNull(relid: string | number): Promise<boolean[]> {
 		const key = String(relid);
-		// CREATE OR REPLACE VIEW allows a view that reads itself through others: waiting for its own
-		// analysis would never end
 		if (this.analyzing.has(key)) return Promise.resolve([]);
 		let cached = this.views.get(key);
 		if (!cached) {
@@ -307,7 +258,6 @@ export class ViewNullability {
 		return this.operators;
 	}
 
-	/** A built-in operator that returns a value for non-NULL operands. */
 	private async strictOperator(e: Node): Promise<boolean> {
 		const op = (await this.loadOperators()).get(String(e["opno"]));
 		return op?.system === true && !NULLABLE_OPERATORS.has(op.name);
@@ -317,7 +267,6 @@ export class ViewNullability {
 		let cached = this.atts.get(relid);
 		if (!cached) {
 			cached = this.query(
-				// NOT NULL: the column's constraint, or a NOT NULL domain anywhere in its domain chain.
 				`SELECT a.attnum, c.relkind,
                 a.attnotnull OR coalesce((
                   WITH RECURSIVE chain(oid, nn) AS (
@@ -335,7 +284,6 @@ export class ViewNullability {
 		return cached;
 	}
 
-	/** Is output column `attno` (1-based) of a (sub)query NOT NULL? */
 	private async queryColumn(
 		value: NodeValue | undefined,
 		attno: number,
@@ -343,8 +291,6 @@ export class ViewNullability {
 		const query = node(value);
 		if (!query) return false;
 		if (query["setOperations"]) {
-			// UNION / INTERSECT / EXCEPT: every arm must be NOT NULL. The range table of a set
-			// operation holds its arms, as subqueries, and nothing else.
 			for (const r of list(query["rtable"]))
 				if (!(await this.queryColumn(node(r)?.["subquery"], attno)))
 					return false;
@@ -358,17 +304,14 @@ export class ViewNullability {
 	}
 
 	private async variable(v: Node, query: Node): Promise<boolean> {
-		// No varnullingrels (PostgreSQL ≤ 15): outer joins are not visible, so nothing is proven.
 		if (!("varnullingrels" in v) || v["varlevelsup"] !== "0") return false;
-		if (list(v["varnullingrels"]).length > 1) return false; // `(b 3)`: an outer join can null it
-		// ROLLUP / CUBE / GROUPING SETS null the grouped columns (PostgreSQL ≤ 17 does not mark them).
+		if (list(v["varnullingrels"]).length > 1) return false;
 		if (list(query["groupingSets"]).length > 0) return false;
 		const rte = node(list(query["rtable"])[Number(v["varno"]) - 1]);
 		const attno = Number(v["varattno"]);
 		if (!rte || !(attno > 0)) return false;
 		switch (rte["rtekind"]) {
 			case "0": {
-				// relation
 				const relid = str(rte["relid"])!;
 				const att = (await this.columns(relid)).find((a) => a.attnum === attno);
 				if (!att) return false;
@@ -376,19 +319,18 @@ export class ViewNullability {
 					return (await this.notNull(relid))[attno - 1] ?? false;
 				return att.notnull;
 			}
-			case "1": // subquery
+			case "1":
 				return this.queryColumn(rte["subquery"], attno);
-			case "2": // join alias variable
+			case "2":
 				return this.expr(list(rte["joinaliasvars"])[attno - 1], query);
-			case "3": // function in FROM
+			case "3":
 				return this.functionColumn(rte, attno);
-			case "9": // PostgreSQL 18 GROUP BY expressions
+			case "9":
 				return this.expr(list(rte["groupexprs"])[attno - 1], query);
 		}
-		return false; // VALUES, CTEs, table functions, ...
+		return false;
 	}
 
-	/** Column `attno` of a single set-returning function in FROM (`WITH ORDINALITY` adds a NOT NULL counter). */
 	private async functionColumn(rte: Node, attno: number): Promise<boolean> {
 		const functions = list(rte["functions"]);
 		const only = node(functions[0]);
@@ -432,10 +374,8 @@ export class ViewNullability {
 			case "FUNCEXPR": {
 				if (e["funcretset"] !== "false") return false;
 				const proc = (await this.loadProcs()).get(String(e["funcid"]));
-				// format_type(type, typmod) is not strict: a NULL typmod still gives a name.
 				if (proc?.system && proc.name === "format_type")
 					return this.expr(list(e["args"])[0], query);
-				// Explicit and implicit casts (funcformat 1, 2) keep a non-NULL input non-NULL.
 				const castLike = e["funcformat"] === "1" || e["funcformat"] === "2";
 				const known =
 					proc?.system === true &&
@@ -448,8 +388,6 @@ export class ViewNullability {
 			case "OPEXPR":
 				return (await this.strictOperator(e)) && this.all(e["args"], query);
 			case "SCALARARRAYOPEXPR": {
-				// `x = ANY (arr)` is NULL when there is no match and `arr` holds a NULL: only an
-				// `ARRAY[…]` of NOT NULL elements is safe.
 				const [left, right] = list(e["args"]);
 				const array = node(right);
 				return (
@@ -474,7 +412,7 @@ export class ViewNullability {
 				for (const w of list(e["args"]))
 					if (!(await this.expr(node(w)?.["result"], query))) return false;
 				return this.expr(e["defresult"], query);
-			case "SUBLINK": // EXISTS (0) and ARRAY (6) sublinks are never NULL
+			case "SUBLINK":
 				return e["subLinkType"] === "0" || e["subLinkType"] === "6";
 			case "AGGREF": {
 				const proc = (await this.loadProcs()).get(String(e["aggfnoid"]));

package/src/type-map.ts

@@ -1,56 +1,9 @@
 import type { DefaultParamTypeMap, DefaultTypeMap } from "@typesql/core";
 
-/**
- * The object node-postgres returns for an `interval` column (package `postgres-interval` 1.x,
- * wired up by `pg-types`). Fields are only present when non-zero; `toPostgres()` renders the
- * value back to Postgres syntax and `toISO()`/`toISOString()` produce an ISO 8601 duration.
- *
- * Written inline in `PgTypeMap` (this alias only reads it back), so row types stay plain
- * object types: declaration emit in a package without a direct `@typesql/pg` dependency does
- * not need to name `PgInterval` (TS2883).
- */
 export type PgInterval = PgTypeMap["interval"];
 
-/**
- * Canonical Postgres type name → TS type as `pg` 8.x returns it with its default type
- * parsers (`pg-types` 2.x, text protocol). Verified against `pg-types/lib/textParsers.js`:
- *
- *   number   int2 (21), int4 (23), oid (26), float4 (700), float8 (701)
- *   string   int8 (20) — `parseBigInteger` keeps the digits as a string, numeric (1700),
- *            money, text, varchar, bpchar, char, name, uuid, time, timetz, inet, cidr,
- *            macaddr, macaddr8, xml, bit, varbit, tsvector, tsquery, every range type,
- *            regclass/regtype/regproc, line/lseg/box/path/polygon — anything without a
- *            registered parser comes back as the raw text representation
- *   boolean  bool (16)
- *   Date     date (1082), timestamp (1114), timestamptz (1184)
- *            (`'infinity'`/`'-infinity'` come back as the numbers Infinity/-Infinity)
- *   unknown  json (114), jsonb (3802): `JSON.parse`d
- *   Buffer   bytea (17)
- *   object   interval (1186) → PgInterval, point (600) → { x, y }, circle (718) → { x, y, radius }
- *
- * `DefaultTypeMap` in core already describes pg; this interface only narrows the entries
- * that differ in detail (`Buffer` instead of `Uint8Array`, the interval object's methods,
- * `record`/`void` as their raw text).
- *
- * Arrays: core maps `T[]` element-wise (`TsTypeOf` checks the `[]` suffix before the map),
- * which matches pg for the array types that `pg-types` registers: bool[], bytea[], int2[],
- * int4[], int8[] (string[]), oid[], float4[], float8[], point[], bpchar[], varchar[], text[],
- * macaddr[], inet[], cidr[], date[], timestamp[], timestamptz[], interval[], json[], jsonb[],
- * uuid[], money[], time[], timetz[], numrange[]. Two kinds of mismatch exist and cannot be
- * expressed in this map:
- *   - `numeric[]` (1231) is parsed with `parseFloat` → `number[]` at runtime, while the
- *     element-wise type says `string[]`.
- *   - Array types without a registered parser come back as the raw `{...}` string, not an
- *     array: name[], "char"[], xml[], bit[], varbit[], tsvector[], tsquery[], circle[],
- *     line[], lseg[], box[], path[], polygon[], int4range[], int8range[], tsrange[],
- *     tstzrange[], daterange[], macaddr8[], regclass[]/regtype[]/regproc[], record[].
- * Register your own parser (`pg.types.setTypeParser`) or cast in SQL if you depend on these.
- * The two that `PgCatalog` columns use are declared here as the text pg returns: `aclitem[]`
- * (`relacl`, `datacl`, ...) and `"char"[]` (`proargmodes`).
- */
 export interface PgTypeMap
 	extends Omit<DefaultTypeMap, "bytea" | "interval" | "record" | "void"> {
-	/** What parameters accept on top of the row types. */
 	$params: PgParamTypeMap;
 	bytea: Buffer;
 	interval: {
@@ -65,28 +18,10 @@ export interface PgTypeMap
 		toISO(): string;
 		toISOString(): string;
 	};
-	/** Anonymous `ROW(...)` results have no parser: raw text such as `"(1,foo)"`. */
 	record: string;
-	/** `void`-returning functions (`pg_sleep`) yield an empty string. */
 	void: string;
-	/** No array parser: the raw `{...}` text, e.g. `"{postgres=arwdDxtm/postgres}"`. */
 	"aclitem[]": string;
-	/** No array parser for `"char"[]`: the raw `{...}` text, e.g. `"{i,o}"`. */
 	"char[]": string;
 }
 
-/**
- * TS types `pg` parameters accept on top of the row type (`PgTypeMap["$params"]`). Verified
- * against `pg/lib/utils.js` (`prepareValue`, 8.x): a `Date` is sent as a timestamp with the
- * local offset, `Buffer`/typed arrays as bytea, a `bigint` or number with `toString()`, and
- * objects with `toPostgres()` (such as `PgInterval`) through it; Postgres parses the text.
- *
- *   int8, numeric, money          number | bigint | string
- *   date, timestamp, timestamptz  Date | string
- *   interval                      string, besides the `PgInterval` row type
- *   bytea                         Uint8Array, besides `Buffer`
- *
- * Plain objects are `JSON.stringify`d and arrays become Postgres array literals, so neither is
- * listed for other types.
- */
 export interface PgParamTypeMap extends DefaultParamTypeMap {}