@lobomfz/db 0.1.0 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # @lobomfz/db
 
-SQLite database with Arktype schemas and typed Kysely client.
+SQLite database with Arktype schemas and typed Kysely client for Bun.
 
 ## Install
 
@@ -11,58 +11,71 @@ bun add @lobomfz/db arktype kysely
 ## Usage
 
 ```typescript
-import { type } from "arktype";
-import { Database, autoIncrement } from "@lobomfz/db";
+import { Database, generated, type } from "@lobomfz/db";
 
 const db = new Database({
   path: "data.db",
-  tables: {
-    users: type({
-      id: autoIncrement(),
-      name: "string",
-      email: type("string").configure({ unique: true }),
-      "bio?": "string",
-    }),
-    posts: type({
-      id: autoIncrement(),
-      user_id: type("number.integer").configure({ references: "users.id", onDelete: "cascade" }),
-      title: "string",
-      tags: "string[]",
-    }),
+  schema: {
+    tables: {
+      users: type({
+        id: generated("autoincrement"),
+        name: "string",
+        email: type("string").configure({ unique: true }),
+        "bio?": "string",                    // optional → nullable in SQLite
+        active: type("boolean").default(true),
+        created_at: generated("now"),          // defaults to current time
+      }),
+      posts: type({
+        id: generated("autoincrement"),
+        user_id: type("number.integer").configure({ references: "users.id", onDelete: "cascade" }),
+        title: "string",
+        published_at: "Date",                   // native Date support
+        tags: "string[]",                      // JSON columns just work
+        metadata: type({ source: "string", "priority?": "number" }), // validated on write by default
+        status: type.enumerated("draft", "published").default("draft"),
+      }),
+    },
+    indexes: {
+      posts: [{ columns: ["user_id", "status"] }, { columns: ["title"], unique: true }],
+    },
+  },
+  pragmas: {
+    journal_mode: "wal",
+    synchronous: "normal",
   },
 });
 
-// Fully typed Kysely client
+// Fully typed Kysely client — generated/default fields are optional on insert
 await db.kysely.insertInto("users").values({ name: "John", email: "john@example.com" }).execute();
 
 const users = await db.kysely.selectFrom("users").selectAll().execute();
+// users[0].active     → true
+// users[0].created_at → Date
 ```
 
-## Features
-
-- Tables auto-created from Arktype schemas
-- Full TypeScript inference
-- JSON columns with validation
-- Foreign keys, unique constraints, defaults
-- `autoIncrement()` for primary keys
+Booleans, dates, objects, arrays — everything round-trips as the type you declared. The schema is the source of truth for table creation, TypeScript types, and runtime coercion.
 
-## Column Configuration
+## API
 
 ```typescript
-type("string").configure({ unique: true })
-type("string").configure({ default: "pending" })
-type("number.integer").configure({ default: "now" }) // Unix timestamp
-type("number.integer").configure({ references: "users.id", onDelete: "cascade" })
+generated("autoincrement");                                               // auto-incrementing primary key
+generated("now");                                                         // defaults to current timestamp, returned as Date
+type("string").default("pending");                                        // SQL DEFAULT
+type("string").configure({ unique: true });                               // UNIQUE
+type("number.integer").configure({ references: "users.id", onDelete: "cascade" }); // FK
 ```
 
-`onDelete` options: `"cascade"`, `"set null"`, `"restrict"`
-
-## Errors
+JSON columns are validated against the schema on write by default. To also validate on read, or to disable write validation:
 
 ```typescript
-import { JsonParseError, JsonValidationError } from "@lobomfz/db";
+new Database({
+  // ...
+  validation: { onRead: true },  // default: { onRead: false, onWrite: true }
+});
 ```
 
+> **Note:** Migrations are not supported yet. Tables are created with `CREATE TABLE IF NOT EXISTS`.
+
 ## License
 
 MIT

package/package.json

@@ -1,23 +1,23 @@
 {
 	"name": "@lobomfz/db",
-	"version": "0.1.0",
-	"description": "SQLite database with Arktype schemas and typed Kysely client",
-	"license": "MIT",
-	"author": "lobomfz",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/lobomfz/db.git"
-	},
+	"version": "0.2.1",
+	"description": "Bun SQLite database with Arktype schemas and typed Kysely client",
 	"keywords": [
-		"sqlite",
-		"database",
 		"arktype",
-		"kysely",
-		"typescript",
 		"bun",
+		"database",
+		"kysely",
 		"schema",
+		"sqlite",
+		"typescript",
 		"validation"
 	],
+	"license": "MIT",
+	"author": "lobomfz",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/lobomfz/db.git"
+	},
 	"files": [
 		"src"
 	],
