true-pg 0.0.2 → 0.0.3

package/src/bin.ts

@@ -1,81 +0,0 @@
-import mri from "mri";
-import { existsSync } from "fs";
-import { generate, adapters } from "./index.ts";
-
-const args = process.argv.slice(2);
-const opts = mri<{
-	"help"?: boolean;
-	"config"?: string;
-	"uri"?: string;
-	"out"?: string;
-	"adapter"?: string | string[];
-	"all-adapters"?: boolean;
-}>(args, {
-	boolean: ["help", "all-adapters"],
-	string: ["config", "uri", "out", "adapter"],
-	alias: {
-		h: "help",
-		c: "config",
-		u: "uri",
-		o: "out",
-		a: "adapter",
-		A: "all-adapters",
-	},
-});
-
-const help = opts.help || (!opts.config && !opts.uri);
-
-if (help) {
-	// if help is triggered unintentionally, it's a user error
-	const type = opts.help ? "log" : "error";
-	const log = console[type];
-
-	log();
-	log("Usage: true-pg [options]");
-	log();
-	log("Options:");
-	log("  -h, --help                  Show help");
-	log("  -u, --uri      [uri]        Database URI (Postgres only!)");
-	log("  -o, --out      [path]       Path to output directory");
-	log("  -a, --adapter  [adapter]    Output adapter to use (default: 'kysely')");
-	log("  -A, --all-adapters          Output all adapters");
-	log("  -c, --config   [path]       Path to config file (JSON)");
-	log("                              Defaults to '.truepgrc.json' or '.config/.truepgrc.json'");
-	log("Example:");
-	log("  true-pg -u postgres://user:pass@localhost:5432/my-database -o models -a kysely -a zod");
-	log();
-	if (opts.help) process.exit(0);
-	else process.exit(1);
-}
-
-let configfile = opts.config;
-if (!configfile) {
-	const candidates = [".truepgrc.json", ".config/.truepgrc.json"];
-	for (const candidate of candidates) {
-		if (await existsSync(candidate)) {
-			configfile = candidate;
-			break;
-		}
-	}
-}
-
-const config = configfile ? await Bun.file(configfile).json() : {};
-
-if (opts["all-adapters"]) {
-	opts.adapter = Object.keys(adapters);
-	console.log("Enabling all built-in adapters:", opts.adapter);
-}
-
-if (!(opts.adapter || config.adapters)) console.warn('No adapters specified, using default: ["kysely"]');
-
-opts.out ??= "models";
-// allow single adapter or comma-separated list of adapters
-if (typeof opts.adapter === "string") opts.adapter = opts.adapter.split(",");
-opts.adapter ??= ["kysely"];
-
-// CLI args take precedence over config file
-config.uri = opts.uri ?? config.uri;
-config.out = opts.out ?? config.out;
-config.adapters = opts.adapter ?? config.adapters;
-
-await generate(config);

package/src/consumer.ts

@@ -1,38 +0,0 @@
-export declare namespace True {
-	export type Column<Selectable, Insertable = Selectable, Updateable = Selectable> = {
-		"@true-pg/insert": Insertable;
-		"@true-pg/update": Updateable;
-		"@true-pg/select": Selectable;
-	};
-
-	export type Generated<T> = Column<T, T | undefined, T | undefined>;
-	export type HasDefault<T> = Column<T, T | undefined, T | undefined>;
-	export type AlwaysGenerated<T> = Column<T, never, never>;
-
-	type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
-	type Simplify<T> = DrainOuterGeneric<{ [K in keyof T]: T[K] } & {}>;
-
-	export type Selectable<T extends Record<string, any>> = Simplify<{
-		[K in keyof T]: T[K] extends Record<string, any>
-			? Selectable<T[K]>
-			: T[K] extends Column<infer S, infer I, infer U>
-				? S
-				: T[K];
-	}>;
-
-	export type Insertable<T extends Record<string, any>> = Simplify<{
-		[K in keyof T]: T[K] extends Record<string, any>
-			? Insertable<T[K]>
-			: T[K] extends Column<infer S, infer I, infer U>
-				? I
-				: T[K];
-	}>;
-
-	export type Updateable<T extends Record<string, any>> = Simplify<{
-		[K in keyof T]?: T[K] extends Record<string, any>
-			? Updateable<T[K]>
-			: T[K] extends Column<infer S, infer I, infer U>
-				? U
-				: T[K];
-	}>;
-}

