@hedystia/db 2.0.0 → 2.0.2

package/dist/schema/registry.mjs

@@ -0,0 +1,125 @@
+import { SchemaError } from "../errors.mjs";
+//#region src/schema/registry.ts
+/**
+* Schema registry that manages table definitions and resolves references
+*/
+var SchemaRegistry = class {
+	tables = /* @__PURE__ */ new Map();
+	definitions = /* @__PURE__ */ new Map();
+	columnMaps = /* @__PURE__ */ new Map();
+	reverseColumnMaps = /* @__PURE__ */ new Map();
+	relations = /* @__PURE__ */ new Map();
+	/**
+	* Register table definitions and resolve all deferred references
+	* @param {readonly TableDefinition[]} schemas - Table definitions to register
+	*/
+	register(schemas) {
+		for (const schema of schemas) {
+			if (!schema.__table || !schema.__name) throw new SchemaError("Invalid table definition");
+			this.definitions.set(schema.__name, schema);
+			this.tables.set(schema.__name, {
+				name: schema.__name,
+				columns: [...schema.__columns]
+			});
+			const colMap = schema.__columnMap ?? {};
+			this.columnMaps.set(schema.__name, colMap);
+			const reverseMap = {};
+			for (const [codeKey, dbName] of Object.entries(colMap)) reverseMap[dbName] = codeKey;
+			this.reverseColumnMaps.set(schema.__name, reverseMap);
+		}
+		for (const schema of schemas) for (const ref of schema.__deferredRefs) {
+			const resolved = ref.resolve();
+			if (!resolved.table || !resolved.column) throw new SchemaError(`Failed to resolve reference for ${schema.__name}.${ref.columnName}`);
+			if (!this.tables.has(resolved.table)) throw new SchemaError(`Referenced table "${resolved.table}" does not exist in schema registry`);
+			const dbColumnName = (this.columnMaps.get(schema.__name) ?? {})[ref.columnName] ?? ref.columnName;
+			const column = schema.__columns.find((c) => c.name === dbColumnName);
+			if (column) column.references = {
+				table: resolved.table,
+				column: resolved.column,
+				onDelete: ref.onDelete,
+				onUpdate: ref.onUpdate,
+				relationName: ref.relationName
+			};
+			const relationName = ref.relationName || ref.columnName.replace(/Id$/, "").replace(/_id$/, "");
+			if (!this.relations.has(schema.__name)) this.relations.set(schema.__name, []);
+			this.relations.get(schema.__name).push({
+				from: {
+					table: schema.__name,
+					column: dbColumnName
+				},
+				to: {
+					table: resolved.table,
+					column: resolved.column
+				},
+				relationName
+			});
+			if (!this.relations.has(resolved.table)) this.relations.set(resolved.table, []);
+			const reverseRelationName = schema.__name;
+			this.relations.get(resolved.table).push({
+				from: {
+					table: resolved.table,
+					column: resolved.column
+				},
+				to: {
+					table: schema.__name,
+					column: dbColumnName
+				},
+				relationName: reverseRelationName
+			});
+		}
+	}
+	/**
+	* Get table metadata by name
+	* @param {string} name - Table name
+	* @returns {TableMetadata | undefined} The table metadata
+	*/
+	getTable(name) {
+		return this.tables.get(name);
+	}
+	/**
+	* Get all registered table metadata
+	* @returns {Map<string, TableMetadata>} All registered tables
+	*/
+	getAllTables() {
+		return this.tables;
+	}
+	/**
+	* Get relations for a table
+	* @param {string} tableName - Table name
+	* @returns {Array<object>} Relations for the table
+	*/
+	getRelations(tableName) {
+		return this.relations.get(tableName) ?? [];
+	}
+	/**
+	* Get the primary key column name for a table (returns DB column name)
+	* @param {string} tableName - Table name
+	* @returns {string | null} The primary key column name or null
+	*/
+	getPrimaryKey(tableName) {
+		const table = this.tables.get(tableName);
+		if (!table) return null;
+		for (const col of table.columns) if (col.primaryKey) return col.name;
+		return null;
+	}
+	/**
+	* Get the column name map (code key -> DB column name) for a table
+	* @param {string} tableName - Table name
+	* @returns {Record<string, string>} Column name map
+	*/
+	getColumnMap(tableName) {
+		return this.columnMaps.get(tableName) ?? {};
+	}
+	/**
+	* Get the reverse column name map (DB column name -> code key) for a table
+	* @param {string} tableName - Table name
+	* @returns {Record<string, string>} Reverse column name map
+	*/
+	getReverseColumnMap(tableName) {
+		return this.reverseColumnMaps.get(tableName) ?? {};
+	}
+};
+//#endregion
+export { SchemaRegistry };
+
+//# sourceMappingURL=registry.mjs.map

