@fugood/bricks-ctor 2.25.0-beta.5 → 2.25.0-beta.51

package/compile/__tests__/config-diff.test.js

@@ -0,0 +1,100 @@
+import { computeConfigChange } from '../config-diff'
+
+describe('computeConfigChange', () => {
+  test('ignores the volatile top-level title and update_timestamp', () => {
+    const before = { title: 'App(1)', update_timestamp: 1, subspace_map: {} }
+    const after = { title: 'App(2)', update_timestamp: 2, subspace_map: {} }
+    expect(computeConfigChange(before, after)).toEqual({ status: 'ok', ops: [], opCount: 0 })
+  })
+
+  test('still diffs nested (subspace/brick) titles', () => {
+    const before = { title: 'App(1)', subspace_map: { S: { title: 'Home' } } }
+    const after = { title: 'App(2)', subspace_map: { S: { title: 'Start' } } }
+    expect(computeConfigChange(before, after).ops).toEqual([
+      { op: 'set', path: ['subspace_map', 'S', 'title'], value: 'Start' },
+    ])
+  })
+
+  test('emits a leaf set for a scalar property change', () => {
+    const wrap = (url) => ({ subspace_map: { S: { brick_map: { B: { property: { url } } } } } })
+    expect(computeConfigChange(wrap('a'), wrap('b')).ops).toEqual([
+      { op: 'set', path: ['subspace_map', 'S', 'brick_map', 'B', 'property', 'url'], value: 'b' },
+    ])
+  })
+
+  test('added key → set, removed key → unset', () => {
+    const change = computeConfigChange({ m: { a: 1 } }, { m: { b: 2 } })
+    expect(change.opCount).toBe(2)
+    expect(change.ops).toContainEqual({ op: 'unset', path: ['m', 'a'] })
+    expect(change.ops).toContainEqual({ op: 'set', path: ['m', 'b'], value: 2 })
+  })
+
+  test('equal-length arrays diff element-wise', () => {
+    const before = { items: [{ x: 1 }, { x: 2 }] }
+    const after = { items: [{ x: 1 }, { x: 9 }] }
+    expect(computeConfigChange(before, after).ops).toEqual([
+      { op: 'set', path: ['items', 1, 'x'], value: 9 },
+    ])
+  })
+
+  test('length-changed arrays emit a single whole-array set', () => {
+    const before = { items: [1, 2] }
+    const after = { items: [1, 2, 3] }
+    expect(computeConfigChange(before, after).ops).toEqual([
+      { op: 'set', path: ['items'], value: [1, 2, 3] },
+    ])
+  })
+
+  test('identical configs produce no ops', () => {
+    const config = { subspace_map: { S: { brick_map: { B: { property: { a: 1, b: [1, 2] } } } } } }
+    expect(computeConfigChange(config, structuredClone(config))).toEqual({
+      status: 'ok',
+      ops: [],
+      opCount: 0,
+    })
+  })
+
+  test('ignores object fields omitted by JSON.stringify', () => {
+    const before = { subspace_map: { S: { title: 'Home' } } }
+    const after = {
+      subspace_map: {
+        S: {
+          title: 'Home',
+          description: undefined,
+        },
+      },
+    }
+    expect(computeConfigChange(before, after)).toEqual({ status: 'ok', ops: [], opCount: 0 })
+  })
+
+  test('emits added values in JSON-compatible shape', () => {
+    const before = { m: {} }
+    const after = {
+      m: {
+        nested: {
+          keep: 1,
+          drop: undefined,
+        },
+        items: [undefined, 2],
+      },
+    }
+    const change = computeConfigChange(before, after)
+    expect(change.ops).toEqual([
+      { op: 'set', path: ['m', 'nested'], value: { keep: 1 } },
+      { op: 'set', path: ['m', 'items'], value: [null, 2] },
+    ])
+  })
+
+  test('compares array undefined entries like JSON nulls', () => {
+    expect(computeConfigChange({ items: [null] }, { items: [undefined] })).toEqual({
+      status: 'ok',
+      ops: [],
+      opCount: 0,
+    })
+  })
+
+  test('reports no_baseline / unavailable for missing sides', () => {
+    expect(computeConfigChange(null, { a: 1 })).toEqual({ status: 'no_baseline' })
+    expect(computeConfigChange({ a: 1 }, null)).toEqual({ status: 'unavailable' })
+  })
+})

package/compile/__tests__/index.test.js

