@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/react/fieldJsHandler.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, beforeEach, mock } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { runJsHandler, __clearJsHandlerCacheForTests } from './fieldJsHandler.js'
-
-describe('runJsHandler — afterStateUpdatedJs runtime', () => {
-  beforeEach(() => {
-    __clearJsHandlerCacheForTests()
-  })
-
-  it('runs the body with $state bound to the changed value', () => {
-    const calls: unknown[] = []
-    const $set = (n: string, v: unknown) => calls.push([n, v])
-    runJsHandler({
-      body:      `$set('out', $state)`,
-      fieldName: 'title',
-      state:     'Hello',
-      $get:      () => undefined,
-      $set,
-    })
-    assert.deepEqual(calls, [['out', 'Hello']])
-  })
-
-  it('exposes $get for sibling reads', () => {
-    const values: Record<string, unknown> = { price: 10, qty: 3 }
-    const $get = (n: string) => values[n]
-    const writes: unknown[] = []
-    const $set = (n: string, v: unknown) => writes.push([n, v])
-    runJsHandler({
-      body:      `$set('total', Number($get('price')) * Number($state))`,
-      fieldName: 'qty',
-      state:     3,
-      $get,
-      $set,
-    })
-    assert.deepEqual(writes, [['total', 30]])
-  })
-
-  it('caches compiled handlers by string identity', () => {
-    const body = `$set('out', $state)`
-    const writes: unknown[] = []
-    const $set = (n: string, v: unknown) => writes.push([n, v])
-
-    // Run twice with the same body — should compile once.
-    runJsHandler({ body, fieldName: 'a', state: 1, $get: () => undefined, $set })
-    runJsHandler({ body, fieldName: 'a', state: 2, $get: () => undefined, $set })
-    assert.equal(writes.length, 2)
-  })
-
-  it('catches throws inside the body without re-raising', () => {
-    const errSpy = mock.method(console, 'error', () => {})
-    try {
-      runJsHandler({
-        body:      `throw new Error('nope')`,
-        fieldName: 'title',
-        state:     'x',
-        $get:      () => undefined,
-        $set:      () => {},
-      })
-      assert.equal(errSpy.mock.callCount(), 1)
-    } finally {
-      errSpy.mock.restore()
-    }
-  })
-
-  it('catches compile errors and skips eval on subsequent runs', () => {
-    const errSpy = mock.method(console, 'error', () => {})
-    try {
-      const $set = mock.fn()
-      // Same bad body run twice — should compile-error once, skip silently after.
-      runJsHandler({ body: `not valid {`, fieldName: 'x', state: 1, $get: () => undefined, $set })
-      runJsHandler({ body: `not valid {`, fieldName: 'x', state: 2, $get: () => undefined, $set })
-      assert.equal(errSpy.mock.callCount(), 1, 'compile-error logged once')
-      assert.equal($set.mock.callCount(), 0, 'never invoked $set')
-    } finally {
-      errSpy.mock.restore()
-    }
-  })
-
-  it('runs in strict mode (no implicit global writes)', () => {
-    const errSpy = mock.method(console, 'error', () => {})
-    try {
-      // In strict mode, assigning to an undeclared identifier throws.
-      runJsHandler({
-        body:      `accidentalGlobal = 1`,
-        fieldName: 'x',
-        state:     undefined,
-        $get:      () => undefined,
-        $set:      () => {},
-      })
-      assert.equal(errSpy.mock.callCount(), 1)
-    } finally {
-      errSpy.mock.restore()
-    }
-  })
-
-  it('does not expose `this` to the body', () => {
-    const writes: unknown[] = []
-    const $set = (n: string, v: unknown) => writes.push([n, v])
-    runJsHandler({
-      body:      `$set('thisType', typeof this)`,
-      fieldName: 'x',
-      state:     undefined,
-      $get:      () => undefined,
-      $set,
-    })
-    // Function-constructor + strict mode → `this` is undefined.
-    assert.deepEqual(writes, [['thisType', 'undefined']])
-  })
-
-  it('lets bodies use multi-line statements + helpers', () => {
-    const writes: unknown[] = []
-    const $set = (n: string, v: unknown) => writes.push([n, v])
-    runJsHandler({
-      body: `
-        const slug = String($state).toLowerCase().replace(/\\s+/g, '-')
-        $set('slug', slug)
-      `,
-      fieldName: 'title',
-      state:     'Hello World',
-      $get:      () => undefined,
-      $set,
-    })
-    assert.deepEqual(writes, [['slug', 'hello-world']])
-  })
-
-  it('empty / whitespace body compiles to a no-op', () => {
-    const writes: unknown[] = []
-    const $set = (n: string, v: unknown) => writes.push([n, v])
-    runJsHandler({
-      body:      `   `,
-      fieldName: 'x',
-      state:     undefined,
-      $get:      () => undefined,
-      $set,
-    })
-    assert.equal(writes.length, 0)
-  })
-})
-
-describe('runJsHandler — readNestedValue / writeNestedValue integration via $get/$set', () => {
-  beforeEach(() => {
-    __clearJsHandlerCacheForTests()
-  })
-
-  it('callers can route dotted-path access through $get/$set themselves', () => {
-    // The handler doesn't itself know about dotted paths — the caller
-    // (FormStateProvider.runFieldJs) wires that. This test just confirms
-    // the contract: $get/$set are pure user-supplied functions.
-    const values: Record<string, unknown> = { items: [{ qty: 2 }, { qty: 5 }] }
-    const $get = (n: string): unknown => {
-      if (n === 'items.0.qty') return (values.items as Array<{ qty: number }>)[0]!.qty
-      return undefined
-    }
-    const writes: unknown[] = []
-    const $set = (n: string, v: unknown): void => { writes.push([n, v]) }
-    runJsHandler({
-      body:      `$set('items.0.qty', Number($get('items.0.qty')) + Number($state))`,
-      fieldName: 'increment',
-      state:     1,
-      $get,
-      $set,
-    })
-    assert.deepEqual(writes, [['items.0.qty', 3]])
-  })
-})

