@lix-js/sdk 0.5.1 → 0.6.0-preview.1

package/src/database/kysely/plugins/json-column-plugin.ts

@@ -1,286 +0,0 @@
-import {
-	ColumnNode,
-	ColumnUpdateNode,
-	InsertQueryNode,
-	OnConflictNode,
-	OperationNodeTransformer,
-	ValueListNode,
-	ValueNode,
-	ValuesNode,
-	type KyselyPlugin,
-	type PluginTransformQueryArgs,
-} from "kysely";
-
-type JsonColumnConfig = {
-	type:
-		| "object"
-		| Array<"string" | "number" | "boolean" | "object" | "array" | "null">;
-};
-
-export function JSONColumnPlugin(
-	jsonColumns: Record<string, Record<string, JsonColumnConfig>>
-): KyselyPlugin {
-	// Build a flat list of all JSON column names for the result transformer
-	const jsonColumnNames = Object.keys(jsonColumns).flatMap((table) =>
-		Object.keys(jsonColumns[table]!)
-	);
-
-	return {
-		transformResult: async (args) => {
-			for (const row of args.result.rows) {
-				for (const col of jsonColumnNames) {
-					const val = row[col];
-					// Only parse when it's a string that looks like an object/array JSON.
-					if (typeof val === "string") {
-						const trimmed = val.trim();
-						if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-							try {
-								row[col] = JSON.parse(val);
-							} catch {
-								// leave as-is if parsing fails
-							}
-						}
-					}
-				}
-			}
-
-			return args.result;
-		},
-		transformQuery(args: PluginTransformQueryArgs) {
-			if (args.node.kind === "InsertQueryNode") {
-				const tableNode = (args.node as InsertQueryNode).into;
-				const table =
-					tableNode && tableNode.kind === "TableNode"
-						? tableNode.table.identifier.name
-						: undefined;
-				const columns = (args.node as InsertQueryNode).columns;
-
-				const transformer = new SerializeJsonbTransformer(
-					jsonColumns,
-					table,
-					columns
-				);
-				return transformer.transformNode(args.node);
-			}
-			if (args.node.kind === "UpdateQueryNode") {
-				const tableNode = args.node.table;
-				let table: string | undefined = undefined;
-				if (tableNode && tableNode.kind === "TableNode") {
-					// @ts-expect-error - kysely type narrowing
-					table = tableNode.table.identifier.name;
-				}
-
-				const transformer = new SerializeJsonbTransformer(
-					jsonColumns,
-					table,
-					undefined
-				);
-				return transformer.transformNode(args.node);
-			}
-			return args.node;
-		},
-	};
-}
-
-class SerializeJsonbTransformer extends OperationNodeTransformer {
-	private readonly jsonbColumns: Record<
-		string,
-		Record<string, JsonColumnConfig>
-	>;
-	private readonly table: string | undefined;
-	private readonly columns: ReadonlyArray<ColumnNode> | undefined;
-
-	constructor(
-		jsonbColumns: Record<string, Record<string, JsonColumnConfig>>,
-		table: string | undefined,
-		columns: ReadonlyArray<ColumnNode> | undefined
-	) {
-		super();
-		this.jsonbColumns = jsonbColumns;
-		this.table = table;
-		this.columns = columns;
-	}
-
-	private getJsonColumnConfig(
-		columnName: string
-	): JsonColumnConfig | undefined {
-		if (!this.table || !columnName) return undefined;
-		return this.jsonbColumns[this.table]?.[columnName];
-	}
-
-	private isJsonbColumn(columnName: string): boolean {
-		return this.getJsonColumnConfig(columnName) !== undefined;
-	}
-
-	private isSqlExpression(node: any): boolean {
-		// Check if the node is a SQL expression that shouldn't be wrapped
-		// Common SQL expression node types:
-		// - RawNode: Created by sql`` template literals
-		// - FunctionNode: SQL functions like json_set()
-		// - BinaryOperationNode: SQL operations
-		// - etc.
-		// ValueNode is the only type we want to wrap in json()
-		return node && node.kind !== "ValueNode";
-	}
-
-	override transformOnConflict(node: OnConflictNode): OnConflictNode {
-		if (!node.updates) {
-			return node;
-		}
-
-		// Map the updates array directly
-		const newUpdates = node.updates.map((updateItem) => {
-			// Check if it's a ColumnUpdateNode first
-			if (updateItem.kind === "ColumnUpdateNode") {
-				// @ts-expect-error - kysely type narrowing
-				const columnName = updateItem.column.column.name;
-				if (this.isJsonbColumn(columnName)) {
-					const valueNode = updateItem.value;
-					// Check if the value is a SQL expression - if so, don't wrap it
-					if (this.isSqlExpression(valueNode)) {
-						return updateItem;
-					}
-					// Check if the value part is specifically a ValueNode
-					if (valueNode.kind === "ValueNode") {
-						// If it is, serialize it
-						return {
-							...updateItem,
-							value: this.serializeValue(
-								// @ts-expect-error - kysely type narrowing
-								valueNode,
-								this.getJsonColumnConfig(columnName)
-							),
-						};
-					}
-				}
-			}
-			// Return unchanged if not a ColumnUpdateNode or not a JSONB column or value is not ValueNode
-			return updateItem;
-		});
-
-		// Return a new node with the transformed updates
-		return {
-			...node,
-			updates: newUpdates,
-		};
-	}
-
-	public override transformNode(node: any): any {
-		if (!node) {
-			return node;
-		}
-		return super.transformNode(node);
-	}
-
-	// Serialize JSONB values in updates for ColumnUpdateNodes
-	protected override transformColumnUpdate(
-		node: ColumnUpdateNode
-	): ColumnUpdateNode {
-		// @ts-expect-error - kysely type narrowing
-		const columnName = node.column.column.name;
-		if (this.isJsonbColumn(columnName)) {
-			// Check if the value is a SQL expression (RawNode, etc.) - if so, don't wrap it
-			if (this.isSqlExpression(node.value)) {
-				return node;
-			}
-			return {
-				...node,
-				value: this.serializeValue(
-					// @ts-expect-error - kysely type narrowing
-					node.value,
-					this.getJsonColumnConfig(columnName)
-				),
-			} as ColumnUpdateNode;
-		}
-		return super.transformColumnUpdate(node);
-	}
-
-	// Support .set("col", value) syntax (SetOperationNode)
-	protected override transformSetOperation(node: any): any {
-		// node.column.column.name is the column name for SetOperationNode
-		const columnName = node.column?.column?.name;
-		if (columnName && this.isJsonbColumn(columnName)) {
-			// Check if the value is a SQL expression - if so, don't wrap it
-			if (this.isSqlExpression(node.value)) {
-				return node;
-			}
-			return {
-				...node,
-				value: this.serializeValue(
-					node.value,
-					this.getJsonColumnConfig(columnName)
-				),
-			};
-		}
-		return super.transformSetOperation(node);
-	}
-
-	protected override transformValues(node: ValuesNode): ValuesNode {
-		const newValues = node.values.map((row) => {
-			// Handle literal JS values row
-			if (row.kind === "PrimitiveValueListNode") {
-				const newValueNodes = row.values.map((val, idx) => {
-					const colNode = this.columns?.[idx];
-					const valNode: ValueNode = { kind: "ValueNode", value: val };
-					if (
-						colNode?.kind === "ColumnNode" &&
-						this.isJsonbColumn(colNode.column.name)
-					) {
-						const config = this.getJsonColumnConfig(colNode.column.name);
-						return this.serializeValue(valNode, config);
-					}
-					return valNode;
-				});
-				return {
-					kind: "ValueListNode",
-					values: newValueNodes,
-				} as ValueListNode;
-			}
-			// Handle AST rows
-			if (row.kind === "ValueListNode") {
-				const newValuesList = row.values.map((valNode, idx) => {
-					const colNode = this.columns?.[idx];
-					if (
-						colNode?.kind === "ColumnNode" &&
-						this.isJsonbColumn(colNode.column.name)
-					) {
-						const config = this.getJsonColumnConfig(colNode.column.name);
-						return this.serializeValue(valNode as ValueNode, config);
-					}
-					return valNode;
-				});
-				return { ...row, values: newValuesList } as ValueListNode;
-			}
-			return row;
-		});
-		return { ...node, values: newValues };
-	}
-
-	private serializeValue(node: ValueNode, config?: JsonColumnConfig): any {
-		const val = node.value;
-		if (val instanceof ArrayBuffer || ArrayBuffer.isView(val) || val === null) {
-			return node;
-		}
-
-		// Check if this column only accepts objects and we have a string
-		// that might be pre-serialized JSON
-		if (config?.type === "object" && typeof val === "string") {
-			// For object-only columns, assume string values are pre-serialized JSON
-			// to avoid double serialization
-			return {
-				kind: "FunctionNode",
-				func: "json",
-				arguments: [{ kind: "ValueNode", value: val }],
-			};
-		}
-
-		// For all other cases, stringify the value
-		const jsonText = JSON.stringify(val);
-
-		return {
-			kind: "FunctionNode",
-			func: "json",
-			arguments: [{ kind: "ValueNode", value: jsonText }],
-		};
-	}
-}

