openpencil/tests/engine/library/storage-catalog.test.ts

import { describe, expect, test } from 'bun:test'

import { getInstanceOverride, SceneGraph, setInstanceOverride } from '@open-pencil/scene-graph'

import type { LibraryObjectStore } from '@/app/integrations/storage'
import { StorageLibraryCatalog } from '@/app/libraries/catalog/storage'

class MemoryObjects implements LibraryObjectStore {
  readonly values = new Map<string, Uint8Array>()
  readonly etags = new Map<string, string>()
  #version = 0

  async getObject(key: string) {
    return this.values.get(key) ?? null
  }

  async getObjectValue(key: string) {
    return { bytes: await this.getObject(key), etag: this.etags.get(key) ?? null }
  }

  async putObject(
    key: string,
    bytes: Uint8Array,
    _contentType?: string,
    options?: { ifMatch?: string; ifNoneMatch?: '*' }
  ) {
    const current = this.etags.get(key)
    if (options?.ifNoneMatch === '*' && current) throw new Error('revision conflict')
    if (options?.ifMatch && options.ifMatch !== current) throw new Error('revision conflict')
    this.values.set(key, new Uint8Array(bytes))
    this.#version += 1
    this.etags.set(key, `etag-${this.#version}`)
  }

  async listObjects(prefix: string) {
    return [...this.values]
      .filter(([key]) => key.startsWith(prefix))
      .map(([key, value]) => ({ key, size: value.byteLength, etag: null }))
  }
}

function sourceGraph() {
  const graph = new SceneGraph()
  const page = graph.getPages()[0]
  graph.createNode('COMPONENT', page.id, { name: 'Button', componentKey: 'button' })
  return graph
}