package/src/react/fieldJsHandler.ts

@@ -1,79 +0,0 @@
-/**
- * Tier-2 follow-up to Plan #5 — `Field.afterStateUpdatedJs(body)`.
- *
- * Compiles a user-provided JS body string into a callable function and
- * caches the result by source identity. The body sees three names:
- *
- *   $state — the changed field's new value
- *   $get   — read a sibling field's current value
- *   $set   — write a sibling field's value (no cascade)
- *
- * Treated as admin-trusted code: written at schema-definition time,
- * never derived from request input. Uses `new Function` (CSP
- * `unsafe-eval` required); compile / run failures are caught and
- * `console.error`'d so a bad handler never breaks the form.
- */
-
-type GetFn = (name: string) => unknown
-type SetFn = (name: string, value: unknown) => void
-
-type HandlerFn = (state: unknown, $get: GetFn, $set: SetFn) => void
-
-type CompiledHandler =
-  | { ok: true;  fn: HandlerFn }
-  | { ok: false; error: string }
-
-const handlerCache = new Map<string, CompiledHandler>()
-
-function compileHandler(body: string, fieldName: string): CompiledHandler {
-  const cached = handlerCache.get(body)
-  if (cached) return cached
-
-  try {
-    // Prepend a sourceURL pragma so devtools attribute thrown frames to a
-    // stable, identifiable name instead of the anonymous "Function" frame.
-    const source = `'use strict';\n${body}\n//# sourceURL=pilotiq:afterStateUpdatedJs:${fieldName}`
-    const fn = new Function('$state', '$get', '$set', source) as HandlerFn
-    const entry: CompiledHandler = { ok: true, fn }
-    handlerCache.set(body, entry)
-    return entry
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err)
-    const entry: CompiledHandler = { ok: false, error }
-    handlerCache.set(body, entry)
-    console.error(`[pilotiq] afterStateUpdatedJs compile failed for "${fieldName}":`, err)
-    return entry
-  }
-}
-
-export interface RunJsHandlerArgs {
-  body:      string
-  fieldName: string
-  state:     unknown
-  $get:      GetFn
-  $set:      SetFn
-}
-
-/** Compile (cached) and run the JS body. Throws inside the body are
- *  caught + logged; the form is left untouched on failure. Compile
- *  failures are also cached so we don't re-attempt every change. */
-export function runJsHandler({ body, fieldName, state, $get, $set }: RunJsHandlerArgs): void {
-  const compiled = compileHandler(body, fieldName)
-  if (!compiled.ok) return
-
-  try {
-    // Invoke with `.call(undefined, …)` so the body's `this` is `undefined`
-    // (in strict mode). A bare `compiled.fn(…)` would bind `this` to the
-    // cache entry object — leaking the framework's internals into the
-    // user-supplied JS.
-    compiled.fn.call(undefined, state, $get, $set)
-  } catch (err) {
-    console.error(`[pilotiq] afterStateUpdatedJs run failed for "${fieldName}":`, err)
-  }
-}
-
-/** Test-only: clear the compile cache between runs. Production code
- *  has no reason to call this. */
-export function __clearJsHandlerCacheForTests(): void {
-  handlerCache.clear()
-}