@typesql/pg 0.1.5 → 0.2.0

package/src/introspect/index.ts

@@ -1,12 +1,11 @@
+export type { IntrospectConfig } from "./cli.js";
+export { type GenerateOptions, generateSource } from "./emit.js";
 export {
-  introspect,
-  type IntrospectOptions,
-  type IntrospectedDatabase,
-  type IntrospectedRelation,
-  type IntrospectedColumn,
-  type IntrospectedEnum,
-  type RelationKind,
+	type IntrospectedColumn,
+	type IntrospectedDatabase,
+	type IntrospectedEnum,
+	type IntrospectedRelation,
+	type IntrospectOptions,
+	introspect,
+	type RelationKind,
 } from "./introspect.js";
-export { generateSource, type GenerateOptions } from "./emit.js";
-export { ViewNullability, parseNodeTree, type NullabilityOptions, type QueryFn } from "./nullability.js";
-export { main, type IntrospectConfig } from "./cli.js";

package/src/introspect/introspect.ts

@@ -1,119 +1,144 @@
 import type { PgQueryable } from "../client.js";
-import { ViewNullability, type NullabilityOptions } from "./nullability.js";
+import { type NullabilityOptions, ViewNullability } from "./nullability.js";
 
-export type RelationKind = "table" | "partitioned table" | "view" | "materialized view" | "foreign table";
+export type RelationKind =
+	| "table"
+	| "partitioned table"
+	| "view"
+	| "materialized view"
+	| "foreign table";
 
 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;
