@lobomfz/db 0.3.6 → 0.3.9

package/README.md

@@ -80,20 +80,20 @@ Schema changes are applied automatically on startup. Every time `new Database(..
 
 ### What's supported
 
-| Change | Strategy |
-|---|---|
-| New table | `CREATE TABLE` |
-| Removed table | `DROP TABLE` |
-| New nullable column | `ALTER TABLE ADD COLUMN` |
+| Change                           | Strategy                 |
+| -------------------------------- | ------------------------ |
+| New table                        | `CREATE TABLE`           |
+| Removed table                    | `DROP TABLE`             |
+| New nullable column              | `ALTER TABLE ADD COLUMN` |
 | New NOT NULL column with DEFAULT | `ALTER TABLE ADD COLUMN` |
-| Removed column | Table rebuild |
-| Type change | Table rebuild |
-| Nullability change | Table rebuild |
-| DEFAULT change | Table rebuild |
-| UNIQUE added/removed | Table rebuild |
-| FK added/removed/changed | Table rebuild |
-| Index added | `CREATE INDEX` |
-| Index removed | `DROP INDEX` |
+| Removed column                   | Table rebuild            |
+| Type change                      | Table rebuild            |
+| Nullability change               | Table rebuild            |
+| DEFAULT change                   | Table rebuild            |
+| UNIQUE added/removed             | Table rebuild            |
+| FK added/removed/changed         | Table rebuild            |
+| Index added                      | `CREATE INDEX`           |
+| Index removed                    | `DROP INDEX`             |
 
 Table rebuilds follow SQLite's [recommended procedure](https://www.sqlite.org/lang_altertable.html#otheralter): create a new table with the target schema, copy data from the old table, drop the old table, rename the new one. Foreign keys are disabled during rebuilds and validated via `PRAGMA foreign_key_check` before committing.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lobomfz/db",
-	"version": "0.3.6",
+	"version": "0.3.9",
 	"description": "Bun SQLite database with Arktype schemas and typed Kysely client",
 	"keywords": [
 		"arktype",
@@ -28,7 +28,7 @@
 		".": "./src/index.ts"
 	},
 	"scripts": {
-		"check": "tsgo && oxlint"
+		"check": "tsgo && oxlint && bun test.ts"
 	},
 	"dependencies": {},
 	"devDependencies": {
@@ -38,6 +38,8 @@
 		"oxlint": "^1.57.0"
 	},
 	"peerDependencies": {
+		"@ark/schema": ">=0.56.0",
+		"@ark/util": ">=0.56.0",
 		"arktype": "^2.1.29",
 		"kysely": "^0.28.14"
 	}

package/src/database.ts

@@ -1,22 +1,23 @@
 import { Database as BunDatabase } from "bun:sqlite";
 
 import type { Type } from "arktype";
-import { Kysely, ParseJSONResultsPlugin } from "kysely";
-
-import { BunSqliteDialect } from "./dialect/dialect";
-import type { DbFieldMeta } from "./env";
-import type { GeneratedPreset } from "./generated";
-import { Differ, type DesiredTable } from "./migration/diff";
-import { Executor } from "./migration/execute";
-import { Introspector } from "./migration/introspect";
-import { DeserializePlugin, type ColumnCoercion, type ColumnsMap } from "./plugin";
+import { Kysely } from "kysely";
+
+import { BunSqliteDialect } from "./dialect/dialect.js";
+import type { DbFieldMeta } from "./env.js";
+import type { GeneratedPreset } from "./generated.js";
+import { Differ, type DesiredTable } from "./migration/diff.js";
+import { Executor } from "./migration/execute.js";
+import { Introspector } from "./migration/introspect.js";
+import { ResultHydrationPlugin, type ColumnCoercion, type ColumnsMap } from "./plugin.js";
 import type {
 	DatabaseOptions,
 	IndexDefinition,
 	SchemaRecord,
 	TablesFromSchemas,
 	DatabasePragmas,
-} from "./types";
+} from "./types.js";
+import { WriteValidationPlugin } from "./write-validation-plugin.js";
 
 type ArkBranch = {
 	domain?: string;
@@ -24,6 +25,7 @@ type ArkBranch = {
 	unit?: unknown;
 	structure?: unknown;
 	inner?: { divisor?: unknown };
+	meta?: DbFieldMeta & { _generated?: GeneratedPreset };
 };
 
 type StructureProp = {
@@ -87,8 +89,8 @@ export class Database<T extends SchemaRecord> {
 		this.kysely = new Kysely<TablesFromSchemas<T>>({
 			dialect: new BunSqliteDialect({ database: this.sqlite }),
 			plugins: [
-				new DeserializePlugin(this.columns, this.tableColumns, validation),
-				new ParseJSONResultsPlugin(),
+				new WriteValidationPlugin(this.columns, validation),
+				new ResultHydrationPlugin(this.columns, this.tableColumns, validation),
 			],
 		});
 	}
@@ -114,46 +116,49 @@ export class Database<T extends SchemaRecord> {
 	private normalizeProp(structureProp: StructureProp, parentSchema: Type) {
 		const { key, value: v, inner } = structureProp;
 		const kind: Prop["kind"] = structureProp.required ? "required" : "optional";
-		const generated = v.meta._generated;
 		const defaultValue = inner.default;
 
-		const nonNull = v.branches.filter((b) => b.unit !== null);
-		const nullable = nonNull.length < v.branches.length;
+		const concrete = v.branches.filter((b) => b.unit !== null && b.domain !== "undefined");
+		const nullable = concrete.length < v.branches.length;
 
-		if (v.proto === Date || nonNull.some((b) => b.proto === Date)) {
+		const branchMeta = v.branches.find((b) => b.meta && Object.keys(b.meta).length > 0)?.meta;
+		const meta = { ...branchMeta, ...v.meta };
+		const generated = meta._generated;
+
+		if (v.proto === Date || concrete.some((b) => b.proto === Date)) {
 			return { key, kind, nullable, isDate: true, generated, defaultValue };
 		}
 
-		if (v.proto === Uint8Array || nonNull.some((b) => b.proto === Uint8Array)) {
+		if (v.proto === Uint8Array || concrete.some((b) => b.proto === Uint8Array)) {
 			return {
 				key,
 				kind,
 				nullable,
 				isBlob: true,
-				meta: v.meta,
+				meta,
 				generated,
 				defaultValue,
 			};
 		}
 
-		if (nonNull.length > 0 && nonNull.every((b) => b.domain === "boolean")) {
+		if (concrete.length > 0 && concrete.every((b) => b.domain === "boolean")) {
 			return { key, kind, nullable, isBoolean: true, generated, defaultValue };
 		}
 
-		if (nonNull.some((b) => !!b.structure)) {
+		if (concrete.some((b) => !!b.structure)) {
 			return {
 				key,
 				kind,
 				nullable,
 				isJson: true,
 				jsonSchema: (parentSchema as any).get(key) as Type,
-				meta: v.meta,
+				meta,
 				generated,
 				defaultValue,
 			};
 		}
 
-		const branch = nonNull[0];
+		const branch = concrete[0];
 
 		return {
 			key,
@@ -161,7 +166,7 @@ export class Database<T extends SchemaRecord> {
 			nullable,
 			domain: branch?.domain,
 			isInteger: !!branch?.inner?.divisor,
-			meta: v.meta,
+			meta,
 			generated,
 			defaultValue,
 		};
@@ -224,7 +229,9 @@ export class Database<T extends SchemaRecord> {
 			return `DEFAULT ${prop.defaultValue}`;
 		}
 
-		throw new Error(`Unsupported default value type: ${typeof prop.defaultValue}`);
+		throw new Error(
+			`Unsupported default value type: ${typeof prop.defaultValue} ${JSON.stringify(prop)}`,
+		);
 	}
 
 	private columnDef(prop: Prop) {

package/src/dialect/connection.ts

@@ -1,6 +1,8 @@
 import type { Database } from "bun:sqlite";
+
 import type { CompiledQuery, DatabaseConnection, QueryResult } from "kysely";
-import { serializeParam } from "./serialize";
+
+import { serializeParam } from "./serialize.js";
 
 export class BunSqliteConnection implements DatabaseConnection {
 	readonly #db: Database;

package/src/dialect/dialect.ts

@@ -9,8 +9,9 @@ import {
 	type Kysely,
 	type QueryCompiler,
 } from "kysely";
-import type { BunSqliteDialectConfig } from "./config";
-import { BunSqliteDriver } from "./driver";
+
+import type { BunSqliteDialectConfig } from "./config.js";
+import { BunSqliteDriver } from "./driver.js";
 
 export class BunSqliteDialect implements Dialect {
 	readonly #config: BunSqliteDialectConfig;

package/src/dialect/driver.ts

@@ -1,8 +1,10 @@
 import type { Database } from "bun:sqlite";
+
 import { CompiledQuery, type DatabaseConnection, type Driver } from "kysely";
-import type { BunSqliteDialectConfig } from "./config";
-import { BunSqliteConnection } from "./connection";
-import { ConnectionMutex } from "./mutex";
+
+import type { BunSqliteDialectConfig } from "./config.js";
+import { BunSqliteConnection } from "./connection.js";
+import { ConnectionMutex } from "./mutex.js";
 
 export class BunSqliteDriver implements Driver {
 	readonly #config: BunSqliteDialectConfig;

package/src/env.ts

@@ -3,6 +3,7 @@ export type DbFieldMeta = {
 	unique?: boolean;
 	references?: `${string}.${string}`;
 	onDelete?: "cascade" | "set null" | "restrict";
+	_generated?: "autoincrement" | "now";
 };
 
 declare global {

package/src/generated.ts

@@ -3,13 +3,10 @@ import { type } from "arktype";
 export type GeneratedPreset = "autoincrement" | "now";
 
 const generatedTypes = {
-	autoincrement: () =>
-		type("number.integer")
-			.configure({ _generated: "autoincrement" } as any)
-			.default(0),
+	autoincrement: () => type("number.integer").configure({ _generated: "autoincrement" }).default(0),
 	now: () =>
 		type("Date")
-			.configure({ _generated: "now" } as any)
+			.configure({ _generated: "now" })
 			.default(() => new Date(0)),
 };
 

package/src/index.ts

@@ -1,10 +1,19 @@
-export { Database } from "./database";
-export { generated, type GeneratedPreset } from "./generated";
-export { JsonParseError } from "./errors";
-export { sql, type Selectable, type Insertable, type Updateable, type Kysely } from "kysely";
-export { type } from "arktype";
-export { JsonValidationError } from "./validation-error";
-export type { DbFieldMeta } from "./env";
+export { Database } from "./database.js";
+export { generated, type GeneratedPreset } from "./generated.js";
+export { JsonParseError } from "./errors.js";
+export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
+export {
+	sql,
+	type Selectable,
+	type Insertable,
+	type Updateable,
+	type Kysely,
+	type ExpressionBuilder,
+} from "kysely";
+export { type, type Type } from "arktype";
+export { configure } from "arktype/config";
+export { JsonValidationError } from "./validation-error.js";
+export type { DbFieldMeta } from "./env.js";
 export type {
 	DatabaseOptions,
 	SchemaRecord,
@@ -16,4 +25,4 @@ export type {
 	DatabaseSchema,
 	JsonValidation,
 	SqliteMasterRow,
-} from "./types";
+} from "./types.js";

package/src/migration/diff.ts

@@ -1,4 +1,4 @@
-import type { ColumnSchema, IntrospectedTable, ColumnCopy, MigrationOp } from "./types";
+import type { ColumnSchema, IntrospectedTable, ColumnCopy, MigrationOp } from "./types.js";
 
 export interface DesiredColumn extends ColumnSchema {
 	addable: boolean;
@@ -42,7 +42,11 @@ export class Differ {
 			const existingTable = this.existing.get(table.name);
 
 			if (!existingTable) {
-				this.ops.push({ type: "CreateTable", table: table.name, sql: table.sql });
+				this.ops.push({
+					type: "CreateTable",
+					table: table.name,
+					sql: table.sql,
+				});
 				this.rebuiltTables.add(table.name);
 				continue;
 			}
@@ -101,13 +105,21 @@ export class Differ {
 			}
 
 			if (!existing.notnull && col.notnull && col.defaultValue !== null) {
-				columnCopies.push({ name: col.name, expr: `COALESCE("${col.name}", ${col.defaultValue})` });
+				columnCopies.push({
+					name: col.name,
+					expr: `COALESCE("${col.name}", ${col.defaultValue})`,
+				});
 			} else {
 				columnCopies.push({ name: col.name, expr: `"${col.name}"` });
 			}
 		}
 
-		this.ops.push({ type: "RebuildTable", table: table.name, createSql: table.sql, columnCopies });
+		this.ops.push({
+			type: "RebuildTable",
+			table: table.name,
+			createSql: table.sql,
+			columnCopies,
+		});
 		this.rebuiltTables.add(table.name);
 	}
 
@@ -134,7 +146,11 @@ export class Differ {
 		}
 
 		for (const col of newColumns) {
-			this.ops.push({ type: "AddColumn", table: table.name, columnDef: col.columnDef });
+			this.ops.push({
+				type: "AddColumn",
+				table: table.name,
+				columnDef: col.columnDef,
+			});
 		}
 	}
 
@@ -163,7 +179,12 @@ export class Differ {
 
 			if (this.rebuiltTables.has(table.name)) {
 				for (const idx of tableIndexes) {
-					this.ops.push({ type: "CreateIndex", table: table.name, columns: idx.columns, sql: idx.sql });
+					this.ops.push({
+						type: "CreateIndex",
+						table: table.name,
+						columns: idx.columns,
+						sql: idx.sql,
+					});
 				}
 
 				continue;
@@ -180,7 +201,12 @@ export class Differ {
 
 			for (const idx of tableIndexes) {
 				if (!existingNames.has(idx.name)) {
-					this.ops.push({ type: "CreateIndex", table: table.name, columns: idx.columns, sql: idx.sql });
+					this.ops.push({
+						type: "CreateIndex",
+						table: table.name,
+						columns: idx.columns,
+						sql: idx.sql,
+					});
 				}
 			}
 

package/src/migration/execute.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite";
-import type { MigrationOp, RebuildTableOp } from "./types";
+
+import type { MigrationOp, RebuildTableOp } from "./types.js";
 
 export class Executor {
 	constructor(

package/src/migration/introspect.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite";
-import type { IntrospectedColumn, IntrospectedIndex, IntrospectedTable } from "./types";
+
+import type { IntrospectedColumn, IntrospectedIndex, IntrospectedTable } from "./types.js";
 
 type TableListRow = {
 	name: string;
@@ -131,7 +132,8 @@ export class Introspector {
 				onDelete: fk?.onDelete ?? null,
 				hasNulls:
 					!isNotnull &&
-					this.db.prepare(`SELECT 1 FROM "${table}" WHERE "${col.name}" IS NULL LIMIT 1`).get() !== null,
+					this.db.prepare(`SELECT 1 FROM "${table}" WHERE "${col.name}" IS NULL LIMIT 1`).get() !==
+						null,
 			});
 		}
 

package/src/plugin.ts

@@ -3,48 +3,95 @@ import type { Type } from "arktype";
 import {
 	type KyselyPlugin,
 	type OperationNode,
+	type QueryId,
 	type RootOperationNode,
 	type UnknownRow,
-	type QueryId,
 	AggregateFunctionNode,
-	TableNode,
 	AliasNode,
-	ValuesNode,
-	ValueNode,
+	CastNode,
 	ColumnNode,
 	IdentifierNode,
-	ReferenceNode,
 	ParensNode,
-	CastNode,
+	ReferenceNode,
 	SelectQueryNode,
+	TableNode,
 } from "kysely";
 
-import { JsonParseError } from "./errors";
-import type { JsonValidation } from "./types";
-import { JsonValidationError } from "./validation-error";
+import { JsonParseError } from "./errors.js";
+import { JsonValidationError } from "./validation-error.js";
 
 export type ColumnCoercion = "boolean" | "date" | { type: "json"; schema: Type };
 export type ColumnsMap = Map<string, Map<string, ColumnCoercion>>;
 
 type ResolvedCoercion = { table: string; coercion: ColumnCoercion };
 
+type CoercionPlan = {
+	kind: "coercion";
+	table: string;
+	column: string;
+	coercion: ColumnCoercion;
+};
+
+type ObjectPlan = {
+	kind: "object";
+	table: string;
+	column: string;
+	fields: Map<string, ValuePlan>;
+};
+
+type ArrayPlan = {
+	kind: "array";
+	table: string;
+	column: string;
+	fields: Map<string, ValuePlan>;
+};
+
+type ValuePlan = CoercionPlan | ObjectPlan | ArrayPlan;
+
+type QueryPlan = {
+	table: string | null;
+	selectionPlans: Map<string, ValuePlan>;
+};
+
+type JsonHelper = {
+	kind: "object" | "array";
+	query: SelectQueryNode;
+};
+
+type RawOperationNode = OperationNode & {
+	kind: "RawNode";
+	sqlFragments: readonly string[];
+	parameters: readonly OperationNode[];
+};
+
+const jsonArrayFromFragments = [
+	"(select coalesce(json_group_array(json_object(",
+	")), '[]') from ",
+	" as agg)",
+] as const;
+
+const jsonObjectFromFragments = [
+	"(select json_object(",
+	") from ",
+	" as obj)",
+] as const;
+
 const typePreservingAggregateFunctions = new Set(["max", "min"]);
 
-export class DeserializePlugin implements KyselyPlugin {
-	private queryNodes = new WeakMap<QueryId, RootOperationNode>();
+export class ResultHydrationPlugin implements KyselyPlugin {
+	private queryPlans = new WeakMap<QueryId, QueryPlan>();
 
 	constructor(
 		private columns: ColumnsMap,
 		private tableColumns: Map<string, Set<string>>,
-		private validation: Required<JsonValidation>,
+		private validation: { onRead: boolean },
 	) {}
 
 	transformQuery: KyselyPlugin["transformQuery"] = (args) => {
-		this.queryNodes.set(args.queryId, args.node);
-
-		if (this.validation.onWrite) {
-			this.validateWriteNode(args.node);
-		}
+		this.queryPlans.set(args.queryId, {
+			table: this.getTableFromNode(args.node),
+			selectionPlans: this.getSelectionPlans(args.node),
+		});
 
 		return args.node;
 	};
@@ -98,116 +145,115 @@ export class DeserializePlugin implements KyselyPlugin {
 		}
 	}
 
-	private validateWriteNode(node: RootOperationNode) {
-		if (node.kind !== "InsertQueryNode" && node.kind !== "UpdateQueryNode") {
-			return;
+	private parseJson(table: string, column: string, value: string) {
+		try {
+			return JSON.parse(value);
+		} catch (e) {
+			throw new JsonParseError(table, column, value, e);
 		}
+	}
 
-		const table = this.getTableFromNode(node);
-
-		if (!table) {
-			return;
+	private hydrateCoercion(plan: CoercionPlan, value: unknown) {
+		if (value === null || value === undefined) {
+			return value;
 		}
 
-		const cols = this.columns.get(table);
+		if (plan.coercion === "boolean") {
+			if (typeof value === "number") {
+				return value === 1;
+			}
 
-		if (!cols) {
-			return;
+			return value;
 		}
 
-		for (const [col, value] of this.writeValues(node)) {
-			const coercion = cols.get(col);
-
-			if (!coercion || typeof coercion === "string") {
-				continue;
+		if (plan.coercion === "date") {
+			if (typeof value === "number") {
+				return new Date(value * 1000);
 			}
 
-			this.validateJsonValue(table, col, value, coercion.schema);
+			return value;
 		}
-	}
-
-	private *writeValues(node: RootOperationNode) {
-		if (node.kind === "InsertQueryNode") {
-			const columns = node.columns?.map((c) => c.column.name);
-
-			if (!columns || !node.values || !ValuesNode.is(node.values)) {
-				return;
-			}
 
-			for (const valueList of node.values.values) {
-				for (let i = 0; i < columns.length; i++) {
-					const col = columns[i]!;
+		const parsed =
+			typeof value === "string" ? this.parseJson(plan.table, plan.column, value) : value;
 
-					if (valueList.kind === "PrimitiveValueListNode") {
-						yield [col, valueList.values[i]] as [string, unknown];
-						continue;
-					}
+		if (this.validation.onRead) {
+			this.validateJsonValue(plan.table, plan.column, parsed, plan.coercion.schema);
+		}
 
-					const raw = valueList.values[i];
-					yield [col, raw && ValueNode.is(raw) ? raw.value : raw] as [string, unknown];
-				}
-			}
+		return parsed;
+	}
 
-			return;
+	private parseStructuredValue(table: string, column: string, value: unknown) {
+		if (value === null || value === undefined) {
+			return value;
 		}
 
-		if (node.kind !== "UpdateQueryNode" || !node.updates) {
-			return;
+		if (typeof value === "string") {
+			return this.parseJson(table, column, value);
 		}
 
-		for (const update of node.updates) {
-			if (ColumnNode.is(update.column) && ValueNode.is(update.value)) {
-				yield [update.column.column.name, update.value.value] as [string, unknown];
-			}
-		}
+		return value;
 	}
 
-	private coerceSingle(table: string, row: UnknownRow, col: string, coercion: ColumnCoercion) {
-		if (coercion === "boolean") {
-			if (typeof row[col] === "number") {
-				row[col] = row[col] === 1;
-			}
+	private isPlainObject(value: unknown): value is Record<string, unknown> {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	}
 
-			return;
+	private hydrateObject(plan: ObjectPlan, value: unknown) {
+		const parsed = this.parseStructuredValue(plan.table, plan.column, value);
+
+		if (!this.isPlainObject(parsed)) {
+			return parsed;
 		}
 
-		if (coercion === "date") {
-			if (typeof row[col] === "number") {
-				row[col] = new Date(row[col] * 1000);
+		for (const [field, fieldPlan] of plan.fields) {
+			if (!(field in parsed)) {
+				continue;
 			}
 
-			return;
+			parsed[field] = this.hydrateValue(fieldPlan, parsed[field]);
 		}
 
-		if (typeof row[col] !== "string") {
-			return;
+		return parsed;
+	}
+
+	private hydrateArray(plan: ArrayPlan, value: unknown) {
+		const parsed = this.parseStructuredValue(plan.table, plan.column, value);
+
+		if (!Array.isArray(parsed)) {
+			return parsed;
 		}
 
-		const value = row[col];
+		for (let i = 0; i < parsed.length; i++) {
+			const item = parsed[i];
 
-		let parsed: unknown;
+			if (!this.isPlainObject(item)) {
+				continue;
+			}
 
-		try {
-			parsed = JSON.parse(value);
-		} catch (e) {
-			throw new JsonParseError(table, col, value, e);
-		}
+			for (const [field, fieldPlan] of plan.fields) {
+				if (!(field in item)) {
+					continue;
+				}
 
-		if (this.validation.onRead) {
-			this.validateJsonValue(table, col, parsed, coercion.schema);
+				item[field] = this.hydrateValue(fieldPlan, item[field]);
+			}
 		}
 
-		row[col] = parsed;
+		return parsed;
 	}
 
-	private coerceRow(table: string, row: UnknownRow, cols: Map<string, ColumnCoercion>) {
-		for (const [col, coercion] of cols) {
-			if (!(col in row)) {
-				continue;
-			}
+	private hydrateValue(plan: ValuePlan, value: unknown): unknown {
+		if (plan.kind === "coercion") {
+			return this.hydrateCoercion(plan, value);
+		}
 
-			this.coerceSingle(table, row, col, coercion);
+		if (plan.kind === "object") {
+			return this.hydrateObject(plan, value);
 		}
+
+		return this.hydrateArray(plan, value);
 	}
 
 	private getIdentifierName(node: OperationNode | undefined) {
@@ -301,17 +347,115 @@ export class DeserializePlugin implements KyselyPlugin {
 		return match;
 	}
 
-	private resolveSelectionCoercion(node: OperationNode, scope: Map<string, string>): ResolvedCoercion | null {
+	private isRawNode(node: OperationNode): node is RawOperationNode {
+		return node.kind === "RawNode";
+	}
+
+	private matchesFragments(
+		fragments: readonly string[],
+		expected: readonly [string, string, string],
+	) {
+		return (
+			fragments.length === expected.length &&
+			fragments.every((fragment, index) => fragment === expected[index])
+		);
+	}
+
+	private getJsonHelper(node: RawOperationNode): JsonHelper | null {
+		const query = node.parameters[1];
+
+		if (!query || !SelectQueryNode.is(query)) {
+			return null;
+		}
+
+		if (this.matchesFragments(node.sqlFragments, jsonObjectFromFragments)) {
+			return { kind: "object", query };
+		}
+
+		if (this.matchesFragments(node.sqlFragments, jsonArrayFromFragments)) {
+			return { kind: "array", query };
+		}
+
+		return null;
+	}
+
+	private getStructuredFieldPlans(node: SelectQueryNode) {
+		const result = new Map<string, ValuePlan>();
+
+		if (!node.selections) {
+			return result;
+		}
+
+		const scope = this.getTableScope(node);
+
+		for (const selectionNode of node.selections) {
+			const output = this.getSelectionOutputName(selectionNode.selection);
+
+			if (!output) {
+				continue;
+			}
+
+			const plan = this.resolveSelectionPlan(selectionNode.selection, scope, output);
+
+			if (plan) {
+				result.set(output, plan);
+			}
+		}
+
+		return result;
+	}
+
+	private resolveJsonHelperPlan(node: RawOperationNode, output: string | null): ValuePlan | null {
+		if (!output) {
+			return null;
+		}
+
+		const helper = this.getJsonHelper(node);
+
+		if (!helper) {
+			return null;
+		}
+
+		const table = this.getTableFromNode(helper.query) ?? output;
+		const fields = this.getStructuredFieldPlans(helper.query);
+
+		if (helper.kind === "object") {
+			return { kind: "object", table, column: output, fields };
+		}
+
+		return { kind: "array", table, column: output, fields };
+	}
+
+	private resolveSelectionPlan(
+		node: OperationNode,
+		scope: Map<string, string>,
+		output: string | null,
+	): ValuePlan | null {
 		if (AliasNode.is(node)) {
-			return this.resolveSelectionCoercion(node.node, scope);
+			return this.resolveSelectionPlan(node.node, scope, output ?? this.getIdentifierName(node.alias));
 		}
 
 		if (ReferenceNode.is(node) || ColumnNode.is(node)) {
-			return this.resolveReferenceCoercion(node, scope);
+			if (!output) {
+				return null;
+			}
+
+			const resolved = this.resolveReferenceCoercion(node, scope);
+
+			if (!resolved) {
+				return null;
+			}
+
+			return {
+				kind: "coercion",
+				table: resolved.table,
+				column: output,
+				coercion: resolved.coercion,
+			};
 		}
 
 		if (SelectQueryNode.is(node)) {
-			return this.resolveScalarSubqueryCoercion(node);
+			return this.resolveScalarSubqueryPlan(node, output);
 		}
 
 		if (AggregateFunctionNode.is(node)) {
@@ -322,29 +466,30 @@ export class DeserializePlugin implements KyselyPlugin {
 				return null;
 			}
 
-			return this.resolveSelectionCoercion(node.aggregated[0]!, scope);
+			return this.resolveSelectionPlan(node.aggregated[0]!, scope, output);
 		}
 
 		if (ParensNode.is(node)) {
-			return this.resolveSelectionCoercion(node.node, scope);
+			return this.resolveSelectionPlan(node.node, scope, output);
 		}
 
 		if (CastNode.is(node)) {
 			return null;
 		}
 
+		if (this.isRawNode(node)) {
+			return this.resolveJsonHelperPlan(node, output);
+		}
+
 		return null;
 	}
 
-	private resolveScalarSubqueryCoercion(node: SelectQueryNode) {
+	private resolveScalarSubqueryPlan(node: SelectQueryNode, output: string | null) {
 		if (!node.selections || node.selections.length !== 1) {
 			return null;
 		}
 
-		return this.resolveSelectionCoercion(
-			node.selections[0]!.selection,
-			this.getTableScope(node),
-		);
+		return this.resolveSelectionPlan(node.selections[0]!.selection, this.getTableScope(node), output);
 	}
 
 	private getSelectionOutputName(node: OperationNode) {
@@ -363,8 +508,8 @@ export class DeserializePlugin implements KyselyPlugin {
 		return null;
 	}
 
-	private getSelectCoercions(node: RootOperationNode) {
-		const result = new Map<string, ResolvedCoercion>();
+	private getSelectionPlans(node: RootOperationNode) {
+		const result = new Map<string, ValuePlan>();
 
 		if (node.kind !== "SelectQueryNode" || !node.selections) {
 			return result;
@@ -379,65 +524,86 @@ export class DeserializePlugin implements KyselyPlugin {
 				continue;
 			}
 
-			const resolved = this.resolveSelectionCoercion(selectionNode.selection, scope);
+			const plan = this.resolveSelectionPlan(selectionNode.selection, scope, output);
 
-			if (resolved) {
-				result.set(output, resolved);
+			if (plan) {
+				result.set(output, plan);
 			}
 		}
 
 		return result;
 	}
 
-	transformResult: KyselyPlugin["transformResult"] = async (args) => {
-		const node = this.queryNodes.get(args.queryId);
+	private coerceMainRow(table: string, row: UnknownRow, cols: Map<string, ColumnCoercion>) {
+		for (const [column, coercion] of cols) {
+			if (!(column in row)) {
+				continue;
+			}
 
-		if (!node) {
-			return args.result;
+			row[column] = this.hydrateCoercion({
+				kind: "coercion",
+				table,
+				column,
+				coercion,
+			}, row[column]);
 		}
+	}
 
-		const table = this.getTableFromNode(node);
+	transformResult: KyselyPlugin["transformResult"] = async (args) => {
+		const plan = this.queryPlans.get(args.queryId);
 
-		if (!table) {
+		if (!plan) {
 			return args.result;
 		}
 
-		const mainCols = this.columns.get(table);
-		const mainTableColumns = this.tableColumns.get(table);
-		const selectCoercions = this.getSelectCoercions(node);
+		const mainCols = plan.table ? this.columns.get(plan.table) : null;
+		const mainTableColumns = plan.table ? this.tableColumns.get(plan.table) : null;
 
 		for (const row of args.result.rows) {
-			if (mainCols) {
-				this.coerceRow(table, row, mainCols);
+			if (plan.table && mainCols) {
+				this.coerceMainRow(plan.table, row, mainCols);
 			}
 
-			for (const col of Object.keys(row)) {
-				const resolved = selectCoercions.get(col);
-
-				if (resolved) {
-					this.coerceSingle(resolved.table, row, col, resolved.coercion);
+			for (const [column, selectionPlan] of plan.selectionPlans) {
+				if (!(column in row)) {
 					continue;
 				}
 
-				if (mainTableColumns?.has(col)) {
+				row[column] = this.hydrateValue(selectionPlan, row[column]);
+			}
+
+			if (!plan.table) {
+				continue;
+			}
+
+			for (const column of Object.keys(row)) {
+				if (plan.selectionPlans.has(column) || mainTableColumns?.has(column)) {
 					continue;
 				}
 
 				for (const [otherTable, otherCols] of this.columns) {
-					if (otherTable === table) {
+					if (otherTable === plan.table) {
 						continue;
 					}
 
-					const coercion = otherCols.get(col);
+					const coercion = otherCols.get(column);
 
-					if (coercion) {
-						this.coerceSingle(otherTable, row, col, coercion);
-						break;
+					if (!coercion) {
+						continue;
 					}
+
+					row[column] = this.hydrateCoercion({
+						kind: "coercion",
+						table: otherTable,
+						column,
+						coercion,
+					}, row[column]);
+
+					break;
 				}
 			}
 		}
 
-		return { ...args.result };
+		return args.result;
 	};
 }

package/src/write-validation-plugin.ts

@@ -0,0 +1,137 @@
+import { type, type Type } from "arktype";
+import {
+	type KyselyPlugin,
+	type RootOperationNode,
+	ColumnNode,
+	DefaultInsertValueNode,
+	TableNode,
+	ValueNode,
+	ValuesNode,
+} from "kysely";
+
+import type { ColumnsMap } from "./plugin.js";
+import { JsonValidationError } from "./validation-error.js";
+
+export class WriteValidationPlugin implements KyselyPlugin {
+	constructor(
+		private columns: ColumnsMap,
+		private validation: { onWrite: boolean },
+	) {}
+
+	transformQuery: KyselyPlugin["transformQuery"] = (args) => {
+		if (this.validation.onWrite) {
+			this.validateWriteNode(args.node);
+		}
+
+		return args.node;
+	};
+
+	transformResult: KyselyPlugin["transformResult"] = async (args) => {
+		return args.result;
+	};
+
+	private getTableFromNode(node: RootOperationNode) {
+		switch (node.kind) {
+			case "InsertQueryNode":
+				return node.into?.table.identifier.name ?? null;
+
+			case "UpdateQueryNode": {
+				if (node.table && TableNode.is(node.table)) {
+					return node.table.table.identifier.name;
+				}
+
+				return null;
+			}
+
+			default:
+				return null;
+		}
+	}
+
+	private validateJsonValue(table: string, col: string, value: unknown, schema: Type) {
+		if (value === null || value === undefined) {
+			return;
+		}
+
+		const result = schema(value);
+
+		if (result instanceof type.errors) {
+			throw new JsonValidationError(table, col, result.summary);
+		}
+	}
+
+	private validateWriteNode(node: RootOperationNode) {
+		if (node.kind !== "InsertQueryNode" && node.kind !== "UpdateQueryNode") {
+			return;
+		}
+
+		const table = this.getTableFromNode(node);
+
+		if (!table) {
+			return;
+		}
+
+		const cols = this.columns.get(table);
+
+		if (!cols) {
+			return;
+		}
+
+		for (const [col, value] of this.writeValues(node)) {
+			const coercion = cols.get(col);
+
+			if (!coercion || typeof coercion === "string") {
+				continue;
+			}
+
+			this.validateJsonValue(table, col, value, coercion.schema);
+		}
+	}
+
+	private *writeValues(node: RootOperationNode) {
+		if (node.kind === "InsertQueryNode") {
+			const columns = node.columns?.map((column) => column.column.name);
+
+			if (!columns || !node.values || !ValuesNode.is(node.values)) {
+				return;
+			}
+
+			for (const valueList of node.values.values) {
+				for (let i = 0; i < columns.length; i++) {
+					const col = columns[i]!;
+
+					if (valueList.kind === "PrimitiveValueListNode") {
+						yield [col, valueList.values[i]] as [string, unknown];
+						continue;
+					}
+
+					const raw = valueList.values[i];
+
+					if (!raw || DefaultInsertValueNode.is(raw)) {
+						continue;
+					}
+
+					yield [col, ValueNode.is(raw) ? raw.value : raw] as [string, unknown];
+				}
+			}
+
+			for (const update of node.onConflict?.updates ?? []) {
+				if (ColumnNode.is(update.column) && ValueNode.is(update.value)) {
+					yield [update.column.column.name, update.value.value] as [string, unknown];
+				}
+			}
+
+			return;
+		}
+
+		if (node.kind !== "UpdateQueryNode" || !node.updates) {
+			return;
+		}
+
+		for (const update of node.updates) {
+			if (ColumnNode.is(update.column) && ValueNode.is(update.value)) {
+				yield [update.column.column.name, update.value.value] as [string, unknown];
+			}
+		}
+	}
+}