@typesql/pg 0.1.5 → 0.2.1

package/src/index.ts

@@ -1,21 +1,25 @@
-import { createTransactionalSql, type RowKeys, type SqlOptions, type TransactionalSql } from "@typesql/core";
+import type { RowKeys, SqlOptions, TransactionalSql } from "@typesql/core";
+import { createTransactionalSql } from "@typesql/core/adapter";
 import { driver, type PgQueryable } from "./client.js";
 import type { PgTypeMap } from "./type-map.js";
 
-export { NoResultError, type Executor, type TransactionalSql } from "@typesql/core";
-export type { PgInterval, PgParamTypeMap, PgTypeMap } from "./type-map.js";
 export {
-  executor,
-  migrate,
-  type MigrationSource,
-  type PgQueryable,
-  type PgResult,
-  type PgTransactionClient,
-  type PgPoolLike,
+	executor,
+	type MigrationSource,
+	migrate,
+	type PgPoolLike,
+	type PgQueryable,
+	type PgResult,
+	type PgTransactionClient,
 } from "./client.js";
+export type { PgInterval, PgParamTypeMap, PgTypeMap } from "./type-map.js";
 
 /** What `createSql<DB>(client)` returns: core's `Sql` under `PgTypeMap`, with `transaction(fn)`. */
-export type PgSql<DB, Keys extends RowKeys = "preserve"> = TransactionalSql<DB, PgTypeMap, Keys>;
+export type PgSql<DB, Keys extends RowKeys = "preserve"> = TransactionalSql<
+	DB,
+	PgTypeMap,
+	Keys
+>;
 
 /**
  * `createSql<DB>()` from core, pre-bound to `PgTypeMap` (`count(*)` is `string`, `int8` is `string`, dates are `Date`).
@@ -23,8 +27,21 @@ export type PgSql<DB, Keys extends RowKeys = "preserve"> = TransactionalSql<DB,
  * `sql.transaction(fn)` runs `fn` with a `sql` bound to one transaction.
  * `{ rowKeys: "camelCase" }` camelCases the rows' keys, in the types and at runtime.
  */