+	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;
 }
 
 export interface IntrospectedRelation {
-  readonly schema: string;
-  readonly name: string;
-  readonly kind: RelationKind;
-  readonly comment: string | null;
-  readonly columns: readonly IntrospectedColumn[];
+	readonly schema: string;
+	readonly name: string;
+	readonly kind: RelationKind;
+	readonly comment: string | null;
+	readonly columns: readonly IntrospectedColumn[];
 }
 
 export interface IntrospectedEnum {
-  readonly schema: string;
-  readonly name: string;
-  /** Labels in sort order. */
-  readonly values: readonly string[];
+	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[];
+	/** `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"];
+	/** 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"];
 }
 
 const globToRegExp = (glob: string): RegExp =>
-  new RegExp(`^${glob.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+	new RegExp(
+		`^${glob
+			.split("*")
+			.map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+			.join(".*")}$`,
+	);
 
 const KINDS: Readonly<Record<string, RelationKind>> = {
-  r: "table",
-  p: "partitioned table",
-  v: "view",
-  m: "materialized view",
-  f: "foreign table",
+	r: "table",
+	p: "partitioned table",
+	v: "view",
+	m: "materialized view",
+	f: "foreign table",
 };
 
 /** Postgres type names TypeSQL spells differently. */
 const TYPE_ALIASES: Readonly<Record<string, string>> = { citext: "text" };
 
 interface TypeRow {
-  readonly oid: string;
-  readonly name: string;
-  readonly schema: string;
-  readonly typtype: string;
-  readonly basetype: string;
-  readonly elem: string;
-  readonly array: string;
-  readonly notnull: boolean;
+	readonly oid: string;
+	readonly name: string;
+	readonly schema: string;
+	readonly typtype: string;
+	readonly basetype: string;
+	readonly elem: string;
+	readonly array: string;
+	readonly notnull: boolean;
 }
 
 interface ResolvedType {
-  readonly type: string;
-  readonly notnull: boolean;
-  readonly enumOid: string | null;
-  readonly domain: string | null;
+	readonly type: string;
+	readonly notnull: boolean;
+	readonly enumOid: string | null;
+	readonly domain: string | null;
 }
 
 function resolver(types: ReadonlyMap<string, TypeRow>) {
-  const resolve = (oid: string): ResolvedType => {
-    const t = types.get(oid);
-    if (!t) return { type: "unknown", notnull: false, enumOid: null, domain: null };
-    if (t.typtype === "d") {
-      const base = resolve(t.basetype);
-      return { ...base, notnull: base.notnull || t.notnull, domain: `${t.schema}.${t.name}` };
-    }
-    const elem = t.elem !== "0" ? types.get(t.elem) : undefined;
-    if (elem && elem.array === t.oid) {
-      const inner = resolve(elem.oid);
-      return { type: inner.type.endsWith("[]") ? inner.type : `${inner.type}[]`, notnull: false, enumOid: inner.enumOid, domain: null };
-    }
-    return { type: TYPE_ALIASES[t.name] ?? t.name, notnull: false, enumOid: t.typtype === "e" ? t.oid : null, domain: null };
-  };
-  return resolve;
+	const resolve = (oid: string): ResolvedType => {
+		const t = types.get(oid);
+		if (!t)
+			return { type: "unknown", notnull: false, enumOid: null, domain: null };
+		if (t.typtype === "d") {
+			const base = resolve(t.basetype);
+			return {
+				...base,
+				notnull: base.notnull || t.notnull,
+				domain: `${t.schema}.${t.name}`,
+			};
+		}
+		const elem = t.elem !== "0" ? types.get(t.elem) : undefined;
+		if (elem && elem.array === t.oid) {
+			const inner = resolve(elem.oid);
+			return {
+				type: inner.type.endsWith("[]") ? inner.type : `${inner.type}[]`,
+				notnull: false,
+				enumOid: inner.enumOid,
+				domain: null,
+			};
+		}
+		return {
+			type: TYPE_ALIASES[t.name] ?? t.name,
+			notnull: false,
+			enumOid: t.typtype === "e" ? t.oid : null,
+			domain: null,
+		};
+	};
+	return resolve;
 }
 
 /** Default schema filter: everything but the system schemas. */
@@ -123,48 +148,79 @@ const USER_SCHEMAS = `n.nspname NOT IN ('pg_catalog', 'information_schema') AND
  * 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 = {}): Promise<IntrospectedDatabase> {
-  const q = async <R>(text: string, values?: unknown[]): Promise<R[]> => (await client.query(text, values)).rows as R[];
+export async function introspect(
+	client: PgQueryable,
+	options: IntrospectOptions = {},
+): Promise<IntrospectedDatabase> {
+	const q = async <R>(text: string, values?: unknown[]): Promise<R[]> =>
+		(await client.query(text, values)).rows as R[];
 
-  const [{ version }] = (await q<{ version: string }>(`SELECT current_setting('server_version') AS version`)) as [{ version: string }];
-  const schemaRows = options.schemas
-    ? await q<{ name: string }>(
-        `SELECT n.nspname AS name FROM unnest($1::text[]) WITH ORDINALITY AS s(name, i)
+	const [{ version }] = (await q<{ version: string }>(
+		`SELECT current_setting('server_version') AS version`,
+	)) as [{ version: string }];
+	const schemaRows = options.schemas
+		? await q<{ name: string }>(
+				`SELECT n.nspname AS name FROM unnest($1::text[]) WITH ORDINALITY AS s(name, i)
            JOIN pg_namespace n ON n.nspname = s.name ORDER BY s.i`,
-        [[...options.schemas]],
-      )
-    : await q<{ name: string }>(
-        `SELECT n.nspname AS name FROM pg_namespace n WHERE ${USER_SCHEMAS}
+				[[...options.schemas]],
+			)
+		: await q<{ name: string }>(
+				`SELECT n.nspname AS name FROM pg_namespace n WHERE ${USER_SCHEMAS}
           ORDER BY n.nspname <> 'public', n.nspname`,
-      );
-  const schemas = schemaRows.map((r) => r.name);
-  const missing = (options.schemas ?? []).filter((s) => !schemas.includes(s));
-  if (missing.length > 0) throw new Error(`schema ${missing.map((s) => JSON.stringify(s)).join(", ")} does not exist`);
-
-  const types = new Map(
-    (await q<TypeRow>(
-      `SELECT t.oid::int8::text AS oid, t.typname AS name, n.nspname AS schema, t.typtype,
+			);
+	const schemas = schemaRows.map((r) => r.name);
+	const missing = (options.schemas ?? []).filter((s) => !schemas.includes(s));
+	if (missing.length > 0)
+		throw new Error(
+			`schema ${missing.map((s) => JSON.stringify(s)).join(", ")} does not exist`,
+		);
+
+	const types = new Map(
+		(
+			await q<TypeRow>(
+				`SELECT t.oid::int8::text AS oid, t.typname AS name, n.nspname AS schema, t.typtype,
               t.typbasetype::int8::text AS basetype, t.typelem::int8::text AS elem,
               t.typarray::int8::text AS array, t.typnotnull AS notnull
          FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace`,
-    )).map((t) => [t.oid, t]),
-  );
-  const resolve = resolver(types);
+			)
+		).map((t) => [t.oid, t]),
+	);
+	const resolve = resolver(types);
 