package/src/database/kysely/plugins/view-insert-returning-error-plugin.test.ts

@@ -1,62 +0,0 @@
-import { test, expect } from "vitest";
-import { openLix } from "../../../lix/open-lix.js";
-
-test("should throw error when using returningAll() on view insert", async () => {
-	const lix = await openLix({});
-
-	// Test with a view that's in the plugin's view list
-	expect(() => {
-		lix.db.insertInto("change_set").defaultValues().returningAll().compile();
-	}).toThrow(
-		"Cannot use returning() or returningAll() with INSERT operations on view 'change_set'. " +
-			"Views do not support returning clauses in INSERT statements. " +
-			"Use a separate SELECT query after the INSERT to retrieve the data."
-	);
-});
-
-test("should throw error when using returning() on view insert", async () => {
-	const lix = await openLix({});
-
-	// Test with returning() instead of returningAll()
-	expect(() => {
-		lix.db
-			.insertInto("conversation")
-			.values({ id: "test-id" })
-			.returning("id")
-			.compile();
-	}).toThrow(
-		"Cannot use returning() or returningAll() with INSERT operations on view 'conversation'. " +
-			"Views do not support returning clauses in INSERT statements. " +
-			"Use a separate SELECT query after the INSERT to retrieve the data."
-	);
-});
-
-test("should allow insert without returning on views", async () => {
-	const lix = await openLix({});
-
-	// This should not throw
-	expect(() => {
-		lix.db.insertInto("change_set").defaultValues().compile();
-	}).not.toThrow();
-});
-
-test("should allow returning on non-view tables", async () => {
-	const lix = await openLix({});
-
-	// This should not throw since 'state' is a table, not a view
-	expect(() => {
-		lix.db
-			.insertInto("state_by_version")
-			.values({
-				entity_id: "test",
-				schema_key: "test",
-				file_id: "test",
-				schema_version: "1.0",
-				plugin_key: "test",
-				snapshot_content: {},
-				version_id: "test",
-			})
-			.returningAll()
-			.compile();
-	}).not.toThrow();
-});

