@fragno-dev/db 0.2.2 → 0.4.1

package/dist/schema/create.js

@@ -1,4 +1,5 @@
 import { createId } from "../id.js";
+import { FragnoDbValidationError, createTableStandardSchemaProps, createTableValidator } from "./validator.js";
 import { generateId } from "./generate-id.js";
 
 //#region src/schema/create.ts
@@ -7,21 +8,24 @@ var RelationInit = class {
 	referencedTable;
 	referencer;
 	on = [];
-	constructor(type, referencedTable, referencer) {
+	foreignKey;
+	constructor(type, referencedTable, referencer, options) {
 		this.type = type;
 		this.referencedTable = referencedTable;
 		this.referencer = referencer;
+		this.foreignKey = options?.foreignKey ?? true;
 	}
 };
 var ExplicitRelationInit = class extends RelationInit {
-	init(ormName) {
+	init(name) {
 		return {
-			id: `${this.referencer.ormName}_${this.referencedTable.ormName}`,
+			id: `${this.referencer.name}_${this.referencedTable.name}`,
 			on: this.on,
-			name: ormName,
+			name,
 			referencer: this.referencer,
 			table: this.referencedTable,
-			type: this.type
+			type: this.type,
+			foreignKey: this.foreignKey
 		};
 	}
 };
@@ -42,7 +46,6 @@ const runtimeDefaultBuilder = {
 var Column = class {
 	type;
 	name = "";
-	ormName = "";
 	isNullable = false;
 	role = "regular";
 	isHidden = false;
@@ -178,6 +181,20 @@ var VersionColumn = class extends Column {
 		this.defaultTo(0).hidden();
 	}
 };
+function cloneColumn(col) {
+	let clonedCol;
+	if (col instanceof InternalIdColumn) clonedCol = new InternalIdColumn();
+	else if (col instanceof VersionColumn) clonedCol = new VersionColumn();
+	else if (col instanceof IdColumn) clonedCol = new IdColumn(col.type);
+	else clonedCol = new Column(col.type);
+	clonedCol.name = col.name;
+	clonedCol.isNullable = col.isNullable;
+	clonedCol.role = col.role;
+	clonedCol.isHidden = col.isHidden;
+	clonedCol.default = col.default;
+	clonedCol.tableName = col.tableName;
+	return clonedCol;
+}
 function column(type) {
 	return new Column(type);
 }
@@ -197,7 +214,7 @@ function referenceColumn() {
 * Input accepts string | FragnoId | null, output returns FragnoId.
 */
 function idColumn() {
-	const col = new IdColumn("varchar(30)");
+	const col = new IdColumn("varchar(128)");
 	col.role = "external-id";
 	col.defaultTo$((b) => b.cuid());
 	return col;
@@ -304,12 +321,15 @@ var FragnoReference = class FragnoReference {
 		return this.#internalId;
 	}
 };
+const validationClasses = {
+	FragnoId,
+	FragnoReference
+};
 var TableBuilder = class {
 	#name;
 	#columns;
 	#relations;
 	#indexes;
-	#ormName = "";
 	#columnOrder = [];
 	constructor(name) {
 		this.#name = name;
@@ -332,15 +352,26 @@ var TableBuilder = class {
 	getColumnOrder() {
 		return this.#columnOrder;
 	}
-	addColumn(ormName, colOrType) {
+	addColumn(name, colOrType) {
 		const col = typeof colOrType === "string" ? column(colOrType) : colOrType;
-		col.ormName = ormName;
-		col.name = ormName;
-		this.#columns[ormName] = col;
-		this.#columnOrder.push(ormName);
+		col.name = name;
+		this.#columns[name] = col;
+		this.#columnOrder.push(name);
 		return this;
 	}
 	/**
+	* Alter an existing column.
+	*/
+	alterColumn(name) {
+		return { nullable: (nullable) => {
+			const column$1 = this.#columns[name];
+			if (!column$1) throw new Error(`Unknown column name ${String(name)}`);
+			const updated = cloneColumn(column$1).nullable(nullable ?? true);
+			this.#columns[name] = updated;
+			return this;
+		} };
+	}
+	/**
 	* Create an index on the specified columns.
 	*/
 	createIndex(name, columns, options) {
@@ -367,20 +398,16 @@ var TableBuilder = class {
 		let versionCol;
 		if (!this.#columns["_internalId"]) {
 			const col = internalIdColumn();
-			col.ormName = "_internalId";
 			col.name = "_internalId";
 			this.#columns["_internalId"] = col;
 		}
 		if (!this.#columns["_version"]) {
 			const col = versionColumn();
-			col.ormName = "_version";
 			col.name = "_version";
 			this.#columns["_version"] = col;
 		}
-		const ormName = this.#ormName || this.#name;
 		const table = {
 			name: this.#name,
-			ormName,
 			columns: this.#columns,
 			relations: this.#relations,
 			indexes: this.#indexes,
@@ -397,6 +424,8 @@ var TableBuilder = class {
 				return versionCol;
 			}
 		};
+		table["~standard"] = createTableStandardSchemaProps(table, validationClasses);
+		table.validate = createTableValidator(table, validationClasses);
 		for (const k in this.#columns) {
 			const column$1 = this.#columns[k];
 			if (!column$1) continue;
@@ -412,15 +441,43 @@ var TableBuilder = class {
 	}
 };
 var SchemaBuilder = class SchemaBuilder {
+	#name;
 	#tables;
 	#version = 0;
 	#operations = [];
-	constructor(existingSchema) {
+	#tableNames = /* @__PURE__ */ new Set();
+	#indexNames = /* @__PURE__ */ new Set();
+	constructor(name, existingSchema) {
+		this.#name = name;
 		if (existingSchema) {
 			this.#tables = existingSchema.tables;
 			this.#version = existingSchema.version;
 			this.#operations = [...existingSchema.operations];
 		} else this.#tables = {};
+		for (const table of Object.values(this.#tables)) {
+			this.#registerTableName(table.name);
+			for (const index of Object.values(table.indexes)) this.#registerIndexName(index.name, table.name);
+		}
+	}
+	#registerTableName(name) {
+		if (this.#tableNames.has(name)) throw new Error(`Duplicate table name "${name}" in schema "${this.#name}".`);
+		this.#tableNames.add(name);
+	}
+	#registerIndexName(name, tableName) {
+		if (this.#indexNames.has(name)) throw new Error(`Duplicate index name "${name}" in schema "${this.#name}". Index names must be unique across tables (conflict on "${tableName}").`);
+		this.#indexNames.add(name);
+	}
+	#rebindRelations(tableName, newTable) {
+		for (const table of Object.values(this.#tables)) for (const relation of Object.values(table.relations)) {
+			if (relation.table.name === tableName) relation.table = newTable;
+			if (relation.referencer.name === tableName) relation.referencer = newTable;
+		}
+	}
+	#isJoinColumnIndexed(table, columnName) {
+		const idColumnName = table.getIdColumn().name;
+		const internalIdColumnName = table.getInternalIdColumn().name;
+		if (columnName === idColumnName || columnName === internalIdColumnName) return true;
+		return Object.values(table.indexes).some((index) => index.columnNames.some((name) => name === columnName));
 	}
 	/**
 	* Add an existing schema to this builder.
@@ -428,29 +485,39 @@ var SchemaBuilder = class SchemaBuilder {
 	*
 	* @example
 	* ```ts
-	* const builder = new SchemaBuilder()
+	* const builder = new SchemaBuilder("combined")
 	*   .add(userSchema)
 	*   .add(postSchema)
 	*   .addTable("comments", ...);
 	* ```
 	*/
 	mergeWithExistingSchema(schema$1) {
+		for (const table of Object.values(schema$1.tables)) {
+			if (this.#tableNames.has(table.name)) throw new Error(`Duplicate table name "${table.name}" in schema "${this.#name}" when merging.`);
+			for (const index of Object.values(table.indexes)) if (this.#indexNames.has(index.name)) throw new Error(`Duplicate index name "${index.name}" in schema "${this.#name}" when merging (conflict on "${table.name}").`);
+		}
 		this.#tables = {
 			...this.#tables,
 			...schema$1.tables
 		};
 		this.#operations = [...this.#operations, ...schema$1.operations];
 		this.#version += schema$1.version;
+		for (const table of Object.values(schema$1.tables)) {
+			this.#tableNames.add(table.name);
+			for (const index of Object.values(table.indexes)) this.#indexNames.add(index.name);
+		}
 		return this;
 	}
 	/**
 	* Add a table to the schema. Increments the version counter.
 	*/
-	addTable(ormName, callback) {
+	addTable(name, callback) {
 		this.#version++;
-		const result = callback(new TableBuilder(ormName));
+		if (this.#tableNames.has(name)) throw new Error(`Duplicate table name "${name}" in schema "${this.#name}".`);
+		const result = callback(new TableBuilder(name));
 		const builtTable = result.build();
-		builtTable.ormName = ormName;
+		const indexNames = result.getIndexes().map((idx) => idx.name);
+		for (const indexName of indexNames) if (this.#indexNames.has(indexName)) throw new Error(`Duplicate index name "${indexName}" in schema "${this.#name}". Index names must be unique across tables (conflict on "${name}").`);
 		const subOperations = [];
 		const columnOrder = result.getColumnOrder();
 		for (const colName of columnOrder) {
@@ -458,34 +525,36 @@ var SchemaBuilder = class SchemaBuilder {
 			subOperations.push({
 				type: "add-column",
 				columnName: colName,
-				column: col
+				column: cloneColumn(col)
 			});
 		}
 		if (builtTable.columns["_internalId"]) subOperations.push({
 			type: "add-column",
 			columnName: "_internalId",
-			column: builtTable.columns["_internalId"]
+			column: cloneColumn(builtTable.columns["_internalId"])
 		});
 		if (builtTable.columns["_version"]) subOperations.push({
 			type: "add-column",
 			columnName: "_version",
-			column: builtTable.columns["_version"]
+			column: cloneColumn(builtTable.columns["_version"])
 		});
 		for (const idx of result.getIndexes()) subOperations.push({
 			type: "add-index",
 			name: idx.name,
-			columns: idx.columns.map((c) => c.ormName),
+			columns: idx.columns.map((c) => c.name),
 			unique: idx.unique
 		});
 		this.#operations.push({
 			type: "add-table",
-			tableName: ormName,
+			tableName: name,
 			operations: subOperations
 		});
 		this.#tables = {
 			...this.#tables,
-			[ormName]: builtTable
+			[name]: builtTable
 		};
+		this.#tableNames.add(name);
+		for (const indexName of indexNames) this.#indexNames.add(indexName);
 		return this;
 	}
 	/**
@@ -497,7 +566,7 @@ var SchemaBuilder = class SchemaBuilder {
 	* @example
 	* ```ts
 	* // One-to-one or many-to-one: post -> user
-	* schema(s => s
+	* schema("blog", s => s
 	*   .addTable("users", t => t.addColumn("id", idColumn()))
 	*   .addTable("posts", t => t
 	*     .addColumn("id", idColumn())
@@ -522,24 +591,43 @@ var SchemaBuilder = class SchemaBuilder {
 	*   from: { table: "users", column: "invitedBy" },
 	*   to: { table: "users", column: "id" },
 	* })
+	*
+	* // Join-only relation (no foreign key)
+	* .addReference("invitedUser", {
+	*   type: "one",
+	*   from: { table: "invitations", column: "email" },
+	*   to: { table: "users", column: "email" },
+	*   foreignKey: false,
+	* })
 	* ```
 	*/
 	addReference(referenceName, config) {
 		this.#version++;
 		const table = this.#tables[config.from.table];
 		const referencedTable = this.#tables[config.to.table];
+		if (!referenceName || referenceName.trim().length === 0) throw new Error(`referenceName is required for addReference on ${config.from.table}`);
 		if (!table) throw new Error(`Table ${config.from.table} not found in schema`);
 		if (!referencedTable) throw new Error(`Referenced table ${config.to.table} not found in schema`);
 		const columnName = config.from.column;
 		const targetColumnName = config.to.column;
-		const actualTargetColumnName = targetColumnName === "id" ? "_internalId" : targetColumnName;
+		const foreignKey = config.foreignKey !== false;
 		const column$1 = table.columns[columnName];
-		const referencedColumn = referencedTable.columns[actualTargetColumnName];
+		const targetColumn = referencedTable.columns[targetColumnName];
 		if (!column$1) throw new Error(`Column ${columnName} not found in table ${config.from.table}`);
-		if (!referencedColumn) throw new Error(`Column ${actualTargetColumnName} not found in table ${config.to.table}`);
+		if (!targetColumn) throw new Error(`Column ${targetColumnName} not found in table ${config.to.table}`);
+		const actualTargetColumnName = targetColumn.role === "external-id" ? referencedTable.getInternalIdColumn().name : targetColumnName;
+		if (!referencedTable.columns[actualTargetColumnName]) throw new Error(`Column ${actualTargetColumnName} not found in table ${config.to.table}`);
+		if (table.relations[referenceName]) throw new Error(`Reference ${referenceName} already exists on table ${config.from.table}`);
 		if (column$1.role === "reference" && column$1.type !== "bigint") throw new Error(`Reference column ${columnName} must be of type bigint to match internal ID type`);
-		const init = new ExplicitRelationInit(config.type, referencedTable, table);
-		init.on.push([columnName, targetColumnName]);
+		if (!foreignKey) {
+			const missingIndexes = [];
+			if (!this.#isJoinColumnIndexed(table, columnName)) missingIndexes.push(`${table.name}.${columnName}`);
+			if (!this.#isJoinColumnIndexed(referencedTable, actualTargetColumnName)) missingIndexes.push(`${referencedTable.name}.${actualTargetColumnName}`);
+			if (missingIndexes.length > 0) throw new Error(`Join-only relation "${referenceName}" requires indexed join columns: ${missingIndexes.join(", ")}.`);
+		}
+		const actualFromColumnName = !foreignKey && column$1.role === "external-id" ? table.getInternalIdColumn().name : columnName;
+		const init = new ExplicitRelationInit(config.type, referencedTable, table, { foreignKey });
+		init.on.push([actualFromColumnName, targetColumnName]);
 		const relation = init.init(referenceName);
 		table.relations[referenceName] = relation;
 		this.#operations.push({
@@ -550,19 +638,20 @@ var SchemaBuilder = class SchemaBuilder {
 				type: config.type,
 				from: {
 					table: config.from.table,
-					column: columnName
+					column: actualFromColumnName
 				},
 				to: {
 					table: config.to.table,
 					column: actualTargetColumnName
-				}
+				},
+				foreignKey
 			}
 		});
 		return this;
 	}
 	/**
-	* Alter an existing table by adding columns or indexes.
-	* This is used for append-only schema modifications.
+	* Alter an existing table by adding columns, altering columns, or adding indexes.
+	* This is used for forward-only schema modifications.
 	*
 	* @param tableName - The name of the table to modify
 	* @param callback - A callback that receives a table builder for adding columns/indexes
@@ -570,11 +659,12 @@ var SchemaBuilder = class SchemaBuilder {
 	* @example
 	* ```ts
 	* // Add a new column to an existing table
-	* schema(s => s
+	* schema("blog", s => s
 	*   .addTable("users", t => t
 	*     .addColumn("id", idColumn())
 	*     .addColumn("name", column("string")))
 	*   .alterTable("users", t => t
+	*     .alterColumn("name").nullable()
 	*     .addColumn("email", column("string"))
 	*     .addColumn("age", column("integer").nullable())
 	*     .createIndex("idx_email", ["email"]))
@@ -590,6 +680,8 @@ var SchemaBuilder = class SchemaBuilder {
 		tableBuilder.setIndexes(table.indexes);
 		const existingColumns = new Set(Object.keys(table.columns));
 		const existingIndexes = new Set(Object.keys(table.indexes));
+		const existingColumnState = /* @__PURE__ */ new Map();
+		for (const [colName, col] of Object.entries(table.columns)) existingColumnState.set(colName, { isNullable: col.isNullable });
 		const resultBuilder = callback(tableBuilder);
 		const newTable = resultBuilder.build();
 		const subOperations = [];
@@ -597,14 +689,29 @@ var SchemaBuilder = class SchemaBuilder {
 		for (const colName of columnOrder) if (!existingColumns.has(colName)) subOperations.push({
 			type: "add-column",
 			columnName: colName,
-			column: newTable.columns[colName]
-		});
-		for (const idx of resultBuilder.getIndexes()) if (!existingIndexes.has(idx.name)) subOperations.push({
-			type: "add-index",
-			name: idx.name,
-			columns: idx.columns.map((c) => c.ormName),
-			unique: idx.unique
+			column: cloneColumn(newTable.columns[colName])
 		});
+		for (const [colName, previousState] of existingColumnState.entries()) {
+			const updatedColumn = newTable.columns[colName];
+			if (!updatedColumn) continue;
+			if (previousState.isNullable !== updatedColumn.isNullable) subOperations.push({
+				type: "update-column",
+				columnName: colName,
+				column: cloneColumn(updatedColumn),
+				updateNullable: true,
+				updateDefault: false,
+				updateDataType: false
+			});
+		}
+		for (const idx of resultBuilder.getIndexes()) if (!existingIndexes.has(idx.name)) {
+			if (this.#indexNames.has(idx.name)) throw new Error(`Duplicate index name "${idx.name}" in schema "${this.#name}". Index names must be unique across tables (conflict on "${tableName}").`);
+			subOperations.push({
+				type: "add-index",
+				name: idx.name,
+				columns: idx.columns.map((c) => c.name),
+				unique: idx.unique
+			});
+		}
 		if (subOperations.length > 0) {
 			this.#version++;
 			this.#operations.push({
@@ -614,6 +721,8 @@ var SchemaBuilder = class SchemaBuilder {
 			});
 		}
 		this.#tables[tableName] = newTable;
+		this.#rebindRelations(tableName, newTable);
+		for (const idx of resultBuilder.getIndexes()) if (!existingIndexes.has(idx.name)) this.#indexNames.add(idx.name);
 		for (const col of Object.values(newTable.columns)) col.tableName = newTable.name;
 		return this;
 	}
@@ -625,6 +734,7 @@ var SchemaBuilder = class SchemaBuilder {
 		const version = this.#version;
 		const tables = this.#tables;
 		return {
+			name: this.#name,
 			version,
 			tables,
 			operations,
@@ -639,7 +749,6 @@ var SchemaBuilder = class SchemaBuilder {
 						else if (col instanceof IdColumn) clonedCol = new IdColumn(col.type);
 						else clonedCol = new Column(col.type);
 						clonedCol.name = col.name;
-						clonedCol.ormName = col.ormName;
 						clonedCol.isNullable = col.isNullable;
 						clonedCol.role = col.role;
 						clonedCol.isHidden = col.isHidden;
@@ -647,19 +756,24 @@ var SchemaBuilder = class SchemaBuilder {
 						clonedCol.tableName = col.tableName;
 						clonedColumns[colName] = clonedCol;
 					}
-					cloneTables[k] = {
+					const clonedTable = {
 						...v,
 						columns: clonedColumns
 					};
+					clonedTable["~standard"] = createTableStandardSchemaProps(clonedTable, validationClasses);
+					clonedTable.validate = createTableValidator(clonedTable, validationClasses);
+					cloneTables[k] = clonedTable;
 				}
-				return new SchemaBuilder({
+				const clonedSchema = {
+					name: this.#name,
 					version,
 					tables: cloneTables,
 					operations: [...operations],
 					clone: () => {
 						throw new Error("Cannot clone during clone");
 					}
-				}).build();
+				};
+				return new SchemaBuilder(this.#name, clonedSchema).build();
 			}
 		};
 	}
@@ -673,19 +787,19 @@ var SchemaBuilder = class SchemaBuilder {
 /**
 * Create a new schema with callback pattern.
 */
-function schema(callback) {
-	return callback(new SchemaBuilder()).build();
+function schema(name, callback) {
+	return callback(new SchemaBuilder(name)).build();
 }
-function compileForeignKey(key, nameType = "orm") {
+function compileForeignKey(key) {
 	return {
 		name: key.name,
-		table: nameType === "sql" ? key.table.name : key.table.ormName,
-		referencedTable: nameType === "sql" ? key.referencedTable.name : key.referencedTable.ormName,
-		referencedColumns: key.referencedColumns.map((col) => nameType === "sql" ? col.name : col.ormName),
-		columns: key.columns.map((col) => nameType === "sql" ? col.name : col.ormName)
+		table: key.table.name,
+		referencedTable: key.referencedTable.name,
+		referencedColumns: key.referencedColumns.map((col) => col.name),
+		columns: key.columns.map((col) => col.name)
 	};
 }
 
 //#endregion
-export { Column, ExplicitRelationInit, FragnoId, FragnoReference, IdColumn, InternalIdColumn, SchemaBuilder, TableBuilder, VersionColumn, column, compileForeignKey, generateId, idColumn, internalIdColumn, referenceColumn, schema, versionColumn };
+export { Column, ExplicitRelationInit, FragnoDbValidationError, FragnoId, FragnoReference, IdColumn, InternalIdColumn, SchemaBuilder, TableBuilder, VersionColumn, column, compileForeignKey, generateId, idColumn, internalIdColumn, referenceColumn, schema, versionColumn };
 //# sourceMappingURL=create.js.map