package/src/index.ts

@@ -1,185 +0,0 @@
-import { Extractor, type FunctionDetails, type Schema } from "pg-extract";
-import { rm, mkdir, writeFile } from "fs/promises";
-import { Nodes, allowed_kind_names, type FolderStructure, type TruePGOpts, type createGenerator } from "./types.ts";
-import { existsSync } from "fs";
-import { join } from "./util.ts";
-
-import { Kysely } from "./kysely/index.ts";
-import { Zod } from "./zod/index.ts";
-
-export const adapters: Record<string, createGenerator> = {
-	kysely: Kysely,
-	zod: Zod,
-};
-
-export * from "./consumer.ts";
-
-const filter_function = (func: FunctionDetails, warnings: string[]) => {
-	const typesToFilter = [
-		"pg_catalog.trigger",
-		"pg_catalog.event_trigger",
-		"pg_catalog.internal",
-		"pg_catalog.language_handler",
-		"pg_catalog.fdw_handler",
-		"pg_catalog.index_am_handler",
-		"pg_catalog.tsm_handler",
-	];
-
-	const warn = (type: string) =>
-		warnings.push(`Skipping function ${func.name}: cannot represent ${type} (safe to ignore)`);
-
-	if (func.returnType.kind === "table") {
-		for (const col of func.returnType.columns) {
-			if (typesToFilter.includes(col.type.canonical_name)) {
-				warn(col.type.canonical_name);
-				return false;
-			}
-		}
-	} else {
-		if (typesToFilter.includes(func.returnType.type.canonical_name)) {
-			warn(func.returnType.type.canonical_name);
-			return false;
-		}
-	}
-
-	for (const param of func.parameters) {
-		if (typesToFilter.includes(param.type.canonical_name)) {
-			warn(param.type.canonical_name);
-			return false;
-		}
-	}
-
-	return func;
-};
-
-const write = (filename: string, file: string) => writeFile(filename, file + "\n");
-
-const multifile = async (generators: createGenerator[], schemas: Record<string, Schema>, opts: TruePGOpts) => {
-	const { out } = opts;
-
-	const warnings: string[] = [];
-	const gens = generators.map(g => g({ ...opts, warnings }));
-	const def_gen = gens[0]!;
-
-	const files: FolderStructure = {
-		name: out,
-		type: "root",
-		children: Object.fromEntries(
-			Object.values(schemas).map(schema => [
-				schema.name,
-				{
-					name: schema.name,
-					type: "schema",
-					children: Object.fromEntries(
-						allowed_kind_names.map(kind => [
-							kind,
-							{
-								kind: kind,
-								type: "kind",
-								children: Object.fromEntries(
-									schema[kind].map(item => [
-										item.name,
-										{
-											name: def_gen.formatSchemaType(item),
-											type: "type",
-										},
-									]),
-								),
-							},
-						]),
-					),
-				},
-			]),
-		),
-	};
-
-	const start = performance.now();
-
-	for (const schema of Object.values(schemas)) {
-		console.log("Selected schema '%s':\n", schema.name);
-
-		const schemaDir = `${out}/${schema.name}`;
-
-		// skip functions that cannot be represented in JavaScript
-		schema.functions = schema.functions.filter(f => filter_function(f, warnings));
-
-		for (const kind of allowed_kind_names) {
-			if (schema[kind].length < 1) continue;
-
-			await mkdir(`${schemaDir}/${kind}`, { recursive: true });
-			console.log(" Creating %s:\n", kind);
-
-			for (const [i, item] of schema[kind].entries()) {
-				const index = "[" + (i + 1 + "]").padEnd(3, " ");
-				const filename = `${schemaDir}/${kind}/${def_gen.formatSchemaType(item)}.ts`;
-
-				const exists = await existsSync(filename);
-
-				if (exists) {
-					warnings.push(
-						`Skipping ${item.kind} "${item.name}": formatted name clashes. Wanted to create ${filename}`,
-					);
-					continue;
-				}
-
-				const start = performance.now();
-
-				let file = "";
-
-				const imports = new Nodes.ImportList([]);
-
-				if (item.kind === "table") file += join(gens.map(gen => gen.table(imports, item)));
-				if (item.kind === "composite") file += join(gens.map(gen => gen.composite(imports, item)));
-				if (item.kind === "enum") file += join(gens.map(gen => gen.enum(imports, item)));
-				if (item.kind === "function") file += join(gens.map(gen => gen.function(imports, item)));
-
-				const parts: string[] = [];
-				parts.push(imports.stringify(filename, files));
-				parts.push(file);
-				file = join(parts);
-
-				await write(filename, file);
-
-				const end = performance.now();
-				console.log("  %s %s \x1b[32m(%sms)\x1B[0m", index, filename, (end - start).toFixed(2));
-			}
-
-			const kindIndex = join(gens.map(gen => gen.schemaKindIndex(schema, kind, def_gen)));
-			const kindIndexFilename = `${schemaDir}/${kind}/index.ts`;
-			await write(kindIndexFilename, kindIndex);
-			console.log('  ✅   Created "%s" %s index: %s\n', schema.name, kind, kindIndexFilename);
-		}
-
-		const index = join(gens.map(gen => gen.schemaIndex(schema, def_gen)));
-		const indexFilename = `${out}/${schema.name}/index.ts`;
-		await write(indexFilename, index);
-		console.log(" Created schema index: %s\n", indexFilename);
-	}
-
-	const fullIndex = join(gens.map(gen => gen.fullIndex(Object.values(schemas))));
-	const fullIndexFilename = `${out}/index.ts`;
-	await write(fullIndexFilename, fullIndex);
-	console.log("Created full index: %s", fullIndexFilename);
-	const end = performance.now();
-	console.log("Completed in \x1b[32m%sms\x1b[0m", (end - start).toFixed(2));
-
-	if (warnings.length > 0) {
-		console.log("\nWarnings generated:");
-		console.log(warnings.map(warning => "* " + warning).join("\n"));
-	}
-};
-
-export async function generate(opts: TruePGOpts, generators?: createGenerator[]) {
-	const out = opts.out || "./models";
-	const extractor = new Extractor(opts.uri);
-	const schemas = await extractor.extractSchemas();
-	generators ??= opts.adapters.map(adapter => {
-		const selected = adapters[adapter];
-		if (!selected) throw new Error(`Requested adapter ${adapter} not found`);
-		return selected;
-	});
-	console.log("Clearing directory and generating schemas at '%s'", out);
-	await rm(out, { recursive: true, force: true });
-	await mkdir(out, { recursive: true });
-	await multifile(generators, schemas, { ...opts, out });
-}