@@ -25,26 +25,20 @@
 	"main": "src/index.ts",
 	"types": "src/index.ts",
 	"exports": {
-		".": {
-			"types": "./src/index.ts",
-			"import": "./src/index.ts"
-		}
+		".": "./src/index.ts"
 	},
 	"scripts": {
-		"check": "tsc"
-	},
-	"dependencies": {
-		"@lobomfz/kysely-bun-sqlite": "^0.4.1"
+		"check": "tsgo && oxlint"
 	},
+	"dependencies": {},
 	"devDependencies": {
-		"@types/bun": "latest",
-		"arktype": "^2.1.29",
-		"oxfmt": "^0.26.0",
-		"oxlint": "^1.41.0"
+		"@types/bun": "^1.3.11",
+		"@typescript/native-preview": "^7.0.0-dev.20260324.1",
+		"oxfmt": "^0.42.0",
+		"oxlint": "^1.57.0"
 	},
 	"peerDependencies": {
-		"arktype": "^2.1.0",
-		"kysely": "^0.27.0",
-		"typescript": "^5"
+		"arktype": "^2.1.29",
+		"kysely": "^0.28.14"
 	}
 }

package/src/database.ts

@@ -1,36 +1,50 @@
 import { Database as BunDatabase } from "bun:sqlite";
 import { Kysely } from "kysely";
-import { BunSqliteDialect } from "@lobomfz/kysely-bun-sqlite";
+import { BunSqliteDialect } from "./dialect/dialect";
 import type { Type } from "arktype";
+import type { GeneratedPreset } from "./generated";
 import type { DbFieldMeta } from "./env";
