@firtoz/drizzle-sqlite-wasm 0.2.9 → 0.2.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @firtoz/drizzle-sqlite-wasm
 
+## 0.2.10
+
+### Patch Changes
+
+- Updated dependencies [[`3c7ce1d`](https://github.com/firtoz/fullstack-toolkit/commit/3c7ce1dbca5c5396386db9927ae7f5e19a562cf6), [`3c7ce1d`](https://github.com/firtoz/fullstack-toolkit/commit/3c7ce1dbca5c5396386db9927ae7f5e19a562cf6)]:
+  - @firtoz/db-helpers@1.0.0
+  - @firtoz/drizzle-utils@1.0.0
+
 ## 0.2.9
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@firtoz/drizzle-sqlite-wasm",
-	"version": "0.2.9",
+	"version": "0.2.10",
 	"description": "Drizzle SQLite WASM bindings",
 	"main": "./src/index.ts",
 	"module": "./src/index.ts",
@@ -69,11 +69,12 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@firtoz/drizzle-utils": "^0.3.3",
+		"@firtoz/db-helpers": "^1.0.0",
+		"@firtoz/drizzle-utils": "^1.0.0",
 		"@firtoz/maybe-error": "^1.5.2",
 		"@firtoz/worker-helper": "^1.3.4",
 		"@sqlite.org/sqlite-wasm": "^3.51.2-build6",
-		"@tanstack/db": "^0.5.25",
+		"@tanstack/db": "^0.5.26",
 		"drizzle-orm": "^0.45.1",
 		"drizzle-valibot": "^0.4.2",
 		"react": "^19.2.4",
@@ -82,6 +83,6 @@
 	},
 	"devDependencies": {
 		"@standard-schema/spec": "^1.1.0",
-		"@types/react": "^19.2.13"
+		"@types/react": "^19.2.14"
 	}
 }

package/src/collections/sqlite-collection.ts

@@ -30,12 +30,12 @@ import {
 	type SQLiteInsertValue,
 	SQLiteColumn,
 } from "drizzle-orm/sqlite-core";