describe('storage library catalog', () => {
  test('publishes immutable revision objects before the latest manifest', async () => {
    const objects = new MemoryObjects()
    const catalog = new StorageLibraryCatalog(objects)
    const revision = await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph: sourceGraph(),
      publishedAt: '2026-01-01T00:00:00.000Z'
    })

    expect([...objects.values.keys()]).toEqual([
      `open-pencil/libraries/design-system/revisions/${revision.manifest.revisionId}.json`,
      'open-pencil/libraries/design-system/manifest.json'
    ])
    expect(await catalog.listLibraries()).toMatchObject([
      { libraryId: 'design-system', latestRevisionId: revision.manifest.revisionId }
    ])
    const restored = await catalog.getRevision('design-system')
    expect(restored.manifest).toEqual(revision.manifest)
    expect([...restored.graph.getAllNodes()].some((node) => node.componentKey === 'button')).toBe(
      true
    )
  })

  test('preserves instance overrides through persisted revisions', async () => {
    const objects = new MemoryObjects()
    const catalog = new StorageLibraryCatalog(objects)
    const graph = sourceGraph()
    const component = [...graph.getAllNodes()].find((node) => node.componentKey === 'button')
    if (!component) throw new Error('Expected component')
    const nestedComponent = graph.createNode('COMPONENT', component.id, {
      name: 'Icon',
      componentKey: 'icon'
    })
    const instance = graph.createInstance(nestedComponent.id, component.id)
    if (!instance) throw new Error('Expected instance')
    setInstanceOverride(instance.instanceOverrides, instance.id, instance.id, 'pluginData', {
      $openPencilType: 'openpencil/map',
      entries: []
    })

    const published = await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph
    })
    const restored = await catalog.getRevision('design-system', published.manifest.revisionId)
    const restoredInstance = [...restored.graph.getAllNodes()].find(
      (node) => node.type === 'INSTANCE'
    )
    if (!restoredInstance) throw new Error('Expected restored instance')

    expect(restoredInstance.instanceOverrides.self).toBeInstanceOf(Map)
    expect(
      getInstanceOverride(
        restoredInstance.instanceOverrides,
        restoredInstance.id,
        restoredInstance.id,
        'pluginData'
      )
    ).toEqual({ $openPencilType: 'openpencil/map', entries: [] })
  })

  test('rejects corrupted revision content', async () => {
    const objects = new MemoryObjects()
    const catalog = new StorageLibraryCatalog(objects)
    const revision = await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph: sourceGraph()
    })
    const key = `open-pencil/libraries/design-system/revisions/${revision.manifest.revisionId}.json`
    const bytes = objects.values.get(key)
    if (!bytes) throw new Error('Expected revision object')
    const source = new TextDecoder().decode(bytes).replace('Button', 'Corrupted')
    objects.values.set(key, new TextEncoder().encode(source))
    await expect(
      catalog.getRevision('design-system', revision.manifest.revisionId)
    ).rejects.toThrow('hash mismatch')
  })

  test('rejects malformed revision objects before deserializing them', async () => {
    const objects = new MemoryObjects()
    const catalog = new StorageLibraryCatalog(objects)
    const revision = await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph: sourceGraph()
    })
    const key = `open-pencil/libraries/design-system/revisions/${revision.manifest.revisionId}.json`
    for (const source of [
      '{not json',
      JSON.stringify({ manifest: revision.manifest, graph: { nodes: 'none' } })
    ]) {
      objects.values.set(key, new TextEncoder().encode(source))
      await expect(
        catalog.getRevision('design-system', revision.manifest.revisionId)
      ).rejects.toThrow('Invalid component library revision')
    }
  })

  test('rejects image bytes with missing indexes, which hashes do not cover', async () => {
    const objects = new MemoryObjects()
    const catalog = new StorageLibraryCatalog(objects)
    const graph = sourceGraph()
    const button = [...graph.getAllNodes()].find((node) => node.componentKey === 'button')
    if (!button) throw new Error('Expected component')
    graph.images.set('logo', new Uint8Array([17, 34, 51]))
    graph.updateNode(button.id, {
      fills: [
        {
          type: 'IMAGE',
          visible: true,
          opacity: 1,
          color: { r: 0, g: 0, b: 0, a: 1 },
          imageHash: 'logo',
          imageScaleMode: 'FILL'
        }
      ]
    })
    const revision = await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph
    })
    const key = `open-pencil/libraries/design-system/revisions/${revision.manifest.revisionId}.json`
    const bytes = objects.values.get(key)
    if (!bytes) throw new Error('Expected revision object')
    const source = new TextDecoder().decode(bytes)
    expect(source).toContain('{"$bytes":"ESIz"}')
    objects.values.set(
      key,
      // The index-keyed form older revisions used, with byte 1 missing.
      new TextEncoder().encode(source.replace('{"$bytes":"ESIz"}', '{"0":17,"2":51}'))
    )

    await expect(
      catalog.getRevision('design-system', revision.manifest.revisionId)
    ).rejects.toThrow('Invalid component library revision')
  })

  test('rejects updates when the provider cannot return latest-manifest ETags', async () => {
    const objects = new MemoryObjects()
    const catalog = new StorageLibraryCatalog(objects)
    const initial = await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph: sourceGraph()
    })
    objects.getObjectValue = async (key) => ({ bytes: await objects.getObject(key), etag: null })
    await expect(
      catalog.publishRevision({
        libraryId: 'design-system',
        name: 'Design system',
        graph: sourceGraph(),
        previousRevisionId: initial.manifest.revisionId
      })
    ).rejects.toThrow('does not support conditional library publication')
  })

  test('allows only one concurrent latest-pointer update', async () => {
    const objects = new MemoryObjects()
    const first = new StorageLibraryCatalog(objects)
    const second = new StorageLibraryCatalog(objects)
    const initial = await first.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph: sourceGraph()
    })
    const delayedWrites: Array<() => void> = []
    const originalPut = objects.putObject.bind(objects)
    objects.putObject = async (key, bytes, contentType, options) => {
      if (key.endsWith('/manifest.json')) {
        await new Promise<void>((resolve) => {
          delayedWrites.push(resolve)
        })
      }
      return originalPut(key, bytes, contentType, options)
    }
    const publications = [first, second].map((catalog, index) =>
      catalog.publishRevision({
        libraryId: 'design-system',
        name: 'Design system',
        graph: sourceGraph(),
        previousRevisionId: initial.manifest.revisionId,
        description: `publisher-${index}`
      })
    )
    while (delayedWrites.length < 2) await Bun.sleep(1)
    for (const release of delayedWrites) release()
    const results = await Promise.allSettled(publications)
    expect(results.filter((result) => result.status === 'fulfilled')).toHaveLength(1)
    expect(results.filter((result) => result.status === 'rejected')).toHaveLength(1)
  })

  test('rejects stale publication pointers', async () => {
    const catalog = new StorageLibraryCatalog(new MemoryObjects())
    await catalog.publishRevision({
      libraryId: 'design-system',
      name: 'Design system',
      graph: sourceGraph()
    })
    await expect(
      catalog.publishRevision({
        libraryId: 'design-system',
        name: 'Design system',
        graph: sourceGraph(),
        previousRevisionId: 'stale'
      })
    ).rejects.toThrow('latest revision has changed')
  })
})