nucleus-core-ts 0.8.0

package/scripts/generate-schema.ts

@@ -0,0 +1,556 @@
+#!/usr/bin/env bun
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+interface Column {
+	name: string;
+	type: string;
+	length?: number;
+	precision?: number;
+	scale?: number;
+	notNull?: boolean;
+	nullable?: boolean;
+	primaryKey?: boolean;
+	unique?: boolean;
+	default?: unknown;
+	defaultRaw?: string;
+	defaultRandom?: boolean;
+	array?: boolean;
+	references?: {
+		table: string;
+		column: string;
+		onDelete?: string;
+		onUpdate?: string;
+	};
+	enumValues?: string[];
+	enum?: {
+		name: string;
+		values: string[];
+	};
+	mode?: string;
+	dimensions?: number;
+	generatedAlwaysAs?: string;
+	comment?: string;
+	check?: string;
+}
+
+interface Index {
+	name?: string;
+	columns: string[];
+	unique?: boolean;
+	where?: string;
+	using?: string;
+}
+
+interface Constraint {
+	unique?: { name: string; columns: string[] }[];
+	check?: { name: string; expression: string }[];
+}
+
+interface TableDef {
+	table_name: string;
+	feature_set?: string[];
+	add_base_columns?: boolean;
+	columns: Column[];
+	indexes?: Index[];
+	constraints?: Constraint;
+}
+
+interface Config {
+	authentication?: { enabled?: boolean };
+	authorization?: { enabled?: boolean };
+	audit?: { enabled?: boolean };
+	verification?: { enabled?: boolean };
+	notification?: { enabled?: boolean };
+	storage?: { enabled?: boolean };
+	"multi-tenant"?: { enabled?: boolean };
+	entities?: TableDef[];
+}
+
+interface SystemTables {
+	tables: TableDef[];
+}
+
+const BASE_COLUMNS: Column[] = [
+	{
+		name: "id",
+		type: "uuid",
+		primaryKey: true,
+		defaultRaw: "gen_random_uuid()",
+	},
+	{
+		name: "created_at",
+		type: "timestamptz",
+		notNull: true,
+		defaultRaw: "now()",
+	},
+	{
+		name: "updated_at",
+		type: "timestamptz",
+		notNull: true,
+		defaultRaw: "now()",
+	},
+	{ name: "is_active", type: "boolean", notNull: true, default: true },
+	{ name: "created_by", type: "uuid" },
+	{ name: "updated_by", type: "uuid" },
+];
+
+const TYPE_MAP: Record<string, string> = {
+	integer: "integer",
+	smallint: "smallint",
+	bigint: "bigint",
+	serial: "serial",
+	smallserial: "smallserial",
+	bigserial: "bigserial",
+	real: "real",
+	doublePrecision: "doublePrecision",
+	numeric: "numeric",
+	decimal: "decimal",
+	text: "text",
+	varchar: "varchar",
+	char: "char",
+	uuid: "uuid",
+	boolean: "boolean",
+	date: "date",
+	time: "time",
+	timestamp: "timestamp",
+	timestamptz: "timestamp",
+	interval: "interval",
+	json: "json",
+	jsonb: "jsonb",
+	vector: "vector",
+	tsvector: "text",
+	geometry: "text",
+	customType: "text",
+};
+
+function toCamelCase(str: string): string {
+	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function getEnabledFeatures(config: Config): Set<string> {
+	const features = new Set<string>();
+	if (config.authentication?.enabled) features.add("authentication");
+	if (config.authorization?.enabled) features.add("authorization");
+	if (config.audit?.enabled) features.add("audit");
+	if (config.verification?.enabled) features.add("verification");
+	if (config.notification?.enabled) features.add("notification");
+	if (config.storage?.enabled) features.add("storage");
+	if (config["multi-tenant"]?.enabled) features.add("multi-tenant");
+	return features;
+}
+
+function isTableEnabled(
+	table: TableDef,
+	enabledFeatures: Set<string>,
+): boolean {
+	if (!table.feature_set || table.feature_set.length === 0) return true;
+	return table.feature_set.every((f) => enabledFeatures.has(f));
+}
+
+function generateColumnCode(
+	col: Column,
+	allTables: string[],
+	currentTable?: string,
+): string {
+	const drizzleType = TYPE_MAP[col.type] || "text";
+	let code = "";
+
+	if (col.type === "varchar" && col.length) {
+		code = `varchar('${col.name}', { length: ${col.length} })`;
+	} else if (col.type === "char" && col.length) {
+		code = `char('${col.name}', { length: ${col.length} })`;
+	} else if (
+		(col.type === "numeric" || col.type === "decimal") &&
+		col.precision
+	) {
+		code = `numeric('${col.name}', { precision: ${col.precision}, scale: ${col.scale ?? 0} })`;
+	} else if (col.type === "timestamp" || col.type === "timestamptz") {
+		const withTz = col.type === "timestamptz";
+		code = `timestamp('${col.name}'${withTz ? ", { withTimezone: true }" : ""})`;
+	} else if (col.type === "bigint" && col.mode) {
+		code = `bigint('${col.name}', { mode: '${col.mode}' })`;
+	} else if (col.type === "vector" && col.dimensions) {
+		code = `vector('${col.name}', { dimensions: ${col.dimensions} })`;
+	} else {
+		code = `${drizzleType}('${col.name}')`;
+	}
+
+	if (col.primaryKey) code += ".primaryKey()";
+	if (col.notNull) code += ".notNull()";
+	if (col.unique) code += ".unique()";
+
+	if (col.defaultRaw) {
+		code += `.default(sql\`${col.defaultRaw}\`)`;
+	} else if (col.defaultRandom) {
+		code += ".defaultRandom()";
+	} else if (col.default !== undefined) {
+		if (typeof col.default === "string") {
+			code += `.default('${col.default}')`;
+		} else if (typeof col.default === "boolean") {
+			code += `.default(${col.default})`;
+		} else if (typeof col.default === "number") {
+			code += `.default(${col.default})`;
+		} else if (Array.isArray(col.default)) {
+			code += `.default(sql\`'{}'\`)`;
+		} else if (typeof col.default === "object") {
+			code += `.default(sql\`'{}'\`)`;
+		}
+	}
+
+	const isSelfReference =
+		col.references && col.references.table === currentTable;
+	if (
+		col.references &&
+		allTables.includes(col.references.table) &&
+		!isSelfReference
+	) {
+		const refTable = toCamelCase(col.references.table);
+		let refCode = `.references(() => ${refTable}.${col.references.column}`;
+		if (col.references.onDelete) {
+			refCode += `, { onDelete: '${col.references.onDelete}' }`;
+		}
+		refCode += ")";
+		code += refCode;
+	}
+
+	return code;
+}
+
+function generateTableCode(table: TableDef, allTables: string[]): string {
+	const tableName = toCamelCase(table.table_name);
+	const TableName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+	const columns = table.add_base_columns
+		? [
+				...BASE_COLUMNS,
+				...table.columns.filter(
+					(c) => !BASE_COLUMNS.find((bc) => bc.name === c.name),
+				),
+			]
+		: table.columns;
+
+	let code = `export const ${tableName}Columns = {\n`;
+	for (const col of columns) {
+		const colCode = generateColumnCode(col, allTables, table.table_name);
+		code += `\t${toCamelCase(col.name)}: ${colCode},\n`;
+	}
+	code += "};\n\n";
+
+	const vectorColumns = new Set(
+		columns.filter((c) => c.type === "vector").map((c) => c.name),
+	);
+	const validIndexes = (table.indexes || []).filter(
+		(idx) => !idx.columns.some((c) => vectorColumns.has(c)),
+	);
+
+	if (validIndexes.length > 0) {
+		const indexColTypes = [
+			...new Set(validIndexes.flatMap((idx) => idx.columns)),
+		]
+			.map((c) => `${toCamelCase(c)}: PgColumn`)
+			.join("; ");
+		code += `export const ${tableName}Indexes = (t: { ${indexColTypes} }) => [\n`;
+		for (const idx of validIndexes) {
+			const idxName =
+				idx.name || `${table.table_name}_${idx.columns.join("_")}_idx`;
+			const cols = idx.columns.map((c) => `t.${toCamelCase(c)}`).join(", ");
+			if (idx.unique) {
+				code += `\tuniqueIndex('${idxName}').on(${cols}),\n`;
+			} else {
+				code += `\tindex('${idxName}').on(${cols}),\n`;
+			}
+		}
+		code += "];\n\n";
+	}
+
+	code += `export const ${tableName} = pgTable('${table.table_name}', ${tableName}Columns`;
+	if (validIndexes.length > 0) {
+		code += `, (t) => [\n`;
+		for (const idx of validIndexes) {
+			const idxName =
+				idx.name || `${table.table_name}_${idx.columns.join("_")}_idx`;
+			const cols = idx.columns.map((c) => `t.${toCamelCase(c)}`).join(", ");
+			if (idx.unique) {
+				code += `\tuniqueIndex('${idxName}').on(${cols}),\n`;
+			} else {
+				code += `\tindex('${idxName}').on(${cols}),\n`;
+			}
+		}
+		code += `]`;
+	}
+	code += ");\n\n";
+
+	const referencedTables = columns
+		.filter(
+			(c): c is typeof c & { references: NonNullable<typeof c.references> } =>
+				c.references !== undefined && allTables.includes(c.references.table),
+		)
+		.map((c) => ({
+			col: c,
+			refTable: c.references.table,
+			isSelf: c.references.table === table.table_name,
+		}));
+
+	const externalRefs = referencedTables.filter((r) => !r.isSelf);
+
+	code += `export function create${TableName}ForSchema(schema: ReturnType<typeof pgSchema>) {\n`;
+
+	if (externalRefs.length > 0) {
+		const uniqueRefTables = [...new Set(externalRefs.map((r) => r.refTable))];
+		for (const refTable of uniqueRefTables) {
+			const refTableName = toCamelCase(refTable);
+			code += `\tconst ${refTableName}Table = schema.table('${refTable}', ${refTableName}Columns, (t) => ${refTableName}Indexes(t));\n`;
+		}
+	}
+
+	if (referencedTables.length > 0) {
+		code += `\treturn schema.table('${table.table_name}', {\n`;
+		code += `\t\t...${tableName}Columns,\n`;
+		for (const { col, refTable, isSelf } of referencedTables) {
+			const colName = toCamelCase(col.name);
+			const refTableName = toCamelCase(refTable);
+			let colCode = "";
+			if (col.type === "uuid") {
+				colCode = `uuid('${col.name}')`;
+			} else {
+				colCode = `${TYPE_MAP[col.type] || "text"}('${col.name}')`;
+			}
+			if (col.notNull) colCode += ".notNull()";
+			if (isSelf) {
+				code += `\t\t${colName}: ${colCode},\n`;
+			} else {
+				const refColName = col.references?.column || "id";
+				colCode += `.references(() => ${refTableName}Table.${refColName}`;
+				if (col.references?.onDelete) {
+					colCode += `, { onDelete: '${col.references.onDelete}' }`;
+				}
+				colCode += ")";
+				code += `\t\t${colName}: ${colCode},\n`;
+			}
+		}
+		code += `\t}`;
+	} else {
+		code += `\treturn schema.table('${table.table_name}', ${tableName}Columns`;
+	}
+
+	if (validIndexes.length > 0) {
+		code += `, (t) => [\n`;
+		for (const idx of validIndexes) {
+			const idxName =
+				idx.name || `${table.table_name}_${idx.columns.join("_")}_idx`;
+			const cols = idx.columns.map((c) => `t.${toCamelCase(c)}`).join(", ");
+			if (idx.unique) {
+				code += `\t\tuniqueIndex('${idxName}').on(${cols}),\n`;
+			} else {
+				code += `\t\tindex('${idxName}').on(${cols}),\n`;
+			}
+		}
+		code += `\t]`;
+	}
+	code += ");\n";
+	code += "}\n";
+
+	return code;
+}
+
+function generateSchemaFile(tables: TableDef[]): string {
+	const allTableNames = tables.map((t) => t.table_name);
+	const imports = new Set<string>();
+
+	imports.add("pgTable");
+	imports.add("pgSchema");
+	imports.add("PgColumn");
+	imports.add("uuid");
+	imports.add("timestamp");
+	imports.add("boolean");
+	imports.add("index");
+	imports.add("uniqueIndex");
+
+	for (const table of tables) {
+		const columns = table.add_base_columns
+			? [...BASE_COLUMNS, ...table.columns]
+			: table.columns;
+		for (const col of columns) {
+			const drizzleType = TYPE_MAP[col.type];
+			if (drizzleType) imports.add(drizzleType);
+		}
+	}
+
+	let code = `import { ${Array.from(imports).sort().join(", ")} } from 'drizzle-orm/pg-core';\n`;
+	code += `import { sql } from 'drizzle-orm';\n\n`;
+
+	for (const table of tables) {
+		code += generateTableCode(table, allTableNames);
+		code += "\n";
+	}
+
+	code += generateCreateAllForSchemaFunction(tables, allTableNames);
+
+	return code;
+}
+
+function generateCreateAllForSchemaFunction(
+	tables: TableDef[],
+	allTableNames: string[],
+): string {
+	const sortedTables = topologicalSort(tables, allTableNames);
+
+	let code = `export function createAllTablesForSchema(schema: ReturnType<typeof pgSchema>) {\n`;
+	code += `\tconst tables: Record<string, unknown> = {};\n\n`;
+
+	for (const table of sortedTables) {
+		const tableName = toCamelCase(table.table_name);
+		const TableName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+		code += `\ttables.${tableName} = create${TableName}ForSchema(schema);\n`;
+	}
+
+	code += `\n\treturn tables;\n`;
+	code += `}\n`;
+
+	return code;
+}
+
+function topologicalSort(
+	tables: TableDef[],
+	allTableNames: string[],
+): TableDef[] {
+	const graph: Map<string, Set<string>> = new Map();
+	const tableMap: Map<string, TableDef> = new Map();
+
+	for (const table of tables) {
+		tableMap.set(table.table_name, table);
+		graph.set(table.table_name, new Set());
+	}
+
+	for (const table of tables) {
+		const columns = table.add_base_columns
+			? [...BASE_COLUMNS, ...table.columns]
+			: table.columns;
+		for (const col of columns) {
+			if (col.references && allTableNames.includes(col.references.table)) {
+				graph.get(table.table_name)?.add(col.references.table);
+			}
+		}
+	}
+
+	const visited = new Set<string>();
+	const result: TableDef[] = [];
+
+	function visit(name: string) {
+		if (visited.has(name)) return;
+		visited.add(name);
+		const deps = graph.get(name);
+		if (deps) {
+			for (const dep of deps) {
+				visit(dep);
+			}
+		}
+		const table = tableMap.get(name);
+		if (table) result.push(table);
+	}
+
+	for (const table of tables) {
+		visit(table.table_name);
+	}
+
+	return result;
+}
+
+function generateRelationsFile(tables: TableDef[]): string {
+	const allTableNames = new Set(tables.map((t) => t.table_name));
+	const relationsByTable: Map<
+		string,
+		{ to: string; fromCol: string; toCol: string; isSelf: boolean }[]
+	> = new Map();
+
+	for (const table of tables) {
+		const columns = table.add_base_columns
+			? [...BASE_COLUMNS, ...table.columns]
+			: table.columns;
+		for (const col of columns) {
+			if (col.references && allTableNames.has(col.references.table)) {
+				if (!relationsByTable.has(table.table_name)) {
+					relationsByTable.set(table.table_name, []);
+				}
+				relationsByTable.get(table.table_name)?.push({
+					to: col.references.table,
+					fromCol: col.name,
+					toCol: col.references.column,
+					isSelf: col.references.table === table.table_name,
+				});
+			}
+		}
+	}
+
+	let code = `import { relations } from 'drizzle-orm';\n`;
+	code += `import { ${tables.map((t) => toCamelCase(t.table_name)).join(", ")} } from './schema';\n\n`;
+
+	for (const [tableName, rels] of relationsByTable) {
+		const fromTable = toCamelCase(tableName);
+		code += `export const ${fromTable}Relations = relations(${fromTable}, ({ one, many }) => ({\n`;
+
+		for (const rel of rels) {
+			const toTable = toCamelCase(rel.to);
+			const relationName = rel.isSelf ? "parent" : toTable;
+			const fields = `${fromTable}.${toCamelCase(rel.fromCol)}`;
+			const references = `${toTable}.${toCamelCase(rel.toCol)}`;
+
+			code += `\t${relationName}: one(${toTable}, {\n`;
+			code += `\t\tfields: [${fields}],\n`;
+			code += `\t\treferences: [${references}],\n`;
+			code += `\t}),\n`;
+		}
+
+		code += `}));\n\n`;
+	}
+
+	return code;
+}
+
+function main() {
+	const args = process.argv.slice(2);
+	const configArg = args[0];
+	const outputArg = args[1];
+	if (!configArg || !outputArg) {
+		console.error(
+			"Usage: bun run generate-schema.ts <config.json> <output-dir>",
+		);
+		process.exit(1);
+	}
+
+	const configPath = path.resolve(configArg);
+	const outputDir = path.resolve(outputArg);
+
+	const configContent = fs.readFileSync(configPath, "utf-8");
+	const config: Config = JSON.parse(configContent);
+
+	const systemTablesPath = path.resolve(__dirname, "../src/system.tables.json");
+	let systemTables: SystemTables = { tables: [] };
+	if (fs.existsSync(systemTablesPath)) {
+		const systemContent = fs.readFileSync(systemTablesPath, "utf-8");
+		systemTables = JSON.parse(systemContent);
+	} else {
+		console.warn(`System tables not found at ${systemTablesPath}`);
+	}
+
+	const enabledFeatures = getEnabledFeatures(config);
+	const enabledSystemTables = systemTables.tables.filter((t) =>
+		isTableEnabled(t, enabledFeatures),
+	);
+	const customTables = config.entities || [];
+	const allTables = [...enabledSystemTables, ...customTables];
+
+	if (!fs.existsSync(outputDir)) {
+		fs.mkdirSync(outputDir, { recursive: true });
+	}
+
+	const schemaCode = generateSchemaFile(allTables);
+	fs.writeFileSync(path.join(outputDir, "schema.ts"), schemaCode);
+	console.log(`Generated: ${path.join(outputDir, "schema.ts")}`);
+
+	const relationsCode = generateRelationsFile(allTables);
+	fs.writeFileSync(path.join(outputDir, "relations.ts"), relationsCode);
+	console.log(`Generated: ${path.join(outputDir, "relations.ts")}`);
+}
+
+main();

package/scripts/generate-system-tables-types.ts

@@ -0,0 +1,18 @@
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const systemTablesPath = join(__dirname, "../src/system.tables.json");
+const outputPath = join(__dirname, "../src/Client/ApiCaller/system-tables.ts");
+
+const systemTablesJson = JSON.parse(readFileSync(systemTablesPath, "utf-8"));
+
+const output = `// Auto-generated from system.tables.json - DO NOT EDIT MANUALLY
+// Run: bun run scripts/generate-system-tables-types.ts
+
+export const SYSTEM_TABLES = ${JSON.stringify(systemTablesJson.tables, null, 2)} as const
+
+export type SystemTables = typeof SYSTEM_TABLES
+`;
+
+writeFileSync(outputPath, output);
+console.log("Generated system-tables.ts");