+import type { CollectionUtils } from "@firtoz/db-helpers";
 import type {
 	SelectSchema,
 	TableWithRequiredFields,
 	BaseSyncConfig,
 	SyncBackend,
-	CollectionUtils,
 } from "@firtoz/drizzle-utils";
 import {
 	createSyncFunction,
@@ -43,6 +43,7 @@ import {
 	createGetKeyFunction,
 	createCollectionConfig,
 } from "@firtoz/drizzle-utils";
+import { exhaustiveGuard } from "@firtoz/maybe-error";
 import type * as v from "valibot";
 
 export type AnyDrizzleDatabase = BaseSQLiteDatabase<
@@ -192,87 +193,81 @@ function convertBasicExpressionToDrizzle<TTable extends Table>(
 	expression: IR.BasicExpression,
 	table: TTable,
 ): SQL {
-	if (expression.type === "ref") {
-		// PropRef - reference to a column
-		const propRef = expression as IR.PropRef;
-		const columnName = propRef.path[propRef.path.length - 1];
-		const column = table[columnName as keyof typeof table];
-
-		if (!column || !(column instanceof SQLiteColumn)) {
-			console.error("[SQLite Collection] Column lookup failed:", {
-				columnName,
-				column,
-				tableKeys: Object.keys(table),
-				hasColumn: columnName in table,
-			});
-			throw new Error(`Column ${String(columnName)} not found in table`);
-		}
-
-		// Drizzle columns can be used directly in expressions
-		return column as unknown as SQL;
-	}
-
-	if (expression.type === "val") {
-		// Value - literal value
-		const value = expression as IR.Value;
-		return sql`${value.value}`;
-	}
-
-	if (expression.type === "func") {
-		// Func - function call like eq, gt, lt, etc.
-		const func = expression as IR.Func;
-		const args = func.args.map((arg) =>
-			convertBasicExpressionToDrizzle(arg, table),
-		);
+	switch (expression.type) {
+		case "ref": {
+			const propRef = expression;
+			const columnName = propRef.path[propRef.path.length - 1];
+			const column = table[columnName as keyof typeof table];
+
+			if (!column || !(column instanceof SQLiteColumn)) {
+				console.error("[SQLite Collection] Column lookup failed:", {
+					columnName,
+					column,
+					tableKeys: Object.keys(table),
+					hasColumn: columnName in table,
+				});
+				throw new Error(`Column ${String(columnName)} not found in table`);
+			}
 
-		switch (func.name) {
-			case "eq":
-				return eq(args[0], args[1]);
-			case "ne":
-				return ne(args[0], args[1]);
-			case "gt":
-				return gt(args[0], args[1]);
-			case "gte":
-				return gte(args[0], args[1]);
-			case "lt":
-				return lt(args[0], args[1]);
-			case "lte":
-				return lte(args[0], args[1]);
-			case "and": {
-				const result = and(...args);
-				if (!result) {
-					throw new Error("Invalid 'and' expression - no arguments provided");
+			return column as unknown as SQL;
+		}
+		case "val": {
+			const value = expression;
+			return sql`${value.value}`;
+		}
+		case "func": {
+			const func = expression;
+			const args = func.args.map((arg) =>
+				convertBasicExpressionToDrizzle(arg, table),
+			);
+
+			switch (func.name) {
+				case "eq":
+					return eq(args[0], args[1]);
+				case "ne":
+					return ne(args[0], args[1]);
+				case "gt":
+					return gt(args[0], args[1]);
+				case "gte":
+					return gte(args[0], args[1]);
+				case "lt":
+					return lt(args[0], args[1]);
+				case "lte":
+					return lte(args[0], args[1]);
+				case "and": {
+					const result = and(...args);
+					if (!result) {
+						throw new Error("Invalid 'and' expression - no arguments provided");
+					}
+					return result;
 				}
-				return result;
-			}
-			case "or": {
-				const result = or(...args);
-				if (!result) {
-					throw new Error("Invalid 'or' expression - no arguments provided");
+				case "or": {
+					const result = or(...args);
+					if (!result) {
+						throw new Error("Invalid 'or' expression - no arguments provided");
+					}
+					return result;
 				}
-				return result;
+				case "not":
+					return not(args[0]);
+				case "isNull":
+					return isNull(args[0]);
+				case "isNotNull":
+					return isNotNull(args[0]);
+				case "like":
+					return like(args[0], args[1]);
+				case "in":
+					return inArray(args[0], args[1]);
+				case "isUndefined":
+					// isUndefined is same as isNull in SQLite
+					return isNull(args[0]);
+				default:
+					throw new Error(`Unsupported function: ${func.name}`);
 			}
-			case "not":
-				return not(args[0]);
-			case "isNull":
-				return isNull(args[0]);
-			case "isNotNull":
-				return isNotNull(args[0]);
-			case "like":
-				return like(args[0], args[1]);
-			case "in":
-				return inArray(args[0], args[1]);
-			case "isUndefined":
-				// isUndefined is same as isNull in SQLite
-				return isNull(args[0]);
-			default:
-				throw new Error(`Unsupported function: ${func.name}`);
 		}
+		default:
+			exhaustiveGuard(expression);
 	}
-
-	throw new Error(
-		`Unsupported expression type: ${(expression as { type: string }).type}`,
-	);
 }
 
 /**

package/src/collections/websocket-collection.ts

@@ -9,6 +9,7 @@ import type {
 	InferSchemaOutput,
 	InferSchemaInput,
 } from "@tanstack/db";
+import { exhaustiveGuard } from "@firtoz/maybe-error";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 
 interface WebSocketMessage<T> {
@@ -155,6 +156,8 @@ export function webSocketCollectionOptions<TSchema extends StandardSchemaV1>(
 						commit();
 					}
 					break;
+				default:
+					exhaustiveGuard(message.type);
 			}
 		};
 
@@ -204,16 +207,30 @@ export function webSocketCollectionOptions<TSchema extends StandardSchemaV1>(
 		const transactionId = crypto.randomUUID();
 
 		// Convert all mutations in the transaction to the wire format
-		const mutations = params.transaction.mutations.map((mutation) => ({
-			type: mutation.type,
-			id: mutation.key,
-			data:
-				mutation.type === "delete"
-					? undefined
-					: mutation.type === "update"
-						? mutation.changes
-						: mutation.modified,
-		}));
+		const mutations = params.transaction.mutations.map((mutation) => {
+			switch (mutation.type) {
+				case "insert":
+					return {
+						type: mutation.type,
+						id: mutation.key,
+						data: mutation.modified,
+					};
+				case "update":
+					return {
+						type: mutation.type,
+						id: mutation.key,
+						data: mutation.changes,
+					};
+				case "delete":
+					return {
+						type: mutation.type,
+						id: mutation.key,
+						data: undefined,
+					};
+				default:
+					return exhaustiveGuard(mutation);
+			}
+		});
 
 		// Send the entire transaction at once
 		ws.send(