@inlang/sdk 2.0.0-prerelease.0 → 2.0.1

package/node_modules/@lix-js/sdk/src/database/init-db.ts

@@ -1,111 +0,0 @@
-import { Kysely } from "kysely";
-import { createDialect, type SqliteDatabase } from "sqlite-wasm-kysely";
-import { v7 as uuid_v7, v4 as uuid_v4 } from "uuid";
-import type { LixDatabaseSchema } from "./schema.js";
-import { applySchema } from "./apply-schema.js";
-import { validateFilePath } from "../file/validate-file-path.js";
-import { jsonSha256 } from "../snapshot/json-sha-256.js";
-import { ParseJsonBPluginV1 } from "./kysely-plugin/parse-jsonb-plugin-v1.js";
-import { SerializeJsonBPlugin } from "./kysely-plugin/serialize-jsonb-plugin.js";
-import { createSession } from "./mutation-log/lix-session.js";
-import { applyOwnChangeControlTriggers } from "../own-change-control/database-triggers.js";
-import { humanId } from "human-id";
-import { nanoid } from "./nano-id.js";
-
-export function initDb(args: {
-	sqlite: SqliteDatabase;
-}): Kysely<LixDatabaseSchema> {
-	initFunctions({ sqlite: args.sqlite });
-	applySchema({ sqlite: args.sqlite });
-	const db = new Kysely<LixDatabaseSchema>({
-		dialect: createDialect({
-			database: args.sqlite,
-		}),
-		plugins: [
-			ParseJsonBPluginV1({
-				// jsonb columns
-				file: ["metadata"],
-				file_queue: ["metadata_before", "metadata_after"],
-				snapshot: ["content"],
-				mutation_log: ["row_id"],
-			}),
-			SerializeJsonBPlugin(),
-		],
-	});
-
-	// need to apply it here because db object needs to be available
-	applyOwnChangeControlTriggers(args.sqlite, db);
-	return db;
-}
-
-function initFunctions(args: { sqlite: SqliteDatabase }) {
-	args.sqlite.createFunction({
-		name: "uuid_v7",
-		arity: 0,
-		xFunc: () => uuid_v7(),
-	});
-
-	args.sqlite.createFunction({
-		name: "uuid_v4",
-		arity: 0,
-		xFunc: () => uuid_v4(),
-	});
-
-	args.sqlite.createFunction({
-		name: "json_sha256",
-		arity: 1,
-		xFunc: (_ctx: number, value) => {
-			if (!value) {
-				return "no-content";
-			}
-
-			const json = args.sqlite.exec("SELECT json(?)", {
-				bind: [value],
-				returnValue: "resultRows",
-			})[0]![0];
-
-			const parsed = JSON.parse(json as string);
-
-			return jsonSha256(parsed);
-		},
-		deterministic: true,
-	});
-
-	args.sqlite.createFunction({
-		name: "is_valid_file_path",
-		arity: 1,
-		xFunc: (_ctx: number, value) => {
-			return validateFilePath(value as string) as unknown as string;
-		},
-		deterministic: true,
-	});
-
-	const lixSession = createSession();
-
-	args.sqlite.createFunction({
-		name: "lix_session",
-		arity: 0,
-		xFunc: () => lixSession.id(),
-	});
-
-	args.sqlite.createFunction({
-		name: "lix_session_clock_tick",
-		arity: 0,
-		xFunc: () => lixSession.sessionClockTick(),
-	});
-
-	args.sqlite.createFunction({
-		name: "human_id",
-		arity: 0,
-		xFunc: () => humanId({ separator: "-", capitalize: false }),
-	});
-
-	args.sqlite.createFunction({
-		name: "nano_id",
-		arity: 1,
-		// @ts-expect-error - not sure why this is not working
-		xFunc: (_ctx: number, length: number) => {
-			return nanoid(length);
-		},
-	});
-}

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

@@ -1,204 +0,0 @@
-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/node_modules/@lix-js/sdk/src/database/kysely-plugin/parse-jsonb-plugin-v1.ts

@@ -1,55 +0,0 @@
-import { type KyselyPlugin } from "kysely";
-import {
-	createInMemoryDatabase,
-	type SqliteDatabase,
-} from "sqlite-wasm-kysely";
-
-// workaround for v1. v2 doesn't need to transform
-// jsonb columns during runtime
-let sqlite: SqliteDatabase;
-
-export function ParseJsonBPluginV1(
-	jsonbColumns: Record<string, string[]>
-): KyselyPlugin {
-	const jsonColumnNames = Object.keys(jsonbColumns).flatMap(
-		(key) => jsonbColumns[key]!
-	);
-
-	return {
-		transformResult: async (args) => {
-			if (!sqlite) {
-				sqlite = await createInMemoryDatabase({});
-			}
-
-			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/node_modules/@lix-js/sdk/src/database/kysely-plugin/parse-jsonb-plugin-v2.no_test.ts

@@ -1,204 +0,0 @@
-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;
-};