package/dist/schema/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.mjs","names":[],"sources":["../../src/schema/registry.ts"],"sourcesContent":["import { SchemaError } from \"../errors\";\nimport type { TableDefinition, TableMetadata } from \"../types\";\n\n/**\n * Schema registry that manages table definitions and resolves references\n */\nexport class SchemaRegistry {\n  private tables = new Map<string, TableMetadata>();\n  private definitions = new Map<string, TableDefinition>();\n  private columnMaps = new Map<string, Record<string, string>>();\n  private reverseColumnMaps = new Map<string, Record<string, string>>();\n  private relations = new Map<\n    string,\n    Array<{\n      from: { table: string; column: string };\n      to: { table: string; column: string };\n      relationName: string;\n    }>\n  >();\n\n  /**\n   * Register table definitions and resolve all deferred references\n   * @param {readonly TableDefinition[]} schemas - Table definitions to register\n   */\n  register(schemas: readonly TableDefinition<any, any, any, any>[]): void {\n    for (const schema of schemas) {\n      if (!schema.__table || !schema.__name) {\n        throw new SchemaError(\"Invalid table definition\");\n      }\n\n      this.definitions.set(schema.__name, schema);\n      this.tables.set(schema.__name, {\n        name: schema.__name,\n        columns: [...schema.__columns],\n      });\n\n      const colMap: Record<string, string> = schema.__columnMap ?? {};\n      this.columnMaps.set(schema.__name, colMap);\n      const reverseMap: Record<string, string> = {};\n      for (const [codeKey, dbName] of Object.entries(colMap)) {\n        reverseMap[dbName] = codeKey;\n      }\n      this.reverseColumnMaps.set(schema.__name, reverseMap);\n    }\n\n    for (const schema of schemas) {\n      for (const ref of schema.__deferredRefs) {\n        const resolved = ref.resolve();\n        if (!resolved.table || !resolved.column) {\n          throw new SchemaError(\n            `Failed to resolve reference for ${schema.__name}.${ref.columnName}`,\n          );\n        }\n\n        if (!this.tables.has(resolved.table)) {\n          throw new SchemaError(\n            `Referenced table \"${resolved.table}\" does not exist in schema registry`,\n          );\n        }\n\n        const colMap = this.columnMaps.get(schema.__name) ?? {};\n        const dbColumnName = colMap[ref.columnName] ?? ref.columnName;\n        const column = schema.__columns.find((c: any) => c.name === dbColumnName);\n        if (column) {\n          column.references = {\n            table: resolved.table,\n            column: resolved.column,\n            onDelete: ref.onDelete,\n            onUpdate: ref.onUpdate,\n            relationName: ref.relationName,\n          };\n        }\n\n        const relationName =\n          ref.relationName || ref.columnName.replace(/Id$/, \"\").replace(/_id$/, \"\");\n\n        if (!this.relations.has(schema.__name)) {\n          this.relations.set(schema.__name, []);\n        }\n        this.relations.get(schema.__name)!.push({\n          from: { table: schema.__name, column: dbColumnName },\n          to: { table: resolved.table, column: resolved.column },\n          relationName,\n        });\n\n        if (!this.relations.has(resolved.table)) {\n          this.relations.set(resolved.table, []);\n        }\n        const reverseRelationName = schema.__name;\n        this.relations.get(resolved.table)!.push({\n          from: { table: resolved.table, column: resolved.column },\n          to: { table: schema.__name, column: dbColumnName },\n          relationName: reverseRelationName,\n        });\n      }\n    }\n  }\n\n  /**\n   * Get table metadata by name\n   * @param {string} name - Table name\n   * @returns {TableMetadata | undefined} The table metadata\n   */\n  getTable(name: string): TableMetadata | undefined {\n    return this.tables.get(name);\n  }\n\n  /**\n   * Get all registered table metadata\n   * @returns {Map<string, TableMetadata>} All registered tables\n   */\n  getAllTables(): Map<string, TableMetadata> {\n    return this.tables;\n  }\n\n  /**\n   * Get relations for a table\n   * @param {string} tableName - Table name\n   * @returns {Array<object>} Relations for the table\n   */\n  getRelations(tableName: string): Array<{\n    from: { table: string; column: string };\n    to: { table: string; column: string };\n    relationName: string;\n  }> {\n    return this.relations.get(tableName) ?? [];\n  }\n\n  /**\n   * Get the primary key column name for a table (returns DB column name)\n   * @param {string} tableName - Table name\n   * @returns {string | null} The primary key column name or null\n   */\n  getPrimaryKey(tableName: string): string | null {\n    const table = this.tables.get(tableName);\n    if (!table) {\n      return null;\n    }\n    for (const col of table.columns) {\n      if (col.primaryKey) {\n        return col.name;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Get the column name map (code key -> DB column name) for a table\n   * @param {string} tableName - Table name\n   * @returns {Record<string, string>} Column name map\n   */\n  getColumnMap(tableName: string): Record<string, string> {\n    return this.columnMaps.get(tableName) ?? {};\n  }\n\n  /**\n   * Get the reverse column name map (DB column name -> code key) for a table\n   * @param {string} tableName - Table name\n   * @returns {Record<string, string>} Reverse column name map\n   */\n  getReverseColumnMap(tableName: string): Record<string, string> {\n    return this.reverseColumnMaps.get(tableName) ?? {};\n  }\n}\n"],"mappings":"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"}

package/dist/schema/table.cjs

@@ -0,0 +1,39 @@
+//#region src/schema/table.ts
+/**
+* Define a database table with its columns
+* @param {string} name - The table name
+* @param {Record<string, ColumnBuilder<any>>} columns - Column definitions
+* @returns {TableDefinition<T, C>} The table definition object with column accessors
+*/
+function table(name, columns) {
+	const columnsArray = [];
+	const deferredRefs = [];
+	const columnMap = {};
+	for (const [key, builder] of Object.entries(columns)) {
+		const meta = builder.__build(key);
+		columnsArray.push(meta);
+		columnMap[key] = meta.name;
+		const ref = builder.__getDeferredRef();
+		if (ref) deferredRefs.push({
+			columnName: key,
+			resolve: ref.resolve,
+			onDelete: ref.onDelete,
+			onUpdate: ref.onUpdate,
+			relationName: ref.relationName
+		});
+		builder.__tableName = name;
+		builder.__columnName = key;
+	}
+	return {
+		__table: true,
+		__name: name,
+		__columns: columnsArray,
+		__columnMap: columnMap,
+		__deferredRefs: deferredRefs,
+		...columns
+	};
+}
+//#endregion
+exports.table = table;
+
+//# sourceMappingURL=table.cjs.map

