@lobomfz/db 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lobomfz/db",
-	"version": "0.3.1",
+	"version": "0.3.3",
 	"description": "Bun SQLite database with Arktype schemas and typed Kysely client",
 	"keywords": [
 		"arktype",

package/src/database.ts

@@ -63,6 +63,7 @@ export class Database<T extends SchemaRecord> {
 	private sqlite: BunDatabase;
 
 	private columns: ColumnsMap = new Map();
+	private tableColumns = new Map<string, Set<string>>();
 
 	readonly infer: TablesFromSchemas<T> = undefined as any;
 
@@ -82,7 +83,7 @@ export class Database<T extends SchemaRecord> {
 
 		this.kysely = new Kysely<TablesFromSchemas<T>>({
 			dialect: new BunSqliteDialect({ database: this.sqlite }),
-			plugins: [new DeserializePlugin(this.columns, validation), new ParseJSONResultsPlugin()],
+			plugins: [new DeserializePlugin(this.columns, this.tableColumns, validation), new ParseJSONResultsPlugin()],
 		});
 	}
 
@@ -264,6 +265,8 @@ export class Database<T extends SchemaRecord> {
 	}
 
 	private registerColumns(tableName: string, props: Prop[]) {
+		this.tableColumns.set(tableName, new Set(props.map((p) => p.key)));
+
 		const colMap = new Map<string, ColumnCoercion>();
 
 		for (const prop of props) {
@@ -365,8 +368,12 @@ export class Database<T extends SchemaRecord> {
 	reset(table?: keyof T & string): void {
 		const tables = table ? [table] : Object.keys(this.options.schema.tables);
 
+		this.sqlite.run("PRAGMA foreign_keys = OFF");
+
 		for (const t of tables) {
 			this.sqlite.run(`DELETE FROM "${t}"`);
 		}
+
+		this.sqlite.run("PRAGMA foreign_keys = ON");
 	}
 }

package/src/plugin.ts

@@ -23,6 +23,7 @@ export class DeserializePlugin implements KyselyPlugin {
 
 	constructor(
 		private columns: ColumnsMap,
+		private tableColumns: Map<string, Set<string>>,
 		private validation: Required<JsonValidation>,
 	) {}
 
@@ -149,47 +150,51 @@ export class DeserializePlugin implements KyselyPlugin {
 		}
 	}
 
-	private coerceRow(table: string, row: UnknownRow, cols: Map<string, ColumnCoercion>) {
-		for (const [col, coercion] of cols) {
-			if (!(col in row)) {
-				continue;
+	private coerceSingle(table: string, row: UnknownRow, col: string, coercion: ColumnCoercion) {
+		if (coercion === "boolean") {
+			if (typeof row[col] === "number") {
+				row[col] = row[col] === 1;
 			}
 
-			if (coercion === "boolean") {
-				if (typeof row[col] === "number") {
-					row[col] = row[col] === 1;
-				}
+			return;
+		}
 
-				continue;
+		if (coercion === "date") {
+			if (typeof row[col] === "number") {
+				row[col] = new Date(row[col] * 1000);
 			}
 
-			if (coercion === "date") {
-				if (typeof row[col] === "number") {
-					row[col] = new Date(row[col] * 1000);
-				}
+			return;
+		}
 
-				continue;
-			}
+		if (typeof row[col] !== "string") {
+			return;
+		}
 
-			if (typeof row[col] !== "string") {
-				continue;
-			}
+		const value = row[col];
 
-			const value = row[col];
+		let parsed: unknown;
 
-			let parsed: unknown;
+		try {
+			parsed = JSON.parse(value);
+		} catch (e) {
+			throw new JsonParseError(table, col, value, e);
+		}
 
-			try {
-				parsed = JSON.parse(value);
-			} catch (e) {
-				throw new JsonParseError(table, col, value, e);
-			}
+		if (this.validation.onRead) {
+			this.validateJsonValue(table, col, parsed, coercion.schema);
+		}
+
+		row[col] = parsed;
+	}
 
-			if (this.validation.onRead) {
-				this.validateJsonValue(table, col, parsed, coercion.schema);
+	private coerceRow(table: string, row: UnknownRow, cols: Map<string, ColumnCoercion>) {
+		for (const [col, coercion] of cols) {
+			if (!(col in row)) {
+				continue;
 			}
 
-			row[col] = parsed;
+			this.coerceSingle(table, row, col, coercion);
 		}
 	}
 
@@ -206,14 +211,32 @@ export class DeserializePlugin implements KyselyPlugin {
 			return args.result;
 		}
 
-		const cols = this.columns.get(table);
-
-		if (!cols) {
-			return args.result;
-		}
+		const mainCols = this.columns.get(table);
+		const mainTableColumns = this.tableColumns.get(table);
 
 		for (const row of args.result.rows) {
-			this.coerceRow(table, row, cols);
+			if (mainCols) {
+				this.coerceRow(table, row, mainCols);
+			}
+
+			for (const col of Object.keys(row)) {
+				if (mainTableColumns?.has(col)) {
+					continue;
+				}
+
+				for (const [otherTable, otherCols] of this.columns) {
+					if (otherTable === table) {
+						continue;
+					}
+
+					const coercion = otherCols.get(col);
+
+					if (coercion) {
+						this.coerceSingle(otherTable, row, col, coercion);
+						break;
+					}
+				}
+			}
 		}
 
 		return { ...args.result };