package/src/kysely/builtins.ts

@@ -1,38 +0,0 @@
-// extended from https://github.com/kristiandupont/kanel/blob/e9332f03ff5e38f5b844dd7a4563580c0d9d1444/packages/kanel/src/defaultTypeMap.ts
-
-export const builtins: Record<string, string> = {
-	"pg_catalog.int2": "number",
-	"pg_catalog.int4": "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": "string",
-
-	"pg_catalog.float4": "number",
-	"pg_catalog.float8": "number",
-	"pg_catalog.numeric": "string",
-	"pg_catalog.bool": "boolean",
-	"pg_catalog.json": "unknown",
-	"pg_catalog.jsonb": "unknown",
-	"pg_catalog.char": "string",
-	"pg_catalog.bpchar": "string",
-	"pg_catalog.varchar": "string",
-	"pg_catalog.text": "string",
-	"pg_catalog.uuid": "string",
-	"pg_catalog.inet": "string",
-	"pg_catalog.date": "Date",
-	"pg_catalog.time": "Date",
-	"pg_catalog.timetz": "Date",
-	"pg_catalog.timestamp": "Date",
-	"pg_catalog.timestamptz": "Date",
-	"pg_catalog.int4range": "string",
-	"pg_catalog.int8range": "string",
-	"pg_catalog.numrange": "string",
-	"pg_catalog.tsrange": "string",
-	"pg_catalog.tstzrange": "string",
-	"pg_catalog.daterange": "string",
-	"pg_catalog.record": "Record<string, unknown>",
-	"pg_catalog.void": "void",
-};

package/src/kysely/index.ts

@@ -1,315 +0,0 @@
-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;
-});