package/dist/schema/table.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.cjs","names":[],"sources":["../../src/schema/table.ts"],"sourcesContent":["import type { ColumnMetadata, DeferredRefMeta, TableDefinition } from \"../types\";\nimport type { ColumnBuilder } from \"./column\";\n\ntype BindColumn<C, TableName extends string, ColName extends string> =\n  C extends ColumnBuilder<infer T, any, any, infer Ref>\n    ? ColumnBuilder<\n        T,\n        TableName,\n        ColName,\n        Ref extends DeferredRefMeta<any, infer ToTable, infer ToColumn, infer RelName>\n          ? DeferredRefMeta<ColName, ToTable, ToColumn, RelName>\n          : never\n      >\n    : never;\n\ntype BoundColumns<C extends Record<string, ColumnBuilder<any, any, any, any>>, N extends string> = {\n  [K in keyof C]: BindColumn<C[K], N, Extract<K, string>>;\n};\n\ntype ExtractDeferredRefs<C extends Record<string, ColumnBuilder<any, any, any, any>>> = {\n  [K in keyof C]: C[K] extends ColumnBuilder<any, any, any, infer Ref> ? Ref : never;\n}[keyof C];\n\n/**\n * Define a database table with its columns\n * @param {string} name - The table name\n * @param {Record<string, ColumnBuilder<any>>} columns - Column definitions\n * @returns {TableDefinition<T, C>} The table definition object with column accessors\n */\nexport function table<\n  N extends string,\n  C extends Record<string, ColumnBuilder<any, any, any, any>>,\n>(\n  name: N,\n  columns: C,\n): TableDefinition<\n  { [K in keyof C]: C[K][\"__type\"] },\n  BoundColumns<C, N>,\n  N,\n  ExtractDeferredRefs<BoundColumns<C, N>>\n> {\n  const columnsArray: ColumnMetadata[] = [];\n  const deferredRefs: TableDefinition[\"__deferredRefs\"] = [];\n  const columnMap: Record<string, string> = {};\n\n  for (const [key, builder] of Object.entries(columns)) {\n    const meta = builder.__build(key);\n    columnsArray.push(meta);\n    columnMap[key] = meta.name;\n\n    const ref = builder.__getDeferredRef();\n    if (ref) {\n      deferredRefs.push({\n        columnName: key,\n        resolve: ref.resolve,\n        onDelete: ref.onDelete,\n        onUpdate: ref.onUpdate,\n        relationName: ref.relationName,\n      });\n    }\n\n    (builder as any).__tableName = name;\n    (builder as any).__columnName = key;\n  }\n\n  const def = {\n    __table: true,\n    __name: name,\n    __columns: columnsArray,\n    __columnMap: columnMap,\n    __deferredRefs: deferredRefs,\n    ...columns,\n  };\n\n  return def as any;\n}\n"],"mappings":";;;;;;;AA6BA,SAAgB,MAId,MACA,SAMA;CACA,MAAM,eAAiC,EAAE;CACzC,MAAM,eAAkD,EAAE;CAC1D,MAAM,YAAoC,EAAE;AAE5C,MAAK,MAAM,CAAC,KAAK,YAAY,OAAO,QAAQ,QAAQ,EAAE;EACpD,MAAM,OAAO,QAAQ,QAAQ,IAAI;AACjC,eAAa,KAAK,KAAK;AACvB,YAAU,OAAO,KAAK;EAEtB,MAAM,MAAM,QAAQ,kBAAkB;AACtC,MAAI,IACF,cAAa,KAAK;GAChB,YAAY;GACZ,SAAS,IAAI;GACb,UAAU,IAAI;GACd,UAAU,IAAI;GACd,cAAc,IAAI;GACnB,CAAC;AAGH,UAAgB,cAAc;AAC9B,UAAgB,eAAe;;AAYlC,QATY;EACV,SAAS;EACT,QAAQ;EACR,WAAW;EACX,aAAa;EACb,gBAAgB;EAChB,GAAG;EACJ"}

package/dist/schema/table.d.cts

@@ -0,0 +1,17 @@
+import { DeferredRefMeta, TableDefinition } from "../types.cjs";
+import { ColumnBuilder } from "./column.cjs";
+
+//#region src/schema/table.d.ts
+type BindColumn<C, TableName extends string, ColName extends string> = C extends ColumnBuilder<infer T, any, any, infer Ref> ? ColumnBuilder<T, TableName, ColName, Ref extends DeferredRefMeta<any, infer ToTable, infer ToColumn, infer RelName> ? DeferredRefMeta<ColName, ToTable, ToColumn, RelName> : never> : never;
+type BoundColumns<C extends Record<string, ColumnBuilder<any, any, any, any>>, N extends string> = { [K in keyof C]: BindColumn<C[K], N, Extract<K, string>> };
+type ExtractDeferredRefs<C extends Record<string, ColumnBuilder<any, any, any, any>>> = { [K in keyof C]: C[K] extends ColumnBuilder<any, any, any, infer Ref> ? Ref : never }[keyof C];
+/**
+ * Define a database table with its columns
+ * @param {string} name - The table name
+ * @param {Record<string, ColumnBuilder<any>>} columns - Column definitions
+ * @returns {TableDefinition<T, C>} The table definition object with column accessors
+ */
+declare function table<N extends string, C extends Record<string, ColumnBuilder<any, any, any, any>>>(name: N, columns: C): TableDefinition<{ [K in keyof C]: C[K]["__type"] }, BoundColumns<C, N>, N, ExtractDeferredRefs<BoundColumns<C, N>>>;
+//#endregion
+export { table };
+//# sourceMappingURL=table.d.cts.map

package/dist/schema/table.d.mts

@@ -0,0 +1,17 @@
+import { DeferredRefMeta, TableDefinition } from "../types.mjs";
+import { ColumnBuilder } from "./column.mjs";
+
+//#region src/schema/table.d.ts
+type BindColumn<C, TableName extends string, ColName extends string> = C extends ColumnBuilder<infer T, any, any, infer Ref> ? ColumnBuilder<T, TableName, ColName, Ref extends DeferredRefMeta<any, infer ToTable, infer ToColumn, infer RelName> ? DeferredRefMeta<ColName, ToTable, ToColumn, RelName> : never> : never;
+type BoundColumns<C extends Record<string, ColumnBuilder<any, any, any, any>>, N extends string> = { [K in keyof C]: BindColumn<C[K], N, Extract<K, string>> };
+type ExtractDeferredRefs<C extends Record<string, ColumnBuilder<any, any, any, any>>> = { [K in keyof C]: C[K] extends ColumnBuilder<any, any, any, infer Ref> ? Ref : never }[keyof C];
+/**
+ * Define a database table with its columns
+ * @param {string} name - The table name
+ * @param {Record<string, ColumnBuilder<any>>} columns - Column definitions
+ * @returns {TableDefinition<T, C>} The table definition object with column accessors
+ */
+declare function table<N extends string, C extends Record<string, ColumnBuilder<any, any, any, any>>>(name: N, columns: C): TableDefinition<{ [K in keyof C]: C[K]["__type"] }, BoundColumns<C, N>, N, ExtractDeferredRefs<BoundColumns<C, N>>>;
+//#endregion
+export { table };
+//# sourceMappingURL=table.d.mts.map

