@lix-js/sdk 0.4.6 → 0.5.0-preview.0

package/src/change/create-change.test.ts

@@ -1,296 +0,0 @@
-import { expect, test } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { createChange } from "./create-change.js";
-import type { Change } from "../database/schema.js";
-import { createAccount } from "../account/create-account.js";
-import { createVersion } from "../version/create-version.js";
-import { switchVersion } from "../version/switch-version.js";
-
-test("should create a change with the correct values", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	const author = await createAccount({
-		lix,
-		name: "author",
-	});
-
-	await switchVersion({ lix, to: version0 });
-
-	const change = await createChange({
-		lix,
-		authors: [author],
-		entityId: "entity1",
-		version: version0,
-		fileId: "file1",
-		pluginKey: "plugin1",
-		schemaKey: "schema1",
-		snapshotContent: { text: "snapshot-content" },
-	});
-
-	const changes = await lix.db
-		.selectFrom("change")
-		.where("change.id", "=", change.id)
-		.selectAll()
-		.execute();
-
-	expect(changes.length).toBe(1);
-	expect(changes[0]?.entity_id).toBe("entity1");
-	expect(changes[0]?.file_id).toBe("file1");
-	expect(changes[0]?.plugin_key).toBe("plugin1");
-	expect(changes[0]?.schema_key).toBe("schema1");
-	expect(changes[0]?.snapshot_id).toBe(change.snapshot_id);
-});
-
-test("should create a snapshot with the correct content", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	await switchVersion({ lix, to: version0 });
-
-	const author = await createAccount({
-		lix,
-		name: "author",
-	});
-
-	const change = await createChange({
-		lix,
-		authors: [author],
-		version: version0,
-		entityId: "entity1",
-		fileId: "file1",
-		pluginKey: "plugin1",
-		schemaKey: "schema1",
-		snapshotContent: { text: "snapshot-content" },
-	});
-
-	const snapshots = await lix.db
-		.selectFrom("snapshot")
-		.where("snapshot.id", "=", change.snapshot_id)
-		.selectAll()
-		.execute();
-
-	expect(snapshots.length).toBe(1);
-	expect(snapshots[0]?.content).toStrictEqual({ text: "snapshot-content" });
-});
-
-test("should create a change and a snapshot in a transaction", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	await switchVersion({ lix, to: version0 });
-
-	const author = await createAccount({
-		lix,
-		name: "author",
-	});
-
-	let change: Change;
-
-	await lix.db.transaction().execute(async (trx) => {
-		change = await createChange({
-			lix: { ...lix, db: trx },
-			authors: [author],
-			version: version0,
-			entityId: "entity1",
-			fileId: "file1",
-			pluginKey: "plugin1",
-			schemaKey: "schema1",
-			snapshotContent: { text: "snapshot-content" },
-		});
-	});
-
-	const changes = await lix.db
-		.selectFrom("change")
-		.where("change.id", "=", change!.id)
-		.selectAll()
-		.execute();
-
-	const snapshots = await lix.db
-		.selectFrom("snapshot")
-		.where("snapshot.id", "=", change!.snapshot_id)
-		.selectAll()
-		.execute();
-
-	expect(changes.length).toBe(1);
-	expect(snapshots.length).toBe(1);
-	expect(changes[0]?.snapshot_id).toBe(snapshots[0]?.id);
-});
-
-test("should create the change authors", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	await switchVersion({ lix, to: version0 });
-
-	const account1 = await createAccount({
-		lix,
-		name: "account1",
-	});
-
-	const account2 = await createAccount({
-		lix,
-		name: "account2",
-	});
-
-	await lix.db
-		.insertInto("active_account")
-		.values([account1, account2])
-		.execute();
-
-	const change = await createChange({
-		lix,
-		version: version0,
-		authors: [account1, account2],
-		entityId: "entity1",
-		fileId: "file1",
-		pluginKey: "plugin1",
-		schemaKey: "schema1",
-		snapshotContent: { text: "snapshot-content" },
-	});
-
-	const changeAuthors = await lix.db
-		.selectFrom("change_author")
-		.where("change_id", "=", change.id)
-		.selectAll()
-		.execute();
-
-	expect(changeAuthors.length).toBe(2);
-	expect(changeAuthors).toMatchObject([
-		{ change_id: change.id, account_id: account1.id },
-		{ change_id: change.id, account_id: account2.id },
-	]);
-});
-
-test("should correctly identify parentChange and create change_edge", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	const author = await createAccount({
-		lix,
-		name: "author",
-	});
-
-	const parentChange = await createChange({
-		lix,
-		version: version0,
-		authors: [author],
-		entityId: "entity1",
-		fileId: "file1",
-		pluginKey: "plugin1",
-		schemaKey: "schema1",
-		snapshotContent: { text: "parent-snapshot-content" },
-	});
-
-	const change = await createChange({
-		lix,
-		version: version0,
-		authors: [author],
-		entityId: "entity1",
-		fileId: "file1",
-		pluginKey: "plugin1",
-		schemaKey: "schema1",
-		snapshotContent: { text: "child-snapshot-content" },
-	});
-
-	const changeEdges = await lix.db
-		.selectFrom("change_edge")
-		.where("change_edge.child_id", "=", change.id)
-		.selectAll()
-		.execute();
-
-	expect(changeEdges.length).toBe(1);
-	expect(changeEdges[0]?.parent_id).toBe(parentChange.id);
-});
-
-test("should update versionChanges with the new change", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	const author = await createAccount({
-		lix,
-		name: "author",
-	});
-
-	const change = await createChange({
-		lix,
-		version: version0,
-		authors: [author],
-		entityId: "entity1",
-		fileId: "file1",
-		pluginKey: "plugin1",
-		schemaKey: "schema1",
-		snapshotContent: { text: "snapshot-content" },
-	});
-
-	const versionChanges = await lix.db
-		.selectFrom("version_change")
-		.where("version_change.version_id", "=", version0.id)
-		.selectAll()
-		.execute();
-
-	expect(versionChanges.length).toBe(1);
-	expect(versionChanges[0]?.change_id).toBe(change.id);
-});
-
-test("should throw an error if authors array is empty", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	await expect(
-		createChange({
-			lix,
-			authors: [],
-			version: version0,
-			entityId: "entity1",
-			fileId: "file1",
-			pluginKey: "plugin1",
-			schemaKey: "schema1",
-			snapshotContent: { text: "snapshot-content" },
-		})
-	).rejects.toThrow("At least one author is required");
-});
-
-test("option to create a change without updating the version changes", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	const author = await createAccount({
-		lix,
-		name: "author",
-	});
-
-	const change = await createChange(
-		{
-			lix,
-			version: version0,
-			authors: [author],
-			entityId: "entity1",
-			fileId: "file1",
-			pluginKey: "plugin1",
-			schemaKey: "schema1",
-			snapshotContent: { text: "snapshot-content" },
-		},
-		{
-			updateVersionChanges: false,
-		}
-	);
-
-	const versionChanges = await lix.db
-		.selectFrom("version_change")
-		.where("version_change.version_id", "=", version0.id)
-		.selectAll()
-		.execute();
-
-	expect(
-		versionChanges.find((vc) => vc.change_id === change.id)
-	).toBeUndefined();
-});

