appflare 0.0.28 → 0.1.0

package/cli/schema-compiler.ts

@@ -0,0 +1,657 @@
+import { mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import type {
+	ColumnDefinition,
+	ColumnType,
+	ManyRelationDefinition,
+	OneRelationDefinition,
+	SchemaDefinition,
+	TableDefinition,
+} from "../schema";
+import { isSchemaDefinition } from "../schema";
+import type { LoadedAppflareConfig } from "./types";
+
+export type CompiledSchemaArtifacts = {
+	schemaPath: string;
+	typesPath: string;
+	zodPath: string;
+	tableNames: string[];
+};
+
+function toSnakeCase(value: string): string {
+	return value
+		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+		.replace(/[\s-]+/g, "_")
+		.toLowerCase();
+}
+
+function toPascalCase(value: string): string {
+	return value
+		.replace(/[_-]+/g, " ")
+		.replace(/\s+(.)/g, (_match, char: string) => char.toUpperCase())
+		.replace(/\s/g, "")
+		.replace(/^(.)/, (_match, char: string) => char.toUpperCase());
+}
+
+function singularize(value: string): string {
+	if (value.endsWith("ies")) {
+		return `${value.slice(0, -3)}y`;
+	}
+	if (value.endsWith("ses")) {
+		return value.slice(0, -2);
+	}
+	if (value.endsWith("s") && value.length > 1) {
+		return value.slice(0, -1);
+	}
+	return value;
+}
+
+function quote(value: string): string {
+	return JSON.stringify(value);
+}
+
+function toSqlLiteral(value: unknown): string {
+	if (typeof value === "string") {
+		return quote(value);
+	}
+	if (typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	if (value === null) {
+		return "null";
+	}
+	if (value instanceof Date) {
+		return quote(value.toISOString());
+	}
+	throw new Error(
+		`Unsupported SQL default value '${String(value)}'. Use string, number, boolean, null, or Date.`,
+	);
+}
+
+function cloneSchemaDefinition(definition: SchemaDefinition): SchemaDefinition {
+	return {
+		kind: "schema",
+		tables: Object.fromEntries(
+			Object.entries(definition.tables).map(([tableName, table]) => {
+				return [
+					tableName,
+					{
+						kind: "table",
+						sqlName: table.sqlName,
+						columns: Object.fromEntries(
+							Object.entries(table.columns).map(([columnName, column]) => {
+								return [columnName, { ...column }];
+							}),
+						),
+						relations: Object.fromEntries(
+							Object.entries(table.relations).map(
+								([relationName, relation]) => {
+									return [relationName, { ...relation }];
+								},
+							),
+						),
+					} satisfies TableDefinition,
+				];
+			}),
+		),
+	};
+}
+
+function getLocalReferenceType(
+	definition: SchemaDefinition,
+	targetTable: string,
+	referenceField: string,
+): ColumnType | undefined {
+	const table = definition.tables[targetTable];
+	if (!table) {
+		return undefined;
+	}
+	const targetColumn = table.columns[referenceField];
+	return targetColumn?.type;
+}
+
+function ensureInferredReferenceColumn(
+	tableName: string,
+	table: TableDefinition,
+	columnName: string,
+	referenceTable: string,
+	referenceField: string,
+	options: {
+		fkType?: ColumnType;
+		sqlName?: string;
+		notNull?: boolean;
+	},
+	inferredType: ColumnType,
+): void {
+	const existing = table.columns[columnName];
+	if (existing) {
+		if (
+			existing.references &&
+			(existing.references.table !== referenceTable ||
+				existing.references.column !== referenceField)
+		) {
+			throw new Error(
+				`Inferred relation '${tableName}.${columnName}' conflicts with explicit references(${existing.references.table}.${existing.references.column}).`,
+			);
+		}
+
+		table.columns[columnName] = {
+			...existing,
+			references: { table: referenceTable, column: referenceField },
+		};
+		return;
+	}
+
+	table.columns[columnName] = {
+		kind: "column",
+		type: options.fkType ?? inferredType,
+		sqlName: options.sqlName,
+		notNull: options.notNull ?? true,
+		references: {
+			table: referenceTable,
+			column: referenceField,
+		},
+	};
+}
+
+function normalizeSchemaDefinition(
+	definition: SchemaDefinition,
+): SchemaDefinition {
+	const normalized = cloneSchemaDefinition(definition);
+
+	for (const [tableName, table] of Object.entries(normalized.tables)) {
+		for (const [relationName, relation] of Object.entries(table.relations)) {
+			if (relation.relation !== "one") {
+				continue;
+			}
+
+			const referenceField = relation.referenceField ?? "id";
+			const inferredField = relation.field ?? `${relationName}Id`;
+			relation.field = inferredField;
+
+			const inferredType =
+				getLocalReferenceType(
+					normalized,
+					relation.targetTable,
+					referenceField,
+				) ??
+				relation.fkType ??
+				"string";
+
+			ensureInferredReferenceColumn(
+				tableName,
+				table,
+				inferredField,
+				relation.targetTable,
+				referenceField,
+				{
+					fkType: relation.fkType,
+					sqlName: relation.sqlName,
+					notNull: relation.notNull,
+				},
+				inferredType,
+			);
+		}
+	}
+
+	for (const [sourceTableName, sourceTable] of Object.entries(
+		normalized.tables,
+	)) {
+		for (const relation of Object.values(sourceTable.relations)) {
+			if (relation.relation !== "many") {
+				continue;
+			}
+
+			const targetTable = normalized.tables[relation.targetTable];
+			if (!targetTable) {
+				continue;
+			}
+
+			const referenceField = relation.referenceField ?? "id";
+			const inferredField =
+				relation.field ?? `${singularize(sourceTableName)}Id`;
+			const inferredType =
+				getLocalReferenceType(normalized, sourceTableName, referenceField) ??
+				relation.fkType ??
+				"string";
+
+			ensureInferredReferenceColumn(
+				relation.targetTable,
+				targetTable,
+				inferredField,
+				sourceTableName,
+				referenceField,
+				{
+					fkType: relation.fkType,
+					sqlName: relation.sqlName,
+					notNull: relation.notNull,
+				},
+				inferredType,
+			);
+		}
+	}
+
+	return normalized;
+}
+
+function isOptionalInsertColumn(column: ColumnDefinition): boolean {
+	return (
+		column.notNull !== true ||
+		column.autoIncrement === true ||
+		column.sqlDefault !== undefined ||
+		column.runtimeDefaultFn !== undefined
+	);
+}
+
+function isNullableSelectColumn(column: ColumnDefinition): boolean {
+	return column.notNull !== true;
+}
+
+function drizzleBaseColumn(
+	fieldName: string,
+	column: ColumnDefinition,
+	strategy: "camelToSnake",
+): string {
+	const resolvedSqlName = column.sqlName ?? toSnakeCase(fieldName);
+	const needsExplicitName = resolvedSqlName !== fieldName;
+
+	if (column.type === "int") {
+		return needsExplicitName ? `t.int(${quote(resolvedSqlName)})` : "t.int()";
+	}
+
+	if (column.type === "string") {
+		if (column.length !== undefined) {
+			if (needsExplicitName) {
+				return `t.text(${quote(resolvedSqlName)}, { length: ${column.length} })`;
+			}
+			return `t.text({ length: ${column.length} })`;
+		}
+
+		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
+	}
+
+	if (column.type === "boolean") {
+		if (needsExplicitName) {
+			return `t.int(${quote(resolvedSqlName)}, { mode: "boolean" })`;
+		}
+		return 't.int({ mode: "boolean" })';
+	}
+
+	if (column.type === "date") {
+		if (needsExplicitName) {
+			return `t.int(${quote(resolvedSqlName)}, { mode: "timestamp_ms" })`;
+		}
+		return 't.int({ mode: "timestamp_ms" })';
+	}
+
+	if (strategy === "camelToSnake") {
+		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
+	}
+
+	return "t.text()";
+}
+
+function resolveOneRelationReference(
+	tableName: string,
+	table: TableDefinition,
+	relation: OneRelationDefinition,
+): { sourceField: string; targetField: string } {
+	const sourceField = relation.field;
+	const targetField = relation.referenceField ?? "id";
+
+	if (!sourceField) {
+		throw new Error(
+			`Relation on '${tableName}' targeting '${relation.targetTable}' is missing a local field.`,
+		);
+	}
+
+	if (!(sourceField in table.columns)) {
+		throw new Error(
+			`Relation '${tableName}.${sourceField}' references missing local field '${sourceField}'.`,
+		);
+	}
+
+	return {
+		sourceField,
+		targetField,
+	};
+}
+
+function buildExternalTableImportLines(externals: Set<string>): string {
+	if (externals.size === 0) {
+		return "";
+	}
+	return `import { ${Array.from(externals).sort().join(", ")} } from \"./auth.schema\";\n`;
+}
+
+function getRelationImports(table: TableDefinition): string[] {
+	return Object.values(table.relations)
+		.filter((relation) => relation.relation === "one")
+		.map((relation) => relation.targetTable);
+}
+
+function resolveColumnReference(
+	fieldName: string,
+	column: ColumnDefinition,
+	table: TableDefinition,
+): { tableName: string; fieldName: string } | undefined {
+	if (column.references) {
+		return {
+			tableName: column.references.table,
+			fieldName: column.references.column,
+		};
+	}
+
+	const matchingOne = Object.values(table.relations).find((relation) => {
+		return relation.relation === "one" && relation.field === fieldName;
+	}) as OneRelationDefinition | undefined;
+
+	if (!matchingOne) {
+		return undefined;
+	}
+
+	return {
+		tableName: matchingOne.targetTable,
+		fieldName: matchingOne.referenceField ?? "id",
+	};
+}
+
+function emitDrizzleSchema(
+	definition: SchemaDefinition,
+	strategy: "camelToSnake",
+): string {
+	const localTables = new Set(Object.keys(definition.tables));
+	const externalTables = new Set<string>();
+
+	for (const table of Object.values(definition.tables)) {
+		for (const relationTarget of getRelationImports(table)) {
+			if (!localTables.has(relationTarget)) {
+				externalTables.add(relationTarget);
+			}
+		}
+		for (const column of Object.values(table.columns)) {
+			if (column.references && !localTables.has(column.references.table)) {
+				externalTables.add(column.references.table);
+			}
+		}
+	}
+
+	const tableBlocks: string[] = [];
+	const relationBlocks: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const sqlTableName = table.sqlName ?? toSnakeCase(tableName);
+		const columnLines: string[] = [];
+		const indexes: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			let expr = drizzleBaseColumn(fieldName, column, strategy);
+
+			if (column.primaryKey) {
+				expr += column.autoIncrement
+					? ".primaryKey({ autoIncrement: true })"
+					: ".primaryKey()";
+			}
+			if (column.notNull) {
+				expr += ".notNull()";
+			}
+			if (column.sqlDefault !== undefined) {
+				expr += `.default(${toSqlLiteral(column.sqlDefault)})`;
+			}
+
+			const reference = resolveColumnReference(fieldName, column, table);
+			if (reference) {
+				expr += `.references(() => ${reference.tableName}.${reference.fieldName})`;
+			}
+
+			if (column.unique) {
+				const uniqueName =
+					typeof column.unique === "object" && column.unique.name
+						? column.unique.name
+						: `${sqlTableName}_${toSnakeCase(fieldName)}_unique_idx`;
+				indexes.push(
+					`\t\tt.uniqueIndex(${quote(uniqueName)}).on(table.${fieldName})`,
+				);
+			}
+
+			if (column.index) {
+				const indexName =
+					typeof column.index === "object" && column.index.name
+						? column.index.name
+						: `${sqlTableName}_${toSnakeCase(fieldName)}_idx`;
+				indexes.push(`\t\tt.index(${quote(indexName)}).on(table.${fieldName})`);
+			}
+
+			columnLines.push(`\t\t${fieldName}: ${expr},`);
+		}
+
+		if (indexes.length > 0) {
+			tableBlocks.push(
+				`export const ${tableName} = table(\n\t${quote(sqlTableName)},\n\t{\n${columnLines.join("\n")}\n\t},\n\t(table) => [\n${indexes.join(",\n")}\n\t],\n);`,
+			);
+		} else {
+			tableBlocks.push(
+				`export const ${tableName} = table(${quote(sqlTableName)}, {\n${columnLines.join("\n")}\n\t});`,
+			);
+		}
+
+		const oneRelations = Object.entries(table.relations).filter(
+			([, relation]) => {
+				return relation.relation === "one";
+			},
+		) as Array<[string, OneRelationDefinition]>;
+		const manyRelations = Object.entries(table.relations).filter(
+			([, relation]) => {
+				return relation.relation === "many";
+			},
+		) as Array<[string, ManyRelationDefinition]>;
+
+		if (oneRelations.length === 0 && manyRelations.length === 0) {
+			continue;
+		}
+
+		const relationLines: string[] = [];
+		for (const [relationName, relation] of oneRelations) {
+			const resolved = resolveOneRelationReference(tableName, table, relation);
+			relationLines.push(
+				`\t${relationName}: one(${relation.targetTable}, {\n\t\tfields: [${tableName}.${resolved.sourceField}],\n\t\treferences: [${relation.targetTable}.${resolved.targetField}],\n\t}),`,
+			);
+		}
+		for (const [relationName, relation] of manyRelations) {
+			relationLines.push(`\t${relationName}: many(${relation.targetTable}),`);
+		}
+
+		relationBlocks.push(
+			`export const ${tableName}Relations = relations(${tableName}, ({ one, many }) => ({\n${relationLines.join("\n")}\n}));`,
+		);
+	}
+
+	return `import * as t from "drizzle-orm/sqlite-core";
+import { sqliteTable as table } from "drizzle-orm/sqlite-core";
+import { relations } from "drizzle-orm";
+${buildExternalTableImportLines(externalTables)}
+${tableBlocks.join("\n\n")}
+
+${relationBlocks.join("\n\n")}
+`;
+}
+
+function zodSchemaExpression(
+	column: ColumnDefinition,
+	optional: boolean,
+): string {
+	let expr = "z.unknown()";
+	if (column.type === "int") {
+		expr = "z.number().int()";
+	} else if (column.type === "string") {
+		expr = "z.string()";
+		if (column.length !== undefined) {
+			expr += `.max(${column.length})`;
+		}
+	} else if (column.type === "boolean") {
+		expr = "z.boolean()";
+	} else if (column.type === "date") {
+		expr = "z.date()";
+	}
+
+	if (optional) {
+		expr += ".optional()";
+	}
+
+	return expr;
+}
+
+function emitZodSchemas(definition: SchemaDefinition): string {
+	const blocks: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const pascal = toPascalCase(tableName);
+		const insertLines: string[] = [];
+		const selectLines: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			insertLines.push(
+				`\t${fieldName}: ${zodSchemaExpression(column, isOptionalInsertColumn(column))},`,
+			);
+			selectLines.push(
+				`\t${fieldName}: ${zodSchemaExpression(column, isNullableSelectColumn(column))},`,
+			);
+		}
+
+		blocks.push(`export const ${tableName}InsertSchema = z.object({\n${insertLines.join("\n")}\n});
+export const ${tableName}SelectSchema = z.object({\n${selectLines.join("\n")}\n});
+
+export type ${pascal}Insert = z.infer<typeof ${tableName}InsertSchema>;
+export type ${pascal}Select = z.infer<typeof ${tableName}SelectSchema>;
+`);
+	}
+
+	return `import { z } from "zod";
+
+${blocks.join("\n")}`;
+}
+
+function toTypeScriptType(column: ColumnDefinition): string {
+	if (column.type === "int") {
+		return "number";
+	}
+	if (column.type === "string") {
+		return "string";
+	}
+	if (column.type === "boolean") {
+		return "boolean";
+	}
+	if (column.type === "date") {
+		return "Date";
+	}
+	return "unknown";
+}
+
+function emitTypes(definition: SchemaDefinition): string {
+	const lines: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const pascal = toPascalCase(tableName);
+		const selectFields: string[] = [];
+		const insertFields: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			const tsType = toTypeScriptType(column);
+			selectFields.push(
+				`\t${fieldName}${isNullableSelectColumn(column) ? "?" : ""}: ${tsType};`,
+			);
+			insertFields.push(
+				`\t${fieldName}${isOptionalInsertColumn(column) ? "?" : ""}: ${tsType};`,
+			);
+		}
+
+		lines.push(`export type ${pascal} = {\n${selectFields.join("\n")}\n};
+
+export type New${pascal} = {\n${insertFields.join("\n")}\n};`);
+	}
+
+	return `${lines.join("\n\n")}
+`;
+}
+
+function findSchemaExport(
+	moduleExports: Record<string, unknown>,
+	exportName?: string,
+): SchemaDefinition {
+	if (exportName) {
+		const explicit = moduleExports[exportName];
+		if (!isSchemaDefinition(explicit)) {
+			throw new Error(
+				`schemaDsl.exportName '${exportName}' does not point to a schema() export.`,
+			);
+		}
+		return explicit;
+	}
+
+	for (const candidate of Object.values(moduleExports)) {
+		if (isSchemaDefinition(candidate)) {
+			return candidate;
+		}
+	}
+
+	throw new Error(
+		"No schema() export found in schemaDsl entry module. Set schemaDsl.exportName to the correct export.",
+	);
+}
+
+export async function compileSchemaDsl(
+	loadedConfig: LoadedAppflareConfig,
+): Promise<CompiledSchemaArtifacts | undefined> {
+	const schemaDsl = loadedConfig.config.schemaDsl;
+	if (!schemaDsl) {
+		return undefined;
+	}
+
+	const namingStrategy = schemaDsl.namingStrategy ?? "camelToSnake";
+	const entryPath = resolve(loadedConfig.configDir, schemaDsl.entry);
+	const outSchemaPath = resolve(
+		loadedConfig.configDir,
+		schemaDsl.outFile ?? resolve(loadedConfig.outDirAbs, "schema.compiled.ts"),
+	);
+	const outTypesPath = resolve(
+		loadedConfig.configDir,
+		schemaDsl.typesOutFile ??
+			resolve(loadedConfig.outDirAbs, "schema.types.ts"),
+	);
+	const outZodPath = resolve(
+		loadedConfig.configDir,
+		schemaDsl.zodOutFile ?? resolve(loadedConfig.outDirAbs, "schema.zod.ts"),
+	);
+
+	const moduleUrl = `${pathToFileURL(entryPath).href}?t=${Date.now()}`;
+	const schemaModule = (await import(moduleUrl)) as Record<string, unknown>;
+	const schemaDefinition = findSchemaExport(schemaModule, schemaDsl.exportName);
+	const normalizedSchema = normalizeSchemaDefinition(schemaDefinition);
+
+	await Promise.all([
+		mkdir(dirname(outSchemaPath), { recursive: true }),
+		mkdir(dirname(outTypesPath), { recursive: true }),
+		mkdir(dirname(outZodPath), { recursive: true }),
+	]);
+
+	const drizzleSchemaSource = emitDrizzleSchema(
+		normalizedSchema,
+		namingStrategy,
+	);
+	const typesSource = emitTypes(normalizedSchema);
+	const zodSource = emitZodSchemas(normalizedSchema);
+
+	await Promise.all([
+		Bun.write(outSchemaPath, drizzleSchemaSource),
+		Bun.write(outTypesPath, typesSource),
+		Bun.write(outZodPath, zodSource),
+	]);
+
+	return {
+		schemaPath: outSchemaPath,
+		typesPath: outTypesPath,
+		zodPath: outZodPath,
+		tableNames: Object.keys(normalizedSchema.tables),
+	};
+}