-export function createSql<DB>(client: PgQueryable | undefined, options: { readonly rowKeys: "camelCase" }): PgSql<DB, "camelCase">;
-export function createSql<DB>(client?: PgQueryable, options?: { readonly rowKeys?: "preserve" }): PgSql<DB>;
-export function createSql<DB>(client?: PgQueryable, options?: SqlOptions): PgSql<DB, RowKeys> {
-  return createTransactionalSql<DB, PgTypeMap, PgQueryable>(client, driver, options);
+export function createSql<DB>(
+	client: PgQueryable | undefined,
+	options: { readonly rowKeys: "camelCase" },
+): PgSql<DB, "camelCase">;
+export function createSql<DB>(
+	client?: PgQueryable,
+	options?: { readonly rowKeys?: "preserve" },
+): PgSql<DB>;
+export function createSql<DB>(
+	client?: PgQueryable,
+	options?: SqlOptions,
+): PgSql<DB, RowKeys> {
+	return createTransactionalSql<DB, PgTypeMap, PgQueryable>(
+		client,
+		driver,
+		options,
+	);
 }

package/src/introspect/cli.ts

@@ -3,15 +3,15 @@ import { dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 import type { PgQueryable } from "../client.js";
-import { generateSource, type GenerateOptions } from "./emit.js";
-import { introspect, type IntrospectOptions } from "./introspect.js";
+import { type GenerateOptions, generateSource } from "./emit.js";
+import { type IntrospectOptions, introspect } from "./introspect.js";
 
 /** What a `--config` module exports as its default: CLI settings plus every generator option. */
 export interface IntrospectConfig extends GenerateOptions, IntrospectOptions {
-  /** Connection string. Default: `--url`, then `$DATABASE_URL`. */
-  readonly url?: string;
-  /** Output file, relative to the working directory. Default: stdout. */
-  readonly out?: string;
+	/** Connection string. Default: `--url`, then `$DATABASE_URL`. */
+	readonly url?: string;
+	/** Output file, relative to the working directory. Default: stdout. */
+	readonly out?: string;
 }
 
 const USAGE = `Usage: typesql introspect [options]
@@ -32,107 +32,131 @@ Options:
 `;
 
 interface Io {
-  readonly stdout: (s: string) => void;
-  readonly stderr: (s: string) => void;
-  readonly env: Readonly<Record<string, string | undefined>>;
-  readonly cwd: string;
-  /** Opens a client for a connection string; default: a `pg.Client`. */
-  readonly connect?: (url: string) => Promise<PgQueryable & { end(): Promise<void> }>;
+	readonly stdout: (s: string) => void;
+	readonly stderr: (s: string) => void;
+	readonly env: Readonly<Record<string, string | undefined>>;
+	readonly cwd: string;
+	/** Opens a client for a connection string; default: a `pg.Client`. */
+	readonly connect?: (
+		url: string,
+	) => Promise<PgQueryable & { end(): Promise<void> }>;
 }
 
 const defaultIo = (): Io => ({
-  stdout: (s) => process.stdout.write(s),
-  stderr: (s) => process.stderr.write(s),
-  env: process.env,
-  cwd: process.cwd(),
+	stdout: (s) => process.stdout.write(s),
+	stderr: (s) => process.stderr.write(s),
+	env: process.env,
+	cwd: process.cwd(),
 });
 
-async function pgConnect(url: string): Promise<PgQueryable & { end(): Promise<void> }> {
-  let Client: typeof import("pg").Client;
-  try {
-    ({ Client } = (await import("pg")).default);
-  } catch {
-    throw new Error('typesql introspect needs the "pg" package: npm install pg');
-  }
-  const client = new Client({ connectionString: url });
-  await client.connect();
-  return client;
+async function pgConnect(
+	url: string,
+): Promise<PgQueryable & { end(): Promise<void> }> {
+	let Client: typeof import("pg").Client;
+	try {
+		({ Client } = (await import("pg")).default);
+	} catch {
+		throw new Error(
+			'typesql introspect needs the "pg" package: npm install pg',
+		);
+	}
+	const client = new Client({ connectionString: url });
+	await client.connect();
+	return client;
 }
 
+const parse = (argv: readonly string[]) =>
+	parseArgs({
+		args: [...argv],
+		allowPositionals: true,
+		options: {
+			url: { type: "string" },
+			out: { type: "string" },
+			schema: { type: "string", multiple: true },
+			exclude: { type: "string", multiple: true },
+			"type-name": { type: "string" },
+			"import-from": { type: "string" },
+			config: { type: "string" },
+			"no-comments": { type: "boolean" },
+			help: { type: "boolean", short: "h" },
+		},
+	});
+
 /** Runs the `typesql` CLI with `argv` (without `node` and the script). Returns the exit code. */
-export async function main(argv: readonly string[], io: Io = defaultIo()): Promise<number> {
-  let parsed;
-  try {
-    parsed = parseArgs({
-      args: [...argv],
-      allowPositionals: true,
-      options: {
-        url: { type: "string" },
-        out: { type: "string" },
-        schema: { type: "string", multiple: true },
-        exclude: { type: "string", multiple: true },
-        "type-name": { type: "string" },
-        "import-from": { type: "string" },
-        config: { type: "string" },
-        "no-comments": { type: "boolean" },
-        help: { type: "boolean", short: "h" },
-      },
-    });
-  } catch (err) {
-    io.stderr(`${(err as Error).message}\n\n${USAGE}`);
-    return 2;
-  }
-  const { values, positionals } = parsed;
-  if (values.help || positionals.length === 0) {
-    (values.help ? io.stdout : io.stderr)(USAGE);
-    return values.help ? 0 : 2;
-  }
-  if (positionals[0] !== "introspect" || positionals.length > 1) {
-    io.stderr(`unknown command: ${positionals.join(" ")}\n\n${USAGE}`);
-    return 2;
-  }
+export async function main(
+	argv: readonly string[],
+	io: Io = defaultIo(),
+): Promise<number> {
+	let parsed: ReturnType<typeof parse>;
+	try {
+		parsed = parse(argv);
+	} catch (err) {
+		io.stderr(`${(err as Error).message}\n\n${USAGE}`);
+		return 2;
+	}
+	const { values, positionals } = parsed;
+	if (values.help || positionals.length === 0) {
+		(values.help ? io.stdout : io.stderr)(USAGE);
+		return values.help ? 0 : 2;
+	}
+	if (positionals[0] !== "introspect" || positionals.length > 1) {
+		io.stderr(`unknown command: ${positionals.join(" ")}\n\n${USAGE}`);
+		return 2;
+	}
 
-  try {
-    let config: IntrospectConfig = {};
-    if (values.config) {
-      const mod = (await import(pathToFileURL(resolve(io.cwd, values.config)).href)) as { default?: IntrospectConfig };
-      config = mod.default ?? {};
-    }
-    const url = values.url ?? config.url ?? io.env["DATABASE_URL"];
-    if (!url) {
-      io.stderr("typesql introspect: pass --url or set DATABASE_URL\n");
-      return 2;
-    }
-    const list = (v: string[] | undefined) => v?.flatMap((s) => s.split(",").map((x) => x.trim()).filter(Boolean));
-    const schemas = list(values.schema) ?? config.schemas;
-    const exclude = list(values.exclude) ?? config.exclude;
-    const options: IntrospectConfig = {
-      ...config,
-      ...(schemas !== undefined && { schemas }),
-      ...(exclude !== undefined && { exclude }),
-      ...(values["type-name"] !== undefined && { typeName: values["type-name"] }),
-      ...(values["import-from"] !== undefined && { importFrom: values["import-from"] }),
-      ...(values["no-comments"] && { comments: false }),
-    };
-    const client = await (io.connect ?? pgConnect)(url);
-    let source: string;
-    try {
-      source = generateSource(await introspect(client, options), options);
-    } finally {
-      await client.end();
-    }
-    const out = values.out ?? config.out;
-    if (out === undefined) {
-      io.stdout(source);
-    } else {
-      const file = resolve(io.cwd, out);
-      await mkdir(dirname(file), { recursive: true });
-      await writeFile(file, source);
-      io.stderr(`typesql introspect: wrote ${out}\n`);
-    }
-    return 0;
-  } catch (err) {
-    io.stderr(`typesql introspect: ${(err as Error).message}\n`);
-    return 1;
-  }
+	try {
+		let config: IntrospectConfig = {};
+		if (values.config) {
+			const mod = (await import(
+				pathToFileURL(resolve(io.cwd, values.config)).href
+			)) as { default?: IntrospectConfig };
+			config = mod.default ?? {};
+		}
+		const url = values.url ?? config.url ?? io.env["DATABASE_URL"];
+		if (!url) {
+			io.stderr("typesql introspect: pass --url or set DATABASE_URL\n");
+			return 2;
+		}
+		const list = (v: string[] | undefined) =>
+			v?.flatMap((s) =>
+				s
+					.split(",")
+					.map((x) => x.trim())
+					.filter(Boolean),
+			);
+		const schemas = list(values.schema) ?? config.schemas;
+		const exclude = list(values.exclude) ?? config.exclude;
+		const options: IntrospectConfig = {
+			...config,
+			...(schemas !== undefined && { schemas }),
+			...(exclude !== undefined && { exclude }),
+			...(values["type-name"] !== undefined && {
+				typeName: values["type-name"],
+			}),
+			...(values["import-from"] !== undefined && {
+				importFrom: values["import-from"],
+			}),
+			...(values["no-comments"] && { comments: false }),
+		};
+		const client = await (io.connect ?? pgConnect)(url);
+		let source: string;
+		try {
+			source = generateSource(await introspect(client, options), options);
+		} finally {
+			await client.end();
+		}
+		const out = values.out ?? config.out;
+		if (out === undefined) {
+			io.stdout(source);
+		} else {
+			const file = resolve(io.cwd, out);
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(file, source);
+			io.stderr(`typesql introspect: wrote ${out}\n`);
+		}
+		return 0;
+	} catch (err) {
+		io.stderr(`typesql introspect: ${(err as Error).message}\n`);
+		return 1;
+	}
 }