true-pg 0.0.1

package/src/kysely/index.ts

@@ -0,0 +1,315 @@
+import type { CanonicalType, Schema, TableColumn } from "pg-extract";
+import { allowed_kind_names, createGenerator, Nodes, type SchemaGenerator } from "../types.ts";
+import { builtins } from "./builtins.ts";
+
+const isIdentifierInvalid = (str: string) => {
+	const invalid = str.match(/[^a-zA-Z0-9_]/);
+	return invalid !== null;
+};
+
+const toPascalCase = (str: string) =>
+	str
+		.replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
+		.replace(/[^a-zA-Z0-9_]+/g, "") // remove non-alphanumeric/underscore characters
+		.replace(" ", "_") // replace spaces with underscores
+		.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()) // capitalize letters after underscores
+		.replace(/^([a-z])/, (_, letter) => letter.toUpperCase()); // capitalize first letter
+
+export const Kysely = createGenerator(opts => {
+	const defaultSchema = opts?.defaultSchema ?? "public";
+
+	const ky = (imports: Nodes.ImportList, name: string) =>
+		imports.add(
+			new Nodes.ExternalImport({
+				name,
+				module: "kysely",
+				typeOnly: true,
+				star: false,
+			}),
+		);
+
+	const add = (imports: Nodes.ImportList, type: CanonicalType) => {
+		if (type.schema === "pg_catalog") return;
+		imports.add(
+			new Nodes.InternalImport({
+				name: generator.formatType(type),
+				canonical_type: type,
+				typeOnly: true,
+				star: false,
+			}),
+		);
+	};
+
+	const column = (
+		/** "this" */
+		generator: SchemaGenerator,
+		/** @out Append used types to this array */
+		imports: Nodes.ImportList,
+		/** Information about the column */
+		col: TableColumn,
+	) => {
+		let base = generator.formatType(col.type);
+		if (col.type.dimensions > 0) base += "[]".repeat(col.type.dimensions);
+		if (col.isNullable) base += " | null";
+
+		let qualified = base;
+		if (col.generated === "ALWAYS") {
+			qualified = `GeneratedAlways<${qualified}>`;
+			ky(imports, "GeneratedAlways");
+		} else if (col.generated === "BY DEFAULT") {
+			qualified = `Generated<${qualified}>`;
+			ky(imports, "Generated");
+		} else if (col.defaultValue) {
+			qualified = `Generated<${qualified}>`;
+			ky(imports, "Generated");
+		}
+
+		let out = col.comment ? `/** ${col.comment} */\n\t` : "";
+		out += col.name;
+		// TODO: update imports for non-primitive types
+		out += `: ${qualified}`;
+		add(imports, col.type);
+
+		return `\t${out};\n`;
+	};
+
+	const composite_attribute = (
+		generator: SchemaGenerator,
+		imports: Nodes.ImportList,
+		attr: CanonicalType.CompositeAttribute,
+	) => {
+		let out = attr.name;
+
+		if (attr.isNullable) out += "?";
+		out += `: ${generator.formatType(attr.type)}`;
+		add(imports, attr.type);
+		if (attr.type.dimensions > 0) out += "[]".repeat(attr.type.dimensions);
+		if (attr.isNullable) out += " | null";
+
+		return out;
+	};
+
+	const generator: SchemaGenerator = {
+		formatSchema(name) {
+			return toPascalCase(name) + "Schema";
+		},
+
+		formatSchemaType(type) {
+			return toPascalCase(type.name);
+		},
+
+		formatType(type) {
+			if (type.schema === "pg_catalog") {
+				const name = type.canonical_name;
+				const format = builtins[name];
+				if (format) return format;
+				opts?.warnings?.push(
+					`Unknown builtin type: ${name}! Pass customBuiltinMap to map this type. Defaulting to "unknown".`,
+				);
+				return "unknown";
+			}
+			return toPascalCase(type.name);
+		},
+
+		table(imports, table) {
+			let out = "";
+
+			if (table.comment) out += `/** ${table.comment} */\n`;
+			out += `export interface ${this.formatSchemaType(table)} {\n`;
+			for (const col of table.columns) out += column(this, imports, col);
+			out += "}";
+
+			return out;
+		},
+
+		enum(imports, en) {
+			let out = "";
+			if (en.comment) out += `/** ${en.comment} */\n`;
+			out += `export type ${this.formatSchemaType(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
+			return out;
+		},
+
+		composite(imports, type) {
+			let out = "";
+
+			if (type.comment) out += `/** ${type.comment} */\n`;
+			out += `export interface ${this.formatSchemaType(type)} {\n`;
+
+			const props = type.canonical.attributes.map(c => composite_attribute(this, imports, c)).map(t => `\t${t};`);
+			out += props.join("\n");
+			out += "\n}";
+
+			return out;
+		},
+
+		function(imports, type) {
+			let out = "";
+
+			out += "/**\n";
+			if (type.comment) out += ` * ${type.comment}\n`;
+			out += ` * @volatility ${type.volatility}\n`;
+			out += ` * @parallelSafety ${type.parallelSafety}\n`;
+			out += ` * @isStrict ${type.isStrict}\n`;
+			out += " */\n";
+			out += `export interface ${this.formatSchemaType(type)} {\n\t`;
+
+			// Get the input parameters (those that appear in function signature)
+			const inputParams = type.parameters.filter(
+				p => p.mode === "IN" || p.mode === "INOUT" || p.mode === "VARIADIC",
+			);
+
+			if (inputParams.length === 0) {
+				out += "(): ";
+			} else if (inputParams.length === 1) {
+				out += "(";
+				out += inputParams[0]!.name;
+				out += ": ";
+				out += this.formatType(inputParams[0]!.type);
+				add(imports, inputParams[0]!.type);
+				if (inputParams[0]!.type.dimensions > 0) out += "[]".repeat(inputParams[0]!.type.dimensions);
+				out += "): ";
+			} else if (inputParams.length > 0) {
+				out += "(\n";
+
+				for (const param of inputParams) {
+					// Handle variadic parameters differently if needed
+					const isVariadic = param.mode === "VARIADIC";
+					const paramName = isVariadic ? `...${param.name}` : param.name;
+
+					out += `\t\t${paramName}`;
+					if (param.hasDefault && !isVariadic) out += "?";
+					out += `: ${this.formatType(param.type)}`;
+					add(imports, param.type);
+					if (param.type.dimensions > 0) out += "[]".repeat(param.type.dimensions);
+					if (!isVariadic) out += ",";
+					out += "\n";
+				}
+
+				out += "\t): ";
+			}
+
+			if (type.returnType.kind === "table") {
+				out += "{\n";
+				for (const col of type.returnType.columns) {
+					out += `\t\t${col.name}: `;
+					out += this.formatType(col.type);
+					add(imports, col.type);
+					if (col.type.dimensions > 0) out += "[]".repeat(col.type.dimensions);
+					out += `;\n`;
+				}
+				out += "\t}";
+			} else {
+				out += this.formatType(type.returnType.type);
+				add(imports, type.returnType.type);
+				if (type.returnType.type.dimensions > 0) out += "[]".repeat(type.returnType.type.dimensions);
+			}
+
+			// Add additional array brackets if it returns a set
+			if (type.returnType.isSet) {
+				out += "[]";
+			}
+
+			out += ";\n}";
+
+			return out;
+		},
+
+		schemaKindIndex(schema, kind, main_generator) {
+			const generator = main_generator ?? this;
+			const imports = schema[kind];
+			if (imports.length === 0) return "";
+
+			return imports
+				.map(each => {
+					const name = this.formatSchemaType(each);
+					const file = generator.formatSchemaType(each);
+					return `export type { ${name} } from "./${file}.ts";`;
+				})
+				.join("\n");
+		},
+
+		schemaIndex(schema) {
+			let out = allowed_kind_names.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
+
+			out += "\n\n";
+			out += `export interface ${this.formatSchema(schema.name)} {\n`;
+
+			for (const kind of allowed_kind_names) {
+				const items = schema[kind];
+				if (items.length === 0) continue;
+
+				out += `\t${kind}: {\n`;
+
+				const formatted = items
+					.map(each => {
+						const formatted = this.formatSchemaType(each);
+						return { ...each, formatted };
+					})
+					.filter(x => x !== undefined);
+
+				out += formatted
+					.map(t => {
+						let name = t.name;
+						if (isIdentifierInvalid(name)) name = `"${name}"`;
+						return `\t\t${name}: ${t.kind}s.${t.formatted};`;
+					})
+					.join("\n");
+				out += "\n\t};\n";
+			}
+
+			out += "}";
+
+			return out;
+		},
+
+		fullIndex(schemas: Schema[]) {
+			let out = "";
+
+			out += schemas
+				.map(s => `import type { ${this.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+				.join("\n");
+
+			out += "\n\n";
+			out += `export interface Database {\n`;
+			out += schemas
+				.map(schema => {
+					// Kysely only wants tables
+					const tables = schema.tables;
+
+					let out = "";
+
+					const seen = new Set<string>();
+					const formatted = tables
+						.map(each => {
+							const formatted = this.formatSchemaType(each);
+							// skip clashing names
+							if (seen.has(formatted)) return;
+							seen.add(formatted);
+							return { ...each, formatted };
+						})
+						.filter(x => x !== undefined);
+
+					if (out.length) out += "\n\n";
+					out += formatted
+						.map(t => {
+							const prefix = defaultSchema === schema.name ? "" : schema.name + ".";
+							let qualified = prefix + t.name;
+							if (isIdentifierInvalid(qualified)) qualified = `"${qualified}"`;
+							return `\t${qualified}: ${this.formatSchema(schema.name)}["${t.kind}s"]["${t.name}"];`;
+						})
+						.join("\n");
+
+					return out;
+				})
+				.join("");
+
+			out += "\n}\n\n";
+
+			out += schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n");
+
+			return out;
+		},
+	};
+
+	return generator;
+});

package/src/types.ts

@@ -0,0 +1,297 @@
+import type {
+	CanonicalType,
+	CompositeTypeDetails,
+	EnumDetails,
+	FunctionDetails,
+	TableDetails,
+	SchemaType,
+	Schema,
+} from "pg-extract";
+
+import { dirname, relative } from "node:path";
+import { join } from "./util.ts";
+
+// To be updated when we add support for other kinds
+export const allowed_kind_names = ["tables", "enums", "composites", "functions"] as const;
+export type allowed_kind_names = (typeof allowed_kind_names)[number];
+
+export interface FolderStructure {
+	name: string;
+	type: "root";
+	children: {
+		[realname: string]: {
+			name: string;
+			type: "schema";
+			children: {
+				[kind: string]: {
+					kind: allowed_kind_names;
+					type: "kind";
+					children: {
+						[realname: string]: {
+							name: string;
+							type: "type";
+						};
+					};
+				};
+			};
+		};
+	};
+}
+
+export namespace Nodes {
+	export class ExternalImport {
+		// what to import
+		name: string;
+		// use `type` syntax?
+		typeOnly: boolean;
+		// use `* as` syntax?
+		star: boolean;
+
+		// this is an external import
+		external: true;
+		// what module to import from
+		module: string;
+
+		constructor(args: { name: string; module: string; typeOnly: boolean; star: boolean }) {
+			this.name = args.name;
+			this.typeOnly = args.typeOnly;
+			this.star = args.star;
+			this.external = true;
+			this.module = args.module;
+		}
+	}
+
+	export class InternalImport {
+		// what to import
+		name: string;
+		// underlying type that is being imported
+		canonical_type: CanonicalType;
+		// use `type` syntax?
+		typeOnly: boolean;
+		// use `* as` syntax?
+		star: boolean;
+
+		// this is an internal import
+		external: false;
+
+		constructor(args: { name: string; canonical_type: CanonicalType; typeOnly: boolean; star: boolean }) {
+			this.name = args.name;
+			this.canonical_type = args.canonical_type;
+			this.star = args.star;
+			this.typeOnly = args.typeOnly;
+			this.external = false;
+		}
+	}
+
+	export class ImportList {
+		constructor(public imports: (ExternalImport | InternalImport)[]) {}
+
+		static merge(lists: ImportList[]) {
+			return new ImportList(lists.flatMap(l => l.imports));
+		}
+
+		add(item: ExternalImport | InternalImport) {
+			this.imports.push(item);
+		}
+
+		stringify(context_file: string, files: FolderStructure) {
+			const externals = this.imports.filter(i => i.external);
+			const internals = this.imports.filter(i => !i.external);
+
+			const modulegroups: Record<string, ExternalImport[]> = {};
+			for (const item of externals) {
+				const group = modulegroups[item.module];
+				if (group) group.push(item);
+				else modulegroups[item.module] = [item];
+			}
+
+			const out = [];
+
+			// TODO: normalise external and internal imports and handle the stringification of the imports in a single place
+
+			{
+				// EXTERNAL IMPORTS
+
+				const imports = [];
+				for (const module in modulegroups) {
+					const items = modulegroups[module]!;
+					const star = items.find(i => i.star);
+					const unique = items.filter((i, index, arr) => {
+						if (i.star) return false;
+						if (arr.findIndex(i2 => i2.name === i.name) !== index) return false;
+						return true;
+					});
+
+					const bits = [];
+					const typeOnlys = unique.filter(i => i.typeOnly);
+					const values = unique.filter(i => !i.typeOnly);
+
+					// if no values to import, use `import type { ... }` instead of `import { type ... }`
+					const typeInline = values.length !== 0;
+
+					let import_line = `import `;
+					for (const type of typeOnlys) bits.push(typeInline ? "type " : "" + type.name);
+					for (const type of values) bits.push(type.name);
+					if (bits.length) import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
+					if (bits.length && star) import_line += `, `;
+					if (star) import_line += `* as ${star.name}`;
+					if (bits.length || star) import_line += ` from`;
+					import_line += `"${module}";`;
+					imports.push(import_line);
+				}
+				out.push(join(imports, "\n"));
+			}
+
+			{
+				// INTERNAL IMPORTS
+
+				const imports = [];
+				const unique_types = internals
+					.filter(({ name: name1, canonical_type: int }, index, arr) => {
+						return (
+							arr.findIndex(({ name: name2, canonical_type: int2 }) => {
+								return (
+									// adapter-assigned name
+									name2 === name1 &&
+									// canonical type details
+									int2.name === int.name &&
+									int2.schema === int.schema &&
+									int2.kind === int.kind
+								);
+							}) === index
+						);
+					})
+					.map(imp => {
+						const t = imp.canonical_type;
+						const schema = files.children[t.schema]!;
+						const kind = schema.children[`${t.kind}s`]!;
+						const type = kind.children[t.name]!;
+						const located_file = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
+						return { ...imp, located_file };
+					});
+
+				const group_by_file: Record<string, (InternalImport & { located_file: string })[]> = {};
+				for (const type of unique_types) {
+					const file = group_by_file[type.located_file] || [];
+					file.push(type);
+					group_by_file[type.located_file] = file;
+				}
+
+				for (const group in group_by_file) {
+					let relative_path = relative(dirname(context_file), group);
+					if (/^[^\.+\/]/.test(relative_path)) relative_path = "./" + relative_path;
+					const items = group_by_file[group]!;
+					const typeOnlys = items.filter(i => i.typeOnly);
+					const values = items.filter(i => !i.typeOnly);
+					const star = values.find(i => i.star);
+					let import_line = "import ";
+					const bits = [];
+
+					// if no values to import, use `import type { ... }` instead of `import { type ... }`
+					const typeInline = values.length !== 0;
+
+					for (const type of typeOnlys) bits.push((typeInline ? "type " : "") + type.name);
+					for (const type of values) bits.push(type.name);
+					if (bits.length) import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
+					if (star) import_line += `* as ${star.name}`;
+					import_line += ` from "${relative_path}";`;
+					imports.push(import_line);
+				}
+
+				out.push(join(imports, "\n"));
+			}
+
+			return join(out);
+		}
+	}
+
+	export interface Export {
+		// what to export
+		name: string;
+		// what kind of thing to export
+		kind: SchemaType["kind"];
+		// what schema to export from
+		schema: string;
+		// use `* as` syntax?
+		star: boolean;
+	}
+}
+
+export interface TruePGOpts {
+	uri: string;
+	out: string;
+	adapters: string[];
+	defaultSchema?: string;
+}
+
+export interface CreateGeneratorOpts {
+	defaultSchema?: string;
+	warnings: string[];
+}
+
+export interface createGenerator {
+	(opts?: CreateGeneratorOpts): SchemaGenerator;
+}
+
+/* convenience function to create a generator with type inference */
+export const createGenerator = (generatorCreator: createGenerator): createGenerator => generatorCreator;
+
+export interface SchemaGenerator {
+	/**
+	 * Use this function to define a name mapping for schema names.
+	 * This is useful if you want to use a different name for a schema in the generated code.
+	 * Example: "public" -> "PublicSchema"
+	 */
+	formatSchema(name: string): string;
+
+	/**
+	 * Use this function to define a name mapping for schema types.
+	 * This is useful if you want to use a different name for a type in the generated code.
+	 * Example: "users" -> "UsersTable"
+	 */
+	formatSchemaType(type: SchemaType): string;
+
+	/**
+	 * Use this function to define a name mapping for type names.
+	 * This is useful if you want to use a different name for a type in the generated code.
+	 * Example: "users" -> "UsersTable"
+	 */
+	formatType(type: CanonicalType): string;
+
+	table(
+		/** @out Append used types to this array */
+		imports: Nodes.ImportList,
+		/** Information about the table */
+		table: TableDetails,
+	): string;
+
+	enum(
+		/** @out Append used types to this array */
+		imports: Nodes.ImportList,
+		/** Information about the enum */
+		en: EnumDetails,
+	): string;
+
+	composite(
+		/** @out Append used types to this array */
+		imports: Nodes.ImportList,
+		/** Information about the composite type */
+		type: CompositeTypeDetails,
+	): string;
+
+	function(
+		/** @out Append used types to this array */
+		imports: Nodes.ImportList,
+		/** Information about the function */
+		type: FunctionDetails,
+	): string;
+
+	/** create the file `$out/$schema.name/$kind/index.ts` */
+	schemaKindIndex(schema: Schema, kind: Exclude<keyof Schema, "name">, main_generator?: SchemaGenerator): string;
+
+	/** create the file `$out/$schema.name/index.ts` */
+	schemaIndex(schema: Schema, main_generator?: SchemaGenerator): string;
+
+	/** create the file `$out/index.ts` */
+	fullIndex(schemas: Schema[], main_generator?: SchemaGenerator): string;
+}

package/src/util.ts

@@ -0,0 +1 @@
+export const join = (parts: Iterable<string>, joiner = "\n\n") => Array.from(parts).filter(Boolean).join(joiner);

package/src/zod/builtins.ts

@@ -0,0 +1,38 @@
+// extended from https://github.com/kristiandupont/kanel/blob/e9332f03ff5e38f5b844dd7a4563580c0d9d1444/packages/kanel/src/defaultTypeMap.ts
+
+export const builtins: Record<string, string> = {
+	"pg_catalog.int2": "z.number()",
+	"pg_catalog.int4": "z.number()",
+
+	// JS numbers are always floating point, so there is only 53 bits of precision
+	// for the integer part. Thus, storing a 64-bit integer in a JS number will
+	// result in potential data loss. We therefore use strings for 64-bit integers
+	// the same way that the pg driver does.
+	"pg_catalog.int8": "z.string()",
+
+	"pg_catalog.float4": "z.number()",
+	"pg_catalog.float8": "z.number()",
+	"pg_catalog.numeric": "z.string()",
+	"pg_catalog.bool": "z.boolean()",
+	"pg_catalog.json": "z.unknown()",
+	"pg_catalog.jsonb": "z.unknown()",
+	"pg_catalog.char": "z.string()",
+	"pg_catalog.bpchar": "z.string()",
+	"pg_catalog.varchar": "z.string()",
+	"pg_catalog.text": "z.string()",
+	"pg_catalog.uuid": "z.string()",
+	"pg_catalog.inet": "z.string()",
+	"pg_catalog.date": "z.date()",
+	"pg_catalog.time": "z.date()",
+	"pg_catalog.timetz": "z.date()",
+	"pg_catalog.timestamp": "z.date()",
+	"pg_catalog.timestamptz": "z.date()",
+	"pg_catalog.int4range": "z.string()",
+	"pg_catalog.int8range": "z.string()",
+	"pg_catalog.numrange": "z.string()",
+	"pg_catalog.tsrange": "z.string()",
+	"pg_catalog.tstzrange": "z.string()",
+	"pg_catalog.daterange": "z.string()",
+	"pg_catalog.record": "z.record(z.string(), z.unknown())",
+	"pg_catalog.void": "z.void()",
+};