package/dist/schema/table.mjs

@@ -0,0 +1,39 @@
+//#region src/schema/table.ts
+/**
+* Define a database table with its columns
+* @param {string} name - The table name
+* @param {Record<string, ColumnBuilder<any>>} columns - Column definitions
+* @returns {TableDefinition<T, C>} The table definition object with column accessors
+*/
+function table(name, columns) {
+	const columnsArray = [];
+	const deferredRefs = [];
+	const columnMap = {};
+	for (const [key, builder] of Object.entries(columns)) {
+		const meta = builder.__build(key);
+		columnsArray.push(meta);
+		columnMap[key] = meta.name;
+		const ref = builder.__getDeferredRef();
+		if (ref) deferredRefs.push({
+			columnName: key,
+			resolve: ref.resolve,
+			onDelete: ref.onDelete,
+			onUpdate: ref.onUpdate,
+			relationName: ref.relationName
+		});
+		builder.__tableName = name;
+		builder.__columnName = key;
+	}
+	return {
+		__table: true,
+		__name: name,
+		__columns: columnsArray,
+		__columnMap: columnMap,
+		__deferredRefs: deferredRefs,
+		...columns
+	};
+}
+//#endregion
+export { table };
+
+//# sourceMappingURL=table.mjs.map

package/dist/schema/table.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.mjs","names":[],"sources":["../../src/schema/table.ts"],"sourcesContent":["import type { ColumnMetadata, DeferredRefMeta, TableDefinition } from \"../types\";\nimport type { ColumnBuilder } from \"./column\";\n\ntype BindColumn<C, TableName extends string, ColName extends string> =\n  C extends ColumnBuilder<infer T, any, any, infer Ref>\n    ? ColumnBuilder<\n        T,\n        TableName,\n        ColName,\n        Ref extends DeferredRefMeta<any, infer ToTable, infer ToColumn, infer RelName>\n          ? DeferredRefMeta<ColName, ToTable, ToColumn, RelName>\n          : never\n      >\n    : never;\n\ntype BoundColumns<C extends Record<string, ColumnBuilder<any, any, any, any>>, N extends string> = {\n  [K in keyof C]: BindColumn<C[K], N, Extract<K, string>>;\n};\n\ntype ExtractDeferredRefs<C extends Record<string, ColumnBuilder<any, any, any, any>>> = {\n  [K in keyof C]: C[K] extends ColumnBuilder<any, any, any, infer Ref> ? Ref : never;\n}[keyof C];\n\n/**\n * Define a database table with its columns\n * @param {string} name - The table name\n * @param {Record<string, ColumnBuilder<any>>} columns - Column definitions\n * @returns {TableDefinition<T, C>} The table definition object with column accessors\n */\nexport function table<\n  N extends string,\n  C extends Record<string, ColumnBuilder<any, any, any, any>>,\n>(\n  name: N,\n  columns: C,\n): TableDefinition<\n  { [K in keyof C]: C[K][\"__type\"] },\n  BoundColumns<C, N>,\n  N,\n  ExtractDeferredRefs<BoundColumns<C, N>>\n> {\n  const columnsArray: ColumnMetadata[] = [];\n  const deferredRefs: TableDefinition[\"__deferredRefs\"] = [];\n  const columnMap: Record<string, string> = {};\n\n  for (const [key, builder] of Object.entries(columns)) {\n    const meta = builder.__build(key);\n    columnsArray.push(meta);\n    columnMap[key] = meta.name;\n\n    const ref = builder.__getDeferredRef();\n    if (ref) {\n      deferredRefs.push({\n        columnName: key,\n        resolve: ref.resolve,\n        onDelete: ref.onDelete,\n        onUpdate: ref.onUpdate,\n        relationName: ref.relationName,\n      });\n    }\n\n    (builder as any).__tableName = name;\n    (builder as any).__columnName = key;\n  }\n\n  const def = {\n    __table: true,\n    __name: name,\n    __columns: columnsArray,\n    __columnMap: columnMap,\n    __deferredRefs: deferredRefs,\n    ...columns,\n  };\n\n  return def as any;\n}\n"],"mappings":";;;;;;;AA6BA,SAAgB,MAId,MACA,SAMA;CACA,MAAM,eAAiC,EAAE;CACzC,MAAM,eAAkD,EAAE;CAC1D,MAAM,YAAoC,EAAE;AAE5C,MAAK,MAAM,CAAC,KAAK,YAAY,OAAO,QAAQ,QAAQ,EAAE;EACpD,MAAM,OAAO,QAAQ,QAAQ,IAAI;AACjC,eAAa,KAAK,KAAK;AACvB,YAAU,OAAO,KAAK;EAEtB,MAAM,MAAM,QAAQ,kBAAkB;AACtC,MAAI,IACF,cAAa,KAAK;GAChB,YAAY;GACZ,SAAS,IAAI;GACb,UAAU,IAAI;GACd,UAAU,IAAI;GACd,cAAc,IAAI;GACnB,CAAC;AAGH,UAAgB,cAAc;AAC9B,UAAgB,eAAe;;AAYlC,QATY;EACV,SAAS;EACT,QAAQ;EACR,WAAW;EACX,aAAa;EACb,gBAAgB;EAChB,GAAG;EACJ"}

package/dist/sync/synchronizer.cjs