package/src/change/create-change.ts

@@ -1,129 +0,0 @@
-import { sql } from "kysely";
-import type { Account } from "../account/database-schema.js";
-import { executeSync } from "../database/execute-sync.js";
-import type { Change, Snapshot, Version } from "../database/schema.js";
-import type { Lix } from "../lix/open-lix.js";
-import { changeIsLeafInVersion } from "../query-filter/change-is-leaf-in-version.js";
-import { updateChangesInVersion } from "../version/update-changes-in-version.js";
-
-/**
- * Programatically create a change in the database.
- *
- * Use this function to directly create a change from a lix app
- * with bypassing of file-based change detection.
- */
-export async function createChange(
-	args: {
-		lix: Pick<Lix, "db" | "sqlite">;
-		authors: Array<Pick<Account, "id">>;
-		version: Pick<Version, "id">;
-		entityId: Change["entity_id"];
-		fileId: Change["file_id"];
-		pluginKey: Change["plugin_key"];
-		schemaKey: Change["schema_key"];
-		snapshotContent: Snapshot["content"];
-	},
-	options?: {
-		/**
-		 * When true, the version changes will be updated.
-		 *
-		 * Defaults to true.
-		 */
-		updateVersionChanges?: boolean;
-	}
-): Promise<Change> {
-	const optionsWithDefaults = {
-		updateVersionChanges: true,
-		...options,
-	};
-
-	if (args.authors.length === 0) {
-		throw new Error("At least one author is required");
-	}
-
-	// const executeInTransaction = async (trx: Lix["db"]) => {
-	const snapshot = executeSync({
-		lix: args.lix,
-		query: args.lix.db
-			.insertInto("snapshot")
-			.values({
-				content: args.snapshotContent ?? null,
-			})
-			.onConflict((oc) =>
-				oc.doUpdateSet((eb) => ({
-					content: eb.ref("excluded.content"),
-				}))
-			)
-			.returningAll()
-			.returning(sql`json(content)`.as("content")),
-	})[0] as Snapshot;
-
-	snapshot.content = JSON.parse(snapshot.content as unknown as string);
-
-	const change = executeSync({
-		lix: args.lix,
-		query: args.lix.db
-			.insertInto("change")
-			.values({
-				entity_id: args.entityId,
-				plugin_key: args.pluginKey,
-				file_id: args.fileId,
-				schema_key: args.schemaKey,
-				snapshot_id: snapshot.id,
-			})
-			.returningAll(),
-	})[0] as Change;
-
-	const parentChange = executeSync({
-		lix: args.lix,
-		query: args.lix.db
-			.selectFrom("change")
-			.where("file_id", "=", change.file_id)
-			.where("schema_key", "=", change.schema_key)
-			.where("entity_id", "=", change.entity_id)
-			.where(changeIsLeafInVersion(args.version))
-			.select("id"),
-	})[0] as Change | undefined;
-
-	// If a parent exists, the change is a child of the parent
-	if (parentChange) {
-		executeSync({
-			lix: args.lix,
-			query: args.lix.db.insertInto("change_edge").values({
-				parent_id: parentChange.id,
-				child_id: change.id,
-			}),
-		});
-	}
-
-	for (const author of args.authors) {
-		try {
-			executeSync({
-				lix: args.lix,
-				query: args.lix.db.insertInto("change_author").values({
-					change_id: change.id,
-					account_id: author.id,
-				}),
-			});
-		} catch (e) {
-			console.log(e);
-		}
-	}
-
-	// update the version with the new change
-	if (optionsWithDefaults.updateVersionChanges) {
-		updateChangesInVersion({
-			lix: { ...args.lix },
-			changes: [change],
-			version: args.version,
-		});
-	}
-
-	return change;
-}
-// if (args.lix.db.isTransaction) {
-// 	return executeInTransaction(args.lix.db);
-// } else {
-// 	return args.lix.db.transaction().execute(executeInTransaction);
-// }
-// }

