@inlang/sdk 2.0.0-prerelease.0 → 2.0.1

package/node_modules/@lix-js/sdk/src/database/kysely-plugin/parse-jsonb-plugin-v2.ts

@@ -1,194 +0,0 @@
-// 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

@@ -1,132 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,72 +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.
- *
- */
-
-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);