package/src/database/kysely/plugins/view-insert-returning-error-plugin.ts

@@ -1,49 +0,0 @@
-import type {
-	KyselyPlugin,
-	PluginTransformQueryArgs,
-	PluginTransformResultArgs,
-	QueryResult,
-	RootOperationNode,
-	UnknownRow,
-} from "kysely";
-
-/**
- * A Kysely plugin that prevents using `returning()` or `returningAll()`
- * with INSERT operations on database views.
- *
- * This provides better developer experience by failing fast with clear
- * error messages instead of letting SQLite return cryptic errors.
- */
-export class ViewInsertReturningErrorPlugin implements KyselyPlugin {
-	private readonly viewNames: Set<string>;
-
-	constructor(viewNames: string[]) {
-		this.viewNames = new Set(viewNames);
-	}
-
-	transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-		const { node } = args;
-
-		// Check if this is an INSERT operation
-		if (node.kind === "InsertQueryNode") {
-			const tableName = node.into?.table.identifier.name;
-
-			// Check if inserting into a view and has returning clause
-			if (tableName && this.viewNames.has(tableName) && node.returning) {
-				throw new Error(
-					`Cannot use returning() or returningAll() with INSERT operations on view '${tableName}'. ` +
-						`Views do not support returning clauses in INSERT statements. ` +
-						`Use a separate SELECT query after the INSERT to retrieve the data.`
-				);
-			}
-		}
-
-		return node;
-	}
-
-	async transformResult(
-		args: PluginTransformResultArgs
-	): Promise<QueryResult<UnknownRow>> {
-		return args.result;
-	}
-}

package/src/database/kysely/plugins.ts

