@fugood/bricks-ctor 2.25.0-beta.60 → 2.25.0-beta.61

package/compile/__tests__/util.test.js

@@ -1,450 +0,0 @@
-import { generateCalulationMap, validateConfig } from '../util'
-
-const baseConfig = (overrides = {}) => ({
-  inputs: {},
-  enable_async: false,
-  disabled_triggers: {},
-  output: null,
-  outputs: {},
-  error: null,
-  code: 'return inputs',
-  ...overrides,
-})
-
-const SANDBOX_PREFIX = 'PROPERTY_BANK_COMMAND_NODE_'
-
-const sandboxNodeIds = (map) =>
-  Object.entries(map)
-    .filter(([id, node]) => id.startsWith(SANDBOX_PREFIX) && node.type === 'command-node-sandbox')
-    .map(([id, node]) => ({ id, command: node.properties.command }))
-
-const findSandboxIds = (map) => {
-  const sandbox = sandboxNodeIds(map)
-  return {
-    run: sandbox.find((s) => s.command === 'SANDBOX_RUN_JAVASCRIPT')?.id,
-    error: sandbox.find((s) => s.command === 'SANDBOX_GET_ERROR')?.id,
-    result: sandbox.find((s) => s.command === 'SANDBOX_GET_RETURN_VALUE')?.id,
-  }
-}
-
-describe('validateConfig', () => {
-  test('returns without throwing for a clean config', () => {
-    expect(() => validateConfig(baseConfig({ inputs: { a: 'foo' } }))).not.toThrow()
-  })
-
-  test('skips overlap checks in manual trigger mode', () => {
-    const config = baseConfig({
-      trigger_mode: 'manual',
-      inputs: { a: 'foo' },
-      output: 'a',
-      error: 'a',
-      outputs: { x: ['a'] },
-    })
-    expect(() => validateConfig(config)).not.toThrow()
-  })
-
-  test('throws when error key collides with an input id', () => {
-    const config = baseConfig({ inputs: { a: 'foo' }, error: 'a' })
-    expect(() => validateConfig(config)).toThrow(/key: error/)
-  })
-
-  test('throws when output key collides with an input id', () => {
-    const config = baseConfig({ inputs: { a: 'foo' }, output: 'a' })
-    expect(() => validateConfig(config)).toThrow(/key: output/)
-  })
-
-  test('throws when any outputs entry references an input id', () => {
-    const config = baseConfig({
-      inputs: { a: 'foo', b: 'bar' },
-      outputs: { x: ['c', 'b'] },
-    })
-    expect(() => validateConfig(config)).toThrow(/key: outputs/)
-  })
-
-  test('does not throw when error/output are falsy and inputs are empty', () => {
-    expect(() => validateConfig(baseConfig())).not.toThrow()
-  })
-
-  // Regression: the overlap checks tested `config.inputs[id]` (the OBJECT_SET path) for
-  // truthiness instead of asking whether `id` is an input key. An empty path ('' is
-  // OBJECT_SET's default "set whole object") is a legitimate input value, so an input with
-  // an empty path that also targets output/error/outputs slipped the guard and compiled into
-  // a node double-wired as both input and output.
-  test('throws when output collides with an input whose path is empty', () => {
-    const config = baseConfig({ inputs: { a: '' }, output: 'a' })
-    expect(() => validateConfig(config)).toThrow(/key: output/)
-  })
-
-  test('throws when error collides with an input whose path is empty', () => {
-    const config = baseConfig({ inputs: { a: '' }, error: 'a' })
-    expect(() => validateConfig(config)).toThrow(/key: error/)
-  })
-
-  test('throws when an outputs entry references an input whose path is empty', () => {
-    const config = baseConfig({ inputs: { a: '' }, outputs: { x: ['a'] } })
-    expect(() => validateConfig(config)).toThrow(/key: outputs/)
-  })
-
-  test('throws when error and output target the same id', () => {
-    const config = baseConfig({ output: 'shared', error: 'shared' })
-    expect(() => validateConfig(config)).toThrow(/key: error\/output/)
-  })
-
-  test('throws when output collides with an outputs target id', () => {
-    const config = baseConfig({ output: 'shared', outputs: { x: ['shared'] } })
-    expect(() => validateConfig(config)).toThrow(/key: output\/outputs/)
-  })
-
-  test('throws when error collides with an outputs target id', () => {
-    const config = baseConfig({ error: 'shared', outputs: { x: ['shared'] } })
-    expect(() => validateConfig(config)).toThrow(/key: error\/outputs/)
-  })
-
-  // The same id reused across *different* outputs entries is a supported last-wins case
-  // (see generateCalulationMap test below) and must stay allowed.
-  test('allows the same id across multiple outputs entries', () => {
-    const config = baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } })
-    expect(() => validateConfig(config)).not.toThrow()
-  })
-})
-
-// generateCalulationMap now seeds command ids from the owning calc id; tests that don't
-// assert id values share one fixed id (ids stay deterministic with no global state).
-const CALC_ID = 'PROPERTY_BANK_COMMAND_MAP_00000000-0000-4000-8000-000000000000'
-const genMap = (config, calcId = CALC_ID) => generateCalulationMap(config, calcId)
-
-describe('generateCalulationMap', () => {
-  test('produces only the three sandbox nodes for an empty config', () => {
-    const result = genMap(baseConfig())
-
-    expect(Object.keys(result.map)).toHaveLength(3)
-    const { run, error, result: returnValue } = findSandboxIds(result.map)
-
-    expect(result.map[run].in.inputs).toEqual([])
-    expect(result.map[error].out.result).toEqual([])
-    expect(result.map[returnValue].out.result).toEqual([])
-    expect(Object.keys(result.editor_info)).toHaveLength(3)
-  })
-
-  test('chains multiple inputs through OBJECT_SET commands', () => {
-    const result = genMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
-
-    const { run } = findSandboxIds(result.map)
-
-    // Each input gets a data-node + an OBJECT_SET command-node.
-    expect(result.map.a.type).toBe('data-node')
-    expect(result.map.b.type).toBe('data-node')
-
-    const aCommandId = result.map.a.out.value[0].id
-    const bCommandId = result.map.b.out.value[0].id
-    expect(aCommandId).not.toBe(bCommandId)
-
-    const aCmd = result.map[aCommandId]
-    const bCmd = result.map[bCommandId]
-    expect(aCmd.properties.command).toBe('OBJECT_SET')
-    expect(aCmd.properties.args.path).toBe('foo.bar')
-    expect(bCmd.properties.command).toBe('OBJECT_SET')
-    expect(bCmd.properties.args.path).toBe('baz')
-
-    // First command has no upstream obj; second command's obj input is the first command.
-    expect(aCmd.in.obj).toBeNull()
-    expect(bCmd.in.obj).toEqual([{ id: aCommandId, port: 'result' }])
-    // First command forwards its result to the second command's `obj` input.
-    expect(aCmd.out.result).toEqual([{ id: bCommandId, port: 'obj' }])
-    // The last command feeds the SANDBOX_RUN_JAVASCRIPT `inputs` port.
-    expect(bCmd.out.result).toEqual([{ id: run, port: 'inputs' }])
-    expect(result.map[run].in.inputs).toEqual([{ id: bCommandId, port: 'result' }])
-  })
-
-  test('builds OBJECT_GET commands and target data-nodes for outputs', () => {
-    const result = genMap(baseConfig({ outputs: { resultPath: ['pb1', 'pb2'] } }))
-
-    const { result: returnValue } = findSandboxIds(result.map)
-
-    // Both target property-bank nodes are created as data-nodes.
-    expect(result.map.pb1.type).toBe('data-node')
-    expect(result.map.pb2.type).toBe('data-node')
-
-    // The SANDBOX_GET_RETURN_VALUE forwards to the OBJECT_GET command for the output entry.
-    const objectGetRefs = result.map[returnValue].out.result
-    expect(objectGetRefs).toHaveLength(1)
-    const getCommandId = objectGetRefs[0].id
-    expect(objectGetRefs[0].port).toBe('obj')
-
-    const getCmd = result.map[getCommandId]
-    expect(getCmd.type).toBe('command-node-object')
-    expect(getCmd.properties.command).toBe('OBJECT_GET')
-    expect(getCmd.properties.args.path).toBe('resultPath')
-    expect(getCmd.in.obj).toEqual([{ id: returnValue, port: 'result' }])
-
-    // OBJECT_GET feeds both target data-nodes' `change` ports.
-    expect(getCmd.out.result).toEqual([
-      { id: 'pb1', port: 'change' },
-      { id: 'pb2', port: 'change' },
-    ])
-    // Target data-nodes consume the OBJECT_GET result via their `change` port.
-    expect(result.map.pb1.in.change).toEqual([{ id: getCommandId, port: 'result' }])
-    expect(result.map.pb2.in.change).toEqual([{ id: getCommandId, port: 'result' }])
-
-    // Without input usage their `out.value` defaults to null.
-    expect(result.map.pb1.out.value).toBeNull()
-    expect(result.map.pb2.out.value).toBeNull()
-  })
-
-  // Manual mode is the only mode that lets an output target reuse an input id
-  // (see validateConfig tests). When that happens, generateCalulationMap must
-  // keep the input-side `out.value` so the data-node remains a usable input.
-  test.each([
-    ['outputs', { outputs: { result: ['shared'] } }],
-    ['output', { output: 'shared' }],
-    ['error', { error: 'shared' }],
-  ])('preserves input out.value when %s target reuses an input id', (_, overrides) => {
-    const result = genMap(
-      baseConfig({ trigger_mode: 'manual', inputs: { shared: 'foo' }, ...overrides }),
-    )
-    expect(Array.isArray(result.map.shared.out.value)).toBe(true)
-    expect(result.map[result.map.shared.out.value[0].id].properties.command).toBe('OBJECT_SET')
-  })
-
-  test('also rewires in.change to OBJECT_GET when an outputs target reuses an input id', () => {
-    const result = genMap(
-      baseConfig({
-        trigger_mode: 'manual',
-        inputs: { shared: 'foo' },
-        outputs: { result: ['shared'] },
-      }),
-    )
-    expect(result.map.shared.in.change).toHaveLength(1)
-    expect(result.map[result.map.shared.in.change[0].id].properties.command).toBe('OBJECT_GET')
-  })
-
-  test('preserves out.value when the same pb appears in multiple outputs entries', () => {
-    // Two outputs entries both target `pb1`. The reduce visits each entry in turn
-    // and must preserve the accumulated `out.value` from the first iteration via
-    // `acc.map[pb]` rather than wiping it on the second.
-    const result = genMap(baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } }))
-    expect(result.map.pb1.type).toBe('data-node')
-    // Without an input, out.value remains null after both passes.
-    expect(result.map.pb1.out.value).toBeNull()
-    // The latest OBJECT_GET wins as the change source — each iteration overwrites
-    // `in.change`, so we end up pointing at the second outputs entry's command.
-    expect(result.map.pb1.in.change).toHaveLength(1)
-  })
-
-  test('wires the error data-node when error is configured', () => {
-    const result = genMap(baseConfig({ error: 'errNode' }))
-
-    const { error } = findSandboxIds(result.map)
-    // SANDBOX_GET_ERROR now broadcasts to the error data-node's `change` port.
-    expect(result.map[error].out.result).toEqual([{ id: 'errNode', port: 'change' }])
-    expect(result.map.errNode.type).toBe('data-node')
-    expect(result.map.errNode.in.change).toEqual([{ id: error, port: 'result' }])
-    // No upstream input → out.value falls back to null.
-    expect(result.map.errNode.out.value).toBeNull()
-    // editor_info contains the new node.
-    expect(result.editor_info.errNode).toBeDefined()
-  })
-
-  test('wires the output data-node when output is configured', () => {
-    const result = genMap(baseConfig({ output: 'outNode' }))
-
-    const { result: returnValue } = findSandboxIds(result.map)
-    expect(result.map[returnValue].out.result).toEqual([{ id: 'outNode', port: 'change' }])
-    expect(result.map.outNode.type).toBe('data-node')
-    expect(result.map.outNode.in.change).toEqual([{ id: returnValue, port: 'result' }])
-    expect(result.editor_info.outNode).toBeDefined()
-  })
-
-  test('manual trigger mode sets disable_trigger_command on input value ports', () => {
-    const result = genMap(
-      baseConfig({
-        trigger_mode: 'manual',
-        inputs: { a: 'foo', b: 'bar' },
-      }),
-    )
-    const aCmdId = result.map.a.out.value[0].id
-    const bCmdId = result.map.b.out.value[0].id
-    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBe(true)
-    expect(result.map[bCmdId].in.value[0].disable_trigger_command).toBe(true)
-  })
-
-  test('auto trigger mode honours per-key disabled_triggers', () => {
-    const result = genMap(
-      baseConfig({
-        inputs: { a: 'foo', b: 'bar' },
-        disabled_triggers: { a: true, b: false },
-      }),
-    )
-    const aCmdId = result.map.a.out.value[0].id
-    const bCmdId = result.map.b.out.value[0].id
-    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBe(true)
-    // Falsy disabled_triggers entry → property is not set (or set to undefined).
-    expect(result.map[bCmdId].in.value[0].disable_trigger_command).toBeUndefined()
-  })
-
-  test('auto trigger mode without disabled_triggers leaves disable_trigger_command undefined', () => {
-    const result = genMap(baseConfig({ inputs: { a: 'foo' } }))
-    const aCmdId = result.map.a.out.value[0].id
-    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBeUndefined()
-  })
-
-  test('derives command ids deterministically from the calc id (stable across compiles)', () => {
-    const config = baseConfig({ inputs: { a: 'foo' }, outputs: { out: ['pb1'] } })
-    const first = generateCalulationMap(config, CALC_ID)
-    const second = generateCalulationMap(config, CALC_ID)
-    // Same calc id + same config must yield byte-identical ids, so recompiling unchanged
-    // source produces no spurious property_bank_calc_map diff.
-    expect(Object.keys(second.map)).toEqual(Object.keys(first.map))
-
-    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
-    sandboxNodeIds(first.map).forEach(({ id }) => {
-      expect(id).toMatch(new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuid}$`))
-    })
-  })
-
-  test('seeds command ids per calc so different calcs never collide (edit isolation)', () => {
-    const config = baseConfig({ inputs: { a: 'foo' } })
-    const a = generateCalulationMap(
-      config,
-      'PROPERTY_BANK_COMMAND_MAP_aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
-    )
-    const b = generateCalulationMap(
-      config,
-      'PROPERTY_BANK_COMMAND_MAP_bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
-    )
-    expect(findSandboxIds(a.map).run).not.toBe(findSandboxIds(b.map).run)
-  })
-
-  test('validateConfig errors propagate out of generateCalulationMap', () => {
-    expect(() => genMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(/key: error/)
-  })
-
-  test('SANDBOX_GET_RETURN_VALUE broadcasts to both output target and outputs commands', () => {
-    const result = genMap(
-      baseConfig({
-        output: 'outNode',
-        outputs: { foo: ['pb1'] },
-      }),
-    )
-    const { result: returnValue } = findSandboxIds(result.map)
-    const refs = result.map[returnValue].out.result
-    // First entry is the output data-node's `change` port; remainder are OBJECT_GET ids.
-    expect(refs[0]).toEqual({ id: 'outNode', port: 'change' })
-    expect(refs).toHaveLength(2)
-    expect(refs[1].port).toBe('obj')
-    expect(result.map[refs[1].id].properties.command).toBe('OBJECT_GET')
-  })
-})
-
-// Direction A: generateCalulationMap also emits a single-node `script_map` the new runtime
-// prefers. These assert that derived graph, independent of the legacy `map` above.
-const scriptNode = (scriptMap) =>
-  Object.entries(scriptMap).find(([, node]) => node.type === 'command-node-script')
-
-describe('generateScriptMap (script_map)', () => {
-  test('empty config produces a single command-node-script node', () => {
-    const { script_map } = genMap(baseConfig())
-    expect(Object.values(script_map)).toHaveLength(1)
-    const [, node] = scriptNode(script_map)
-    expect(node.properties.command).toBe('SCRIPT_RUN')
-    expect(node.properties.args.code).toBe('return inputs')
-    expect(node.properties.args.inputs).toEqual({})
-    expect(node.properties.args.outputs).toEqual({})
-    expect(node.in).toEqual({})
-    expect(node.out).toEqual({})
-  })
-
-  test('wires keyed input ports and input data nodes, preserving order', () => {
-    const { script_map } = genMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
-    const [scriptId, node] = scriptNode(script_map)
-    expect(script_map.a.out.value).toEqual([{ id: scriptId, port: 'a' }])
-    expect(script_map.b.out.value).toEqual([{ id: scriptId, port: 'b' }])
-    expect(script_map.a.in.change).toBeNull()
-    expect(node.in.a).toEqual([{ id: 'a', port: 'value' }])
-    expect(node.in.b).toEqual([{ id: 'b', port: 'value' }])
-    // args.inputs maps each input port (data-node id) to its inputs-object path, in order.
-    expect(node.properties.args.inputs).toEqual({ a: 'foo.bar', b: 'baz' })
-    expect(Object.keys(node.properties.args.inputs)).toEqual(['a', 'b'])
-  })
-
-  test('fans out output / error / outputs to distinct ports and target data nodes', () => {
-    const { script_map } = genMap(
-      baseConfig({ output: 'outNode', error: 'errNode', outputs: { sum: ['pb1', 'pb2'] } }),
-    )
-    const [scriptId, node] = scriptNode(script_map)
-    expect(node.out.output).toEqual([{ id: 'outNode', port: 'change' }])
-    expect(node.out.error).toEqual([{ id: 'errNode', port: 'change' }])
-    expect(node.out['out:sum']).toEqual([
-      { id: 'pb1', port: 'change' },
-      { id: 'pb2', port: 'change' },
-    ])
-    expect(node.properties.args.outputs).toEqual({ 'out:sum': 'sum' })
-    expect(script_map.outNode.in.change).toEqual([{ id: scriptId, port: 'output' }])
-    expect(script_map.errNode.in.change).toEqual([{ id: scriptId, port: 'error' }])
-    expect(script_map.pb1.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
-    expect(script_map.pb2.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
-  })
-
-  test('manual mode disables every input edge', () => {
-    const { script_map } = genMap(
-      baseConfig({ trigger_mode: 'manual', inputs: { a: 'foo', b: 'bar' } }),
-    )
-    const [, node] = scriptNode(script_map)
-    expect(node.in.a[0].disable_trigger_command).toBe(true)
-    expect(node.in.b[0].disable_trigger_command).toBe(true)
-  })
-
-  test('auto mode honours per-key disabled_triggers', () => {
-    const { script_map } = genMap(
-      baseConfig({ inputs: { a: 'foo', b: 'bar' }, disabled_triggers: { a: true, b: false } }),
-    )
-    const [, node] = scriptNode(script_map)
-    expect(node.in.a[0].disable_trigger_command).toBe(true)
-    expect(node.in.b[0].disable_trigger_command).toBeUndefined()
-  })
-
-  test('a node reused as input and output keeps both edges (manual mode)', () => {
-    const { script_map } = genMap(
-      baseConfig({
-        trigger_mode: 'manual',
-        inputs: { shared: 'foo' },
-        outputs: { sum: ['shared'] },
-      }),
-    )
-    const [scriptId] = scriptNode(script_map)
-    // Input side (out.value) is preserved alongside the output side (in.change).
-    expect(script_map.shared.out.value).toEqual([{ id: scriptId, port: 'shared' }])
-    expect(script_map.shared.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
-  })
-
-  test('outputs port names never collide with the reserved output port', () => {
-    const { script_map } = genMap(baseConfig({ output: 'outNode', outputs: { output: ['pb1'] } }))
-    const [, node] = scriptNode(script_map)
-    // The whole-return-value port stays `output`; an outputs path literally named "output"
-    // is namespaced to `out:output`.
-    expect(node.out.output).toEqual([{ id: 'outNode', port: 'change' }])
-    expect(node.out['out:output']).toEqual([{ id: 'pb1', port: 'change' }])
-    expect(node.properties.args.outputs).toEqual({ 'out:output': 'output' })
-  })
-
-  test('script node id is byte-stable across recompiles and unique per calc', () => {
-    const config = baseConfig({ inputs: { a: 'foo' }, outputs: { out: ['pb1'] } })
-    const first = generateCalulationMap(config, CALC_ID)
-    const second = generateCalulationMap(config, CALC_ID)
-    expect(Object.keys(second.script_map)).toEqual(Object.keys(first.script_map))
-    const [idA] = scriptNode(first.script_map)
-    const [idB] = scriptNode(
-      generateCalulationMap(
-        config,
-        'PROPERTY_BANK_COMMAND_MAP_bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
-      ).script_map,
-    )
-    expect(idA).not.toBe(idB)
-    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
-    expect(idA).toMatch(new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuid}$`))
-  })
-
-  test('validateConfig still guards the script_map path (auto mode overlap)', () => {
-    expect(() => genMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(/key: error/)
-  })
-})