@fragno-dev/db 0.0.1 → 0.1.0

package/dist/schema/create.js

@@ -1,4 +1,4 @@
-import { createId } from "../cuid.js";
+import { createId } from "../id.js";
 
 //#region src/schema/create.ts
 var RelationInit = class {
@@ -12,37 +12,10 @@ var RelationInit = class {
 		this.referencer = referencer;
 	}
 };
-/**
-* Helper function to add an index to a table's index array
-*/
-function addIndexToTable(indexes, name, columns, unique) {
-	indexes.push({
-		name,
-		columns,
-		unique
-	});
-}
 var ExplicitRelationInit = class extends RelationInit {
-	foreignKeyName;
-	initForeignKey(ormName) {
-		const columns = [];
-		const referencedColumns = [];
-		for (const [left, right] of this.on) {
-			columns.push(this.referencer.columns[left]);
-			referencedColumns.push(this.referencedTable.columns[right]);
-		}
-		return {
-			columns,
-			referencedColumns,
-			referencedTable: this.referencedTable,
-			table: this.referencer,
-			name: this.foreignKeyName ?? `${this.referencer.ormName}_${this.referencedTable.ormName}_${ormName}_fk`
-		};
-	}
 	init(ormName) {
 		return {
 			id: `${this.referencer.ormName}_${this.referencedTable.ormName}`,
-			foreignKey: this.initForeignKey(ormName),
 			on: this.on,
 			name: ormName,
 			referencer: this.referencer,
@@ -50,23 +23,16 @@ var ExplicitRelationInit = class extends RelationInit {
 			type: this.type
 		};
 	}
-	/**
-	* Define custom foreign key name.
-	*/
-	foreignKey(name) {
-		this.foreignKeyName = name;
-		return this;
-	}
 };
-var Column = class Column {
+var Column = class {
 	type;
 	name = "";
 	ormName = "";
 	isNullable = false;
-	isUnique = false;
-	isReference = false;
+	role = "regular";
+	isHidden = false;
 	default;
-	table = void 0;
+	tableName = "";
 	constructor(type) {
 		this.type = type;
 	}
@@ -74,6 +40,10 @@ var Column = class Column {
 		this.isNullable = nullable ?? true;
 		return this;
 	}
+	hidden(hidden) {
+		this.isHidden = hidden ?? true;
+		return this;
+	}
 	/**
 	* Generate default value on runtime
 	*/
@@ -90,20 +60,6 @@ var Column = class Column {
 		this.default = { value };
 		return this;
 	}
-	clone() {
-		const clone = new Column(this.type);
-		clone.name = this.name;
-		clone.ormName = this.ormName;
-		clone.isNullable = this.isNullable;
-		clone.isUnique = this.isUnique;
-		clone.isReference = this.isReference;
-		clone.default = this.default;
-		clone.table = this.table;
-		return clone;
-	}
-	getUniqueConstraintName() {
-		return `unique_c_${this.table.ormName}_${this.ormName}`;
-	}
 	/**
 	* Generate default value for the column on runtime.
 	*/
@@ -114,26 +70,19 @@ var Column = class Column {
 		if (this.default.runtime === "now") return new Date(Date.now());
 		return this.default.runtime();
 	}
-	get $in() {
-		throw new Error("Type inference only");
-	}
-	get $out() {
-		throw new Error("Type inference only");
-	}
+	/**
+	* @description This is used for type inference only. Runtime value will be undefined.
+	* @internal
+	*/
+	get $in() {}
+	/**
+	* @description This is used for type inference only. Runtime value will be undefined.
+	* @internal
+	*/
+	get $out() {}
 };
-var IdColumn = class IdColumn extends Column {
+var IdColumn = class extends Column {
 	id = true;
-	clone() {
-		const clone = new IdColumn(this.type);
-		clone.name = this.name;
-		clone.ormName = this.ormName;
-		clone.isNullable = this.isNullable;
-		clone.isUnique = this.isUnique;
-		clone.isReference = this.isReference;
-		clone.default = this.default;
-		clone.table = this.table;
-		return clone;
-	}
 	defaultTo$(fn) {
 		return super.defaultTo$(fn);
 	}
@@ -141,73 +90,206 @@ var IdColumn = class IdColumn extends Column {
 		return super.defaultTo(value);
 	}
 };
+/**
+* Internal ID column - used for database-native joins and foreign keys.
+* Hidden from user API by default.
+*/
+var InternalIdColumn = class extends Column {
+	role = "internal-id";
+	constructor() {
+		super("bigint");
+		this.hidden();
+	}
+};
+/**
+* Version column - used for optimistic concurrency control.
+* Automatically incremented on each update.
+*/
+var VersionColumn = class extends Column {
+	role = "version";
+	constructor() {
+		super("integer");
+		this.defaultTo(0).hidden();
+	}
+};
 function column(type) {
 	return new Column(type);
 }
 /**
-* Create a reference column that points to another table.
+* Create a reference column that points to another table's internal ID.
 * This is used for foreign key relationships.
+* Always uses bigint to match the internal ID type.
 */
-function referenceColumn(type) {
-	const col = new Column(type ?? "varchar(30)");
-	col.isReference = true;
+function referenceColumn() {
+	const col = new Column("bigint");
+	col.role = "reference";
 	return col;
 }
+/**
+* Create an external ID column (user-facing).
+* This is a CUID string that can be auto-generated or user-provided.
+* Input accepts string | FragnoId | null, output returns FragnoId.
+*/
 function idColumn() {
 	const col = new IdColumn("varchar(30)");
+	col.role = "external-id";
 	col.defaultTo$("auto");
 	return col;
 }
-var TableBuilder = class TableBuilder {
+/**
+* Create an internal ID column (database-native, hidden from user API).
+* Used for joins and foreign keys.
+* @internal
+*/
+function internalIdColumn() {
+	const col = new InternalIdColumn();
+	col.role = "internal-id";
+	col.hidden();
+	return col;
+}
+/**
+* Create a version column for optimistic concurrency control.
+* @internal
+*/
+function versionColumn() {
+	const col = new VersionColumn();
+	col.role = "version";
+	col.hidden();
+	return col;
+}
+/**
+* FragnoId represents a unified ID object that can contain external ID, internal ID, or both.
+* @internal
+*
+* For query inputs: externalId is sufficient (internalId is optional)
+* For query results: both externalId and internalId are provided
+*/
+var FragnoId = class FragnoId {
+	#externalId;
+	#internalId;
+	#version;
+	constructor({ externalId, internalId, version }) {
+		this.#externalId = externalId;
+		this.#internalId = internalId;
+		this.#version = version;
+	}
+	/**
+	* Create a FragnoId from just an external ID (for inputs)
+	*/
+	static fromExternal(externalId, version) {
+		return new FragnoId({
+			externalId,
+			version
+		});
+	}
+	get version() {
+		return this.#version;
+	}
+	get externalId() {
+		return this.#externalId;
+	}
+	get internalId() {
+		return this.#internalId;
+	}
+	/**
+	* Get the appropriate ID for database operations
+	* Prefers internal ID if available, falls back to external ID
+	*/
+	get databaseId() {
+		return this.#internalId ?? this.#externalId;
+	}
+	/**
+	* Convert to a plain object for serialization
+	*/
+	toJSON() {
+		return {
+			externalId: this.#externalId,
+			internalId: this.#internalId?.toString()
+		};
+	}
+	toString() {
+		return this.#externalId;
+	}
+	valueOf() {
+		return this.#externalId;
+	}
+};
+/**
+* FragnoReference represents a foreign key reference to another table's internal ID.
+* Unlike FragnoId, it only contains the internal ID (bigint) of the referenced record.
+* This is used for reference columns in query results.
+* @internal
+*/
+var FragnoReference = class FragnoReference {
+	#internalId;
+	constructor(internalId) {
+		this.#internalId = internalId;
+	}
+	/**
+	* Create a FragnoReference from an internal ID
+	*/
+	static fromInternal(internalId) {
+		return new FragnoReference(internalId);
+	}
+	/**
+	* Get the internal ID for database operations
+	*/
+	get internalId() {
+		return this.#internalId;
+	}
+};
+var TableBuilder = class {
 	#name;
 	#columns;
 	#relations;
-	#foreignKeys = [];
-	#indexes = [];
-	#version = 0;
+	#indexes;
 	#ormName = "";
-	#operations = [];
+	#columnOrder = [];
 	constructor(name) {
 		this.#name = name;
 		this.#columns = {};
 		this.#relations = {};
+		this.#indexes = {};
+	}
+	setColumns(columns) {
+		this.#columns = { ...columns };
+	}
+	setRelations(relations) {
+		this.#relations = { ...relations };
+	}
+	setIndexes(indexes) {
+		this.#indexes = { ...indexes };
+	}
+	getIndexes() {
+		return Object.values(this.#indexes);
+	}
+	getColumnOrder() {
+		return this.#columnOrder;
 	}
 	addColumn(ormName, colOrType) {
-		this.#version++;
 		const col = typeof colOrType === "string" ? column(colOrType) : colOrType;
-		const builder = new TableBuilder(this.#name);
-		builder.#columns = {
-			...this.#columns,
-			[ormName]: col
-		};
-		builder.#relations = this.#relations;
-		builder.#foreignKeys = this.#foreignKeys;
-		builder.#indexes = this.#indexes;
-		builder.#version = this.#version;
-		builder.#ormName = this.#ormName;
-		builder.#operations = this.#operations;
 		col.ormName = ormName;
 		col.name = ormName;
-		return builder;
+		this.#columns[ormName] = col;
+		this.#columnOrder.push(ormName);
+		return this;
 	}
 	/**
-	* Create an index on the specified columns. Increments the version counter.
+	* Create an index on the specified columns.
 	*/
 	createIndex(name, columns, options) {
-		this.#version++;
-		const cols = columns.map((name$1) => {
-			const column$1 = this.#columns[name$1];
-			if (!column$1) throw new Error(`Unknown column name ${name$1}`);
+		const cols = columns.map((colName) => {
+			const column$1 = this.#columns[colName];
+			if (!column$1) throw new Error(`Unknown column name ${colName}`);
 			return column$1;
 		});
 		const unique = options?.unique ?? false;
-		addIndexToTable(this.#indexes, name, cols, unique);
-		this.#operations.push({
-			type: "add-index",
+		this.#indexes[name] = {
 			name,
-			columns,
+			columns: cols,
+			columnNames: columns,
 			unique
-		});
+		};
 		return this;
 	}
 	/**
@@ -215,13 +297,26 @@ var TableBuilder = class TableBuilder {
 	*/
 	build() {
 		let idCol;
+		let internalIdCol;
+		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$1 = {
+		const table = {
 			name: this.#name,
 			ormName,
 			columns: this.#columns,
 			relations: this.#relations,
-			foreignKeys: this.#foreignKeys,
 			indexes: this.#indexes,
 			getColumnByName: (name) => {
 				return Object.values(this.#columns).find((c) => c.name === name);
@@ -229,165 +324,234 @@ var TableBuilder = class TableBuilder {
 			getIdColumn: () => {
 				return idCol;
 			},
-			clone: () => {
-				const cloneColumns = {};
-				for (const [k, v] of Object.entries(this.#columns)) cloneColumns[k] = v.clone();
-				const builder = new TableBuilder(this.#name);
-				builder.#columns = cloneColumns;
-				builder.#relations = this.#relations;
-				builder.#foreignKeys = [...this.#foreignKeys];
-				builder.#indexes = [...this.#indexes];
-				builder.#version = this.#version;
-				builder.#ormName = this.#ormName;
-				builder.#operations = [...this.#operations];
-				return builder.build();
+			getInternalIdColumn: () => {
+				return internalIdCol;
+			},
+			getVersionColumn: () => {
+				return versionCol;
 			}
 		};
 		for (const k in this.#columns) {
 			const column$1 = this.#columns[k];
 			if (!column$1) continue;
-			column$1.table = table$1;
-			if (column$1 instanceof IdColumn) idCol = column$1;
+			column$1.tableName = table.name;
+			if (column$1 instanceof IdColumn || column$1.role === "external-id") idCol = column$1;
+			if (column$1 instanceof InternalIdColumn || column$1.role === "internal-id") internalIdCol = column$1;
+			if (column$1 instanceof VersionColumn || column$1.role === "version") versionCol = column$1;
 		}
 		if (idCol === void 0) throw new Error(`there's no id column in your table ${this.#name}`);
-		return table$1;
-	}
-	/**
-	* Get the current version of the table builder.
-	*/
-	getVersion() {
-		return this.#version;
-	}
-	/**
-	* Get the operations performed on this table.
-	*/
-	getOperations() {
-		return this.#operations;
+		if (internalIdCol === void 0) throw new Error(`there's no internal id column in your table ${this.#name}`);
+		if (versionCol === void 0) throw new Error(`there's no version column in your table ${this.#name}`);
+		return table;
 	}
 };
-/**
-* Create a new table with callback pattern.
-*/
-function table(name, callback) {
-	const builder = new TableBuilder(name);
-	return callback(builder).build();
-}
 var SchemaBuilder = class SchemaBuilder {
 	#tables;
 	#version = 0;
 	#operations = [];
-	constructor() {
-		this.#tables = {};
+	constructor(existingSchema) {
+		if (existingSchema) {
+			this.#tables = existingSchema.tables;
+			this.#version = existingSchema.version;
+			this.#operations = [...existingSchema.operations];
+		} else this.#tables = {};
+	}
+	/**
+	* Add an existing schema to this builder.
+	* Merges tables and operations from the provided schema.
+	*
+	* @example
+	* ```ts
+	* const builder = new SchemaBuilder()
+	*   .add(userSchema)
+	*   .add(postSchema)
+	*   .addTable("comments", ...);
+	* ```
+	*/
+	mergeWithExistingSchema(schema$1) {
+		this.#tables = {
+			...this.#tables,
+			...schema$1.tables
+		};
+		this.#operations = [...this.#operations, ...schema$1.operations];
+		this.#version += schema$1.version;
+		return this;
 	}
 	/**
 	* Add a table to the schema. Increments the version counter.
 	*/
 	addTable(ormName, callback) {
 		this.#version++;
-		const tableBuilder = new TableBuilder(ormName);
-		const result = callback(tableBuilder);
+		const result = callback(new TableBuilder(ormName));
 		const builtTable = result.build();
 		builtTable.ormName = ormName;
-		const builder = new SchemaBuilder();
-		builder.#tables = {
+		const subOperations = [];
+		const columnOrder = result.getColumnOrder();
+		for (const colName of columnOrder) {
+			const col = builtTable.columns[colName];
+			subOperations.push({
+				type: "add-column",
+				columnName: colName,
+				column: col
+			});
+		}
+		if (builtTable.columns["_internalId"]) subOperations.push({
+			type: "add-column",
+			columnName: "_internalId",
+			column: builtTable.columns["_internalId"]
+		});
+		if (builtTable.columns["_version"]) subOperations.push({
+			type: "add-column",
+			columnName: "_version",
+			column: builtTable.columns["_version"]
+		});
+		for (const idx of result.getIndexes()) subOperations.push({
+			type: "add-index",
+			name: idx.name,
+			columns: idx.columns.map((c) => c.ormName),
+			unique: idx.unique
+		});
+		this.#operations.push({
+			type: "add-table",
+			tableName: ormName,
+			operations: subOperations
+		});
+		this.#tables = {
 			...this.#tables,
 			[ormName]: builtTable
 		};
-		const newOperations = [...this.#operations, {
-			type: "add-table",
-			tableName: ormName,
-			table: builtTable
-		}];
-		const tableOps = result.getOperations();
-		for (const tableOp of tableOps) if (tableOp.type === "add-index") {
-			this.#version++;
-			newOperations.push({
-				type: "add-index",
-				tableName: ormName,
-				name: tableOp.name,
-				columns: tableOp.columns,
-				unique: tableOp.unique
-			});
-		}
-		builder.#version = this.#version;
-		builder.#operations = newOperations;
-		return builder;
+		return this;
 	}
 	/**
-	* Add a foreign key reference from this table to another table.
+	* Add a relation between two tables.
 	*
-	* @param tableName - The table that has the foreign key column
-	* @param referenceName - A name for this reference (e.g., "author", "category")
-	* @param config - Configuration specifying the foreign key mapping
+	* @param referenceName - A name for this relation (e.g., "author", "posts")
+	* @param config - Configuration specifying the relation type and foreign key mapping
 	*
 	* @example
 	* ```ts
-	* // Basic foreign key: post -> user
+	* // One-to-one or many-to-one: post -> user
 	* schema(s => s
 	*   .addTable("users", t => t.addColumn("id", idColumn()))
 	*   .addTable("posts", t => t
 	*     .addColumn("id", idColumn())
-	*     .addColumn("authorId", referenceColumn()))
-	*   .addReference("posts", "author", {
-	*     columns: ["authorId"],
-	*     targetTable: "users",
-	*     targetColumns: ["id"],
+	*     .addColumn("userId", referenceColumn()))
+	*   .addReference("author", {
+	*     type: "one",
+	*     from: { table: "posts", column: "userId" },
+	*     to: { table: "users", column: "id" },
 	*   })
 	* )
 	*
-	* // Self-referencing foreign key
-	* .addReference("users", "inviter", {
-	*   columns: ["invitedBy"],
-	*   targetTable: "users",
-	*   targetColumns: ["id"],
+	* // One-to-many (inverse relation): user -> posts
+	* .addReference("posts", {
+	*   type: "many",
+	*   from: { table: "users", column: "id" },
+	*   to: { table: "posts", column: "userId" },
 	* })
 	*
-	* // Multiple foreign keys - call addReference multiple times
-	* .addReference("posts", "author", {
-	*   columns: ["authorId"],
-	*   targetTable: "users",
-	*   targetColumns: ["id"],
-	* })
-	* .addReference("posts", "category", {
-	*   columns: ["categoryId"],
-	*   targetTable: "categories",
-	*   targetColumns: ["id"],
+	* // Self-referencing foreign key
+	* .addReference("inviter", {
+	*   type: "one",
+	*   from: { table: "users", column: "invitedBy" },
+	*   to: { table: "users", column: "id" },
 	* })
 	* ```
 	*/
-	addReference(tableName, referenceName, config) {
+	addReference(referenceName, config) {
 		this.#version++;
-		const table$1 = this.#tables[tableName];
-		const referencedTable = this.#tables[config.targetTable];
-		if (!table$1) throw new Error(`Table ${tableName} not found in schema`);
-		if (!referencedTable) throw new Error(`Referenced table ${config.targetTable} not found in schema`);
-		const { columns, targetColumns } = config;
-		if (columns.length !== targetColumns.length) throw new Error(`Reference ${referenceName}: columns and targetColumns must have the same length`);
-		if (columns.length !== 1) throw new Error(`Reference ${referenceName}: currently only single column foreign keys are supported`);
-		const columnName = columns[0];
-		const targetColumnName = targetColumns[0];
-		const column$1 = table$1.columns[columnName];
-		const referencedColumn = referencedTable.columns[targetColumnName];
-		if (!column$1) throw new Error(`Column ${columnName} not found in table ${tableName}`);
-		if (!referencedColumn) throw new Error(`Column ${targetColumnName} not found in table ${config.targetTable}`);
-		const init = new ExplicitRelationInit("one", referencedTable, table$1);
+		const table = this.#tables[config.from.table];
+		const referencedTable = this.#tables[config.to.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 column$1 = table.columns[columnName];
+		const referencedColumn = referencedTable.columns[actualTargetColumnName];
+		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 (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]);
 		const relation = init.init(referenceName);
-		table$1.relations[referenceName] = relation;
-		table$1.foreignKeys.push(relation.foreignKey);
+		table.relations[referenceName] = relation;
 		this.#operations.push({
 			type: "add-reference",
-			tableName,
+			tableName: config.from.table,
 			referenceName,
 			config: {
-				columns,
-				targetTable: config.targetTable,
-				targetColumns
+				type: config.type,
+				from: {
+					table: config.from.table,
+					column: columnName
+				},
+				to: {
+					table: config.to.table,
+					column: actualTargetColumnName
+				}
 			}
 		});
 		return this;
 	}
 	/**
+	* Alter an existing table by adding columns or indexes.
+	* This is used for append-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
+	*
+	* @example
+	* ```ts
+	* // Add a new column to an existing table
+	* schema(s => s
+	*   .addTable("users", t => t
+	*     .addColumn("id", idColumn())
+	*     .addColumn("name", column("string")))
+	*   .alterTable("users", t => t
+	*     .addColumn("email", column("string"))
+	*     .addColumn("age", column("integer").nullable())
+	*     .createIndex("idx_email", ["email"]))
+	* )
+	* ```
+	*/
+	alterTable(tableName, callback) {
+		const table = this.#tables[tableName];
+		if (!table) throw new Error(`Table ${tableName} not found in schema`);
+		const tableBuilder = new TableBuilder(tableName);
+		tableBuilder.setColumns(table.columns);
+		tableBuilder.setRelations(table.relations);
+		tableBuilder.setIndexes(table.indexes);
+		const existingColumns = new Set(Object.keys(table.columns));
+		const existingIndexes = new Set(Object.keys(table.indexes));
+		const resultBuilder = callback(tableBuilder);
+		const newTable = resultBuilder.build();
+		const subOperations = [];
+		const columnOrder = resultBuilder.getColumnOrder();
+		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
+		});
+		if (subOperations.length > 0) {
+			this.#version++;
+			this.#operations.push({
+				type: "alter-table",
+				tableName,
+				operations: subOperations
+			});
+		}
+		this.#tables[tableName] = newTable;
+		for (const col of Object.values(newTable.columns)) col.tableName = newTable.name;
+		return this;
+	}
+	/**
 	* Build the final schema. This should be called after all tables are added.
 	*/
 	build() {
@@ -400,12 +564,36 @@ var SchemaBuilder = class SchemaBuilder {
 			operations,
 			clone: () => {
 				const cloneTables = {};
-				for (const [k, v] of Object.entries(tables)) cloneTables[k] = v.clone();
-				const builder = new SchemaBuilder();
-				builder.#tables = cloneTables;
-				builder.#version = version;
-				builder.#operations = [...operations];
-				return builder.build();
+				for (const [k, v] of Object.entries(tables)) {
+					const clonedColumns = {};
+					for (const [colName, col] of Object.entries(v.columns)) {
+						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.ormName = col.ormName;
+						clonedCol.isNullable = col.isNullable;
+						clonedCol.role = col.role;
+						clonedCol.isHidden = col.isHidden;
+						clonedCol.default = col.default;
+						clonedCol.tableName = col.tableName;
+						clonedColumns[colName] = clonedCol;
+					}
+					cloneTables[k] = {
+						...v,
+						columns: clonedColumns
+					};
+				}
+				return new SchemaBuilder({
+					version,
+					tables: cloneTables,
+					operations: [...operations],
+					clone: () => {
+						throw new Error("Cannot clone during clone");
+					}
+				}).build();
 			}
 		};
 	}
@@ -422,16 +610,16 @@ var SchemaBuilder = class SchemaBuilder {
 function schema(callback) {
 	return callback(new SchemaBuilder()).build();
 }
-function compileForeignKey(key) {
+function compileForeignKey(key, nameType = "orm") {
 	return {
 		name: key.name,
-		table: key.table.name,
-		referencedTable: key.referencedTable.name,
-		referencedColumns: key.referencedColumns.map((col) => col.name),
-		columns: key.columns.map((col) => col.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)
 	};
 }
 
 //#endregion
-export { Column, ExplicitRelationInit, IdColumn, SchemaBuilder, TableBuilder, column, compileForeignKey, idColumn, referenceColumn, schema, table };
+export { Column, ExplicitRelationInit, FragnoId, FragnoReference, IdColumn, InternalIdColumn, SchemaBuilder, TableBuilder, VersionColumn, column, compileForeignKey, idColumn, internalIdColumn, referenceColumn, schema, versionColumn };
 //# sourceMappingURL=create.js.map