package/src/change/mock-change.ts

@@ -1,21 +0,0 @@
-import type { Change, NewChange } from "../database/schema.js";
-
-/**
- * Creates a mock change object with the given properties.
- *
- * @example
- *   const change = mockChange({ id: "change1" });
- *   await lix.db.insertInto("change").values(change).execute();
- */
-export function mockChange(args: Partial<NewChange>): Change {
-	return {
-		id: "mock",
-		created_at: "mock",
-		plugin_key: "mock",
-		file_id: "mock",
-		entity_id: "mock",
-		schema_key: "mock",
-		snapshot_id: "no-content",
-		...args,
-	};
-}

package/src/change-schema/README.md

@@ -1,3 +0,0 @@
-THIS IS EXPERIMENTAL AND NOT YET READY FOR USE.
-
-talk to @samuelstroschein if you want to know more.

package/src/change-schema/index.ts

@@ -1,4 +0,0 @@
-export {
-	type ExperimentalChangeSchema,
-	type ExperimentalInferType,
-} from "./types.js";

package/src/change-schema/types.test-d.ts

@@ -1,52 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import type {
-	ExperimentalChangeSchema,
-	ExperimentalInferType,
-} from "./types.js";
-import { test, assertType } from "vitest";
-
-test("a json change schema should be infer the properties", () => {
-	const jsonChangeSchema = {
-		key: "mock",
-		type: "json",
-		schema: {
-			type: "object",
-			properties: {
-				name: { type: "string" },
-				age: { type: "number" },
-				location: { type: "object" },
-			},
-			required: ["name", "age", "location"],
-		},
-	} as const satisfies ExperimentalChangeSchema;
-
-	const snapshot: ExperimentalInferType<typeof jsonChangeSchema> = {
-		name: "John",
-		age: 5,
-		location: {
-			city: "New York",
-			country: "USA",
-		},
-	};
-
-	assertType<{
-		[x: string]: unknown;
-		name: string;
-		age: number;
-		location: {
-			[x: string]: unknown;
-		};
-	}>(snapshot);
-});
-
-test("a blob change schema should be infer the properties", () => {
-	const blobChangeSchema = {
-		key: "mock",
-		type: "blob",
-	} as const satisfies ExperimentalChangeSchema;
-
-	const snapshot: ExperimentalInferType<typeof blobChangeSchema> =
-		new ArrayBuffer(0);
-
-	assertType<ArrayBuffer>(snapshot);
-});