@@ -1,16 +0,0 @@
-import { ParseJSONResultsPlugin, type KyselyPlugin } from "kysely";
-import { JSONColumnPlugin } from "./plugins/json-column-plugin.js";
-import { ViewInsertReturningErrorPlugin } from "./plugins/view-insert-returning-error-plugin.js";
-import { buildJsonColumnConfig } from "./json-column-config.js";
-import { LixSchemaViewMap } from "../schema-view-map.js";
-
-export function createDefaultPlugins(): KyselyPlugin[] {
-	const jsonColumnsConfig = buildJsonColumnConfig({ includeChangeView: true });
-	const viewNames = Object.keys(LixSchemaViewMap);
-
-	return [
-		new ParseJSONResultsPlugin(),
-		JSONColumnPlugin(jsonColumnsConfig),
-		new ViewInsertReturningErrorPlugin(viewNames),
-	];
-}

package/src/database/nano-id.test.ts

@@ -1,42 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { _nanoIdAlphabet, randomNanoId } from "./nano-id.js";
-
-test("length is obeyed", () => {
-	const id = randomNanoId(10);
-	expect(id.length).toBe(10);
-});
-
-test("the alphabet does not contain underscores `_` because they are not URL safe", () => {
-	expect(_nanoIdAlphabet).not.toContain("_");
-});
-
-test("the alphabet does not contain dashes `-` because they break selecting the ID from the URL in the browser", () => {
-	expect(_nanoIdAlphabet).not.toContain("-");
-});
-
-/**
- * Test the crypto polyfill that was added to fix environments without crypto support
- * like older versions of Node in Stackblitz.
- *
- * See: https://github.com/opral/lix-sdk/issues/258
- */
-test("polyfill works when crypto is not available", () => {
-	// Store original crypto
-	const originalCrypto = globalThis.crypto as any;
-
-	// Mock crypto as undefined to test the polyfill
-	vi.stubGlobal("crypto", undefined);
-
-	try {
-		const id = randomNanoId(10);
-		expect(id.length).toBe(10);
-		expect(typeof id).toBe("string");
-		// Check that it only contains characters from our alphabet
-		for (let i = 0; i < id.length; i++) {
-			expect(_nanoIdAlphabet).toContain(id[i]);
-		}
-	} finally {
-		// Restore original crypto
-		vi.stubGlobal("crypto", originalCrypto);
-	}
-});

package/src/database/nano-id.ts

