true-pg 0.0.2 → 0.1.0

package/src/types.ts

@@ -1,297 +0,0 @@
-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

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

package/src/zod/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": "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()",
-};

package/src/zod/index.ts

@@ -1,301 +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";
-import { join } from "../util.ts";
-
-const isIdentifierInvalid = (str: string) => {
-	const invalid = str.match(/[^a-zA-Z0-9_]/);
-	return invalid !== null;
-};
-
-const to_snake_case = (str: string) =>
-	str
-		.replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
-		.replace(/[^a-zA-Z0-9]+/g, "_") // replace non-alphanumeric characters with underscores
-		.replace(/([A-Z])/g, "_$1") // insert underscores before uppercase letters
-		.toLowerCase();
-
-// TODO: create an insert and update zod interface for each type
-export const Zod = createGenerator(opts => {
-	const defaultSchema = opts?.defaultSchema ?? "public";
-
-	const zod = (imports: Nodes.ImportList, name?: string) =>
-		imports.add(
-			new Nodes.ExternalImport({
-				name: name ?? "z",
-				module: "zod",
-				typeOnly: false,
-				star: !name,
-			}),
-		);
-
-	const add = (imports: Nodes.ImportList, type: CanonicalType) => {
-		if (type.schema === "pg_catalog") zod(imports, "z");
-		else
-			imports.add(
-				new Nodes.InternalImport({
-					name: generator.formatType(type),
-					canonical_type: type,
-					typeOnly: false,
-					star: false,
-				}),
-			);
-	};
-
-	const column = (
-		imports: Nodes.ImportList,
-		/** Information about the column */
-		col: TableColumn,
-	) => {
-		// don't create a property for always generated columns
-		if (col.generated === "ALWAYS") return "";
-
-		let out = col.comment ? `/** ${col.comment} */\n\t` : "";
-		out += col.name;
-		let type = generator.formatType(col.type);
-		add(imports, col.type);
-		if (col.type.dimensions > 0) type += ".array()".repeat(col.type.dimensions);
-		if (col.isNullable || col.generated === "BY DEFAULT" || col.defaultValue) type += `.nullable().optional()`;
-		out += `: ${type}`;
-
-		return `\t${out},\n`;
-	};
-
-	const composite_attribute = (imports: Nodes.ImportList, attr: CanonicalType.CompositeAttribute) => {
-		let out = attr.name;
-		out += `: ${generator.formatType(attr.type)}`;
-		add(imports, attr.type);
-		if (attr.type.dimensions > 0) out += ".array()".repeat(attr.type.dimensions);
-		if (attr.isNullable) out += ".nullable().optional()";
-
-		return out;
-	};
-
-	const generator: SchemaGenerator = {
-		formatSchema(name) {
-			return to_snake_case(name) + "_validators";
-		},
-
-		formatSchemaType(type) {
-			return to_snake_case(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 "z.unknown()".`,
-				);
-				return "z.unknown()";
-			}
-			return to_snake_case(type.name);
-		},
-
-		table(imports, table) {
-			let out = "";
-
-			if (table.comment) out += `/** ${table.comment} */\n`;
-			out += `export const ${this.formatSchemaType(table)} = z.object({\n`;
-			zod(imports, "z");
-			for (const col of table.columns) out += column(imports, col);
-			out += "});";
-
-			return out;
-		},
-
-		enum(imports, en) {
-			let out = "";
-
-			if (en.comment) out += `/** ${en.comment} */\n`;
-
-			out += `export const ${this.formatSchemaType(en)} = z.union([\n`;
-			out += en.values.map(v => `\tz.literal("${v}")`).join(",\n");
-			out += "\n]);";
-
-			zod(imports, "z");
-
-			return out;
-		},
-
-		composite(imports, type) {
-			let out = "";
-
-			if (type.comment) out += `/** ${type.comment} */\n`;
-			out += `export const ${this.formatSchemaType(type)} = z.object({\n`;
-
-			const props = type.canonical.attributes.map(c => composite_attribute(imports, c)).map(t => `\t${t},`);
-			out += props.join("\n");
-			out += "\n});";
-
-			return out;
-		},
-
-		function(imports, type) {
-			let out = "export const ";
-			out += this.formatSchemaType(type);
-			out += " = {\n";
-
-			out += `\tparameters: z.tuple([`;
-
-			// Get the input parameters (those that appear in function signature)
-			const inputParams = type.parameters.filter(p => p.mode === "IN" || p.mode === "INOUT");
-
-			if (inputParams.length === 0) {
-				out += "])";
-			} else {
-				out += "\n";
-
-				for (const param of inputParams) {
-					// TODO: update imports for non-primitive types based on typeInfo.kind
-					out += "\t\t" + this.formatType(param.type);
-					add(imports, param.type);
-					if (param.type.dimensions > 0) out += ".array()".repeat(param.type.dimensions);
-					if (param.hasDefault) out += ".nullable().optional()";
-					out += `, // ${param.name}\n`;
-				}
-
-				out += "\t])";
-			}
-
-			const variadic = type.parameters.find(p => p.mode === "VARIADIC");
-			if (variadic) {
-				out += ".rest(";
-				out += this.formatType(variadic.type);
-				// reduce by 1 because it's already a rest parameter
-				if (variadic.type.dimensions > 1) out += ".array()".repeat(variadic.type.dimensions - 1);
-				out += ")" + ", // " + variadic.name + "\n";
-			} else out += ",\n";
-
-			out += "\treturnType: ";
-
-			if (type.returnType.kind === "table") {
-				out += "z.object({\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 += ".array()".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 += ".array()".repeat(type.returnType.type.dimensions);
-			}
-
-			// Add additional array brackets if it returns a set
-			if (type.returnType.isSet) out += ".array()";
-			out += ",\n};";
-
-			return out;
-		},
-
-		schemaKindIndex(schema, kind, main_generator) {
-			const imports = schema[kind];
-			if (imports.length === 0) return "";
-			const generator = main_generator ?? this;
-
-			return imports
-				.map(each => {
-					const name = this.formatSchemaType(each);
-					const file = generator.formatSchemaType(each);
-					return `export { ${name} } from "./${file}.ts";`;
-				})
-				.join("\n");
-		},
-
-		schemaIndex(schema, main_generator) {
-			let out = allowed_kind_names.map(kind => `import * as zod_${kind} from "./${kind}/index.ts";`).join("\n");
-
-			out += "\n\n";
-			out += `export const ${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}: zod_${t.kind}s.${t.formatted},`;
-					})
-					.join("\n");
-				out += "\n\t},\n";
-			}
-
-			out += "}";
-
-			return out;
-		},
-
-		fullIndex(schemas: Schema[], main_generator) {
-			const generator = main_generator ?? this;
-
-			let out = "";
-
-			out += schemas
-				.map(s => `import { ${generator.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
-				.join("\n");
-
-			out += "\n\n";
-			out += `export const Validators = {\n`;
-			out += join(
-				schemas.map(schema => {
-					const schema_validators = join(
-						allowed_kind_names.map(kind => {
-							const current = schema[kind];
-
-							const seen = new Set<string>();
-							const formatted = current
-								.map(each => {
-									const formatted = generator.formatSchemaType(each);
-									// skip clashing names
-									if (seen.has(formatted)) return;
-									seen.add(formatted);
-									return { ...each, formatted };
-								})
-								.filter(x => x !== undefined);
-
-							if (!formatted.length) return "";
-
-							let out = "";
-							out += "\t// " + kind + "\n";
-							out += join(
-								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}"],`;
-								}),
-								"\n",
-							);
-							return out;
-						}),
-					);
-					return `\t/* -- ${schema.name} --*/\n\n` + schema_validators || "\t-- no validators\n\n";
-				}),
-			);
-
-			out += "\n}\n\n";
-
-			out += schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n");
-
-			return out;
-		},
-	};
-
-	return generator;
-});

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-	"compilerOptions": {
-		// Environment setup & latest features
-		"lib": ["esnext"],
-		"target": "ESNext",
-		"module": "NodeNext",
-		"moduleDetection": "force",
-
-		// Bundler mode
-		"moduleResolution": "nodenext",
-		"allowImportingTsExtensions": true,
-		"rewriteRelativeImportExtensions": true,
-		"verbatimModuleSyntax": true,
-
-		// Best practices
-		"strict": true,
-		"skipLibCheck": true,
-		"noFallthroughCasesInSwitch": true,
-		"noUncheckedIndexedAccess": true,
-		"declaration": true,
-
-		// Some stricter flags (disabled by default)
-		"noUnusedLocals": false,
-		"noUnusedParameters": false,
-		"noPropertyAccessFromIndexSignature": false,
-		"outDir": "lib"
-	},
-	"include": ["src/**/*.ts"]
-}