@@ -0,0 +1,43 @@
+const require_errors = require("../errors.cjs");
+//#region src/sync/synchronizer.ts
+/**
+* Schema synchronizer that compares the database state with the schema registry
+* and applies non-destructive changes
+*/
+var Synchronizer = class {
+	driver;
+	registry;
+	constructor(driver, registry) {
+		this.driver = driver;
+		this.registry = registry;
+	}
+	/**
+	* Synchronize database schema with registry definitions
+	* @param {boolean} [force=false] - Allow destructive operations (drop columns)
+	*/
+	async sync(force = false) {
+		const tables = this.registry.getAllTables();
+		for (const [, tableMeta] of tables) await this.syncTable(tableMeta, force);
+	}
+	async syncTable(meta, force) {
+		if (!await this.driver.tableExists(meta.name)) {
+			await this.driver.createTable(meta);
+			return;
+		}
+		const existingCols = await this.driver.getTableColumns(meta.name);
+		const existingNames = new Set(existingCols.map((c) => c.name));
+		const schemaNames = new Set(meta.columns.map((c) => c.name));
+		for (const colMeta of meta.columns) if (!existingNames.has(colMeta.name)) await this.driver.addColumn(meta.name, colMeta);
+		if (force) {
+			for (const existingName of existingNames) if (!schemaNames.has(existingName)) try {
+				await this.driver.dropColumn(meta.name, existingName);
+			} catch (err) {
+				throw new require_errors.SyncError(`Failed to drop column ${existingName}: ${err.message}`);
+			}
+		}
+	}
+};
+//#endregion
+exports.Synchronizer = Synchronizer;
+
+//# sourceMappingURL=synchronizer.cjs.map

package/dist/sync/synchronizer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.cjs","names":["SyncError"],"sources":["../../src/sync/synchronizer.ts"],"sourcesContent":["import { SyncError } from \"../errors\";\nimport type { SchemaRegistry } from \"../schema\";\nimport type { DatabaseDriver, TableMetadata } from \"../types\";\n\n/**\n * Schema synchronizer that compares the database state with the schema registry\n * and applies non-destructive changes\n */\nexport class Synchronizer {\n  private driver: DatabaseDriver;\n  private registry: SchemaRegistry;\n\n  constructor(driver: DatabaseDriver, registry: SchemaRegistry) {\n    this.driver = driver;\n    this.registry = registry;\n  }\n\n  /**\n   * Synchronize database schema with registry definitions\n   * @param {boolean} [force=false] - Allow destructive operations (drop columns)\n   */\n  async sync(force = false): Promise<void> {\n    const tables = this.registry.getAllTables();\n\n    for (const [, tableMeta] of tables) {\n      await this.syncTable(tableMeta, force);\n    }\n  }\n\n  private async syncTable(meta: TableMetadata, force: boolean): Promise<void> {\n    const exists = await this.driver.tableExists(meta.name);\n    if (!exists) {\n      await this.driver.createTable(meta);\n      return;\n    }\n\n    const existingCols = await this.driver.getTableColumns(meta.name);\n    const existingNames = new Set(existingCols.map((c) => c.name));\n    const schemaNames = new Set(meta.columns.map((c) => c.name));\n\n    for (const colMeta of meta.columns) {\n      if (!existingNames.has(colMeta.name)) {\n        await this.driver.addColumn(meta.name, colMeta);\n      }\n    }\n\n    if (force) {\n      for (const existingName of existingNames) {\n        if (!schemaNames.has(existingName)) {\n          try {\n            await this.driver.dropColumn(meta.name, existingName);\n          } catch (err: any) {\n            throw new SyncError(`Failed to drop column ${existingName}: ${err.message}`);\n          }\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,eAAb,MAA0B;CACxB;CACA;CAEA,YAAY,QAAwB,UAA0B;AAC5D,OAAK,SAAS;AACd,OAAK,WAAW;;;;;;CAOlB,MAAM,KAAK,QAAQ,OAAsB;EACvC,MAAM,SAAS,KAAK,SAAS,cAAc;AAE3C,OAAK,MAAM,GAAG,cAAc,OAC1B,OAAM,KAAK,UAAU,WAAW,MAAM;;CAI1C,MAAc,UAAU,MAAqB,OAA+B;AAE1E,MAAI,CADW,MAAM,KAAK,OAAO,YAAY,KAAK,KAAK,EAC1C;AACX,SAAM,KAAK,OAAO,YAAY,KAAK;AACnC;;EAGF,MAAM,eAAe,MAAM,KAAK,OAAO,gBAAgB,KAAK,KAAK;EACjE,MAAM,gBAAgB,IAAI,IAAI,aAAa,KAAK,MAAM,EAAE,KAAK,CAAC;EAC9D,MAAM,cAAc,IAAI,IAAI,KAAK,QAAQ,KAAK,MAAM,EAAE,KAAK,CAAC;AAE5D,OAAK,MAAM,WAAW,KAAK,QACzB,KAAI,CAAC,cAAc,IAAI,QAAQ,KAAK,CAClC,OAAM,KAAK,OAAO,UAAU,KAAK,MAAM,QAAQ;AAInD,MAAI;QACG,MAAM,gBAAgB,cACzB,KAAI,CAAC,YAAY,IAAI,aAAa,CAChC,KAAI;AACF,UAAM,KAAK,OAAO,WAAW,KAAK,MAAM,aAAa;YAC9C,KAAU;AACjB,UAAM,IAAIA,eAAAA,UAAU,yBAAyB,aAAa,IAAI,IAAI,UAAU"}

package/dist/sync/synchronizer.d.cts

@@ -0,0 +1,22 @@
+import { DatabaseDriver } from "../types.cjs";
+import { SchemaRegistry } from "../schema/registry.cjs";
+
+//#region src/sync/synchronizer.d.ts
+/**
+ * Schema synchronizer that compares the database state with the schema registry
+ * and applies non-destructive changes
+ */
+declare class Synchronizer {
+  private driver;
+  private registry;
+  constructor(driver: DatabaseDriver, registry: SchemaRegistry);
+  /**
+   * Synchronize database schema with registry definitions
+   * @param {boolean} [force=false] - Allow destructive operations (drop columns)
+   */
+  sync(force?: boolean): Promise<void>;
+  private syncTable;
+}
+//#endregion
+export { Synchronizer };
+//# sourceMappingURL=synchronizer.d.cts.map