@@ -1,100 +0,0 @@
-/**
- * Code taken from the [nanoid](https://github.com/ai/nanoid/blob/main/index.browser.js)
- * browser implementation. The code is licensed under the MIT license.
- *
- */
-
-/**
- * Polyfill for crypto.getRandomValues in environments that don't have it,
- * such as older versions of Node in Stackblitz.
- *
- * This implementation is not cryptographically secure, but is sufficient for ID generation
- * in these environments. In environments with proper crypto support, we'll use the native implementation.
- *
- * See: https://github.com/opral/lix-sdk/issues/258
- */
-const insecureRandom = (array: Uint8Array) => {
-	for (let i = 0; i < array.length; i++) {
-		array[i] = Math.floor(Math.random() * 256);
-	}
-	return array;
-};
-
-// Use crypto.getRandomValues if available, otherwise use our polyfill
-const random = (bytes: any) => {
-	const array = new Uint8Array(bytes);
-	if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-		return crypto.getRandomValues(array);
-	}
-
-	// Fallback to insecure random number generator if crypto is not available
-	return insecureRandom(array);
-};
-
-const customRandom = (
-	alphabet: string,
-	defaultSize: number,
-	getRandom: any
-) => {
-	// First, a bitmask is necessary to generate the ID. The bitmask makes bytes
-	// values closer to the alphabet size. The bitmask calculates the closest
-	// `2^31 - 1` number, which exceeds the alphabet size.
-	// For example, the bitmask for the alphabet size 30 is 31 (00011111).
-	// `Math.clz32` is not used, because it is not available in browsers.
-	const mask = (2 << Math.log2(alphabet.length - 1)) - 1;
-	// Though, the bitmask solution is not perfect since the bytes exceeding
-	// the alphabet size are refused. Therefore, to reliably generate the ID,
-	// the random bytes redundancy has to be satisfied.
-
-	// Note: every hardware random generator call is performance expensive,
-	// because the system call for entropy collection takes a lot of time.
-	// So, to avoid additional system calls, extra bytes are requested in advance.
-
-	// Next, a step determines how many random bytes to generate.
-	// The number of random bytes gets decided upon the ID size, mask,
-	// alphabet size, and magic number 1.6 (using 1.6 peaks at performance
-	// according to benchmarks).
-
-	// `-~f => Math.ceil(f)` if f is a float
-	// `-~i => i + 1` if i is an integer
-	const step = -~((1.6 * mask * defaultSize) / alphabet.length);
-
-	return (size = defaultSize) => {
-		let id = "";
-		while (true) {
-			const bytes = getRandom(step);
-			// A compact alternative for `for (var i = 0; i < step; i++)`.
-			let j = step | 0;
-			while (j--) {
-				// Adding `|| ''` refuses a random byte that exceeds the alphabet size.
-				id += alphabet[bytes[j] & mask] || "";
-				if (id.length >= size) return id;
-			}
-		}
-	};
-};
-
-const customAlphabet = (alphabet: string, size = 21) =>
-	customRandom(alphabet, size | 0, random);
-
-/**
- * Uses every character from nano id except for the `-` and `_` character.
- *
- * - Underscore `_` is not URL safe https://github.com/ai/nanoid/issues/347.
- * - Dash `-` breaks selecting the ID from the URL in the browser.
- */
-export const _nanoIdAlphabet =
-	"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-/**
- * Generate secure URL-friendly unique ID.
- *
- * NOTE: This is the non-deterministic version. For deterministic IDs in tests,
- * use `nanoid({ lix })` from './functions.js' instead.
- *
- * Use https://zelark.github.io/nano-id-cc/ to calculate the length
- * of the ID for the use case with the alphabet provided in the
- * implementation.
- */
-export const randomNanoId: (size?: number) => string =
-	customAlphabet(_nanoIdAlphabet);

package/src/database/schema-view-map.ts

@@ -1,48 +0,0 @@
-import {
-	LixAccountSchema,
-	LixActiveAccountSchema,
-} from "../account/schema-definition.js";
-import { LixChangeAuthorSchema } from "../change-author/schema-definition.js";
-import { LixChangeProposalSchema } from "../change-proposal/schema-definition.js";
-import {
-	LixChangeSetElementSchema,
-	LixChangeSetSchema,
-} from "../change-set/schema-definition.js";
-import {
-	LixCommitEdgeSchema,
-	LixCommitSchema,
-} from "../commit/schema-definition.js";
-import {
-	LixConversationMessageSchema,
-	LixConversationSchema,
-} from "../conversation/schema-definition.js";
-import { LixEntityConversationSchema } from "../entity/conversation/schema-definition.js";
-import { LixEntityLabelSchema } from "../entity/label/schema-definition.js";
-import { LixDirectoryDescriptorSchema } from "../filesystem/directory/schema-definition.js";
-import { LixFileDescriptorSchema } from "../filesystem/file/schema-definition.js";
-import { LixKeyValueSchema } from "../key-value/schema-definition.js";
-import { LixLabelSchema } from "../label/schema-definition.js";
-import { LixLogSchema } from "../log/schema-definition.js";
-import type { LixSchemaDefinition } from "../schema-definition/definition.js";
-import { LixStoredSchemaSchema } from "../stored-schema/schema-definition.js";
-
-export const LixSchemaViewMap: Record<string, LixSchemaDefinition> = {
-	change_set: LixChangeSetSchema,
-	change_set_element: LixChangeSetElementSchema,
-	commit: LixCommitSchema,
-	commit_edge: LixCommitEdgeSchema,
-	file_descriptor: LixFileDescriptorSchema,
-	directory_descriptor: LixDirectoryDescriptorSchema,
-	log: LixLogSchema,
-	stored_schema: LixStoredSchemaSchema,
-	key_value: LixKeyValueSchema,
-	account: LixAccountSchema,
-	active_account: LixActiveAccountSchema,
-	change_author: LixChangeAuthorSchema,
-	label: LixLabelSchema,
-	entity_label: LixEntityLabelSchema,
-	entity_conversation: LixEntityConversationSchema,
-	conversation: LixConversationSchema,
-	conversation_message: LixConversationMessageSchema,
-	change_proposal: LixChangeProposalSchema,
-};