package/src/change-schema/types.ts

@@ -1,53 +0,0 @@
-import type { FromSchema, JSONSchema } from "json-schema-to-ts";
-
-/**
- * Infers the snapshot content type from the schema.
- */
-export type ExperimentalInferType<ChangeSchema> =
-	// If the schema is a JSON schema and the schema is provided,
-	ChangeSchema extends {
-		type: "json";
-		schema: JSONSchema;
-	}
-		? // infer the type from the schema.
-			FromSchema<ChangeSchema["schema"]>
-		: // else if the schema is a JSON schema and the schema is not provided,
-			ChangeSchema extends { type: "json" }
-			? // infer the type as any.
-				any
-			: // else if the schema is a blob schema,
-				// infer the type as an ArrayBuffer.
-				ChangeSchema extends { type: "blob" }
-				? ArrayBuffer
-				: // else infer the type as never.
-					never;
-
-/**
- * The schema of a detected change.
- *
- * The key is used to identify the schema. It is highly
- * recommended to use a unique key for each schema and
- * include a version number in the key when breaking
- * changes are made.
- *
- * - use `as const` to narrow the types
- * - use `... satisfies ChangeSchema` to get autocomplete
- *
- * @example
- *   const FooV1 = {
- *      key: "csv-plugin-foo-v1",
- *      type: "json",
- *      schema: jsonSchema,
- *   } as const satisfies ChangeSchema;
- */
-export type ExperimentalChangeSchema =
-	| {
-			key: string;
-			type: "json";
-			schema: JSONSchema;
-	  }
-	| {
-			key: string;
-			type: "blob";
-			schema?: undefined;
-	  };

package/src/change-set/change-set-element-in-symmetric-difference.test.ts

