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

package/dist/version/schema.test.js

@@ -0,0 +1,661 @@
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { createVersion } from "./create-version.js";
+test("insert, update, delete on the version view", async () => {
+    const lix = await openLix({});
+    // Create required change sets first
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "change_set_id_0", lixcol_version_id: "global" },
+        { id: "change_set_id_1", lixcol_version_id: "global" },
+        { id: "working_cs_0", lixcol_version_id: "global" },
+        { id: "working_cs_1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version_all")
+        .values([
+        {
+            id: "version0",
+            name: "version0",
+            change_set_id: "change_set_id_0",
+            working_change_set_id: "working_cs_0",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "version1",
+            name: "version1",
+            change_set_id: "change_set_id_1",
+            working_change_set_id: "working_cs_1",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    const viewAfterInsert = await lix.db
+        .selectFrom("version")
+        .orderBy("name", "asc")
+        .where("id", "in", ["version0", "version1"])
+        .selectAll()
+        .execute();
+    expect(viewAfterInsert).toMatchObject([
+        {
+            name: "version0",
+            change_set_id: "change_set_id_0",
+        },
+        {
+            name: "version1",
+            change_set_id: "change_set_id_1",
+        },
+    ]);
+    await lix.db
+        .updateTable("version")
+        .where("name", "=", "version0")
+        .set({ change_set_id: "change_set_id_1" })
+        .execute();
+    const viewAfterUpdate = await lix.db
+        .selectFrom("version")
+        .orderBy("name", "asc")
+        .where("id", "in", ["version0", "version1"])
+        .selectAll()
+        .execute();
+    expect(viewAfterUpdate).toMatchObject([
+        {
+            name: "version0",
+            change_set_id: "change_set_id_1",
+        },
+        {
+            name: "version1",
+            change_set_id: "change_set_id_1",
+        },
+    ]);
+    await lix.db.deleteFrom("version").where("id", "=", "version0").execute();
+    const viewAfterDelete = await lix.db
+        .selectFrom("version")
+        .orderBy("name", "asc")
+        .where("id", "in", ["version0", "version1"])
+        .selectAll()
+        .execute();
+    expect(viewAfterDelete).toMatchObject([
+        {
+            id: "version1",
+            name: "version1",
+            change_set_id: "change_set_id_1",
+            working_change_set_id: "working_cs_1",
+            inherits_from_version_id: "global",
+        },
+    ]);
+    const changes = await lix.db
+        .selectFrom("change")
+        .where("schema_key", "=", "lix_version")
+        .where("entity_id", "in", ["version0", "version1"])
+        .orderBy("change.created_at", "asc")
+        .selectAll("change")
+        .execute();
+    expect(changes.map((change) => change.snapshot_content)).toMatchObject([
+        // version 0's insert
+        {
+            name: "version0",
+            change_set_id: "change_set_id_0",
+        },
+        // version 0's insert
+        {
+            name: "version1",
+            change_set_id: "change_set_id_1",
+        },
+        {
+            // version 0's update
+            name: "version0",
+            change_set_id: "change_set_id_1",
+        },
+        // version 0's delete
+        null,
+    ]);
+});
+test("querying by id", async () => {
+    const lix = await openLix({});
+    // Create required change sets first
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "change_set_id_0", lixcol_version_id: "global" },
+        { id: "change_set_id_1", lixcol_version_id: "global" },
+        { id: "working_cs_0", lixcol_version_id: "global" },
+        { id: "working_cs_1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values([
+        {
+            id: "version0",
+            name: "version0",
+            change_set_id: "change_set_id_0",
+            working_change_set_id: "working_cs_0",
+        },
+        {
+            id: "version1",
+            name: "version1",
+            change_set_id: "change_set_id_1",
+            working_change_set_id: "working_cs_1",
+        },
+    ])
+        .execute();
+    const versions = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "version0")
+        .select("id")
+        .execute();
+    expect(versions).toHaveLength(1);
+    expect(versions[0]?.id).toBe("version0");
+});
+test("update active version view", async () => {
+    const lix = await openLix({});
+    // Create required change sets and version first
+    await lix.db
+        .insertInto("change_set_all")
+        .values([{ id: "cs1", lixcol_version_id: "global" }])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "version_id_1",
+        name: "test_version",
+        change_set_id: "cs1",
+        working_change_set_id: "cs1",
+    })
+        .execute();
+    await lix.db
+        .updateTable("active_version")
+        .set({ version_id: "version_id_1" })
+        .execute();
+    const viewAfterUpdate = await lix.db
+        .selectFrom("active_version")
+        .selectAll()
+        .execute();
+    expect(viewAfterUpdate).toMatchObject([
+        {
+            version_id: "version_id_1",
+        },
+    ]);
+});
+test("applying the schema should create an initial 'main' version", async () => {
+    const lix = await openLix({});
+    const initialVersion = await lix.db
+        .selectFrom("version")
+        .where("name", "=", "main")
+        .selectAll()
+        .executeTakeFirst();
+    expect(initialVersion).toBeDefined();
+});
+test("applying the schema should set the initial active version to 'main'", async () => {
+    const lix = await openLix({});
+    const activeVersion = await lix.db
+        .selectFrom("active_version")
+        .selectAll()
+        .executeTakeFirst();
+    expect(activeVersion).toBeDefined();
+    // Verify the active version points to the main version
+    const mainVersion = await lix.db
+        .selectFrom("version")
+        .where("name", "=", "main")
+        .selectAll()
+        .executeTakeFirst();
+    expect(mainVersion).toBeDefined();
+    expect(activeVersion?.version_id).toBe(mainVersion?.id);
+});
+test("should use default id and name if not provided", async () => {
+    const lix = await openLix({});
+    // Pre-populate change_set table
+    await lix.db
+        .insertInto("change_set_all")
+        .values([{ id: "cs1", lixcol_version_id: "global" }])
+        .execute();
+    // Insert a version providing only change_set_id
+    await lix.db
+        .insertInto("version")
+        .values({
+        change_set_id: "cs1",
+        working_change_set_id: "cs1",
+    })
+        .execute();
+    // Verify the inserted data (id and name should be defaulted)
+    const version = await lix.db
+        .selectFrom("version")
+        .selectAll()
+        .where("change_set_id", "=", "cs1")
+        .executeTakeFirstOrThrow();
+    expect(version?.id).toBeTypeOf("string");
+    expect(version?.id.length).toBeGreaterThan(0);
+    expect(version?.name).toBeTypeOf("string");
+    expect(version?.name?.length).toBeGreaterThan(0);
+    expect(version?.change_set_id).toBe("cs1");
+    await lix.db
+        .updateTable("version")
+        .where("id", "=", version.id)
+        .set({
+        name: "new_name",
+    })
+        .executeTakeFirstOrThrow();
+    const updatedVersion = await lix.db
+        .selectFrom("version")
+        .selectAll()
+        .where("id", "=", version.id)
+        .executeTakeFirstOrThrow();
+    expect(updatedVersion?.name).toBe("new_name");
+});
+test("should enforce foreign key constraint on change_set_id", async () => {
+    const lix = await openLix({});
+    // Attempt to insert version with non-existent change_set_id
+    await expect(lix.db
+        .insertInto("version")
+        .values({
+        id: "version1",
+        name: "test_version",
+        change_set_id: "cs_nonexistent",
+        working_change_set_id: "cs_nonexistent",
+    })
+        .execute()).rejects.toThrow(/Foreign key constraint violation/i);
+});
+test("should enforce foreign key constraint on working_change_set_id", async () => {
+    const lix = await openLix({});
+    // Create valid change set for change_set_id
+    await lix.db
+        .insertInto("change_set_all")
+        .values({ id: "cs1", lixcol_version_id: "global" })
+        .execute();
+    // Attempt to insert version with non-existent working_change_set_id
+    await expect(lix.db
+        .insertInto("version")
+        .values({
+        id: "version1",
+        name: "test_version",
+        change_set_id: "cs1",
+        working_change_set_id: "cs_nonexistent",
+    })
+        .execute()).rejects.toThrow(/Foreign key constraint violation/i);
+});
+test("should allow version insertion with valid change set references", async () => {
+    const lix = await openLix({});
+    // Create valid change sets
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "cs1", lixcol_version_id: "global" },
+        { id: "cs2", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // This should succeed with valid foreign key references
+    await expect(lix.db
+        .insertInto("version")
+        .values({
+        id: "version1",
+        name: "test_version",
+        change_set_id: "cs1",
+        working_change_set_id: "cs2",
+    })
+        .execute()).resolves.toBeDefined();
+});
+// having the active_version as regular table is easier
+test.skip("should enforce foreign key constraint on active_version.version_id", async () => {
+    const lix = await openLix({});
+    // Now attempt to update active_version with non-existent version_id
+    await expect(lix.db
+        .updateTable("active_version")
+        .set({ version_id: "version_nonexistent" })
+        .execute()).rejects.toThrow(/Foreign key constraint violation/i);
+});
+test("should allow active_version update with valid version_id", async () => {
+    const lix = await openLix({});
+    // Create valid change set and version
+    await lix.db
+        .insertInto("change_set_all")
+        .values({ id: "cs1", lixcol_version_id: "global" })
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "version1",
+        name: "test_version",
+        change_set_id: "cs1",
+        working_change_set_id: "cs1",
+    })
+        .execute();
+    // This should succeed with valid foreign key reference
+    await expect(lix.db
+        .updateTable("active_version")
+        .set({ version_id: "version1" })
+        .execute()).resolves.toBeDefined();
+});
+test("versions should be globally accessible regardless of version context", async () => {
+    const lix = await openLix({});
+    // Create required change sets
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "cs_a", lixcol_version_id: "global" },
+        { id: "cs_b", lixcol_version_id: "global" },
+        { id: "cs_c", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Create versions using the version view (simulating creation from different version contexts)
+    await lix.db
+        .insertInto("version")
+        .values([
+        {
+            id: "version_a",
+            name: "Version A",
+            change_set_id: "cs_a",
+            working_change_set_id: "cs_a",
+        },
+        {
+            id: "version_b",
+            name: "Version B",
+            change_set_id: "cs_b",
+            working_change_set_id: "cs_b",
+        },
+        {
+            id: "version_c",
+            name: "Version C",
+            change_set_id: "cs_c",
+            working_change_set_id: "cs_c",
+        },
+    ])
+        .execute();
+    // Query all versions globally (without version_id filtering)
+    const allVersions = await lix.db
+        .selectFrom("version")
+        .selectAll()
+        .orderBy("name", "asc")
+        .execute();
+    // Should include main version (created automatically) + our 3 created versions
+    expect(allVersions).toHaveLength(5);
+    const versionNames = allVersions.map((v) => v.name);
+    expect(versionNames).toContain("global");
+    expect(versionNames).toContain("main");
+    expect(versionNames).toContain("Version A");
+    expect(versionNames).toContain("Version B");
+    expect(versionNames).toContain("Version C");
+});
+test("mutation of a version's state should NOT lead to duplicate version entries", async () => {
+    const lix = await openLix({});
+    const versionA = await createVersion({
+        lix,
+        id: "versionA",
+        name: "versionA",
+    });
+    const versionsBeforeMutation = await lix.db
+        .selectFrom("version")
+        .where("id", "=", versionA.id)
+        .groupBy("id")
+        .select(["id", "name", "change_set_id", "working_change_set_id"])
+        .execute();
+    expect(versionsBeforeMutation).toHaveLength(1);
+    expect(versionsBeforeMutation[0]).toMatchObject({
+        id: versionA.id,
+        name: "versionA",
+        change_set_id: expect.any(String),
+        working_change_set_id: expect.any(String),
+    });
+    await lix.db
+        .insertInto("state_all")
+        .values({
+        entity_id: "test_entity",
+        version_id: versionA.id,
+        snapshot_content: { foo: "bar" },
+        schema_key: "test_schema",
+        file_id: "test_file",
+        plugin_key: "test_plugin",
+        schema_version: "1.0",
+    })
+        .execute();
+    const versionAAfterMutation = await lix.db
+        .selectFrom("version")
+        .where("id", "=", versionA.id)
+        .groupBy("id")
+        .select(["id", "name", "change_set_id", "working_change_set_id"])
+        .execute();
+    expect(versionAAfterMutation).toHaveLength(1);
+    // The changeset should have advanced due to the state mutation
+    expect(versionAAfterMutation[0]?.change_set_id).not.toEqual(versionA.change_set_id);
+});
+test("direct mutation of a version shouldn't lead to duplicate entries", async () => {
+    const lix = await openLix({});
+    const versionA = await createVersion({
+        lix,
+        id: "versionA",
+        name: "versionA",
+    });
+    const versionABeforeMutation = await lix.db
+        .selectFrom("version")
+        .where("id", "=", versionA.id)
+        .selectAll()
+        .execute();
+    const globalVersionBeforeMutation = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "global")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(versionABeforeMutation).toMatchObject([
+        {
+            id: versionA.id,
+            name: "versionA",
+            change_set_id: expect.any(String),
+            working_change_set_id: expect.any(String),
+        },
+    ]);
+    await lix.db
+        .updateTable("version")
+        .where("id", "=", versionA.id)
+        .set({
+        name: "new name",
+    })
+        .execute();
+    const versionsAfterMutation = await lix.db
+        .selectFrom("version")
+        .where("id", "=", versionA.id)
+        .selectAll()
+        .execute();
+    const globalVersionAfterMutation = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "global")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(versionsAfterMutation).toMatchObject([
+        {
+            id: versionA.id,
+            name: "new name",
+            change_set_id: expect.any(String),
+            working_change_set_id: expect.any(String),
+        },
+    ]);
+    // the version was updated in the global version aka
+    // the versions change set did not change itself
+    expect(versionsAfterMutation[0]?.change_set_id).toEqual(versionABeforeMutation[0]?.change_set_id);
+    // but the global version's change set id should have changed
+    expect(globalVersionAfterMutation.change_set_id).not.toEqual(globalVersionBeforeMutation.change_set_id);
+});
+test("should enforce UNIQUE constraint on working_change_set_id", async () => {
+    const lix = await openLix({});
+    // Insert necessary change sets to satisfy foreign keys
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "cs1", lixcol_version_id: "global" },
+        { id: "cs2", lixcol_version_id: "global" },
+        { id: "workingCs1", lixcol_version_id: "global" },
+        { id: "workingCs2", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Insert first version referencing workingCs1
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "v1",
+        name: "version one",
+        change_set_id: "cs1",
+        working_change_set_id: "workingCs1",
+    })
+        .execute();
+    // Attempt to insert another version referencing the SAME workingCs1 -> should fail
+    await expect(lix.db
+        .insertInto("version")
+        .values({
+        id: "v2",
+        name: "version two",
+        change_set_id: "cs2", // Different historical point is fine
+        working_change_set_id: "workingCs1", // <<< Same working_change_set_id
+    })
+        .execute()).rejects.toThrow(/Unique constraint violation.*working_change_set_id.*workingCs1/i);
+    // Inserting another version with a DIFFERENT working_change_set_id should succeed
+    await expect(lix.db
+        .insertInto("version")
+        .values({
+        id: "v3",
+        name: "version three",
+        change_set_id: "cs1", // Can branch from same historical point
+        working_change_set_id: "workingCs2", // <<< Different working_change_set_id
+    })
+        .execute()).resolves.toBeDefined();
+});
+// there was a bug that wiped the cache, leading to a missing change_set
+test("initial version's change_set_id and working_change_set_id should exist in the change_set table", async () => {
+    const lix = await openLix({});
+    // Get the initial 'main' version
+    const mainVersion = await lix.db
+        .selectFrom("version")
+        .where("name", "=", "main")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Verify change_set_id exists in change_set table
+    const changeSet = await lix.db
+        .selectFrom("change_set")
+        .where("id", "=", mainVersion.change_set_id)
+        .selectAll()
+        .executeTakeFirst();
+    expect(changeSet).toBeDefined();
+    expect(changeSet?.id).toBe(mainVersion.change_set_id);
+    // Verify working_change_set_id exists in change_set table
+    const workingChangeSet = await lix.db
+        .selectFrom("change_set")
+        .where("id", "=", mainVersion.working_change_set_id)
+        .selectAll()
+        .executeTakeFirst();
+    expect(workingChangeSet).toBeDefined();
+    expect(workingChangeSet?.id).toBe(mainVersion.working_change_set_id);
+});
+test("inherits_from_version_id should default to global", async () => {
+    const lix = await openLix({});
+    // Create required change sets first
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "change_set_1", lixcol_version_id: "global" },
+        { id: "working_change_set_1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "test_version",
+        name: "Test Version",
+        change_set_id: "change_set_1",
+        working_change_set_id: "working_change_set_1",
+        inherits_from_version_id: undefined, // Should default to 'global'
+    })
+        .execute();
+    const version = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "test_version")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(version.id).toBe("test_version");
+});
+test("global version should not inherit from itself", async () => {
+    const lix = await openLix({});
+    // Get the existing global version
+    const globalVersion = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "global")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Global version should not inherit from anything
+    expect(globalVersion.inherits_from_version_id).toBeNull();
+});
+test("versions should have hidden property defaulting to false", async () => {
+    const lix = await openLix({});
+    // Create required change sets first
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "cs_test", lixcol_version_id: "global" },
+        { id: "working_cs_test", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Insert a version without specifying hidden
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "test_version",
+        name: "Test Version",
+        change_set_id: "cs_test",
+        working_change_set_id: "working_cs_test",
+    })
+        .execute();
+    const version = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "test_version")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Hidden should default to false (SQLite stores as 0)
+    expect(version.hidden).toBe(0);
+});
+test("global version should have hidden set to true", async () => {
+    const lix = await openLix({});
+    const globalVersion = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "global")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Global version should be hidden (SQLite stores as 1)
+    expect(globalVersion.hidden).toBe(1);
+});
+test("main version should have hidden set to false", async () => {
+    const lix = await openLix({});
+    const mainVersion = await lix.db
+        .selectFrom("version")
+        .where("name", "=", "main")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Main version should not be hidden (SQLite stores as 0)
+    expect(mainVersion.hidden).toBe(0);
+});
+test("can explicitly set hidden to true", async () => {
+    const lix = await openLix({});
+    // Create required change sets first
+    await lix.db
+        .insertInto("change_set_all")
+        .values([
+        { id: "cs_hidden", lixcol_version_id: "global" },
+        { id: "working_cs_hidden", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Insert a version with hidden explicitly set to true
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "hidden_version",
+        name: "Hidden Version",
+        change_set_id: "cs_hidden",
+        working_change_set_id: "working_cs_hidden",
+        hidden: true,
+    })
+        .execute();
+    const version = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "hidden_version")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(version.hidden).toBe(1);
+});
+//# sourceMappingURL=schema.test.js.map