@sixb/core 0.1.21 → 0.1.22

package/src/testing/artifact-storage-contract.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import { ARTIFACT_STATE_LIMITS } from "../artifacts/limits"
 import type { Principal } from "../auth"
 import type { FileRef } from "../blob-storage"
 import {
@@ -120,6 +121,50 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
       })
     })
 
+    test("publishes from a base version, and refuses one the artifact has moved past", async () => {
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput())
+        const edited = await artifacts.publish({
+          ...publishInput({ author: otherOwner, origin: undefined, createdAt: at(1) }),
+          baseVersion: 1,
+        })
+        expect(edited.version.version).toBe(2)
+
+        // A second save from version 1 would replace version 2's changes unseen.
+        const error = await artifacts
+          .publish({ ...publishInput({ createdAt: at(2) }), baseVersion: 1 })
+          .then(
+            () => null,
+            (caught: unknown) => caught
+          )
+        expect(error).toBeInstanceOf(ArtifactStorageError)
+        expect(error).toMatchObject({
+          code: "artifact_moved",
+          latest: { version: 2, author: otherOwner },
+        })
+        expect((await artifacts.get({ projectId, id: "art_report" }))?.latestVersion).toBe(2)
+
+        // Of two publishes racing from one base, one is stored and the other finds it moved. This
+        // fixes the outcome only: the in-memory and SQLite storages run each call whole under
+        // their own lock, so the race cannot fail there. Postgres proves its row lock in
+        // `storage/pg/tests/pg-artifact-storage.e2e.ts`.
+        const raced = await Promise.allSettled([
+          artifacts.publish({ ...publishInput({ createdAt: at(3) }), baseVersion: 2 }),
+          artifacts.publish({ ...publishInput({ createdAt: at(4) }), baseVersion: 2 }),
+        ])
+        expect(raced.filter((result) => result.status === "fulfilled")).toHaveLength(1)
+        const refused = raced.find((result) => result.status === "rejected")
+        expect(refused?.status === "rejected" && refused.reason).toMatchObject({
+          code: "artifact_moved",
+          latest: { version: 3 },
+        })
+        // Without a base, a publish is stored over whatever is latest.
+        expect((await artifacts.publish(publishInput({ createdAt: at(5) }))).version.version).toBe(
+          4
+        )
+      })
+    })
+
     test("stores a version's files, outline, references, and origin exactly", async () => {
       await withStorage(async (artifacts) => {
         const version = versionInput({
@@ -149,6 +194,22 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
       })
     })
 
+    test("keeps a page, and lists it as its kind", async () => {
+      await withStorage(async (artifacts) => {
+        const version = versionInput({
+          entry: "index.html",
+          files: [{ path: "index.html", file: fileRef("a", "text/html") }],
+          outline: { kind: "page", title: "Fleet planner" },
+        })
+        await artifacts.create(createInput({ id: "art_planner", kind: "page", version }))
+        expect(
+          await artifacts.getVersion({ projectId, artifactId: "art_planner", version: 1 })
+        ).toMatchObject({ outline: { kind: "page", title: "Fleet planner" } })
+        const pages = await artifacts.list({ projectId, kind: "page", limit: 10 })
+        expect(pages.artifacts.map((artifact) => artifact.id)).toEqual(["art_planner"])
+      })
+    })
+
     test("lists the latest versions that refer to an artifact, at any version, file, or part", async () => {
       await withStorage(async (artifacts) => {
         const refer = (address: string) => ({
@@ -271,7 +332,7 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
       })
     })
 
-    test("lists by owner, by the thread a version came from, and only within the project", async () => {
+    test("lists by owner, by the thread it is shared in, and only within the project", async () => {
       await withStorage(async (artifacts) => {
         await artifacts.create(createInput({ id: "art_mine" }))
         await artifacts.create(
@@ -300,13 +361,173 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
 
         expect(await ids({ projectId, owner })).toEqual(["art_api", "art_mine"])
         expect(await ids({ projectId, owner: otherOwner })).toEqual(["art_theirs"])
-        expect(await ids({ projectId, originThreadId: "thr_1" })).toEqual(["art_mine"])
-        expect(await ids({ projectId, originThreadId: "thr_3" })).toEqual(["art_api"])
-        expect(await ids({ projectId, owner, originThreadId: "thr_2" })).toEqual([])
+        expect(await ids({ projectId, threadId: "thr_1" })).toEqual(["art_mine"])
+        expect(await ids({ projectId, threadId: "thr_3" })).toEqual(["art_api"])
+        expect(await ids({ projectId, owner, threadId: "thr_2" })).toEqual([])
         expect(await ids({ projectId: otherProjectId })).toEqual(["art_elsewhere"])
       })
     })
 
+    // Regression proof: drop `sharedIn` from the in-memory publish, or the link insert from a SQL
+    // provider's; the revised artifact is then not shared in thr_2.
+    test("shares an artifact in each thread a version came from", async () => {
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput({ id: "art_mine" }))
+        await artifacts.publish(
+          publishInput(
+            { origin: { threadId: "thr_2", runId: "run_2" }, createdAt: at(1) },
+            "art_mine"
+          )
+        )
+        await artifacts.publish(publishInput({ origin: undefined, createdAt: at(2) }, "art_mine"))
+        expect(await artifacts.listThreadIds({ projectId, id: "art_mine" })).toEqual([
+          "thr_1",
+          "thr_2",
+        ])
+        expect(
+          (await artifacts.list({ projectId, threadId: "thr_2" })).artifacts.map(
+            (artifact) => artifact.id
+          )
+        ).toEqual(["art_mine"])
+
+        await artifacts.delete({ projectId, id: "art_mine" })
+        expect(await artifacts.listThreadIds({ projectId, id: "art_mine" })).toEqual([])
+        await artifacts.create(
+          createInput({ id: "art_mine", version: versionInput({ origin: undefined }) })
+        )
+        expect(await artifacts.listThreadIds({ projectId, id: "art_mine" })).toEqual([])
+      })
+    })
+
+    // Regression proof: keep every link in a provider's `deleteVersionsByOrigin`; thr_2 then keeps
+    // sharing art_mine with nothing from it left.
+    test("unshares an artifact from a retried run's thread once nothing from there remains", async () => {
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput({ id: "art_mine" }))
+        await artifacts.publish(
+          publishInput(
+            { origin: { threadId: "thr_2", runId: "run_2" }, createdAt: at(1) },
+            "art_mine"
+          )
+        )
+        await artifacts.publish(
+          publishInput(
+            { origin: { threadId: "thr_3", runId: "run_3" }, createdAt: at(2) },
+            "art_mine"
+          )
+        )
+        await artifacts.publish(
+          publishInput(
+            { origin: { threadId: "thr_3", runId: "run_4" }, createdAt: at(3) },
+            "art_mine"
+          )
+        )
+
+        // A retried turn takes back what it published, and the link it alone made.
+        await artifacts.deleteVersionsByOrigin({ projectId, runId: "run_2" })
+        expect(await artifacts.listThreadIds({ projectId, id: "art_mine" })).toEqual([
+          "thr_1",
+          "thr_3",
+        ])
+        expect((await artifacts.list({ projectId, threadId: "thr_2" })).total).toBe(0)
+
+        // Another turn's version from thr_3 keeps it shared there.
+        await artifacts.deleteVersionsByOrigin({ projectId, runId: "run_3" })
+        expect(await artifacts.listThreadIds({ projectId, id: "art_mine" })).toEqual([
+          "thr_1",
+          "thr_3",
+        ])
+      })
+    })
+
+    // Regression proof: copy only the latest version in a provider's `copy`; the copy then has no
+    // version 1, and its next version is 2.
+    test("copies an artifact with every version under its number, shared in one thread", async () => {
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput())
+        await artifacts.publish(
+          publishInput({ title: "Second", author: otherOwner, createdAt: at(1) })
+        )
+        await artifacts.publish(publishInput({ title: "Third", createdAt: at(2) }))
+        // Version 4 was a retried turn's: the copy numbers its next version 5, as the source does.
+        await artifacts.publish(
+          publishInput({
+            title: "Retried",
+            origin: { threadId: "thr_1", runId: "run_9" },
+            createdAt: at(3),
+          })
+        )
+        await artifacts.deleteVersionsByOrigin({ projectId, runId: "run_9" })
+
+        const copy = await artifacts.copy({
+          projectId,
+          sourceId: "art_report",
+          id: "art_copy",
+          owner: otherOwner,
+          threadId: "thr_fork",
+          copiedAt: at(5),
+        })
+        expect(copy).toEqual({
+          projectId,
+          id: "art_copy",
+          kind: "document",
+          title: "Third",
+          owner: otherOwner,
+          latestVersion: 3,
+          createdAt: t0,
+          updatedAt: at(2),
+        })
+
+        const { versions } = await artifacts.listVersions({ projectId, artifactId: "art_copy" })
+        expect(versions.map(({ version, title, author }) => ({ version, title, author }))).toEqual([
+          { version: 3, title: "Third", author: owner },
+          { version: 2, title: "Second", author: otherOwner },
+          { version: 1, title: "Q3 report", author: owner },
+        ])
+        // Without an origin, a retry of the source's turns never takes the copy's versions.
+        expect(versions.every((version) => version.origin === undefined)).toBe(true)
+        const source = await artifacts.getVersion({
+          projectId,
+          artifactId: "art_report",
+          version: 3,
+        })
+        expect(versions[0]?.files).toEqual(source?.files ?? [])
+
+        expect(await artifacts.listThreadIds({ projectId, id: "art_copy" })).toEqual(["thr_fork"])
+        expect(await artifacts.listThreadIds({ projectId, id: "art_report" })).toEqual(["thr_1"])
+
+        // A turn in the fork revises the copy, and a retry of it keeps the copy shared there.
+        const revised = await artifacts.publish(
+          publishInput({ origin: { threadId: "thr_fork", runId: "run_fork" } }, "art_copy")
+        )
+        expect(revised.version.version).toBe(5)
+        await artifacts.deleteVersionsByOrigin({ projectId, runId: "run_fork" })
+        expect(await artifacts.listThreadIds({ projectId, id: "art_copy" })).toEqual(["thr_fork"])
+
+        await expectArtifactError(
+          artifacts.copy({
+            projectId,
+            sourceId: "art_report",
+            id: "art_copy",
+            owner,
+            threadId: "thr_fork",
+          }),
+          "artifact_exists"
+        )
+        await expectArtifactError(
+          artifacts.copy({
+            projectId,
+            sourceId: "art_nope",
+            id: "art_x",
+            owner,
+            threadId: "thr_x",
+          }),
+          "artifact_not_found"
+        )
+        expect(await artifacts.get({ projectId, id: "art_x" })).toBeNull()
+      })
+    })
+
     test("lists versions newest first, a page at a time", async () => {
       await withStorage(async (artifacts) => {
         await artifacts.create(createInput())
@@ -406,6 +627,107 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
       })
     })
 
