@inlang/sdk 0.36.2 → 2.0.0-prerelease.0

package/node_modules/@lix-js/sdk/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,
+	};
+}

package/node_modules/@lix-js/sdk/src/database/kysely-plugin/serialize-jsonb-plugin.test.ts

@@ -0,0 +1,132 @@
+import { Kysely, sql, type Generated } from "kysely";
+import { expect, test } from "vitest";
+import { createDialect, createInMemoryDatabase } from "sqlite-wasm-kysely";
+import { SerializeJsonBPlugin } from "./serialize-jsonb-plugin.js";
+
+test("inserts should work", async () => {
+	const db = await mockDatabase();
+
+	const result = await db
+		.insertInto("mock_table")
+		.values({
+			metadata: { a: 1 },
+			other: "value",
+			just_blob: new Uint8Array(),
+		})
+		.returningAll()
+		// no parsing json plugin is installed, hence select json from db instead
+		.returning(sql`json(metadata)`.as("metadata"))
+		.executeTakeFirstOrThrow();
+
+	expect(result).toEqual({
+		id: 1,
+		metadata: JSON.stringify({ a: 1 }),
+		other: "value",
+		just_blob: new Uint8Array(),
+	});
+});
+
+test("updates should work", async () => {
+	const db = await mockDatabase();
+
+	const insert = await db
+		.insertInto("mock_table")
+		.values({
+			metadata: { a: 1 },
+			other: "value",
+			just_blob: new Uint8Array(),
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	const result = await db
+		.updateTable("mock_table")
+		.set({ metadata: { b: 2 } })
+		.where("id", "=", insert.id)
+		.returningAll()
+		// no parsing json plugin is installed, hence select json from db instead
+		.returning(sql`json(metadata)`.as("metadata"))
+		.executeTakeFirstOrThrow();
+
+	expect(result).toEqual({
+		id: 1,
+		metadata: JSON.stringify({ b: 2 }),
+		other: "value",
+		just_blob: new Uint8Array(),
+	});
+});
+
+test("onConflict should work", async () => {
+	const db = await mockDatabase();
+
+	const insert = await db
+		.insertInto("mock_table")
+		.values({
+			metadata: { a: 1 },
+			other: "value",
+			just_blob: new Uint8Array(),
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	const result = await db
+		.insertInto("mock_table")
+		.values({
+			id: insert.id,
+			metadata: { b: 2 },
+			other: "value",
+			just_blob: new Uint8Array(),
+		})
+		.onConflict((oc) => oc.doUpdateSet({ metadata: { b: 2 } }))
+		.returningAll()
+		// no parsing json plugin is installed, hence select json from db instead
+		.returning(sql`json(metadata)`.as("metadata"))
+		.executeTakeFirstOrThrow();
+
+	expect(result).toEqual({
+		id: 1,
+		metadata: JSON.stringify({ b: 2 }),
+		other: "value",
+		just_blob: new 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: [SerializeJsonBPlugin()],
+	});
+
+	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/node_modules/@lix-js/sdk/src/database/kysely-plugin/serialize-jsonb-plugin.ts

@@ -0,0 +1,122 @@
+import {
+	OnConflictNode,
+	OperationNodeTransformer,
+	sql,
+	ValueListNode,
+	ValueNode,
+	ValuesNode,
+	type KyselyPlugin,
+} from "kysely";
+
+export function SerializeJsonBPlugin(): KyselyPlugin {
+	const parseJsonTransformer = new SerializeJsonbTransformer();
+
+	return {
+		transformResult: async (args) => args.result,
+		transformQuery(args) {
+			if (
+				args.node.kind === "InsertQueryNode" ||
+				args.node.kind === "UpdateQueryNode"
+			) {
+				const result = parseJsonTransformer.transformNode(args.node);
+
+				return result;
+			}
+			return args.node;
+		},
+	};
+}
+
+class SerializeJsonbTransformer extends OperationNodeTransformer {
+	override transformOnConflict(node: OnConflictNode): OnConflictNode {
+		return super.transformOnConflict({
+			...node,
+			updates: node.updates?.map((updateItem) => {
+				if (updateItem.kind !== "ColumnUpdateNode") {
+					return updateItem;
+				}
+				return {
+					kind: "ColumnUpdateNode",
+					column: updateItem.column,
+					value: this.transformValue(
+						// @ts-expect-error - type mismatch
+						updateItem.value
+					),
+				};
+			}),
+		});
+	}
+
+	override transformValue(node: ValueNode): ValueNode {
+		const { value } = node;
+		const serializedValue = maybeSerializeJson(value);
+		if (value === serializedValue) {
+			return node;
+		}
+		// @ts-expect-error - type mismatch
+		return sql`jsonb(${serializedValue})`.toOperationNode();
+	}
+	/**
+	 * Transforms the value list node by replacing all JSON objects with `jsonb` function calls.
+	 */
+	override transformValueList(node: ValueListNode): ValueListNode {
+		return super.transformValueList({
+			...node,
+			values: node.values.map((listNodeItem) => {
+				if (listNodeItem.kind !== "ValueNode") {
+					return listNodeItem;
+				}
+				// @ts-expect-error - type mismatch
+				const { value } = listNodeItem;
+				const serializedValue = maybeSerializeJson(value);
+
+				if (value === serializedValue) {
+					return listNodeItem;
+				}
+				return sql`jsonb(${serializedValue})`.toOperationNode();
+			}),
+		});
+	}
+
+	/**
+	 * changes PrimitiveValueListNode to ValueListNode to allow kysely to process objects
+	 */
+	override transformValues(node: ValuesNode): ValuesNode {
+		return super.transformValues({
+			...node,
+			values: node.values.map((valueItemNode) => {
+				if (valueItemNode.kind !== "PrimitiveValueListNode") {
+					return valueItemNode;
+				}
+
+				// change PrimitiveValueListNode to ValueListNode
+				return {
+					kind: "ValueListNode",
+					values: valueItemNode.values.map(
+						(value) =>
+							({
+								kind: "ValueNode",
+								value,
+							}) as ValueNode
+					),
+				} as ValueListNode;
+			}),
+		});
+	}
+}
+
+function maybeSerializeJson(value: any): any {
+	if (
+		// binary data
+		value instanceof ArrayBuffer ||
+		// uint8array, etc
+		ArrayBuffer.isView(value) ||
+		value === null ||
+		value === undefined
+	) {
+		return value;
+	} else if (typeof value === "object" || Array.isArray(value)) {
+		return JSON.stringify(value);
+	}
+	return value;
+}

package/node_modules/@lix-js/sdk/src/database/mutation-log/database-schema.ts

@@ -0,0 +1,126 @@
+import type { Insertable, Selectable } from "kysely";
+import type { SqliteDatabase } from "sqlite-wasm-kysely";
+
+export const tablesByDepencies: string[] = [
+	// no dependencies
+	"snapshot",
+	"label",
+	"version",
+	"account",
+	"file",
+	"change_set",
+	"key_value",
+	// Depends on: snapshot
+	"change",
+
+	// Depends on: file
+	"file_queue",
+	// Depends on: change
+	"change_author",
+	// Depends on: change
+	"change_edge",
+	// Depends on: change_set
+	"change_conflict",
+	// Depends on: change_conflict, change
+	"change_conflict_resolution",
+	// Depends on: change_set, change
+	"change_set_element",
+	// Depends on: label, change_set
+	"change_set_label",
+	//Depends on: change_set
+	"discussion",
+	// Depends on: account, discussion, comment
+	"comment",
+	// Depends on: version, change
+	"version_change",
+	// Depends on: version, change_conflict
+	"version_change_conflict",
+	// Depends on: version
+	"current_version",
+];
+
+export const tableIdColumns: Record<string, Array<string>> = {
+	// file - File is not synced. Is construcuted from the change table. (see https://github.com/opral/monorepo/pull/3242#discussion_r1863981413)
+	change: ["id"],
+	snapshot: ["id"],
+	change_conflict: ["id"],
+	change_edge: ["parent_id", "child_id"],
+	change_conflict_resolution: ["change_conflict_id", "resolved_change_id"],
+	version_change_conflict: ["version_id", "change_conflict_id"],
+	// version_change: ["version_id", "change_id"],
+};
+
+export function applyMutationLogDatabaseSchema(sqlite: SqliteDatabase): void {
+	// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+	sqlite.exec`
+  -- vector clock
+  CREATE TABLE IF NOT EXISTS mutation_log (
+    row_id BLOB,
+    table_name TEXT,
+    -- TODO SYNC - we might not need the operation as long as we don't expect a delete operation since we utilize upsert queries anyway
+    operation TEXT,
+    session TEXT NOT NULL DEFAULT (lix_session()),
+    session_time INTEGER NOT NULL DEFAULT (lix_session_clock_tick()),
+    wall_clock INTEGER DEFAULT (strftime('%s', 'now') * 1000 + (strftime('%f', 'now') - strftime('%S', 'now')) * 1000)
+  ) STRICT;
+   
+  CREATE TRIGGER IF NOT EXISTS ignore_mutation_during_sync
+  BEFORE INSERT ON mutation_log
+  FOR EACH ROW
+  WHEN EXISTS (SELECT 1 FROM mutation_log WHERE table_name = 'mutation_log')
+  BEGIN
+    SELECT RAISE(IGNORE);
+  END;
+ 
+  `;
+
+	for (const [tableName, idColumns] of Object.entries(tableIdColumns)) {
+		if (idColumns.length === 0) {
+			throw new Error("at least one id required");
+		}
+		sqlite.exec(`
+      -- Trigger for INSERT operations
+      CREATE TRIGGER IF NOT EXISTS ${tableName}_after_insert_log
+      AFTER INSERT ON ${tableName}
+      BEGIN
+          INSERT INTO mutation_log (row_id, table_name, operation)
+          VALUES (JSONB(${toSqliteJson(idColumns)}), '${tableName}', 'INSERT');
+      END;
+  
+      -- Trigger for UPDATE operations
+      CREATE TRIGGER IF NOT EXISTS ${tableName}_after_update_log
+      AFTER UPDATE ON ${tableName}
+      BEGIN
+          INSERT INTO mutation_log (row_id, table_name, operation)
+          VALUES (JSONB(${toSqliteJson(idColumns)}), '${tableName}', 'UPDATE');
+      END;
+    `);
+	}
+}
+
+export type MutationLog = Selectable<MutationLogTable>;
+export type NewMutationLog = Insertable<MutationLogTable>;
+
+export type MutationLogTable = {
+	row_id: Record<string, string>;
+	table_name: string;
+	// -1 = delete, 0 = insert, 1 = update
+	// TODO SYNC - we might not need the operation as long as we don't expect a delete operation since we utilize upsert queries anyway
+	operation: "INSERT" | "UPDATE";
+	session: string;
+	session_time: number;
+	wall_clock: number;
+};
+
+function toSqliteJson(keyColumns: string[]) {
+	if (keyColumns.length === 0) {
+		throw new Error("Key columns array cannot be empty.");
+	}
+
+	const jsonObjectArgs = keyColumns.map(
+		(keyColumnName) => `'${keyColumnName}', NEW.${keyColumnName}`
+	);
+
+	const jsonObjectExpression = "json_object(" + jsonObjectArgs.join(", ") + ")";
+	return jsonObjectExpression;
+}

package/node_modules/@lix-js/sdk/src/database/mutation-log/lix-session.ts

@@ -0,0 +1,19 @@
+import { v4 as uuid_v4 } from "uuid";
+
+export function createSession() {
+	const sessionId = uuid_v4(); // we use v4 here since the order of session should explicetly not matter!
+	let time: number = 0;
+
+	return {
+		/**
+		 * Returns the current lix session id.
+		 */
+		id: (): string => {
+			return sessionId;
+		},
+		sessionClockTick: (): number => {
+			time += 1;
+			return time;
+		},
+	};
+}

package/node_modules/@lix-js/sdk/src/database/nano-id.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from "vitest";
+import { _nanoIdAlphabet, nanoid } from "./nano-id.js";
+
+test("length is obeyed", () => {
+	const id = nanoid(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("-");
+});

package/node_modules/@lix-js/sdk/src/database/nano-id.ts

@@ -0,0 +1,72 @@
+/**
+ * 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.
+ *
+ */
+
+const random = (bytes: any) => crypto.getRandomValues(new Uint8Array(bytes));
+
+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.
+ *
+ * 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 nanoid: (size?: number) => string =
+	customAlphabet(_nanoIdAlphabet);