-import { JsonPlugin, type JsonColumnsMap } from "./plugin";
-import type { DatabaseOptions, SchemaRecord, TablesFromSchemas } from "./types";
-
-type PropValue =
-	| string
-	| { unit: unknown }[]
-	| {
-			domain?: string | { domain: string };
-			divisor?: { rule: number };
-			meta?: DbFieldMeta;
-			proto?: string;
-			sequence?: unknown;
-			required?: RawProp[];
-			optional?: RawProp[];
-	  };
-
-type RawProp = { key: string; value: PropValue };
-type InnerJson = { required?: RawProp[]; optional?: RawProp[] };
+import { DeserializePlugin, type ColumnCoercion, type ColumnsMap } from "./plugin";
+import type {
+	DatabaseOptions,
+	IndexDefinition,
+	SchemaRecord,
+	TablesFromSchemas,
+	DatabasePragmas,
+} from "./types";
+
+type ArkBranch = {
+	domain?: string;
+	proto?: unknown;
+	unit?: unknown;
+	structure?: unknown;
+	inner?: { divisor?: unknown };
+};
+
+type StructureProp = {
+	key: string;
+	required: boolean;
+	value: Type & {
+		branches: ArkBranch[];
+		proto?: unknown;
+		meta: DbFieldMeta & { _generated?: GeneratedPreset };
+	};
+	inner: { default?: unknown };
+};
 
 type Prop = {
 	key: string;
 	kind: "required" | "optional";
 	domain?: string;
+	nullable?: boolean;
 	isBoolean?: boolean;
 	isInteger?: boolean;
+	isDate?: boolean;
 	isJson?: boolean;
 	jsonSchema?: Type;
 	meta?: DbFieldMeta;
+	generated?: GeneratedPreset;
+	defaultValue?: unknown;
 };
 
 const typeMap: Record<string, string> = {
@@ -38,10 +52,14 @@ const typeMap: Record<string, string> = {
 	number: "REAL",
 };
 
+const defaultPragmas: DatabasePragmas = {
+	foreign_keys: true,
+};
+
 export class Database<T extends SchemaRecord> {
 	private sqlite: BunDatabase;
 
-	private jsonColumns: JsonColumnsMap = new Map();
+	private columns: ColumnsMap = new Map();
 
 	readonly infer: TablesFromSchemas<T> = undefined as any;
 
@@ -50,153 +68,203 @@ export class Database<T extends SchemaRecord> {
 	constructor(private options: DatabaseOptions<T>) {
 		this.sqlite = new BunDatabase(options.path);
 
-		this.sqlite.run("PRAGMA foreign_keys = ON");
+		this.applyPragmas();
 
 		this.createTables();
 
+		const validation = {
+			onRead: options.validation?.onRead ?? false,
+			onWrite: options.validation?.onWrite ?? true,
+		};
+
 		this.kysely = new Kysely<TablesFromSchemas<T>>({
 			dialect: new BunSqliteDialect({ database: this.sqlite }),
-			plugins: [new JsonPlugin(this.jsonColumns)],
+			plugins: [new DeserializePlugin(this.columns, validation)],
 		});
 	}
 
-	private isJsonValue(value: PropValue): boolean {
-		if (typeof value === "string" || Array.isArray(value)) return false;
+	private applyPragmas() {
+		const pragmas = { ...defaultPragmas, ...this.options.pragmas };
 
-		if (value.proto === "Array") return true;
-		if (value.domain === "object" && (value.required || value.optional)) return true;
+		if (pragmas.journal_mode) {
+			this.sqlite.run(`PRAGMA journal_mode = ${pragmas.journal_mode.toUpperCase()}`);
+		}
 
-		return false;
-	}
+		if (pragmas.synchronous) {
+			this.sqlite.run(`PRAGMA synchronous = ${pragmas.synchronous.toUpperCase()}`);
+		}
 
-	private normalizeProp(raw: RawProp, kind: "required" | "optional", parentSchema: Type): Prop {
-		const { key, value } = raw;
+		this.sqlite.run(`PRAGMA foreign_keys = ${pragmas.foreign_keys ? "ON" : "OFF"}`);
 
-		if (typeof value === "string") {
-			return { key, kind, domain: value };
+		if (pragmas.busy_timeout_ms !== undefined) {
+			this.sqlite.run(`PRAGMA busy_timeout = ${pragmas.busy_timeout_ms}`);
 		}
+	}
 
-		if (Array.isArray(value)) {
-			let hasTrue = false;
-			let hasFalse = false;
+	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;
 
-			for (const u of value) {
-				if (u.unit === true) hasTrue = true;
-				if (u.unit === false) hasFalse = true;
-			}
+		const nonNull = v.branches.filter((b) => b.unit !== null);
+		const nullable = nonNull.length < v.branches.length;
 
-			const isBool = value.length === 2 && hasTrue && hasFalse;
+		if (v.proto === Date || nonNull.some((b) => b.proto === Date)) {
+			return { key, kind, nullable, isDate: true, generated, defaultValue };
+		}
 
-			return { key, kind, isBoolean: isBool };
+		if (nonNull.length > 0 && nonNull.every((b) => b.domain === "boolean")) {
+			return { key, kind, nullable, isBoolean: true, generated, defaultValue };
 		}
 
-		if (this.isJsonValue(value)) {
+		if (nonNull.some((b) => !!b.structure)) {
 			return {
 				key,
 				kind,
+				nullable,
 				isJson: true,
 				jsonSchema: (parentSchema as any).get(key) as Type,
-				meta: value.meta,
+				meta: v.meta,
+				generated,
+				defaultValue,
 			};
 		}
 
-		const domain = typeof value.domain === "string" ? value.domain : value.domain?.domain;
+		const branch = nonNull[0];
 
 		return {
 			key,
 			kind,
-			domain,
-			isInteger: value.divisor?.rule === 1,
-			meta: value.meta,
+			nullable,
+			domain: branch?.domain,
+			isInteger: !!branch?.inner?.divisor,
+			meta: v.meta,
+			generated,
+			defaultValue,
 		};
 	}
 
 	private sqlType(prop: Prop) {
-		if (prop.isJson) return "TEXT";
-		if (prop.isBoolean || prop.isInteger) return "INTEGER";
-		if (prop.domain && typeMap[prop.domain]) return typeMap[prop.domain];
+		if (prop.isJson) {
+			return "TEXT";
+		}
+
+		if (prop.isDate || prop.isBoolean || prop.isInteger) {
+			return "INTEGER";
+		}
+
+		if (prop.domain) {
+			return typeMap[prop.domain] ?? "TEXT";
+		}
+
 		return "TEXT";
 	}
 
-	private columnDef(prop: Prop) {
-		const parts = [`"${prop.key}"`, this.sqlType(prop)];
-		const meta = prop.meta;
+	private columnConstraint(prop: Prop) {
+		if (prop.generated === "autoincrement") {
+			return "PRIMARY KEY AUTOINCREMENT";
+		}
 
-		if (meta?.primaryKey) {
-			parts.push("PRIMARY KEY");
-			if ((meta as any)._autoincrement) parts.push("AUTOINCREMENT");
-		} else if (prop.kind === "required") {
-			parts.push("NOT NULL");
+		if (prop.meta?.primaryKey) {
+			return "PRIMARY KEY";
 		}
 
-		if (meta?.unique) parts.push("UNIQUE");
+		if (prop.kind === "required" && !prop.nullable) {
+			return "NOT NULL";
+		}
 
-		if (meta?.default !== undefined) {
-			let val: string | number | boolean;
+		return null;
+	}
 
-			if (meta.default === "now") {
-				val = "(unixepoch())";
-			} else if (typeof meta.default === "string") {
-				val = `'${meta.default}'`;
-			} else {
-				val = meta.default;
-			}
+	private defaultClause(prop: Prop) {
+		if (prop.generated === "now") {
+			return "DEFAULT (unixepoch())";
+		}
+
+		if (prop.defaultValue === undefined || prop.generated === "autoincrement") {
+			return null;
+		}
+
+		if (prop.defaultValue === null) {
+			return "DEFAULT NULL";
+		}
+
+		if (typeof prop.defaultValue === "string") {
+			return `DEFAULT '${prop.defaultValue}'`;
+		}
 
-			parts.push(`DEFAULT ${val}`);
+		if (typeof prop.defaultValue === "number" || typeof prop.defaultValue === "boolean") {
+			return `DEFAULT ${prop.defaultValue}`;
 		}
 
-		return parts.join(" ");
+		throw new Error(`Unsupported default value type: ${typeof prop.defaultValue}`);
+	}
+
+	private columnDef(prop: Prop) {
+		return [
+			`"${prop.key}"`,
+			this.sqlType(prop),
+			this.columnConstraint(prop),
+			prop.meta?.unique ? "UNIQUE" : null,
+			this.defaultClause(prop),
+		]
+			.filter(Boolean)
+			.join(" ");
 	}
 
 	private foreignKey(prop: Prop) {
 		const ref = prop.meta?.references;
-		if (!ref) return null;
+
+		if (!ref) {
+			return null;
+		}
 
 		const [table, column] = ref.split(".");
+
 		let fk = `FOREIGN KEY ("${prop.key}") REFERENCES "${table}"("${column}")`;
 
-		switch (prop.meta?.onDelete) {
-			case "cascade":
-				fk += " ON DELETE CASCADE";
-				break;
-			case "set null":
-				fk += " ON DELETE SET NULL";
-				break;
-			case "restrict":
-				fk += " ON DELETE RESTRICT";
-				break;
+		const onDelete = prop.meta?.onDelete;
+
+		if (onDelete) {
+			fk += ` ON DELETE ${onDelete.toUpperCase()}`;
 		}
 
 		return fk;
 	}
 
 	private parseSchemaProps(schema: Type) {
-		const { required = [], optional = [] } = (schema as any).innerJson as InnerJson;
-		const props: Prop[] = [];
-
-		for (const r of required) {
-			props.push(this.normalizeProp(r, "required", schema));
-		}
+		const structureProps = (schema as any).structure?.props as StructureProp[] | undefined;
 
-		for (const r of optional) {
-			props.push(this.normalizeProp(r, "optional", schema));
+		if (!structureProps) {
+			return [];
 		}
 
-		return props;
+		return structureProps.map((p) => this.normalizeProp(p, schema));
 	}
 
-	private registerJsonColumns(tableName: string, props: Prop[]) {
-		const tableJsonCols = new Map<string, { schema: Type }>();
+	private registerColumns(tableName: string, props: Prop[]) {
+		const colMap = new Map<string, ColumnCoercion>();
 
 		for (const prop of props) {
-			if (!prop.isJson || !prop.jsonSchema) continue;
+			if (prop.isBoolean) {
+				colMap.set(prop.key, "boolean");
+				continue;
+			}
 
-			tableJsonCols.set(prop.key, { schema: prop.jsonSchema });
-		}
+			if (prop.isDate) {
+				colMap.set(prop.key, "date");
+				continue;
+			}
 
-		if (tableJsonCols.size === 0) return;
+			if (prop.isJson && prop.jsonSchema) {
+				colMap.set(prop.key, { type: "json", schema: prop.jsonSchema });
+			}
+		}
 
-		this.jsonColumns.set(tableName, tableJsonCols);
+		if (colMap.size > 0) {
+			this.columns.set(tableName, colMap);
+		}
 	}
 
 	private generateCreateTableSQL(tableName: string, props: Prop[]) {
@@ -207,29 +275,64 @@ export class Database<T extends SchemaRecord> {
 			columns.push(this.columnDef(prop));
 
 			const fk = this.foreignKey(prop);
-			if (fk) fks.push(fk);
+
+			if (fk) {
+				fks.push(fk);
+			}
 		}
 
 		return `CREATE TABLE IF NOT EXISTS "${tableName}" (${columns.concat(fks).join(", ")})`;
 	}
 
 	private createTables() {
-		for (const [name, schema] of Object.entries(this.options.tables)) {
+		for (const [name, schema] of Object.entries(this.options.schema.tables)) {
 			const props = this.parseSchemaProps(schema);
 
-			this.registerJsonColumns(name, props);
+			this.registerColumns(name, props);
 			this.sqlite.run(this.generateCreateTableSQL(name, props));
 		}
+
+		this.createIndexes();
+	}
+
+	private generateIndexName(tableName: string, columns: string[], unique: boolean) {
+		const prefix = unique ? "ux" : "ix";
+
+		return `${prefix}_${tableName}_${columns.join("_")}`;
+	}
+
+	private generateCreateIndexSQL(tableName: string, indexDef: IndexDefinition) {
+		const indexName = this.generateIndexName(tableName, indexDef.columns, indexDef.unique ?? false);
+		const unique = indexDef.unique ? "UNIQUE " : "";
+		const columns = indexDef.columns.map((c) => `"${c}"`).join(", ");
+
+		return `CREATE ${unique}INDEX IF NOT EXISTS "${indexName}" ON "${tableName}" (${columns})`;
+	}
+
+	private createIndexes() {
+		const indexes = this.options.schema.indexes;
+
+		if (!indexes) {
+			return;
+		}
+
+		for (const [tableName, tableIndexes] of Object.entries(indexes)) {
+			if (!tableIndexes) {
+				continue;
+			}
+
+			for (const indexDef of tableIndexes) {
+				this.sqlite.run(this.generateCreateIndexSQL(tableName, indexDef));
+			}
+		}
 	}
 
-	reset(table?: keyof T & string) {
-		const tables = table ? [table] : Object.keys(this.options.tables);
+	reset(table?: keyof T & string): void {
+		const tables = table ? [table] : Object.keys(this.options.schema.tables);
+
 		for (const t of tables) {
 			this.sqlite.run(`DELETE FROM "${t}"`);
 		}
 	}
 
-	close() {
-		this.sqlite.close();
-	}
 }

package/src/dialect/config.ts

@@ -0,0 +1,7 @@
+import type { Database } from "bun:sqlite";
+import type { DatabaseConnection } from "kysely";
+
+export interface BunSqliteDialectConfig {
+	database: Database;
+	onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+}

package/src/dialect/connection.ts

@@ -0,0 +1,41 @@
+import type { Database } from "bun:sqlite";
+import type { CompiledQuery, DatabaseConnection, QueryResult } from "kysely";
+import { serializeParam } from "./serialize";
+
+export class BunSqliteConnection implements DatabaseConnection {
+	readonly #db: Database;
+
+	constructor(db: Database) {
+		this.#db = db;
+	}
+
+	async executeQuery<O>(compiled: CompiledQuery): Promise<QueryResult<O>> {
+		const serializedParams = compiled.parameters.map(serializeParam);
+
+		const stmt = this.#db.query(compiled.sql);
+
+		if (stmt.columnNames.length > 0) {
+			return {
+				rows: stmt.all(serializedParams as any) as O[],
+			};
+		}
+
+		const results = stmt.run(serializedParams as any);
+
+		return {
+			insertId: BigInt(results.lastInsertRowid),
+			numAffectedRows: BigInt(results.changes),
+			rows: [],
+		};
+	}
+
+	async *streamQuery<R>(compiledQuery: CompiledQuery): AsyncIterableIterator<QueryResult<R>> {
+		const serializedParams = compiledQuery.parameters.map(serializeParam);
+
+		const stmt = this.#db.prepare(compiledQuery.sql);
+
+		for await (const row of stmt.iterate(serializedParams as any)) {
+			yield { rows: [row as R] };
+		}
+	}
+}

package/src/dialect/dialect.ts

@@ -0,0 +1,37 @@
+import {
+	SqliteAdapter,
+	SqliteIntrospector,
+	SqliteQueryCompiler,
+	type DatabaseIntrospector,
+	type Dialect,
+	type DialectAdapter,
+	type Driver,
+	type Kysely,
+	type QueryCompiler,
+} from "kysely";
+import type { BunSqliteDialectConfig } from "./config";
+import { BunSqliteDriver } from "./driver";
+
+export class BunSqliteDialect implements Dialect {
+	readonly #config: BunSqliteDialectConfig;
+
+	constructor(config: BunSqliteDialectConfig) {
+		this.#config = { ...config };
+	}
+
+	createDriver(): Driver {
+		return new BunSqliteDriver(this.#config);
+	}
+
+	createQueryCompiler(): QueryCompiler {
+		return new SqliteQueryCompiler();
+	}
+
+	createAdapter(): DialectAdapter {
+		return new SqliteAdapter();
+	}
+
+	createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+		return new SqliteIntrospector(db);
+	}
+}

package/src/dialect/driver.ts

@@ -0,0 +1,48 @@
+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";
+
+export class BunSqliteDriver implements Driver {
+	readonly #config: BunSqliteDialectConfig;
+	readonly #connectionMutex = new ConnectionMutex();
+
+	#db?: Database;
+	#connection?: DatabaseConnection;
+
+	constructor(config: BunSqliteDialectConfig) {
+		this.#config = { ...config };
+	}
+
+	async init(): Promise<void> {
+		this.#db = this.#config.database;
+		this.#connection = new BunSqliteConnection(this.#db);
+		await this.#config.onCreateConnection?.(this.#connection);
+	}
+
+	async acquireConnection(): Promise<DatabaseConnection> {
+		await this.#connectionMutex.lock();
+		return this.#connection!;
+	}
+
+	async beginTransaction(connection: DatabaseConnection): Promise<void> {
+		await connection.executeQuery(CompiledQuery.raw("begin"));
+	}
+
+	async commitTransaction(connection: DatabaseConnection): Promise<void> {
+		await connection.executeQuery(CompiledQuery.raw("commit"));
+	}
+
+	async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+		await connection.executeQuery(CompiledQuery.raw("rollback"));
+	}
+
+	async releaseConnection(): Promise<void> {
+		this.#connectionMutex.unlock();
+	}
+
+	async destroy(): Promise<void> {
+		this.#db?.close();
+	}
+}

package/src/dialect/mutex.ts

@@ -0,0 +1,23 @@
+export class ConnectionMutex {
+	#promise?: Promise<void>;
+	#resolve?: () => void;
+
+	async lock(): Promise<void> {
+		while (this.#promise) {
+			await this.#promise;
+		}
+
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+
+	unlock(): void {
+		const resolve = this.#resolve;
+
+		this.#promise = undefined;
+		this.#resolve = undefined;
+
+		resolve?.();
+	}
+}

package/src/dialect/serialize.ts

@@ -0,0 +1,11 @@
+export function serializeParam(p: unknown): unknown {
+	if (p instanceof Date) {
+		return Math.floor(p.getTime() / 1000);
+	}
+
+	if (typeof p === "object" && p !== null && !ArrayBuffer.isView(p)) {
+		return JSON.stringify(p);
+	}
+
+	return p;
+}

package/src/env.ts

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

package/src/generated.ts

@@ -0,0 +1,18 @@
+import { type } from "arktype";
+
+export type GeneratedPreset = "autoincrement" | "now";
+
+const generatedTypes = {
+	autoincrement: () =>
+		type("number.integer")
+			.configure({ _generated: "autoincrement" } as any)
+			.default(0),
+	now: () =>
+		type("Date")
+			.configure({ _generated: "now" } as any)
+			.default(() => new Date(0)),
+};
+
+export function generated<P extends GeneratedPreset>(preset: P): ReturnType<(typeof generatedTypes)[P]> {
+	return generatedTypes[preset]() as ReturnType<(typeof generatedTypes)[P]>;
+}

package/src/index.ts

@@ -1,6 +1,19 @@
-export { Database } from "./database.ts";
-export { autoIncrement } from "./autoincrement.ts";
-export { JsonParseError } from "./errors.ts";
-export { JsonValidationError } from "./validation-error.ts";
-export type { DbFieldMeta } from "./env.ts";
-export type { DatabaseOptions, SchemaRecord, TablesFromSchemas, InferTableType } from "./types.ts";
+export { Database } from "./database";
+export { generated, type GeneratedPreset } from "./generated";
+export { JsonParseError } from "./errors";
+export { sql, type Selectable, type Insertable, type Updateable } from "kysely";
+export { type } from "arktype";
+export { JsonValidationError } from "./validation-error";
+export type { DbFieldMeta } from "./env";
+export type {
+	DatabaseOptions,
+	SchemaRecord,
+	TablesFromSchemas,
+	InferTableType,
+	IndexDefinition,
+	IndexesConfig,
+	DatabasePragmas,
+	DatabaseSchema,
+	JsonValidation,
+	SqliteMasterRow,
+} from "./types";

package/src/plugin.ts

@@ -1,82 +1,221 @@
 import {
 	type KyselyPlugin,
-	type PluginTransformQueryArgs,
-	type PluginTransformResultArgs,
-	type QueryResult,
 	type RootOperationNode,
 	type UnknownRow,
+	type QueryId,
+	TableNode,
+	AliasNode,
+	ValuesNode,
+	ValueNode,
+	ColumnNode,
 } from "kysely";
 import { type } from "arktype";
 import type { Type } from "arktype";
-import { JsonSerializer } from "./serializer";
 import { JsonParseError } from "./errors";
 import { JsonValidationError } from "./validation-error";
+import type { JsonValidation } from "./types";
 
-export type JsonColumnInfo = { schema: Type };
-export type JsonColumnsMap = Map<string, Map<string, JsonColumnInfo>>;
+export type ColumnCoercion = "boolean" | "date" | { type: "json"; schema: Type };
+export type ColumnsMap = Map<string, Map<string, ColumnCoercion>>;
 
-export class JsonPlugin implements KyselyPlugin {
-	private serializer = new JsonSerializer();
-	private queryNodes = new Map<unknown, RootOperationNode>();
+export class DeserializePlugin implements KyselyPlugin {
+	private queryNodes = new WeakMap<QueryId, RootOperationNode>();
 
-	constructor(private jsonColumns: JsonColumnsMap) {}
+	constructor(
+		private columns: ColumnsMap,
+		private validation: Required<JsonValidation>,
+	) {}
 
-	transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+	transformQuery: KyselyPlugin["transformQuery"] = (args) => {
 		this.queryNodes.set(args.queryId, args.node);
-		return this.serializer.transformNode(args.node);
-	}
 
-	private getTableFromNode(node: RootOperationNode): string | null {
+		if (this.validation.onWrite) {
+			this.validateWriteNode(args.node);
+		}
+
+		return args.node;
+	};
+
+	private getTableFromNode(node: RootOperationNode) {
 		switch (node.kind) {
 			case "InsertQueryNode":
-			case "UpdateQueryNode":
-				return (node as any).table?.table?.identifier?.name ?? null;
+				return node.into?.table.identifier.name ?? null;
+
+			case "UpdateQueryNode": {
+				if (node.table && TableNode.is(node.table)) {
+					return node.table.table.identifier.name;
+				}
+
+				return null;
+			}
 
 			case "SelectQueryNode":
-			case "DeleteQueryNode":
-				return (node as any).from?.froms?.[0]?.table?.identifier?.name ?? null;
+			case "DeleteQueryNode": {
+				const fromNode = node.from?.froms[0];
+
+				if (!fromNode) {
+					return null;
+				}
+
+				if (AliasNode.is(fromNode) && TableNode.is(fromNode.node)) {
+					return fromNode.node.table.identifier.name;
+				}
+
+				if (TableNode.is(fromNode)) {
+					return fromNode.table.identifier.name;
+				}
+
+				return null;
+			}
 
 			default:
 				return null;
 		}
 	}
 
-	// oxlint-disable-next-line require-await
-	async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
-		const node = this.queryNodes.get(args.queryId);
-		this.queryNodes.delete(args.queryId);
+	private validateJsonValue(table: string, col: string, value: unknown, schema: Type) {
+		if (value === null || value === undefined) {
+			return;
+		}
 
-		if (!node) return args.result;
+		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 args.result;
+		if (!table) {
+			return;
+		}
 
-		const columns = this.jsonColumns.get(table);
+		const cols = this.columns.get(table);
 
-		if (!columns) return args.result;
+		if (!cols) {
+			return;
+		}
 
-		for (const row of args.result.rows) {
-			for (const [col, info] of columns.entries()) {
-				if (!(col in row) || typeof row[col] !== "string") continue;
+		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((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]!;
+
+					if (valueList.kind === "PrimitiveValueListNode") {
+						yield [col, valueList.values[i]] as [string, unknown];
+						continue;
+					}
+
+					const raw = valueList.values[i];
+					yield [col, raw && ValueNode.is(raw) ? raw.value : raw] 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];
+			}
+		}
+	}
 
-				const value = row[col] as string;
+	private coerceRow(table: string, row: UnknownRow, cols: Map<string, ColumnCoercion>) {
+		for (const [col, coercion] of cols) {
+			if (!(col in row)) {
+				continue;
+			}
 
-				let parsed: unknown;
-				try {
-					parsed = JSON.parse(value);
-				} catch (e) {
-					throw new JsonParseError(table, col, value, e);
+			if (coercion === "boolean") {
+				if (typeof row[col] === "number") {
+					row[col] = row[col] === 1;
 				}
 
-				const validated = info.schema(parsed);
-				if (validated instanceof type.errors) {
-					throw new JsonValidationError(table, col, validated.summary);
+				continue;
+			}
+
+			if (coercion === "date") {
+				if (typeof row[col] === "number") {
+					row[col] = new Date(row[col] * 1000);
 				}
-				row[col] = validated;
+
+				continue;
+			}
+
+			if (typeof row[col] !== "string") {
+				continue;
+			}
+
+			const value = row[col];
+
+			let parsed: unknown;
+
+			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;
+		}
+	}
+
+	transformResult: KyselyPlugin["transformResult"] = async (args) => {
+		const node = this.queryNodes.get(args.queryId);
+
+		if (!node) {
+			return args.result;
+		}
+
+		const table = this.getTableFromNode(node);
+
+		if (!table) {
+			return args.result;
+		}
+
+		const cols = this.columns.get(table);
+
+		if (!cols) {
+			return args.result;
+		}
+
+		for (const row of args.result.rows) {
+			this.coerceRow(table, row, cols);
 		}
 
 		return { ...args.result };
-	}
+	};
 }

package/src/types.ts

@@ -1,34 +1,71 @@
 import type { Generated } from "kysely";
 import type { Type } from "arktype";
-import type { AutoIncrementNumber } from "./autoincrement";
 
-type NullableIf<T, Condition> = Condition extends true ? T | null : T;
+type ExtractInput<T> = T extends { inferIn: infer I } ? I : never;
+type ExtractOutput<T> = T extends { infer: infer O } ? O : never;
 
 type IsOptional<T, K extends keyof T> = undefined extends T[K] ? true : false;
 
-type TransformColumn<T> = T extends AutoIncrementNumber
-	? Generated<number>
-	: T extends boolean
-		? number
-		: T extends (infer U)[]
-			? U[]
-			: T extends object
-				? T
-				: T;
+type TransformColumn<T> = T extends (infer U)[] ? U[] : T;
 
-type TransformTable<T> = {
-	[K in keyof T]: NullableIf<TransformColumn<NonNullable<T[K]>>, IsOptional<T, K>>;
+type TransformField<TOutput, TInput, K extends keyof TOutput & keyof TInput> =
+	IsOptional<TInput, K> extends true
+		? IsOptional<TOutput, K> extends true
+			? TransformColumn<NonNullable<TOutput[K]>> | null
+			: Generated<TransformColumn<NonNullable<TOutput[K]>>>
+		: TransformColumn<TOutput[K]>;
+
+type TransformTable<TOutput, TInput> = {
+	[K in keyof TOutput & keyof TInput]: TransformField<TOutput, TInput, K>;
 };
 
 export type SchemaRecord = Record<string, Type>;
 
-export type InferTableType<T> = T extends Type<infer Output> ? TransformTable<Output> : never;
+export type InferTableType<T> = TransformTable<ExtractOutput<T>, ExtractInput<T>>;
+
+export type SqliteMasterRow = {
+	type: "table" | "index" | "view" | "trigger";
+	name: string;
+	tbl_name: string;
+	rootpage: number;
+	sql: string | null;
+};
 
 export type TablesFromSchemas<T extends SchemaRecord> = {
 	[K in keyof T]: InferTableType<T[K]>;
+} & { sqlite_master: SqliteMasterRow };
+
+type TableColumns<T extends SchemaRecord, K extends keyof T> = keyof ExtractOutput<T[K]> & string;
+
+export type IndexDefinition<Columns extends string = string> = {
+	columns: Columns[];
+	unique?: boolean;
+};
+
+export type IndexesConfig<T extends SchemaRecord> = {
+	[K in keyof T]?: IndexDefinition<TableColumns<T, K>>[];
+};
+
+export type DatabasePragmas = {
+	journal_mode?: "delete" | "truncate" | "persist" | "memory" | "wal" | "off";
+	synchronous?: "off" | "normal" | "full" | "extra";
+	foreign_keys?: boolean;
+	busy_timeout_ms?: number;
+};
+
+export type DatabaseSchema<T extends SchemaRecord> = {
+	tables: T;
+	indexes?: IndexesConfig<T>;
+};
+
+export type JsonValidation = {
+	onRead?: boolean;
+	onWrite?: boolean;
 };
 
 export type DatabaseOptions<T extends SchemaRecord> = {
 	path: string;
-	tables: T;
+	schema: DatabaseSchema<T>;
+	pragmas?: DatabasePragmas;
+	validation?: JsonValidation;
 };

package/src/validation-error.ts

@@ -1,13 +1,11 @@
 export class JsonValidationError extends Error {
-	readonly table: string;
-	readonly column: string;
-	readonly summary: string;
-
-	constructor(table: string, column: string, summary: string) {
+	constructor(
+		readonly table: string,
+		readonly column: string,
+		readonly summary: string,
+	) {
 		super(`JSON validation failed for ${table}.${column}: ${summary}`);
+
 		this.name = "JsonValidationError";
-		this.table = table;
-		this.column = column;
-		this.summary = summary;
 	}
 }

package/src/autoincrement.ts

@@ -1,14 +0,0 @@
-import { type, Type } from "arktype";
-
-declare const AutoIncrementBrand: unique symbol;
-
-export type AutoIncrementNumber = number & { [AutoIncrementBrand]: true };
-
-export type AutoIncrementType = Type<AutoIncrementNumber>;
-
-export const autoIncrement = (): AutoIncrementType => {
-	return type("number.integer").configure({
-		primaryKey: true,
-		_autoincrement: true,
-	} as any) as unknown as AutoIncrementType;
-};

package/src/serializer.ts

@@ -1,19 +0,0 @@
-import { OperationNodeTransformer, type PrimitiveValueListNode } from "kysely";
-
-export class JsonSerializer extends OperationNodeTransformer {
-	protected override transformPrimitiveValueList(
-		node: PrimitiveValueListNode,
-	): PrimitiveValueListNode {
-		const values: unknown[] = [];
-
-		for (const v of node.values) {
-			if (typeof v === "object" && v !== null && !ArrayBuffer.isView(v)) {
-				values.push(JSON.stringify(v));
-			} else {
-				values.push(v);
-			}
-		}
-
-		return super.transformPrimitiveValueList({ ...node, values });
-	}
-}