@@ -0,0 +1,386 @@
+jest.mock('../../tools/_shell', () => ({
+  sh: jest.fn(),
+}))
+
+// Mirrors the chainable `sh` result (supports `.nothrow()` like the real helper).
+const shResult = (over = {}) => {
+  const result = Promise.resolve({ exitCode: 0, stdout: '', stderr: '', ...over })
+  result.nothrow = () => result
+  return result
+}
+
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import { sh } from '../../tools/_shell'
+import { checkConfig, compile, compileTestCase } from '../index'
+
+const SUBSPACE_ID = 'SUBSPACE_00000000-0000-0000-0000-000000000001'
+const CANVAS_ID = 'CANVAS_00000000-0000-0000-0000-000000000001'
+const ANIMATION_ID = 'ANIMATION_00000000-0000-0000-0000-000000000001'
+const DATA_ID = 'PROPERTY_BANK_DATA_NODE_00000000-0000-0000-0000-000000000001'
+
+const makeApp = (animations = [], data = []) => {
+  const rootCanvas = {
+    __typename: 'Canvas',
+    id: CANVAS_ID,
+    items: [],
+  }
+  const rootSubspace = {
+    __typename: 'Subspace',
+    id: SUBSPACE_ID,
+    title: 'Main Subspace',
+    layout: {
+      width: 96,
+      height: 54,
+    },
+    rootCanvas,
+    canvases: [rootCanvas],
+    animations,
+    bricks: [],
+    generators: [],
+    data,
+    dataRouting: [],
+    dataCalculation: [],
+  }
+
+  return {
+    name: 'Compile animation test',
+    rootSubspace,
+    subspaces: [rootSubspace],
+  }
+}
+
+const makeData = (remoteUpdate) => ({
+  __typename: 'Data',
+  id: DATA_ID,
+  type: 'string',
+  remoteUpdate,
+})
+
+const commandOf = ([strings, ...values]) =>
+  strings.reduce((acc, chunk, index) => `${acc}${chunk}${values[index] ?? ''}`, '')
+
+describe('checkConfig', () => {
+  beforeEach(() => {
+    sh.mockReset()
+    sh.mockImplementation(() => shResult())
+  })
+
+  test('runs doctor after check-config', async () => {
+    await checkConfig('.bricks/build/application-config.json')
+
+    expect(sh.mock.calls.map(commandOf)).toEqual([
+      'bricks app check-config --validate-automation .bricks/build/application-config.json',
+      'bricks app doctor --validate-automation .bricks/build/application-config.json',
+    ])
+  })
+
+  test('skips doctor when the CLI lacks the command', async () => {
+    sh.mockReturnValueOnce(shResult()) // check-config
+    sh.mockReturnValueOnce(shResult({ exitCode: 1, stderr: "error: unknown command 'doctor'" }))
+
+    await expect(checkConfig('config.json')).resolves.toBeUndefined()
+  })
+
+  test('throws when doctor reports config errors', async () => {
+    sh.mockReturnValueOnce(shResult()) // check-config
+    sh.mockReturnValueOnce(shResult({ exitCode: 1, stderr: 'DATA_RACE: conflicting writes' }))
+
+    await expect(checkConfig('config.json')).rejects.toThrow()
+  })
+})
+
+describe('compile animations', () => {
+  test('normalizes mixed legacy spring config', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const config = await compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            alias: 'btnPressOut',
+            title: 'Button Press Out',
+            property: 'transform.scale',
+            config: {
+              __type: 'AnimationSpringConfig',
+              toValue: 1,
+              friction: 5,
+              tension: 200,
+              speed: 14,
+              bounciness: 8,
+            },
+          },
+        ]),
+      )
+
+      expect(config.subspace_map[SUBSPACE_ID].animation_map[ANIMATION_ID].config).toEqual({
+        toValue: 1,
+        friction: 5,
+        tension: 200,
+      })
+      const warning = warnSpy.mock.calls[0][0]
+      expect(warning).toContain('Resolved animation spring config')
+      expect(warning).toContain('Button Press Out')
+      expect(warning).toContain('btnPressOut')
+      expect(warning).toContain('transform.scale')
+      expect(warning).toContain('Main Subspace')
+      expect(warning).not.toContain('ANIMATION_')
+      expect(warning).not.toContain('SUBSPACE_')
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  test('rejects invalid animation property', async () => {
+    await expect(
+      compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            property: 'transform.skewX',
+            config: {
+              __type: 'AnimationTimingConfig',
+              toValue: 1,
+            },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/Invalid animation property/)
+  })
+
+  test('rejects invalid animation config type', async () => {
+    await expect(
+      compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            property: 'opacity',
+            config: {
+              __type: 'AnimationUnknownConfig',
+              toValue: 1,
+            },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/Invalid animation config type/)
+  })
+})
+
+describe('compile event handlers', () => {
+  const BRICK_ID = 'BRICK_00000000-0000-0000-0000-000000000002'
+
+  test('preserves item-brick string handler casing and normalizes only system', async () => {
+    // A mixed-case ItemBrickID handler — must survive compile verbatim because the
+    // runtime resolves handlers case-sensitively (mapEventMapHandlersWithNewId).
+    const itemHandlerId = 'itemBrickHandlerId'
+    const app = makeApp()
+    app.rootSubspace.bricks = [
+      {
+        __typename: 'Brick',
+        id: BRICK_ID,
+        templateKey: 'BRICK_VIEW',
+        property: {},
+        events: {
+          onPress: [
+            { handler: itemHandlerId, action: { __actionName: 'SCROLL_TO_INDEX' } },
+            { handler: 'system', action: { __actionName: 'NAVIGATE' } },
+          ],
+        },
+      },
+    ]
+
+    const config = await compile(app)
+    const eventMap = config.subspace_map[SUBSPACE_ID].brick_map[BRICK_ID].event_map
+    const events = eventMap.BRICK_VIEW_ON_PRESS
+
+    // ItemBrickID handler kept verbatim (was wrongly uppercased to ITEMBRICKHANDLERID).
+    expect(events[0].handler).toBe(itemHandlerId)
+    // The literal 'system' handler still normalizes to SYSTEM.
+    expect(events[1].handler).toBe('SYSTEM')
+  })
+})
+
+describe('compile data remote update', () => {
+  test.each([
+    [undefined, { bank_type: 'none' }],
+    [{ type: 'auto' }, { bank_type: 'create', enable_remote_update: true }],
+    [
+      { type: 'device-specific' },
+      {
+        bank_type: 'create-device-specific',
+        enable_remote_update: true,
+        use_remote_id_prefix: true,
+      },
+    ],
+    [
+      { type: 'global-data', id: 'GLOBAL_PROP_1' },
+      {
+        bank_type: 'global',
+        enable_remote_update: true,
+        global_remote_update_prop: 'GLOBAL_PROP_1',
+      },
+    ],
+  ])('emits bank_type for %p', async (remoteUpdate, expectedRemoteUpdate) => {
+    const config = await compile(makeApp([], [makeData(remoteUpdate)]))
+
+    expect(config.subspace_map[SUBSPACE_ID].property_bank_map[DATA_ID]).toMatchObject(
+      expectedRemoteUpdate,
+    )
+  })
+})
+
+describe('compile asset preload normalization', () => {
+  const makeAssetData = (id, kindType) => ({
+    __typename: 'Data',
+    id,
+    type: 'string',
+    kind: {
+      type: kindType,
+      preload: { type: 'url', hashType: 'sha256', hash: 'abc123' },
+    },
+  })
+
+  test('rive-file-uri normalizes preload like lottie-file-uri (hash re-keyed by hashType)', async () => {
+    const RIVE_ID = 'PROPERTY_BANK_DATA_NODE_00000000-0000-0000-0000-0000000000a1'
+    const LOTTIE_ID = 'PROPERTY_BANK_DATA_NODE_00000000-0000-0000-0000-0000000000a2'
+    const config = await compile(
+      makeApp(
+        [],
+        [makeAssetData(RIVE_ID, 'rive-file-uri'), makeAssetData(LOTTIE_ID, 'lottie-file-uri')],
+      ),
+    )
+
+    const rive = config.subspace_map[SUBSPACE_ID].property_bank_map[RIVE_ID]
+    const lottie = config.subspace_map[SUBSPACE_ID].property_bank_map[LOTTIE_ID]
+
+    // Rive must get the same normalized preload as every sibling asset kind: the hash
+    // re-keyed under its hashType (the runtime reads preload[hashType]), not left raw under
+    // `hash`. Regression: rive was missing from preloadTypes, so it fell to the raw else
+    // branch and the runtime preload[hashType] lookup missed.
+    expect(rive.preload).toEqual({ type: 'url', hashType: 'sha256', sha256: 'abc123' })
+    expect(rive.preload).toEqual(lottie.preload)
+  })
+})
+
+describe('compile config-change audit log', () => {
+  const readAudit = async (projectDir) =>
+    (await readFile(path.join(projectDir, '.bricks/edits.jsonl'), 'utf8'))
+      .trim()
+      .split('\n')
+      .map((line) => JSON.parse(line))
+
+  const seedArtifact = async (projectDir, config) => {
+    const artifactPath = path.join(projectDir, '.bricks/build/application-config.json')
+    await mkdir(path.dirname(artifactPath), { recursive: true })
+    await writeFile(artifactPath, JSON.stringify(config))
+  }
+
+  test('records the config delta only in the editing-tools context', async () => {
+    const prevCwd = process.cwd()
+    const prevEnv = process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS
+    let projectDir
+    try {
+      projectDir = await mkdtemp(path.join(os.tmpdir(), 'bricks-compile-audit-'))
+      process.chdir(projectDir)
+
+      // (1) Editing tools disabled: even a real delta against a baseline is not recorded.
+      delete process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS
+      const empty = await compile(makeApp([], []))
+      await seedArtifact(projectDir, empty)
+      await compile(makeApp([], [makeData(undefined)]))
+      await expect(readFile(path.join(projectDir, '.bricks/edits.jsonl'))).rejects.toThrow()
+
+      // (2) Editing tools enabled: the compiled-config delta is recorded.
+      process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS = '1'
+      await seedArtifact(projectDir, empty)
+      const withData = await compile(makeApp([], [makeData(undefined)]))
+      const audit = await readAudit(projectDir)
+      expect(audit).toHaveLength(1)
+      expect(audit[0].tool).toBe('compile')
+      expect(audit[0].outcome).toBe('ok')
+      expect(audit[0].summary).toMatch(/compile: \d+ config op\(s\)/)
+      expect(JSON.stringify(audit[0].configChange)).toContain('property_bank_map')
+      // The audit log gets gitignored on first write.
+      const gitignore = await readFile(path.join(projectDir, '.gitignore'), 'utf8')
+      expect(gitignore).toContain('.bricks/edits.jsonl')
+
+      // (3) Recompiling with no source change records a "no config change" entry.
+      await seedArtifact(projectDir, withData)
+      await compile(makeApp([], [makeData(undefined)]))
+      const afterNoop = await readAudit(projectDir)
+      expect(afterNoop).toHaveLength(2)
+      expect(afterNoop[1].summary).toBe('compile: no config change')
+
+      // (4) Turning the flag off again (as the editing tools do for their verify compiles)
+      // suppresses the record even though there is a real delta.
+      process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS = '0'
+      await seedArtifact(projectDir, withData)
+      await compile(makeApp([], []))
+      expect(await readAudit(projectDir)).toHaveLength(2)
+    } finally {
+      if (prevEnv === undefined) delete process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS
+      else process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS = prevEnv
+      process.chdir(prevCwd)
+      if (projectDir) await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('compile linked-module subspace', () => {
+  const LINKED_SUBSPACE_ID = 'SUBSPACE_00000000-0000-0000-0000-000000000002'
+  const makeLinkedApp = () => {
+    const app = makeApp()
+    app.subspaces = [
+      app.rootSubspace,
+      {
+        __typename: 'Subspace',
+        id: LINKED_SUBSPACE_ID,
+        title: 'Linked Module',
+        layout: { width: 96, height: 54 },
+        module: { link: true, id: 'MODULE_00000000-0000-0000-0000-000000000001', version: 1 },
+      },
+    ]
+    return app
+  }
+
+  test('uses a deterministic placeholder canvas id stable across recompiles', async () => {
+    // Regression: the placeholder canvas id came from makeId('canvas'), whose count-fallback
+    // branch uses a never-reset process-global counter, so recompiling identical source produced
+    // a different id and broke compile's byte-stable-output contract (phantom config-change ops).
+    const first = await compile(makeLinkedApp())
+    const second = await compile(makeLinkedApp())
+
+    const firstKeys = Object.keys(first.subspace_map[LINKED_SUBSPACE_ID].canvas_map)
+    const secondKeys = Object.keys(second.subspace_map[LINKED_SUBSPACE_ID].canvas_map)
+    expect(firstKeys).toHaveLength(1)
+    expect(secondKeys).toEqual(firstKeys)
+    expect(first.subspace_map[LINKED_SUBSPACE_ID].root_canvas_id).toBe(firstKeys[0])
+    expect(second.subspace_map[LINKED_SUBSPACE_ID].root_canvas_id).toBe(firstKeys[0])
+  })
+
+  test('compileTestCase resolves a jump_to getter to its id (survives serialization)', () => {
+    // Regression: jump_cond[].jump_to may be a getter (() => TestCase) for dynamic case ids — the
+    // project generator emits `jump_to: () => caseVar`. compileTestCase passed it through verbatim
+    // (unlike the `run` array, which resolves getters via compileRunElement), so JSON.stringify of
+    // the compiled config dropped the function and the conditional jump silently vanished.
+    const compiled = compileTestCase({
+      __typename: 'TestCase',
+      id: 'TEST_CASE_src',
+      name: 'src',
+      run: [],
+      jump_cond: [
+        { type: 'status', status: 'finished', jump_to: () => ({ id: 'TEST_CASE_target' }) },
+        { type: 'status', status: 'failed', jump_to: 'TEST_CASE_literal' },
+      ],
+    })
+    // The compiled config is serialized to disk, so the value must survive JSON round-tripping.
+    const serialized = JSON.parse(JSON.stringify(compiled))
+    expect(serialized.jump_cond[0].jump_to).toBe('TEST_CASE_target') // getter resolved to its id
+    expect(serialized.jump_cond[1].jump_to).toBe('TEST_CASE_literal') // string passes through
+  })
+})