+    test("keeps a value for each reader under its key, replacing one there", async () => {
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput())
+        const mine = { projectId, artifactId: "art_report", principal: owner }
+        const theirs = { ...mine, principal: otherOwner }
+        await artifacts.setState({ ...mine, key: "rate", value: "412", updatedAt: at(1) })
+        await artifacts.setState({
+          ...mine,
+          key: "filters",
+          value: '{"region":"Lisboa ☀"}',
+          updatedAt: at(1),
+        })
+        await artifacts.setState({ ...mine, key: "rate", value: "450", updatedAt: at(2) })
+        await artifacts.setState({ ...theirs, key: "rate", value: "380", updatedAt: at(2) })
+
+        expect(await artifacts.getState({ ...mine, key: "rate" })).toEqual({
+          key: "rate",
+          value: "450",
+          sizeBytes: 3,
+          updatedAt: at(2),
+        })
+        // Bytes as UTF-8: 21 characters, the sun three bytes of them.
+        expect((await artifacts.getState({ ...mine, key: "filters" }))?.sizeBytes).toBe(23)
+        expect((await artifacts.listState(mine)).map((entry) => entry.key)).toEqual([
+          "filters",
+          "rate",
+        ])
+        // Another reader keeps their own, and another project sees none.
+        expect((await artifacts.getState({ ...theirs, key: "rate" }))?.value).toBe("380")
+        expect(await artifacts.listState({ ...mine, projectId: otherProjectId })).toEqual([])
+        expect(await artifacts.getState({ ...mine, key: "missing" })).toBeNull()
+
+        expect(await artifacts.deleteState({ ...mine, key: "rate" })).toBe(true)
+        expect(await artifacts.deleteState({ ...mine, key: "rate" })).toBe(false)
+        expect(await artifacts.clearState(mine)).toBe(1)
+        expect(await artifacts.listState(mine)).toEqual([])
+        expect(await artifacts.listState(theirs)).toHaveLength(1)
+        await expectArtifactError(
+          artifacts.setState({
+            ...mine,
+            artifactId: "art_missing",
+            key: "a",
+            value: "1",
+            updatedAt: at(3),
+          }),
+          "artifact_not_found"
+        )
+      })
+    })
+
+    test("refuses a value past the limits, counting a replaced value once", async () => {
+      // Reproduce by dropping `checkArtifactStateWrite` from a provider's setState: the reader's
+      // values grow past every limit.
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput())
+        const mine = { projectId, artifactId: "art_report", principal: owner }
+        const value = (bytes: number) => JSON.stringify("x".repeat(bytes - 2))
+        const set = (key: string, bytes: number) =>
+          artifacts.setState({ ...mine, key, value: value(bytes), updatedAt: at(1) })
+
+        await expectArtifactError(
+          set("big", ARTIFACT_STATE_LIMITS.maxValueBytes + 1),
+          "artifact_state_full"
+        )
+        await set("big", ARTIFACT_STATE_LIMITS.maxValueBytes)
+        // Sixteen values of 64 KB are 1 MB: a seventeenth is past the reader's bytes, but the
+        // sixteenth replaced is not.
+        for (let index = 1; index < 16; index++)
+          await set(`big-${index}`, ARTIFACT_STATE_LIMITS.maxValueBytes)
+        await expectArtifactError(set("one-more", 2), "artifact_state_full")
+        await set("big-15", ARTIFACT_STATE_LIMITS.maxValueBytes)
+        await artifacts.clearState(mine)
+
+        for (let index = 0; index < ARTIFACT_STATE_LIMITS.maxKeys; index++)
+          await set(`key-${index}`, 4)
+        await expectArtifactError(set("key-extra", 4), "artifact_state_full")
+        await set("key-0", 8)
+        // Another reader's limits are their own.
+        await artifacts.setState({
+          ...mine,
+          principal: otherOwner,
+          key: "key-extra",
+          value: "1",
+          updatedAt: at(1),
+        })
+        expect(await artifacts.getState({ ...mine, key: "key-extra" })).toBeNull()
+      })
+    })
+
+    test("drops what an artifact keeps for its readers with the artifact", async () => {
+      await withStorage(async (artifacts) => {
+        await artifacts.create(createInput())
+        const mine = { projectId, artifactId: "art_report", principal: owner }
+        await artifacts.setState({ ...mine, key: "rate", value: "412", updatedAt: at(1) })
+        await artifacts.delete({ projectId, id: "art_report" })
+        await artifacts.create(createInput())
+        // To see this fail, leave state out of `InMemoryArtifactStorage.deleteArtifact`.
+        expect(await artifacts.listState(mine)).toEqual([])
+      })
+    })
+
     test("rolls back with its containing storage transaction", async () => {
       await withStorage(async (artifacts, storage) => {
         await artifacts.create(createInput())
@@ -417,6 +739,14 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
             await tx.artifacts.publish(publishInput({ createdAt: at(1) }))
             await tx.artifacts.create(createInput({ id: "art_rolled_back" }))
             await tx.artifacts.createFrameGrant(frameGrant("a"))
+            await tx.artifacts.setState({
+              projectId,
+              artifactId: "art_report",
+              principal: owner,
+              key: "rate",
+              value: "450",
+              updatedAt: at(1),
+            })
             expect((await tx.artifacts.get({ projectId, id: "art_report" }))?.latestVersion).toBe(2)
             throw rollback
           })
@@ -426,6 +756,10 @@ export function runArtifactStorageContractSuite<TStorage extends ArtifactStorage
         expect(await artifacts.get({ projectId, id: "art_rolled_back" })).toBeNull()
         // To see this fail, leave frame grants out of `InMemoryArtifactStorage.restore`.
         expect(await artifacts.findFrameGrant({ projectId, tokenHash: "a".repeat(64) })).toBeNull()
+        // To see this fail, leave state out of `InMemoryArtifactStorage.restore`.
+        expect(
+          await artifacts.listState({ projectId, artifactId: "art_report", principal: owner })
+        ).toEqual([])
         expect((await artifacts.publish(publishInput({ createdAt: at(2) }))).version.version).toBe(
           2
         )