@lobomfz/db 0.3.5 → 0.3.8

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.5",
+	"version": "0.3.8",
 	"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,20 +1,22 @@
 import { Database as BunDatabase } from "bun:sqlite";
-import { Kysely, ParseJSONResultsPlugin } from "kysely";
-import { BunSqliteDialect } from "./dialect/dialect";
+
 import type { Type } from "arktype";
-import type { GeneratedPreset } from "./generated";
-import type { DbFieldMeta } from "./env";
-import { DeserializePlugin, type ColumnCoercion, type ColumnsMap } from "./plugin";
+import { Kysely, ParseJSONResultsPlugin } 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 { DeserializePlugin, type ColumnCoercion, type ColumnsMap } from "./plugin.js";
 import type {
 	DatabaseOptions,
 	IndexDefinition,
 	SchemaRecord,
 	TablesFromSchemas,
 	DatabasePragmas,
-} from "./types";
-import { Introspector } from "./migration/introspect";
-import { Differ, type DesiredTable } from "./migration/diff";
-import { Executor } from "./migration/execute";
+} from "./types.js";
 
 type ArkBranch = {
 	domain?: string;
@@ -22,6 +24,7 @@ type ArkBranch = {
 	unit?: unknown;
 	structure?: unknown;
 	inner?: { divisor?: unknown };
+	meta?: DbFieldMeta & { _generated?: GeneratedPreset };
 };
 
 type StructureProp = {
@@ -43,6 +46,7 @@ type Prop = {
 	isBoolean?: boolean;
 	isInteger?: boolean;
 	isDate?: boolean;
+	isBlob?: boolean;
 	isJson?: boolean;
 	jsonSchema?: Type;
 	meta?: DbFieldMeta;
@@ -83,7 +87,10 @@ 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()],
+			plugins: [
+				new DeserializePlugin(this.columns, this.tableColumns, validation),
+				new ParseJSONResultsPlugin(),
+			],
 		});
 	}
 
@@ -108,34 +115,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;
+
+		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 || nonNull.some((b) => b.proto === Date)) {
+		if (v.proto === Date || concrete.some((b) => b.proto === Date)) {
 			return { key, kind, nullable, isDate: true, generated, defaultValue };
 		}
 
-		if (nonNull.length > 0 && nonNull.every((b) => b.domain === "boolean")) {
+		if (v.proto === Uint8Array || concrete.some((b) => b.proto === Uint8Array)) {
+			return {
+				key,
+				kind,
+				nullable,
+				isBlob: true,
+				meta,
+				generated,
+				defaultValue,
+			};
+		}
+
+		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,
@@ -143,7 +165,7 @@ export class Database<T extends SchemaRecord> {
 			nullable,
 			domain: branch?.domain,
 			isInteger: !!branch?.inner?.divisor,
-			meta: v.meta,
+			meta,
 			generated,
 			defaultValue,
 		};
@@ -154,6 +176,10 @@ export class Database<T extends SchemaRecord> {
 			return "TEXT";
 		}
 
+		if (prop.isBlob) {
+			return "BLOB";
+		}
+
 		if (prop.isDate || prop.isBoolean || prop.isInteger) {
 			return "INTEGER";
 		}
@@ -202,7 +228,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) {
@@ -328,8 +356,8 @@ export class Database<T extends SchemaRecord> {
 					type: this.sqlType(prop),
 					notnull: isNotNull,
 					defaultValue: defaultClause
-					? defaultClause.replace("DEFAULT ", "").replace(/^\((.+)\)$/, "$1")
-					: null,
+						? defaultClause.replace("DEFAULT ", "").replace(/^\((.+)\)$/, "$1")
+						: null,
 					unique: !!prop.meta?.unique,
 					references: prop.meta?.references ?? null,
 					onDelete: prop.meta?.onDelete?.toUpperCase() ?? null,
@@ -342,7 +370,12 @@ export class Database<T extends SchemaRecord> {
 				sql: this.generateCreateIndexSQL(name, indexDef),
 			}));
 
-			desiredTables.push({ name, sql: this.generateCreateTableSQL(name, props), columns, indexes });
+			desiredTables.push({
+				name,
+				sql: this.generateCreateTableSQL(name, props),
+				columns,
+				indexes,
+			});
 		}
 
 		const existing = new Introspector(this.sqlite).introspect();

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

@@ -12,6 +12,7 @@ import {
 	ValuesNode,
 	ValueNode,
 	ColumnNode,
+	DefaultInsertValueNode,
 	IdentifierNode,
 	ReferenceNode,
 	ParensNode,
@@ -19,9 +20,9 @@ import {
 	SelectQueryNode,
 } from "kysely";
 
-import { JsonParseError } from "./errors";
-import type { JsonValidation } from "./types";
-import { JsonValidationError } from "./validation-error";
+import { JsonParseError } from "./errors.js";
+import type { JsonValidation } from "./types.js";
+import { JsonValidationError } from "./validation-error.js";
 
 export type ColumnCoercion = "boolean" | "date" | { type: "json"; schema: Type };
 export type ColumnsMap = Map<string, Map<string, ColumnCoercion>>;
@@ -144,7 +145,18 @@ export class DeserializePlugin implements KyselyPlugin {
 					}
 
 					const raw = valueList.values[i];
-					yield [col, raw && ValueNode.is(raw) ? raw.value : raw] as [string, unknown];
+
+					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];
 				}
 			}
 
@@ -301,7 +313,10 @@ export class DeserializePlugin implements KyselyPlugin {
 		return match;
 	}
 
-	private resolveSelectionCoercion(node: OperationNode, scope: Map<string, string>): ResolvedCoercion | null {
+	private resolveSelectionCoercion(
+		node: OperationNode,
+		scope: Map<string, string>,
+	): ResolvedCoercion | null {
 		if (AliasNode.is(node)) {
 			return this.resolveSelectionCoercion(node.node, scope);
 		}
@@ -341,10 +356,7 @@ export class DeserializePlugin implements KyselyPlugin {
 			return null;
 		}
 
-		return this.resolveSelectionCoercion(
-			node.selections[0]!.selection,
-			this.getTableScope(node),
-		);
+		return this.resolveSelectionCoercion(node.selections[0]!.selection, this.getTableScope(node));
 	}
 
 	private getSelectionOutputName(node: OperationNode) {