package/dist/sync/synchronizer.d.mts

@@ -0,0 +1,22 @@
+import { DatabaseDriver } from "../types.mjs";
+import { SchemaRegistry } from "../schema/registry.mjs";
+
+//#region src/sync/synchronizer.d.ts
+/**
+ * Schema synchronizer that compares the database state with the schema registry
+ * and applies non-destructive changes
+ */
+declare class Synchronizer {
+  private driver;
+  private registry;
+  constructor(driver: DatabaseDriver, registry: SchemaRegistry);
+  /**
+   * Synchronize database schema with registry definitions
+   * @param {boolean} [force=false] - Allow destructive operations (drop columns)
+   */
+  sync(force?: boolean): Promise<void>;
+  private syncTable;
+}
+//#endregion
+export { Synchronizer };
+//# sourceMappingURL=synchronizer.d.mts.map

package/dist/sync/synchronizer.mjs

@@ -0,0 +1,43 @@
+import { SyncError } from "../errors.mjs";
+//#region src/sync/synchronizer.ts
+/**
+* Schema synchronizer that compares the database state with the schema registry
+* and applies non-destructive changes
+*/
+var Synchronizer = class {
+	driver;
+	registry;
+	constructor(driver, registry) {
+		this.driver = driver;
+		this.registry = registry;
+	}
+	/**
+	* Synchronize database schema with registry definitions
+	* @param {boolean} [force=false] - Allow destructive operations (drop columns)
+	*/
+	async sync(force = false) {
+		const tables = this.registry.getAllTables();
+		for (const [, tableMeta] of tables) await this.syncTable(tableMeta, force);
+	}
+	async syncTable(meta, force) {
+		if (!await this.driver.tableExists(meta.name)) {
+			await this.driver.createTable(meta);
+			return;
+		}
+		const existingCols = await this.driver.getTableColumns(meta.name);
+		const existingNames = new Set(existingCols.map((c) => c.name));
+		const schemaNames = new Set(meta.columns.map((c) => c.name));
+		for (const colMeta of meta.columns) if (!existingNames.has(colMeta.name)) await this.driver.addColumn(meta.name, colMeta);
+		if (force) {
+			for (const existingName of existingNames) if (!schemaNames.has(existingName)) try {
+				await this.driver.dropColumn(meta.name, existingName);
+			} catch (err) {
+				throw new SyncError(`Failed to drop column ${existingName}: ${err.message}`);
+			}
+		}
+	}
+};
+//#endregion
+export { Synchronizer };
+
+//# sourceMappingURL=synchronizer.mjs.map

package/dist/sync/synchronizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.mjs","names":[],"sources":["../../src/sync/synchronizer.ts"],"sourcesContent":["import { SyncError } from \"../errors\";\nimport type { SchemaRegistry } from \"../schema\";\nimport type { DatabaseDriver, TableMetadata } from \"../types\";\n\n/**\n * Schema synchronizer that compares the database state with the schema registry\n * and applies non-destructive changes\n */\nexport class Synchronizer {\n  private driver: DatabaseDriver;\n  private registry: SchemaRegistry;\n\n  constructor(driver: DatabaseDriver, registry: SchemaRegistry) {\n    this.driver = driver;\n    this.registry = registry;\n  }\n\n  /**\n   * Synchronize database schema with registry definitions\n   * @param {boolean} [force=false] - Allow destructive operations (drop columns)\n   */\n  async sync(force = false): Promise<void> {\n    const tables = this.registry.getAllTables();\n\n    for (const [, tableMeta] of tables) {\n      await this.syncTable(tableMeta, force);\n    }\n  }\n\n  private async syncTable(meta: TableMetadata, force: boolean): Promise<void> {\n    const exists = await this.driver.tableExists(meta.name);\n    if (!exists) {\n      await this.driver.createTable(meta);\n      return;\n    }\n\n    const existingCols = await this.driver.getTableColumns(meta.name);\n    const existingNames = new Set(existingCols.map((c) => c.name));\n    const schemaNames = new Set(meta.columns.map((c) => c.name));\n\n    for (const colMeta of meta.columns) {\n      if (!existingNames.has(colMeta.name)) {\n        await this.driver.addColumn(meta.name, colMeta);\n      }\n    }\n\n    if (force) {\n      for (const existingName of existingNames) {\n        if (!schemaNames.has(existingName)) {\n          try {\n            await this.driver.dropColumn(meta.name, existingName);\n          } catch (err: any) {\n            throw new SyncError(`Failed to drop column ${existingName}: ${err.message}`);\n          }\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,eAAb,MAA0B;CACxB;CACA;CAEA,YAAY,QAAwB,UAA0B;AAC5D,OAAK,SAAS;AACd,OAAK,WAAW;;;;;;CAOlB,MAAM,KAAK,QAAQ,OAAsB;EACvC,MAAM,SAAS,KAAK,SAAS,cAAc;AAE3C,OAAK,MAAM,GAAG,cAAc,OAC1B,OAAM,KAAK,UAAU,WAAW,MAAM;;CAI1C,MAAc,UAAU,MAAqB,OAA+B;AAE1E,MAAI,CADW,MAAM,KAAK,OAAO,YAAY,KAAK,KAAK,EAC1C;AACX,SAAM,KAAK,OAAO,YAAY,KAAK;AACnC;;EAGF,MAAM,eAAe,MAAM,KAAK,OAAO,gBAAgB,KAAK,KAAK;EACjE,MAAM,gBAAgB,IAAI,IAAI,aAAa,KAAK,MAAM,EAAE,KAAK,CAAC;EAC9D,MAAM,cAAc,IAAI,IAAI,KAAK,QAAQ,KAAK,MAAM,EAAE,KAAK,CAAC;AAE5D,OAAK,MAAM,WAAW,KAAK,QACzB,KAAI,CAAC,cAAc,IAAI,QAAQ,KAAK,CAClC,OAAM,KAAK,OAAO,UAAU,KAAK,MAAM,QAAQ;AAInD,MAAI;QACG,MAAM,gBAAgB,cACzB,KAAI,CAAC,YAAY,IAAI,aAAa,CAChC,KAAI;AACF,UAAM,KAAK,OAAO,WAAW,KAAK,MAAM,aAAa;YAC9C,KAAU;AACjB,UAAM,IAAI,UAAU,yBAAyB,aAAa,IAAI,IAAI,UAAU"}

