@lix-js/sdk 0.0.1

package/src/database/kysely-plugin/parse-jsonb-plugin-v1.test.ts

@@ -0,0 +1,204 @@
+import { Kysely, sql, type Generated } from "kysely";
+import { expect, test } from "vitest";
+import { createDialect, createInMemoryDatabase } from "sqlite-wasm-kysely";
+import { ParseJsonBPluginV1 } from "./parse-jsonb-plugin-v1.js";
+
+test("select()", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			metadata: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.select("metadata")
+		.executeTakeFirst();
+
+	expect(result).toEqual({ metadata: { a: 1 } });
+});
+
+test("select() with alias on the column is expected to fail", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			metadata: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.select("metadata as jc")
+		.executeTakeFirst();
+
+	expect(result).not.toEqual({ jc: { a: 1 } });
+});
+
+test("select() with joins should work as long as no aliases are used", async () => {
+	const db = await mockDatabase();
+
+	const insert = await db
+		.insertInto("mock_table")
+		.values({
+			metadata: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	await db
+		.insertInto("other_table")
+		.values({
+			mock_table_id: insert.id,
+			content: new TextEncoder().encode(JSON.stringify({ b: 2 })),
+		})
+		.execute();
+
+	const result0 = await db
+		.selectFrom("mock_table")
+		.innerJoin("other_table", "mock_table.id", "other_table.mock_table_id")
+		.select("mock_table.metadata")
+		.executeTakeFirst();
+
+	expect(result0).toEqual({ metadata: { a: 1 } });
+
+	// other way around
+	const result1 = await db
+		.selectFrom("mock_table")
+		.innerJoin("other_table", "mock_table.id", "other_table.mock_table_id")
+		.select("other_table.content")
+		.executeTakeFirst();
+
+	expect(result1).toEqual({ content: { b: 2 } });
+});
+
+test("selectAll() without aliases should work", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			metadata: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(result?.metadata).toStrictEqual({ a: 1 });
+	expect(result?.other).toBe("value");
+	expect(result?.just_blob).toBeInstanceOf(Uint8Array);
+});
+
+test("selectAll() with alias on table should work", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			metadata: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table as mt")
+		.selectAll("mt")
+		.executeTakeFirst();
+
+	expect(result?.metadata).toStrictEqual({ a: 1 });
+	expect(result?.other).toBe("value");
+	expect(result?.just_blob).toBeInstanceOf(Uint8Array);
+});
+
+test("selectAll() with joins should succeed as long as no aliases are used", async () => {
+	const db = await mockDatabase();
+
+	const insert = await db
+		.insertInto("mock_table")
+		.values({
+			metadata: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	await db
+		.insertInto("other_table")
+		.values({
+			mock_table_id: insert.id,
+			content: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.innerJoin("other_table", "mock_table.id", "other_table.mock_table_id")
+		.selectAll("mock_table")
+		.executeTakeFirst();
+
+	expect(result?.metadata).toStrictEqual({ a: 1 });
+	expect(result?.other).toBe("value");
+	expect(result?.just_blob).toBeInstanceOf(Uint8Array);
+});
+
+const mockDatabase = async () => {
+	const database = await createInMemoryDatabase({ readOnly: false });
+
+	const db = new Kysely<{
+		mock_table: {
+			id: Generated<number>;
+			metadata: Record<string, any>;
+			other: string;
+			just_blob: Uint8Array;
+		};
+		other_table: {
+			mock_table_id: number;
+			content: Record<string, any>;
+		};
+	}>({
+		dialect: createDialect({
+			database,
+		}),
+		plugins: [
+			await ParseJsonBPluginV1({
+				mock_table: ["metadata"],
+				other_table: ["content"],
+			}),
+		],
+	});
+
+	await sql`
+		CREATE TABLE mock_table (
+	    id INTEGER PRIMARY KEY AUTOINCREMENT,
+			metadata BLOB,
+			other TEXT,
+			just_blob BLOB
+		) strict;
+
+		CREATE TABLE other_table (
+		  mock_table_id INTEGER,
+			content BLOB,
+
+			FOREIGN KEY (mock_table_id) REFERENCES mock_table (id)
+		) strict;
+	`.execute(db);
+
+	return db;
+};

package/src/database/kysely-plugin/parse-jsonb-plugin-v1.ts

@@ -0,0 +1,48 @@
+import { type KyselyPlugin } from "kysely";
+import { createInMemoryDatabase } from "sqlite-wasm-kysely";
+
+// workaround for v1. v2 doesn't need to transform
+// jsonb columns during runtime
+const sqlite = await createInMemoryDatabase({});
+
+export function ParseJsonBPluginV1(
+	jsonbColumns: Record<string, string[]>
+): KyselyPlugin {
+	const jsonColumnNames = Object.keys(jsonbColumns).flatMap(
+		(key) => jsonbColumns[key]!
+	);
+
+	return {
+		transformResult: async (args) => {
+			for (const row of args.result.rows) {
+				for (const col of jsonColumnNames) {
+					if (!row[col]) {
+						// result does not have a whitelisted json column
+						// ! this is a heursitic. ideally, we invest into
+						// ! building ParseJsonBPluginV2 that detects
+						// ! json columns from the query itself
+						// see https://github.com/opral/lix-sdk/issues/145
+						continue;
+					}
+					try {
+						// sqlite has it's own jsonb format
+						// hence, need to query sqlite to convert
+						// to json
+						const json = sqlite.exec("SELECT json(?)", {
+							bind: [row[col] as Uint8Array],
+							returnValue: "resultRows",
+						})[0]![0];
+
+						row[col] = JSON.parse(json as string);
+					} catch {
+						// it's not a json binary
+						continue;
+					}
+				}
+			}
+
+			return args.result;
+		},
+		transformQuery: (args) => args.node,
+	};
+}

package/src/database/kysely-plugin/parse-jsonb-plugin-v2.no_test.ts

@@ -0,0 +1,204 @@
+import { Kysely, sql, type Generated } from "kysely";
+import { expect, test } from "vitest";
+import { createDialect, createInMemoryDatabase } from "sqlite-wasm-kysely";
+import { ParseJsonBPluginV2 } from "./parse-jsonb-plugin-v2.js";
+
+test("select()", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.select("json_column")
+		.executeTakeFirst();
+
+	expect(result).toEqual({ json_column: { a: 1 } });
+});
+
+test("select() with alias", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.select("json_column as jc")
+		.executeTakeFirst();
+
+	expect(result).toEqual({ jc: { a: 1 } });
+});
+
+test("select() with joins", async () => {
+	const db = await mockDatabase();
+
+	const insert = await db
+		.insertInto("mock_table")
+		.values({
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	await db
+		.insertInto("other_table")
+		.values({
+			mock_table_id: insert.id,
+			json_column: new TextEncoder().encode(JSON.stringify({ b: 2 })),
+		})
+		.execute();
+
+	const result0 = await db
+		.selectFrom("mock_table")
+		.innerJoin("other_table", "mock_table.id", "other_table.mock_table_id")
+		.select("mock_table.json_column")
+		.executeTakeFirst();
+
+	expect(result0).toEqual({ json_column: { a: 1 } });
+
+	// other way around
+	const result1 = await db
+		.selectFrom("mock_table")
+		.innerJoin("other_table", "mock_table.id", "other_table.mock_table_id")
+		.select("other_table.json_column")
+		.executeTakeFirst();
+
+	expect(result1).toEqual({ json_column: { b: 2 } });
+});
+
+test("selectAll()", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(result?.json_column).toStrictEqual({ a: 1 });
+	expect(result?.other).toBe("value");
+	expect(result?.just_blob).toBeInstanceOf(Uint8Array);
+});
+
+test("selectAll() with alias", async () => {
+	const db = await mockDatabase();
+
+	await db
+		.insertInto("mock_table")
+		.values({
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table as mt")
+		.selectAll("mt")
+		.executeTakeFirst();
+
+	expect(result?.json_column).toStrictEqual({ a: 1 });
+	expect(result?.other).toBe("value");
+	expect(result?.just_blob).toBeInstanceOf(Uint8Array);
+});
+
+test("selectAll() with joins", async () => {
+	const db = await mockDatabase();
+
+	const insert = await db
+		.insertInto("mock_table")
+		.values({
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+			other: "value",
+			just_blob: new TextEncoder().encode("{mock blob value that's not a json"),
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	await db
+		.insertInto("other_table")
+		.values({
+			mock_table_id: insert.id,
+			json_column: new TextEncoder().encode(JSON.stringify({ a: 1 })),
+		})
+		.execute();
+
+	const result = await db
+		.selectFrom("mock_table")
+		.innerJoin("other_table", "mock_table.id", "other_table.mock_table_id")
+		.selectAll("mock_table")
+		.executeTakeFirst();
+
+	expect(result?.json_column).toStrictEqual({ a: 1 });
+	expect(result?.other).toBe("value");
+	expect(result?.just_blob).toBeInstanceOf(Uint8Array);
+});
+
+const mockDatabase = async () => {
+	const database = await createInMemoryDatabase({ readOnly: false });
+
+	const db = new Kysely<{
+		mock_table: {
+			id: Generated<number>;
+			json_column: Record<string, any>;
+			other: string;
+			just_blob: Uint8Array;
+		};
+		other_table: {
+			mock_table_id: number;
+			json_column: Record<string, any>;
+		};
+	}>({
+		dialect: createDialect({
+			database,
+		}),
+		plugins: [
+			ParseJsonBPluginV2({
+				mock_table: ["json_column"],
+				other_table: ["json_column"],
+			}),
+		],
+	});
+
+	await sql`
+		CREATE TABLE mock_table (
+	    id INTEGER PRIMARY KEY AUTOINCREMENT,
+			json_column BLOB,
+			other TEXT,
+			just_blob BLOB
+		) strict;
+
+		CREATE TABLE other_table (
+		  mock_table_id INTEGER,
+			json_column BLOB,
+
+			FOREIGN KEY (mock_table_id) REFERENCES mock_table (id)
+		) strict;
+	`.execute(db);
+
+	return db;
+};

package/src/database/kysely-plugin/parse-jsonb-plugin-v2.ts

@@ -0,0 +1,194 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+/**
+ * THIS WAS A PROTOYPE FOR DETECTING JSONB COLUMNS
+ * INSTEAD OF RELYING ON HEURISTICS BUT WAS TOO COMPLEX
+ * FOR v1 of lix.
+ *
+ * Code still exists for future reference.
+ *
+ * https://github.com/opral/lix-sdk/issues/145
+ */
+
+import {
+	AliasNode,
+	FromNode,
+	SelectionNode,
+	type KyselyPlugin,
+	type PluginTransformQueryArgs,
+} from "kysely";
+
+type QueryId = PluginTransformQueryArgs["queryId"];
+
+export function ParseJsonBPluginV2(
+	jsonbColumns: Record<string, string[]>
+): KyselyPlugin {
+	const data = new WeakMap<QueryId, { jsonbColumNames: string[] }>();
+
+	return {
+		transformResult: async (args) => {
+			const jsonbColumNames = data.get(args.queryId)?.jsonbColumNames;
+			if (!jsonbColumNames) return args.result;
+
+			for (const row of args.result.rows) {
+				for (const col of jsonbColumNames) {
+					row[col] = JSON.parse(row[col] as string);
+				}
+			}
+
+			return args.result;
+		},
+		transformQuery: (args) => {
+			const query = args.node;
+
+			if (query.kind !== "SelectQueryNode") {
+				return query;
+			}
+
+			// Transform the selections (handles both select and selectAll)
+			const { transformedSelections, jsonbColumNames } = transformSelections(
+				query.selections,
+				query.from?.froms ?? [],
+				jsonbColumns
+			);
+
+			// Store the transformed column aliases for result parsing
+			data.set(args.queryId, { jsonbColumNames });
+
+			// Return the updated query node
+			return {
+				...query,
+				selections: transformedSelections,
+			};
+		},
+	};
+}
+
+/**
+ * Transforms selections to include JSONB column parsing, respecting aliases.
+ */
+function transformSelections(
+	selections: readonly SelectionNode[] | undefined,
+	fromNodes: readonly FromNode[] | undefined,
+	jsonbColumns: Record<string, string[]>
+): { transformedSelections: readonly any[]; jsonbColumNames: string[] } {
+	if (!fromNodes)
+		return { transformedSelections: selections ?? [], jsonbColumNames: [] };
+
+	const jsonbSelections = [];
+	const jsonbColumNames: string[] = [];
+
+	// Extract the fallback table name if there's only one table in fromNodes
+	let fallbackTableName: string | undefined;
+	let fallbackTableAlias: string | undefined;
+
+	if (fromNodes.length === 1) {
+		const node = fromNodes[0];
+		if (node.kind === "TableNode") {
+			fallbackTableName = node.table?.identifier.name;
+		} else if (node.kind === "AliasNode") {
+			fallbackTableName = (node as AliasNode).node.table?.identifier.name;
+			fallbackTableAlias = (node as AliasNode).alias?.name as string;
+		}
+	}
+
+	// Iterate over the selection nodes
+	for (const selection of selections ?? []) {
+		let tableName: string | undefined;
+		let columnName: string | undefined;
+		let aliasName: string | undefined;
+
+		if (selection.selection?.kind === "ReferenceNode") {
+			const potentialTableName =
+				selection.selection.table?.table?.identifier?.name || fallbackTableName;
+
+			const alias = fromNodes.find(
+				(n) => n.kind === "AliasNode" && n.alias.name === potentialTableName
+			);
+
+			if (alias) {
+				tableName = (alias as AliasNode).node.table?.identifier.name;
+				aliasName = (alias as AliasNode).alias.name;
+			} else {
+				tableName = potentialTableName;
+			}
+
+			columnName = selection.selection.column?.column?.name;
+
+			const isAlias = fromNodes.some(
+				(n) => n.kind === "AliasNode" && n.alias.name === tableName
+			);
+
+			// If the table name is an alias, find the real name
+			if (isAlias) {
+				const aliasNode = fromNodes.find(
+					(n) => n.kind === "AliasNode" && n.alias.name === tableName
+				) as AliasNode;
+				tableName = aliasNode.node.table?.identifier.name;
+			}
+		} else if (selection.selection?.kind === "AliasNode") {
+			// AliasNode: Extract alias and reference details
+			aliasName = selection.selection.alias?.name;
+			if (selection.selection.node?.kind === "ReferenceNode") {
+				tableName =
+					selection.selection.node?.table?.table?.identifier?.name ||
+					fallbackTableName;
+				columnName = selection.selection.node?.column?.column?.name;
+			}
+		} else if (selection.selection.kind === "SelectAllNode") {
+			tableName =
+				selection.selection.table?.table?.identifier?.name || fallbackTableName;
+			aliasName = selection.selection.alias?.name || fallbackTableAlias;
+		}
+
+		if (!tableName) continue;
+
+		const jsonbCols = jsonbColumns[tableName] ?? [];
+
+		for (const col of jsonbCols) {
+			const effectiveAlias = aliasName ?? columnName ?? col;
+
+			// Track the column key for result transformation
+			jsonbColumNames.push(effectiveAlias);
+
+			// Add the JSON transformation
+			jsonbSelections.push({
+				kind: "SelectionNode",
+				selection: {
+					kind: "AliasNode",
+					node: {
+						kind: "FunctionNode",
+						func: "json",
+						arguments: [
+							{
+								kind: "ReferenceNode",
+								table: {
+									kind: "TableNode",
+									table: {
+										kind: "SchemableIdentifierNode",
+										identifier: {
+											kind: "IdentifierNode",
+											name: tableName,
+										},
+									},
+								},
+								column: {
+									kind: "ColumnNode",
+									column: { kind: "IdentifierNode", name: effectiveAlias },
+								},
+							},
+						],
+					},
+					alias: { kind: "IdentifierNode", name: effectiveAlias },
+				},
+			});
+		}
+	}
+
+	// Merge existing selections with new JSONB transformations
+	return {
+		transformedSelections: [...(selections ?? []), ...jsonbSelections],
+		jsonbColumNames,
+	};
+}