@fragno-dev/db 0.0.1

package/dist/schema/create.js

@@ -0,0 +1,437 @@
+import { createId } from "../cuid.js";
+
+//#region src/schema/create.ts
+var RelationInit = class {
+	type;
+	referencedTable;
+	referencer;
+	on = [];
+	constructor(type, referencedTable, referencer) {
+		this.type = type;
+		this.referencedTable = referencedTable;
+		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,
+			table: this.referencedTable,
+			type: this.type
+		};
+	}
+	/**
+	* Define custom foreign key name.
+	*/
+	foreignKey(name) {
+		this.foreignKeyName = name;
+		return this;
+	}
+};
+var Column = class Column {
+	type;
+	name = "";
+	ormName = "";
+	isNullable = false;
+	isUnique = false;
+	isReference = false;
+	default;
+	table = void 0;
+	constructor(type) {
+		this.type = type;
+	}
+	nullable(nullable) {
+		this.isNullable = nullable ?? true;
+		return this;
+	}
+	/**
+	* Generate default value on runtime
+	*/
+	defaultTo$(fn) {
+		this.default = { runtime: fn };
+		return this;
+	}
+	/**
+	* Set a database-level default value
+	*
+	* For schemaless database, it's still generated on runtime
+	*/
+	defaultTo(value) {
+		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.
+	*/
+	generateDefaultValue() {
+		if (!this.default) return;
+		if ("value" in this.default) return this.default.value;
+		if (this.default.runtime === "auto") return createId();
+		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");
+	}
+};
+var IdColumn = class IdColumn 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);
+	}
+	defaultTo(value) {
+		return super.defaultTo(value);
+	}
+};
+function column(type) {
+	return new Column(type);
+}
+/**
+* Create a reference column that points to another table.
+* This is used for foreign key relationships.
+*/
+function referenceColumn(type) {
+	const col = new Column(type ?? "varchar(30)");
+	col.isReference = true;
+	return col;
+}
+function idColumn() {
+	const col = new IdColumn("varchar(30)");
+	col.defaultTo$("auto");
+	return col;
+}
+var TableBuilder = class TableBuilder {
+	#name;
+	#columns;
+	#relations;
+	#foreignKeys = [];
+	#indexes = [];
+	#version = 0;
+	#ormName = "";
+	#operations = [];
+	constructor(name) {
+		this.#name = name;
+		this.#columns = {};
+		this.#relations = {};
+	}
+	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;
+	}
+	/**
+	* Create an index on the specified columns. Increments the version counter.
+	*/
+	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}`);
+			return column$1;
+		});
+		const unique = options?.unique ?? false;
+		addIndexToTable(this.#indexes, name, cols, unique);
+		this.#operations.push({
+			type: "add-index",
+			name,
+			columns,
+			unique
+		});
+		return this;
+	}
+	/**
+	* Build the final table. This should be called after all columns are added.
+	*/
+	build() {
+		let idCol;
+		const ormName = this.#ormName || this.#name;
+		const table$1 = {
+			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);
+			},
+			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();
+			}
+		};
+		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;
+		}
+		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;
+	}
+};
+/**
+* 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 = {};
+	}
+	/**
+	* 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 builtTable = result.build();
+		builtTable.ormName = ormName;
+		const builder = new SchemaBuilder();
+		builder.#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;
+	}
+	/**
+	* Add a foreign key reference from this table to another table.
+	*
+	* @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
+	*
+	* @example
+	* ```ts
+	* // Basic foreign key: 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"],
+	*   })
+	* )
+	*
+	* // Self-referencing foreign key
+	* .addReference("users", "inviter", {
+	*   columns: ["invitedBy"],
+	*   targetTable: "users",
+	*   targetColumns: ["id"],
+	* })
+	*
+	* // 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"],
+	* })
+	* ```
+	*/
+	addReference(tableName, 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);
+		init.on.push([columnName, targetColumnName]);
+		const relation = init.init(referenceName);
+		table$1.relations[referenceName] = relation;
+		table$1.foreignKeys.push(relation.foreignKey);
+		this.#operations.push({
+			type: "add-reference",
+			tableName,
+			referenceName,
+			config: {
+				columns,
+				targetTable: config.targetTable,
+				targetColumns
+			}
+		});
+		return this;
+	}
+	/**
+	* Build the final schema. This should be called after all tables are added.
+	*/
+	build() {
+		const operations = this.#operations;
+		const version = this.#version;
+		const tables = this.#tables;
+		return {
+			version,
+			tables,
+			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();
+			}
+		};
+	}
+	/**
+	* Get the current version of the schema builder.
+	*/
+	getVersion() {
+		return this.#version;
+	}
+};
+/**
+* Create a new schema with callback pattern.
+*/
+function schema(callback) {
+	return callback(new SchemaBuilder()).build();
+}
+function compileForeignKey(key) {
+	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)
+	};
+}
+
+//#endregion
+export { Column, ExplicitRelationInit, IdColumn, SchemaBuilder, TableBuilder, column, compileForeignKey, idColumn, referenceColumn, schema, table };
+//# sourceMappingURL=create.js.map

package/dist/schema/create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","names":["columns: AnyColumn[]","referencedColumns: AnyColumn[]","#name","#columns","#relations","#version","#foreignKeys","#indexes","#ormName","#operations","column","name","idCol: AnyColumn | undefined","table: Table<TColumns, TRelations>","cloneColumns: Record<string, AnyColumn>","table","#tables","newOperations: SchemaOperation[]","cloneTables: Record<string, AnyTable>"],"sources":["../../src/schema/create.ts"],"sourcesContent":["import { createId } from \"../cuid\";\n\nexport type AnySchema = Schema<Record<string, AnyTable>>;\n\nexport type AnyRelation = Relation;\n\nexport type AnyTable = Table;\n\nexport type AnyColumn =\n  | Column<keyof TypeMap, unknown, unknown>\n  | IdColumn<IdColumnType, unknown, unknown>;\n\n/**\n * Operations that can be performed on a table during its definition.\n */\nexport type TableOperation = {\n  type: \"add-index\";\n  name: string;\n  columns: string[];\n  unique: boolean;\n};\n\n/**\n * Operations that can be performed on a schema during its definition.\n * These are tracked so we can generate migrations for specific version ranges.\n */\nexport type SchemaOperation =\n  | {\n      type: \"add-table\";\n      tableName: string;\n      table: AnyTable;\n    }\n  | {\n      type: \"add-reference\";\n      tableName: string;\n      referenceName: string;\n      config: {\n        columns: string[];\n        targetTable: string;\n        targetColumns: string[];\n      };\n    }\n  | {\n      type: \"add-index\";\n      tableName: string;\n      name: string;\n      columns: string[];\n      unique: boolean;\n    };\n\nexport interface ForeignKey {\n  name: string;\n  table: AnyTable;\n  columns: AnyColumn[];\n\n  referencedTable: AnyTable;\n  referencedColumns: AnyColumn[];\n}\n\nclass RelationInit<\n  TRelationType extends RelationType,\n  TTables extends Record<string, AnyTable>,\n  TTableName extends keyof TTables,\n> {\n  type: TRelationType;\n  referencedTable: TTables[TTableName];\n  referencer: AnyTable;\n  on: [string, string][] = [];\n\n  constructor(type: TRelationType, referencedTable: TTables[TTableName], referencer: AnyTable) {\n    this.type = type;\n    this.referencedTable = referencedTable;\n    this.referencer = referencer;\n  }\n}\n\nexport interface Index {\n  name: string;\n  columns: AnyColumn[];\n  unique: boolean;\n}\n\n/**\n * Helper function to add an index to a table's index array\n */\nfunction addIndexToTable(\n  indexes: Index[],\n  name: string,\n  columns: AnyColumn[],\n  unique: boolean,\n): void {\n  indexes.push({\n    name,\n    columns,\n    unique,\n  });\n}\n\nexport class ExplicitRelationInit<\n  TRelationType extends RelationType,\n  TTables extends Record<string, AnyTable>,\n  TTableName extends keyof TTables,\n> extends RelationInit<TRelationType, TTables, TTableName> {\n  private foreignKeyName?: string;\n\n  private initForeignKey(ormName: string): ForeignKey {\n    const columns: AnyColumn[] = [];\n    const referencedColumns: AnyColumn[] = [];\n\n    for (const [left, right] of this.on) {\n      columns.push(this.referencer.columns[left]);\n      referencedColumns.push(this.referencedTable.columns[right]);\n    }\n\n    return {\n      columns,\n      referencedColumns,\n      referencedTable: this.referencedTable,\n      table: this.referencer,\n      name:\n        this.foreignKeyName ??\n        `${this.referencer.ormName}_${this.referencedTable.ormName}_${ormName}_fk`,\n    };\n  }\n\n  init(ormName: string): Relation<TRelationType, TTables[TTableName]> {\n    const id = `${this.referencer.ormName}_${this.referencedTable.ormName}`;\n\n    return {\n      id,\n      foreignKey: this.initForeignKey(ormName),\n      on: this.on,\n      name: ormName,\n      referencer: this.referencer,\n      table: this.referencedTable,\n      type: this.type,\n    };\n  }\n\n  /**\n   * Define custom foreign key name.\n   */\n  foreignKey(name: string) {\n    this.foreignKeyName = name;\n    return this;\n  }\n}\n\nexport interface Relation<\n  TRelationType extends RelationType = RelationType,\n  TTable extends AnyTable = AnyTable,\n> {\n  id: string;\n  name: string;\n  type: TRelationType;\n\n  table: TTable;\n  referencer: AnyTable;\n\n  on: [string, string][];\n  foreignKey: ForeignKey;\n}\n\nexport interface Table<\n  TColumns extends Record<string, AnyColumn> = Record<string, AnyColumn>,\n  TRelations extends Record<string, AnyRelation> = Record<string, AnyRelation>,\n> {\n  name: string;\n  ormName: string;\n\n  columns: TColumns;\n  relations: TRelations;\n  foreignKeys: ForeignKey[];\n  indexes: Index[];\n\n  /**\n   * Get column by name\n   */\n  getColumnByName: (name: string) => AnyColumn | undefined;\n  getIdColumn: () => AnyColumn;\n\n  clone: () => Table<TColumns, TRelations>;\n}\n\ntype DefaultFunctionMap = {\n  date: \"now\";\n  timestamp: \"now\";\n  string: \"auto\";\n} & Record<`varchar(${number})`, \"auto\">;\n\ntype DefaultFunction<TType extends keyof TypeMap> =\n  | (TType extends keyof DefaultFunctionMap ? DefaultFunctionMap[TType] : never)\n  | (() => TypeMap[TType]);\n\ntype IdColumnType = `varchar(${number})`;\n\nexport type TypeMap = {\n  string: string;\n  bigint: bigint;\n  integer: number;\n  decimal: number;\n  bool: boolean;\n  json: unknown;\n  /**\n   * this follows the same specs as Prisma `Bytes` for consistency.\n   */\n  binary: Uint8Array;\n  date: Date;\n  timestamp: Date;\n} & Record<`varchar(${number})`, string>;\n\nexport class Column<TType extends keyof TypeMap, TIn = unknown, TOut = unknown> {\n  type: TType;\n  name: string = \"\";\n  ormName: string = \"\";\n  isNullable: boolean = false;\n  isUnique: boolean = false;\n  isReference: boolean = false;\n  default?:\n    | { value: TypeMap[TType] }\n    | {\n        runtime: DefaultFunction<TType>;\n      };\n\n  table: AnyTable = undefined as unknown as AnyTable;\n\n  constructor(type: TType) {\n    this.type = type;\n  }\n\n  nullable<TNullable extends boolean = true>(nullable?: TNullable) {\n    this.isNullable = nullable ?? true;\n\n    return this as Column<\n      TType,\n      TNullable extends true ? TIn | null : Exclude<TIn, null>,\n      TNullable extends true ? TOut | null : Exclude<TOut, null>\n    >;\n  }\n\n  /**\n   * Generate default value on runtime\n   */\n  defaultTo$(fn: DefaultFunction<TType>): Column<TType, TIn | null, TOut> {\n    this.default = { runtime: fn };\n    return this;\n  }\n\n  /**\n   * Set a database-level default value\n   *\n   * For schemaless database, it's still generated on runtime\n   */\n  defaultTo(value: TypeMap[TType]): Column<TType, TIn | null, TOut> {\n    this.default = { value };\n    return this;\n  }\n\n  clone() {\n    const clone = new Column(this.type);\n    clone.name = this.name;\n    clone.ormName = this.ormName;\n    clone.isNullable = this.isNullable;\n    clone.isUnique = this.isUnique;\n    clone.isReference = this.isReference;\n    clone.default = this.default;\n    clone.table = this.table;\n    return clone;\n  }\n\n  getUniqueConstraintName(): string {\n    return `unique_c_${this.table.ormName}_${this.ormName}`;\n  }\n\n  /**\n   * Generate default value for the column on runtime.\n   */\n  generateDefaultValue(): TypeMap[TType] | undefined {\n    if (!this.default) {\n      return;\n    }\n\n    if (\"value\" in this.default) {\n      return this.default.value;\n    }\n    if (this.default.runtime === \"auto\") {\n      return createId() as TypeMap[TType];\n    }\n    if (this.default.runtime === \"now\") {\n      return new Date(Date.now()) as TypeMap[TType];\n    }\n\n    return this.default.runtime();\n  }\n\n  get $in(): TIn {\n    throw new Error(\"Type inference only\");\n  }\n  get $out(): TOut {\n    throw new Error(\"Type inference only\");\n  }\n}\n\nexport class IdColumn<\n  TType extends IdColumnType = IdColumnType,\n  TIn = unknown,\n  TOut = unknown,\n> extends Column<TType, TIn, TOut> {\n  id = true;\n\n  clone() {\n    const clone = new IdColumn(this.type);\n    clone.name = this.name;\n    clone.ormName = this.ormName;\n    clone.isNullable = this.isNullable;\n    clone.isUnique = this.isUnique;\n    clone.isReference = this.isReference;\n    clone.default = this.default;\n    clone.table = this.table;\n    return clone;\n  }\n\n  override defaultTo$(fn: DefaultFunction<TType>) {\n    return super.defaultTo$(fn) as IdColumn<TType, TIn | null, TOut>;\n  }\n\n  override defaultTo(value: TypeMap[TType]) {\n    return super.defaultTo(value) as IdColumn<TType, TIn | null, TOut>;\n  }\n}\n\nexport function column<TType extends keyof TypeMap>(\n  type: TType,\n): Column<TType, TypeMap[TType], TypeMap[TType]> {\n  return new Column(type);\n}\n\n/**\n * Create a reference column that points to another table.\n * This is used for foreign key relationships.\n */\nexport function referenceColumn<TType extends keyof TypeMap = \"varchar(30)\">(\n  type?: TType,\n): Column<TType, TypeMap[TType], TypeMap[TType]> {\n  const actualType = (type ?? \"varchar(30)\") as TType;\n  const col = new Column<TType, TypeMap[TType], TypeMap[TType]>(actualType);\n  col.isReference = true;\n  return col as Column<TType, TypeMap[TType], TypeMap[TType]>;\n}\n\nexport function idColumn(): IdColumn<\"varchar(30)\", string, string> {\n  const col = new IdColumn<\"varchar(30)\", string, string>(\"varchar(30)\");\n  col.defaultTo$(\"auto\");\n  return col as IdColumn<\"varchar(30)\", string, string>;\n}\n\ntype RelationType = \"one\";\n\nexport class TableBuilder<\n  TColumns extends Record<string, AnyColumn> = Record<string, AnyColumn>,\n  TRelations extends Record<string, AnyRelation> = Record<string, AnyRelation>,\n> {\n  #name: string;\n  #columns: TColumns;\n  #relations: TRelations;\n  #foreignKeys: ForeignKey[] = [];\n  #indexes: Index[] = [];\n  #version: number = 0;\n  #ormName: string = \"\";\n  #operations: TableOperation[] = [];\n\n  constructor(name: string) {\n    this.#name = name;\n    this.#columns = {} as TColumns;\n    this.#relations = {} as TRelations;\n  }\n\n  /**\n   * Add a column to the table. Increments the version counter.\n   */\n  addColumn<TColumnName extends string, TColumn extends AnyColumn>(\n    ormName: TColumnName,\n    col: TColumn,\n  ): TableBuilder<TColumns & Record<TColumnName, TColumn>, TRelations>;\n\n  /**\n   * Add a column to the table with simplified syntax. Increments the version counter.\n   */\n  addColumn<TColumnName extends string, TType extends keyof TypeMap>(\n    ormName: TColumnName,\n    type: TType,\n  ): TableBuilder<\n    TColumns & Record<TColumnName, Column<TType, TypeMap[TType], TypeMap[TType]>>,\n    TRelations\n  >;\n\n  addColumn<TColumnName extends string, TColumn extends AnyColumn, TType extends keyof TypeMap>(\n    ormName: TColumnName,\n    colOrType: TColumn | TType,\n  ): TableBuilder<TColumns & Record<TColumnName, TColumn>, TRelations> {\n    this.#version++;\n\n    // Create the column if a type string was provided\n    const col = typeof colOrType === \"string\" ? column(colOrType) : colOrType;\n\n    // Create a new instance to ensure immutability semantics\n    const builder = new TableBuilder<TColumns & Record<TColumnName, TColumn>, TRelations>(\n      this.#name,\n    );\n    builder.#columns = { ...this.#columns, [ormName]: col } as TColumns &\n      Record<TColumnName, TColumn>;\n    builder.#relations = this.#relations;\n    builder.#foreignKeys = this.#foreignKeys;\n    builder.#indexes = this.#indexes;\n    builder.#version = this.#version;\n    builder.#ormName = this.#ormName;\n    builder.#operations = this.#operations;\n\n    // Set column metadata\n    col.ormName = ormName;\n    col.name = ormName;\n\n    return builder;\n  }\n\n  /**\n   * Create an index on the specified columns. Increments the version counter.\n   */\n  createIndex<TColumnName extends string & keyof TColumns>(\n    name: string,\n    columns: TColumnName[],\n    options?: { unique?: boolean },\n  ): TableBuilder<TColumns, TRelations> {\n    this.#version++;\n\n    const cols = columns.map((name) => {\n      const column = this.#columns[name];\n      if (!column) {\n        throw new Error(`Unknown column name ${name}`);\n      }\n      return column;\n    });\n\n    const unique = options?.unique ?? false;\n    addIndexToTable(this.#indexes, name, cols, unique);\n\n    // Record the operation\n    this.#operations.push({\n      type: \"add-index\",\n      name,\n      columns: columns as string[],\n      unique,\n    });\n\n    return this;\n  }\n\n  /**\n   * Build the final table. This should be called after all columns are added.\n   */\n  build(): Table<TColumns, TRelations> {\n    let idCol: AnyColumn | undefined;\n\n    // Use name as ormName if ormName is not set\n    const ormName = this.#ormName || this.#name;\n\n    const table: Table<TColumns, TRelations> = {\n      name: this.#name,\n      ormName,\n      columns: this.#columns,\n      relations: this.#relations,\n      foreignKeys: this.#foreignKeys,\n      indexes: this.#indexes,\n      getColumnByName: (name) => {\n        return Object.values(this.#columns).find((c) => c.name === name);\n      },\n      getIdColumn: () => {\n        return idCol!;\n      },\n      clone: () => {\n        const cloneColumns: Record<string, AnyColumn> = {};\n\n        for (const [k, v] of Object.entries(this.#columns)) {\n          cloneColumns[k] = v.clone();\n        }\n\n        const builder = new TableBuilder<TColumns, TRelations>(this.#name);\n        builder.#columns = cloneColumns as TColumns;\n        builder.#relations = this.#relations;\n        builder.#foreignKeys = [...this.#foreignKeys];\n        builder.#indexes = [...this.#indexes];\n        builder.#version = this.#version;\n        builder.#ormName = this.#ormName;\n        builder.#operations = [...this.#operations];\n\n        const cloned = builder.build();\n\n        return cloned;\n      },\n    };\n\n    // Set table reference and find id column\n    for (const k in this.#columns) {\n      const column = this.#columns[k];\n      if (!column) {\n        continue;\n      }\n\n      column.table = table;\n      if (column instanceof IdColumn) {\n        idCol = column;\n      }\n    }\n\n    if (idCol === undefined) {\n      throw new Error(`there's no id column in your table ${this.#name}`);\n    }\n\n    return table;\n  }\n\n  /**\n   * Get the current version of the table builder.\n   */\n  getVersion(): number {\n    return this.#version;\n  }\n\n  /**\n   * Get the operations performed on this table.\n   */\n  getOperations(): TableOperation[] {\n    return this.#operations;\n  }\n}\n\n/**\n * Create a new table with callback pattern.\n */\nexport function table<\n  TColumns extends Record<string, AnyColumn> = Record<string, AnyColumn>,\n  TRelations extends Record<string, AnyRelation> = Record<string, AnyRelation>,\n>(\n  name: string,\n  callback: (\n    builder: TableBuilder<Record<string, AnyColumn>, Record<string, AnyRelation>>,\n  ) => TableBuilder<TColumns, TRelations>,\n): Table<TColumns, TRelations> {\n  const builder = new TableBuilder(name);\n  const result = callback(builder);\n  return result.build();\n}\n\nexport interface Schema<TTables extends Record<string, AnyTable> = Record<string, AnyTable>> {\n  /**\n   * @description The version of the schema, automatically incremented on each change.\n   */\n  version: number;\n  tables: TTables;\n  /**\n   * @description Operations performed on this schema, in order.\n   * Used to generate migrations for specific version ranges.\n   */\n  operations: SchemaOperation[];\n\n  clone: () => Schema<TTables>;\n}\n\nexport class SchemaBuilder<TTables extends Record<string, AnyTable> = Record<string, never>> {\n  #tables: TTables;\n  #version: number = 0;\n  #operations: SchemaOperation[] = [];\n\n  constructor() {\n    this.#tables = {} as TTables;\n  }\n\n  /**\n   * Add a table to the schema. Increments the version counter.\n   */\n  addTable<\n    TTableName extends string,\n    TColumns extends Record<string, AnyColumn>,\n    TRelations extends Record<string, AnyRelation>,\n  >(\n    ormName: TTableName,\n    callback: (\n      builder: TableBuilder<Record<string, AnyColumn>, Record<string, AnyRelation>>,\n    ) => TableBuilder<TColumns, TRelations>,\n  ): SchemaBuilder<TTables & Record<TTableName, Table<TColumns, TRelations>>> {\n    this.#version++;\n\n    const tableBuilder = new TableBuilder(ormName);\n    const result = callback(tableBuilder);\n    const builtTable = result.build();\n\n    // Set table metadata\n    builtTable.ormName = ormName;\n\n    const builder = new SchemaBuilder<TTables & Record<TTableName, Table<TColumns, TRelations>>>();\n    builder.#tables = { ...this.#tables, [ormName]: builtTable } as TTables &\n      Record<TTableName, Table<TColumns, TRelations>>;\n\n    // Start with existing operations plus the add-table operation\n    const newOperations: SchemaOperation[] = [\n      ...this.#operations,\n      {\n        type: \"add-table\",\n        tableName: ormName,\n        table: builtTable,\n      },\n    ];\n\n    // Promote table operations to schema operations and increment version for each\n    const tableOps = result.getOperations();\n    for (const tableOp of tableOps) {\n      if (tableOp.type === \"add-index\") {\n        this.#version++;\n        newOperations.push({\n          type: \"add-index\",\n          tableName: ormName,\n          name: tableOp.name,\n          columns: tableOp.columns,\n          unique: tableOp.unique,\n        });\n      }\n    }\n\n    builder.#version = this.#version;\n    builder.#operations = newOperations;\n\n    return builder;\n  }\n\n  /**\n   * Add a foreign key reference from this table to another table.\n   *\n   * @param tableName - The table that has the foreign key column\n   * @param referenceName - A name for this reference (e.g., \"author\", \"category\")\n   * @param config - Configuration specifying the foreign key mapping\n   *\n   * @example\n   * ```ts\n   * // Basic foreign key: post -> user\n   * schema(s => s\n   *   .addTable(\"users\", t => t.addColumn(\"id\", idColumn()))\n   *   .addTable(\"posts\", t => t\n   *     .addColumn(\"id\", idColumn())\n   *     .addColumn(\"authorId\", referenceColumn()))\n   *   .addReference(\"posts\", \"author\", {\n   *     columns: [\"authorId\"],\n   *     targetTable: \"users\",\n   *     targetColumns: [\"id\"],\n   *   })\n   * )\n   *\n   * // Self-referencing foreign key\n   * .addReference(\"users\", \"inviter\", {\n   *   columns: [\"invitedBy\"],\n   *   targetTable: \"users\",\n   *   targetColumns: [\"id\"],\n   * })\n   *\n   * // Multiple foreign keys - call addReference multiple times\n   * .addReference(\"posts\", \"author\", {\n   *   columns: [\"authorId\"],\n   *   targetTable: \"users\",\n   *   targetColumns: [\"id\"],\n   * })\n   * .addReference(\"posts\", \"category\", {\n   *   columns: [\"categoryId\"],\n   *   targetTable: \"categories\",\n   *   targetColumns: [\"id\"],\n   * })\n   * ```\n   */\n  addReference<\n    TTableName extends string & keyof TTables,\n    TReferencedTableName extends string & keyof TTables,\n  >(\n    tableName: TTableName,\n    referenceName: string,\n    config: {\n      columns: (keyof TTables[TTableName][\"columns\"])[];\n      targetTable: TReferencedTableName;\n      targetColumns: (keyof TTables[TReferencedTableName][\"columns\"])[];\n    },\n  ): SchemaBuilder<TTables> {\n    this.#version++;\n\n    const table = this.#tables[tableName];\n    const referencedTable = this.#tables[config.targetTable];\n\n    if (!table) {\n      throw new Error(`Table ${tableName} not found in schema`);\n    }\n    if (!referencedTable) {\n      throw new Error(`Referenced table ${config.targetTable} not found in schema`);\n    }\n\n    const { columns, targetColumns } = config;\n\n    if (columns.length !== targetColumns.length) {\n      throw new Error(\n        `Reference ${referenceName}: columns and targetColumns must have the same length`,\n      );\n    }\n\n    // For now, only support single column foreign keys\n    if (columns.length !== 1) {\n      throw new Error(\n        `Reference ${referenceName}: currently only single column foreign keys are supported`,\n      );\n    }\n\n    const columnName = columns[0] as string;\n    const targetColumnName = targetColumns[0] as string;\n\n    const column = table.columns[columnName];\n    const referencedColumn = referencedTable.columns[targetColumnName];\n\n    if (!column) {\n      throw new Error(`Column ${columnName} not found in table ${tableName}`);\n    }\n    if (!referencedColumn) {\n      throw new Error(`Column ${targetColumnName} not found in table ${config.targetTable}`);\n    }\n\n    // Create the relation\n    const init = new ExplicitRelationInit(\"one\", referencedTable, table);\n    init.on.push([columnName, targetColumnName]);\n    const relation = init.init(referenceName);\n\n    // Add relation and foreign key to the table\n    table.relations[referenceName] = relation;\n    table.foreignKeys.push(relation.foreignKey);\n\n    // Record the operation\n    this.#operations.push({\n      type: \"add-reference\",\n      tableName: tableName as string,\n      referenceName,\n      config: {\n        columns: columns as string[],\n        targetTable: config.targetTable as string,\n        targetColumns: targetColumns as string[],\n      },\n    });\n\n    return this;\n  }\n\n  /**\n   * Build the final schema. This should be called after all tables are added.\n   */\n  build(): Schema<TTables> {\n    const operations = this.#operations;\n    const version = this.#version;\n    const tables = this.#tables;\n\n    const schema: Schema<TTables> = {\n      version,\n      tables,\n      operations,\n      clone: () => {\n        const cloneTables: Record<string, AnyTable> = {};\n\n        for (const [k, v] of Object.entries(tables)) {\n          cloneTables[k] = v.clone();\n        }\n\n        const builder = new SchemaBuilder<TTables>();\n        builder.#tables = cloneTables as TTables;\n        builder.#version = version;\n        builder.#operations = [...operations];\n\n        return builder.build();\n      },\n    };\n\n    return schema;\n  }\n\n  /**\n   * Get the current version of the schema builder.\n   */\n  getVersion(): number {\n    return this.#version;\n  }\n}\n\n/**\n * Create a new schema with callback pattern.\n */\nexport function schema<TTables extends Record<string, AnyTable> = Record<string, never>>(\n  callback: (builder: SchemaBuilder<Record<string, never>>) => SchemaBuilder<TTables>,\n): Schema<TTables> {\n  return callback(new SchemaBuilder()).build();\n}\n\nexport function compileForeignKey(key: ForeignKey) {\n  return {\n    name: key.name,\n    table: key.table.name,\n    referencedTable: key.referencedTable.name,\n    referencedColumns: key.referencedColumns.map((col) => col.name),\n    columns: key.columns.map((col) => col.name),\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@fragno-dev/db",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    "./schema": {
+      "bun": "./src/schema/create.ts",
+      "development": "./src/schema/create.ts",
+      "types": "./dist/schema/create.d.ts",
+      "default": "./dist/schema/create.js"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "types:check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@fragno-private/typescript-config": "0.0.1",
+    "@types/node": "^22",
+    "vitest": "^3.2.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rejot-dev/fragno.git",
+    "directory": "packages/fragno-db"
+  },
+  "homepage": "https://fragno.dev",
+  "license": "MIT",
+  "dependencies": {
+    "@paralleldrive/cuid2": "^2.2.2",
+    "kysely": "^0.28.7"
+  }
+}

package/src/cuid.ts

@@ -0,0 +1,3 @@
+import { createId } from "@paralleldrive/cuid2";
+
+export { createId };