package/dist/types.d.cts

@@ -0,0 +1,229 @@
+//#region src/types.d.ts
+type ColumnDataType = "integer" | "varchar" | "text" | "boolean" | "json" | "datetime" | "decimal" | "float" | "char" | "timestamp" | "bigint" | "blob";
+type DatabaseType = "mysql" | "mariadb" | "sqlite" | "file" | {
+  name: "mysql";
+  provider: "mysql" | "mysql2";
+} | {
+  name: "mariadb";
+  provider: "mysql" | "mysql2";
+} | {
+  name: "sqlite";
+  provider: "better-sqlite3" | "sqlite3" | "sql.js" | "bun:sqlite";
+} | {
+  name: "file";
+  provider: string;
+};
+interface ColumnMetadata {
+  name: string;
+  type: ColumnDataType;
+  primaryKey: boolean;
+  autoIncrement: boolean;
+  notNull: boolean;
+  unique: boolean;
+  defaultValue: unknown;
+  length?: number;
+  precision?: number;
+  scale?: number;
+  columnAlias?: string;
+  references?: {
+    table: string;
+    column: string;
+    onDelete?: ReferenceAction;
+    onUpdate?: ReferenceAction;
+    relationName?: string;
+  };
+}
+type ReferenceAction = "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION";
+interface TableMetadata {
+  name: string;
+  columns: ColumnMetadata[];
+}
+type DeferredRefMeta<ColumnName extends string = string, TargetTable extends string = string, TargetColumn extends string = string, RelationName extends string | undefined = string | undefined> = {
+  columnName: ColumnName;
+  targetTable: TargetTable;
+  targetColumn: TargetColumn;
+  relationName?: RelationName;
+  onDelete?: ReferenceAction;
+  onUpdate?: ReferenceAction;
+};
+type TableDefinition<T extends Record<string, any> = Record<string, any>, C extends Record<string, any> = {}, N extends string = string, Refs extends DeferredRefMeta = any> = {
+  __table: true;
+  __name: N;
+  __row: T;
+  __refs: Refs;
+  __columns: ColumnMetadata[];
+  __columnMap: Record<string, string>;
+  __deferredRefs: Array<{
+    columnName: string;
+    resolve: () => {
+      table: string;
+      column: string;
+    };
+    onDelete?: ReferenceAction;
+    onUpdate?: ReferenceAction;
+    relationName?: string;
+  }>;
+} & C;
+type InferRow<T> = T extends {
+  __row: infer R;
+} ? R : never;
+type InferInsert<T> = T extends TableDefinition<infer R, any, any> ? { [K in keyof R as K extends AutoIncrementKeys<T> ? never : K]: R[K] } & { [K in AutoIncrementKeys<T>]?: R[K] } : never;
+type AutoIncrementKeys<T> = T extends TableDefinition<infer R, any, any> ? keyof R : never;
+type InferUpdate<T> = T extends TableDefinition<infer R, any, any> ? Partial<R> : never;
+interface WhereCondition {
+  eq?: unknown;
+  neq?: unknown;
+  gt?: unknown;
+  gte?: unknown;
+  lt?: unknown;
+  lte?: unknown;
+  like?: string;
+  notLike?: string;
+  in?: unknown[];
+  notIn?: unknown[];
+  isNull?: boolean;
+  between?: [unknown, unknown];
+}
+type WhereClause<T = Record<string, any>> = { [K in keyof T]?: T[K] | WhereCondition } & {
+  OR?: WhereClause<T>[];
+  AND?: WhereClause<T>[];
+};
+interface QueryOptions<T = Record<string, any>, Rel extends Record<string, any> = {}> {
+  where?: WhereClause<T>;
+  select?: Extract<keyof T, string>[];
+  orderBy?: Partial<Record<Extract<keyof T, string>, "asc" | "desc">>;
+  take?: number;
+  skip?: number;
+  with?: { [K in keyof Rel]?: boolean | QueryOptions<Rel[K] extends {
+    row: infer R;
+  } ? R : Rel[K]> };
+}
+interface UpdateOptions<T = Record<string, any>> {
+  where: WhereClause<T>;
+  data: Partial<T>;
+}
+interface DeleteOptions<T = Record<string, any>> {
+  where: WhereClause<T>;
+}
+interface MySQLConnectionConfig {
+  host: string;
+  port?: number;
+  user: string;
+  password: string;
+  database: string;
+}
+interface SQLiteConnectionConfig {
+  filename: string;
+}
+interface FileConnectionConfig {
+  directory: string;
+}
+type ConnectionConfig = MySQLConnectionConfig | SQLiteConnectionConfig | FileConnectionConfig;
+interface CacheConfig {
+  enabled: boolean;
+  ttl?: number;
+  maxTtl?: number;
+  maxEntries?: number;
+}
+interface DatabaseConfig {
+  schemas: readonly TableDefinition<any, any, any>[];
+  migrations?: any[];
+  database: DatabaseType;
+  connection: ConnectionConfig | ConnectionConfig[];
+  runMigrations?: boolean;
+  syncSchemas?: boolean;
+  cache?: boolean | CacheConfig;
+}
+interface MigrationContext {
+  schema: {
+    createTable: (table: TableDefinition) => Promise<void>;
+    dropTable: (name: string) => Promise<void>;
+    addColumn: (table: string, name: string, column: ColumnMetadata) => Promise<void>;
+    dropColumn: (table: string, name: string) => Promise<void>;
+    renameColumn: (table: string, oldName: string, newName: string) => Promise<void>;
+    addIndex: (table: string, columns: string[], unique?: boolean) => Promise<void>;
+    dropIndex: (table: string, indexName: string) => Promise<void>;
+  };
+  sql: (query: string, params?: unknown[]) => Promise<unknown>;
+}
+interface MigrationDefinition {
+  name: string;
+  up: (ctx: MigrationContext) => Promise<void>;
+  down: (ctx: MigrationContext) => Promise<void>;
+}
+interface DatabaseDriver {
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  execute(sql: string, params?: unknown[]): Promise<any>;
+  query(sql: string, params?: unknown[]): Promise<any[]>;
+  tableExists(name: string): Promise<boolean>;
+  getTableColumns(name: string): Promise<ColumnMetadata[]>;
+  createTable(meta: TableMetadata): Promise<void>;
+  dropTable(name: string): Promise<void>;
+  addColumn(table: string, column: ColumnMetadata): Promise<void>;
+  dropColumn(table: string, name: string): Promise<void>;
+  renameColumn(table: string, oldName: string, newName: string): Promise<void>;
+  transaction<T>(fn: () => Promise<T>): Promise<T>;
+  getAllTableColumns?(): Promise<Record<string, ColumnMetadata[]>>;
+}
+interface Repository<T extends Record<string, any>> {
+  find(options?: QueryOptions<T>): Promise<T[]>;
+  findMany(options?: QueryOptions<T>): Promise<T[]>;
+  findFirst(options?: QueryOptions<T>): Promise<T | null>;
+  insert(data: Partial<T> | Partial<T>[]): Promise<T>;
+  insertMany(data: Partial<T>[]): Promise<T[]>;
+  update(options: UpdateOptions<T>): Promise<T[]>;
+  delete(options: DeleteOptions<T>): Promise<number>;
+  count(options?: Pick<QueryOptions<T>, "where">): Promise<number>;
+  exists(options: Pick<QueryOptions<T>, "where">): Promise<boolean>;
+  upsert(options: {
+    where: WhereClause<T>;
+    create: Partial<T>;
+    update: Partial<T>;
+  }): Promise<T>;
+  truncate(): Promise<void>;
+}
+type AnyTableDef = TableDefinition<any, any, any, any>;
+type TableRefs<T> = T extends {
+  __refs: infer R;
+} ? R : never;
+type TableName<T> = T extends {
+  __name: infer N extends string;
+} ? N : never;
+type SchemaByName<S extends readonly AnyTableDef[], N extends string> = Extract<S[number], {
+  __name: N;
+}>;
+type StripIdSuffix<S extends string> = S extends `${infer Base}Id` ? Base : S extends `${infer Base}_id` ? Base : S;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type ForwardRelationEntries<S extends readonly AnyTableDef[], T extends AnyTableDef> = TableRefs<T> extends infer R ? R extends DeferredRefMeta<infer Col, infer ToTable, any, infer Name> ? { [K in Name extends string ? Name : StripIdSuffix<Col>]: {
+  table: SchemaByName<S, ToTable>;
+  many: false;
+} } : never : never;
+type ReverseRelationEntry<U extends AnyTableDef, TargetName extends string> = TableRefs<U> extends infer R ? R extends DeferredRefMeta<any, TargetName, any, any> ? { [K in TableName<U>]: {
+  table: U;
+  many: true;
+} } : never : never;
+type ReverseRelationEntries<S extends readonly AnyTableDef[], T extends AnyTableDef> = ReverseRelationEntry<S[number], TableName<T>>;
+type RelationsFor<S extends readonly AnyTableDef[], T extends AnyTableDef> = Simplify<UnionToIntersection<ForwardRelationEntries<S, T> | ReverseRelationEntries<S, T>>>;
+type DepthPrev = [never, 0, 1, 2, 3];
+type ExtractRelationRow<Rel> = Rel extends {
+  table: infer R;
+} ? InferRow<R> : never;
+type ExtractRelationMany<Rel> = Rel extends {
+  many: true;
+} ? true : false;
+type RelationQueryMap<S extends readonly AnyTableDef[], T extends AnyTableDef, D extends number = 3> = [D] extends [never] ? {} : { [K in keyof RelationsFor<S, T>]: {
+  row: ExtractRelationRow<RelationsFor<S, T>[K]>;
+  many: ExtractRelationMany<RelationsFor<S, T>[K]>;
+  relations: RelationsFor<S, T>[K] extends {
+    table: infer R extends AnyTableDef;
+  } ? RelationQueryMap<S, R, DepthPrev[D]> : {};
+} };
+type ResolveWith<S extends readonly AnyTableDef[], T extends AnyTableDef, W> = [W] extends [undefined] ? {} : W extends Record<string, any> ? { [K in keyof W & keyof RelationsFor<S, T>]: ExtractRelationMany<RelationsFor<S, T>[K]> extends true ? ExtractRelationRow<RelationsFor<S, T>[K]>[] : ExtractRelationRow<RelationsFor<S, T>[K]> | null } : {};
+type ResolveResult<S extends readonly AnyTableDef[], T extends AnyTableDef, O> = InferRow<T> & ResolveWith<S, T, O extends {
+  with: infer W;
+} ? W : undefined>;
+//#endregion
+export { AnyTableDef, CacheConfig, ColumnDataType, ColumnMetadata, ConnectionConfig, DatabaseConfig, DatabaseDriver, DatabaseType, DeferredRefMeta, DeleteOptions, FileConnectionConfig, InferInsert, InferRow, InferUpdate, MigrationContext, MigrationDefinition, MySQLConnectionConfig, QueryOptions, ReferenceAction, RelationQueryMap, RelationsFor, Repository, ResolveResult, SQLiteConnectionConfig, TableDefinition, TableMetadata, UpdateOptions, WhereClause, WhereCondition };
+//# sourceMappingURL=types.d.cts.map