@@ -1,128 +0,0 @@
-import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { changeSetElementInSymmetricDifference } from "./change-set-element-in-symmetric-difference.js";
-import type { ChangeSet, ChangeSetElement } from "../database/schema.js";
-import { mockChange } from "../change/mock-change.js";
-
-test("should return the symmetric difference between two change sets", async () => {
-	const lix = await openLixInMemory({});
-
-	// Insert test data
-	const changeSetA: ChangeSet = { id: "changeSetA" };
-	const changeSetB: ChangeSet = { id: "changeSetB" };
-
-	await lix.db
-		.insertInto("change_set")
-		.values([changeSetA, changeSetB])
-		.execute();
-
-	await lix.db
-		.insertInto("change")
-		.values([
-			mockChange({ id: "change1" }),
-			mockChange({ id: "change2" }),
-			mockChange({ id: "change3" }),
-			mockChange({ id: "change4" }),
-		])
-		.returningAll()
-		.execute();
-
-	const changesA: ChangeSetElement[] = [
-		{ change_set_id: "changeSetA", change_id: "change1" },
-		{ change_set_id: "changeSetA", change_id: "change2" },
-	];
-
-	const changesB: ChangeSetElement[] = [
-		{ change_set_id: "changeSetB", change_id: "change2" },
-		{ change_set_id: "changeSetB", change_id: "change3" },
-	];
-
-	await lix.db
-		.insertInto("change_set_element")
-		.values([...changesA, ...changesB])
-		.execute();
-
-	const result = await lix.db
-		.selectFrom("change_set_element")
-		.where(changeSetElementInSymmetricDifference(changeSetA, changeSetB))
-		.selectAll()
-		.execute();
-
-	expect(result).toEqual([
-		// change 1 is in A but not in B
-		expect.objectContaining({
-			change_set_id: "changeSetA",
-			change_id: "change1",
-		}),
-		// change 3 is in B but not in A
-		expect.objectContaining({
-			change_set_id: "changeSetB",
-			change_id: "change3",
-		}),
-		// change 4 is in neither A nor B
-		// hence not in the symmetric difference
-	]);
-});
-
-test("should return an empty array if there are no differences", async () => {
-	const lix = await openLixInMemory({});
-
-	// Insert test data
-	const changeSetA: ChangeSet = { id: "changeSetA" };
-	const changeSetB: ChangeSet = { id: "changeSetB" };
-
-	await lix.db
-		.insertInto("change_set")
-		.values([changeSetA, changeSetB])
-		.execute();
-
-	await lix.db
-		.insertInto("change")
-		.values([
-			mockChange({ id: "change1" }),
-			mockChange({ id: "change2" }),
-			mockChange({ id: "change3" }),
-			mockChange({ id: "change4" }),
-		])
-		.returningAll()
-		.execute();
-
-	const changes: ChangeSetElement[] = [
-		{ change_set_id: "changeSetA", change_id: "change1" },
-		{ change_set_id: "changeSetA", change_id: "change2" },
-		{ change_set_id: "changeSetB", change_id: "change1" },
-		{ change_set_id: "changeSetB", change_id: "change2" },
-	];
-
-	await lix.db.insertInto("change_set_element").values(changes).execute();
-
-	const result = await lix.db
-		.selectFrom("change_set_element")
-		.where(changeSetElementInSymmetricDifference(changeSetA, changeSetB))
-		.selectAll()
-		.execute();
-
-	expect(result).toEqual([]);
-});
-
-test("should handle empty change sets", async () => {
-	const lix = await openLixInMemory({});
-
-	// Insert test data
-	const changeSetA: ChangeSet = { id: "changeSetA" };
-	const changeSetB: ChangeSet = { id: "changeSetB" };
-
-	await lix.db
-		.insertInto("change_set")
-		.values([changeSetA, changeSetB])
-		.execute();
-
-	const result = await lix.db
-		.selectFrom("change_set_element")
-		.where(changeSetElementInSymmetricDifference(changeSetA, changeSetB))
-		.selectAll()
-		.execute();
-
-	// Verify the results
-	expect(result).toEqual([]);
-});