-  const excluded = (options.exclude ?? []).map(globToRegExp);
-  const relRows = (await q<{ oid: string; schema: string; name: string; relkind: string; comment: string | null }>(
-    `SELECT c.oid::int8::text AS oid, n.nspname AS schema, c.relname AS name, c.relkind,
+	const excluded = (options.exclude ?? []).map(globToRegExp);
+	const relRows = (
+		await q<{
+			oid: string;
+			schema: string;
+			name: string;
+			relkind: string;
+			comment: string | null;
+		}>(
+			`SELECT c.oid::int8::text AS oid, n.nspname AS schema, c.relname AS name, c.relkind,
             obj_description(c.oid, 'pg_class') AS comment
        FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
       WHERE c.relkind IN ('r', 'p', 'v', 'm', 'f') AND n.nspname = ANY($1::text[])
       ORDER BY array_position($1::text[], n.nspname::text), c.relname`,
-    [schemas],
-  )).filter((r) => !excluded.some((re) => re.test(r.name) || re.test(`${r.schema}.${r.name}`)));
-  const colRows = await q<{
-    relid: string; name: string; typid: string; declared: string; notnull: boolean;
-    identity: string; generated: string; default: string | null; comment: string | null;
-  }>(
-    `SELECT a.attrelid::int8::text AS relid, a.attname AS name, a.atttypid::int8::text AS typid,
+			[schemas],
+		)
+	).filter(
+		(r) =>
+			!excluded.some(
+				(re) => re.test(r.name) || re.test(`${r.schema}.${r.name}`),
+			),
+	);
+	const colRows = await q<{
+		relid: string;
+		name: string;
+		typid: string;
+		declared: string;
+		notnull: boolean;
+		identity: string;
+		generated: string;
+		default: string | null;
+		comment: string | null;
+	}>(
+		`SELECT a.attrelid::int8::text AS relid, a.attname AS name, a.atttypid::int8::text AS typid,
             format_type(a.atttypid, a.atttypmod) AS declared, a.attnotnull AS notnull,
             a.attidentity AS identity, a.attgenerated AS generated,
             pg_get_expr(d.adbin, d.adrelid) AS default, col_description(a.attrelid, a.attnum) AS comment
@@ -172,50 +228,78 @@ export async function introspect(client: PgQueryable, options: IntrospectOptions
        LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
       WHERE a.attrelid = ANY($1::oid[]) AND a.attnum > 0 AND NOT a.attisdropped
       ORDER BY a.attrelid, a.attnum`,
-    [relRows.map((r) => r.oid)],
-  );
-  const colsByRel = new Map<string, typeof colRows>();
-  for (const c of colRows) colsByRel.set(c.relid, [...(colsByRel.get(c.relid) ?? []), c]);
-
-  const views = new ViewNullability((text, values) => client.query(text, values), {
-    ...(options.viewNotNull && { notNull: options.viewNotNull }),
-  });
-  const usedEnums = new Set<string>();
-  const relations: IntrospectedRelation[] = [];
-  for (const rel of relRows) {
-    const kind = KINDS[rel.relkind]!;
-    const isView = kind === "view" || kind === "materialized view";
-    const viewNotNull = isView ? await views.notNull(rel.oid) : [];
-    const columns = (colsByRel.get(rel.oid) ?? []).map((c, i): IntrospectedColumn => {
-      const t = resolve(c.typid);
-      if (t.enumOid) usedEnums.add(t.enumOid);
-      const generated = c.generated !== "" ? c.default : null;
-      const identity = c.identity === "a" ? "always" : c.identity === "d" ? "by default" : null;
-      return {
-        name: c.name,
-        type: t.type,
-        declaredType: c.declared,
-        domain: t.domain,
-        nullable: isView ? !viewNotNull[i] : !(c.notnull || t.notnull),
-        hasDefault: !isView && (c.default !== null || identity !== null || generated !== null),
-        identity,
-        generated,
-        default: generated === null ? c.default : null,
-        comment: c.comment,
-      };
-    });
-    relations.push({ schema: rel.schema, name: rel.name, kind, comment: rel.comment, columns });
-  }
-
-  const enumRows = await q<{ oid: string; schema: string; name: string; values: string[] }>(
-    `SELECT t.oid::int8::text AS oid, n.nspname AS schema, t.typname AS name,
+		[relRows.map((r) => r.oid)],
+	);
+	const colsByRel = new Map<string, typeof colRows>();
+	for (const c of colRows)
+		colsByRel.set(c.relid, [...(colsByRel.get(c.relid) ?? []), c]);
+
+	const views = new ViewNullability(
+		(text, values) => client.query(text, values),
+		{
+			...(options.viewNotNull && { notNull: options.viewNotNull }),
+		},
+	);
+	const usedEnums = new Set<string>();
+	const relations: IntrospectedRelation[] = [];
+	for (const rel of relRows) {
+		const kind = KINDS[rel.relkind]!;
+		const isView = kind === "view" || kind === "materialized view";
+		const viewNotNull = isView ? await views.notNull(rel.oid) : [];
+		const columns = (colsByRel.get(rel.oid) ?? []).map(
+			(c, i): IntrospectedColumn => {
+				const t = resolve(c.typid);
+				if (t.enumOid) usedEnums.add(t.enumOid);
+				const generated = c.generated !== "" ? c.default : null;
+				const identity =
+					c.identity === "a"
+						? "always"
+						: c.identity === "d"
+							? "by default"
+							: null;
+				return {
+					name: c.name,
+					type: t.type,
+					declaredType: c.declared,
+					domain: t.domain,
+					nullable: isView ? !viewNotNull[i] : !(c.notnull || t.notnull),
+					hasDefault:
+						!isView &&
+						(c.default !== null || identity !== null || generated !== null),
+					identity,
+					generated,
+					default: generated === null ? c.default : null,
+					comment: c.comment,
+				};
+			},
+		);
+		relations.push({
+			schema: rel.schema,
+			name: rel.name,
+			kind,
+			comment: rel.comment,
+			columns,
+		});
+	}
+
+	const enumRows = await q<{
+		oid: string;
+		schema: string;
+		name: string;
+		values: string[];
+	}>(
+		`SELECT t.oid::int8::text AS oid, n.nspname AS schema, t.typname AS name,
             array_agg(e.enumlabel::text ORDER BY e.enumsortorder) AS values
        FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace JOIN pg_enum e ON e.enumtypid = t.oid
       WHERE n.nspname = ANY($1::text[]) OR t.oid = ANY($2::oid[])
       GROUP BY t.oid, n.nspname, t.typname
       ORDER BY t.typname, n.nspname`,
-    [schemas, [...usedEnums]],
-  );
-  const enums = enumRows.map(({ schema, name, values }) => ({ schema, name, values }));
-  return { version, schemas, relations, enums };
+		[schemas, [...usedEnums]],
+	);
+	const enums = enumRows.map(({ schema, name, values }) => ({
+		schema,
+		name,
+		values,
+	}));
+	return { version, schemas, relations, enums };
 }