@invisibleloop/pulse 0.20.37 → 0.20.39

package/src/spec/schema.test.js

@@ -1,467 +0,0 @@
-/**
- * Spec schema tests — run with: node src/spec/schema.test.js
- */
-import { validateSpec, assertValidSpec, getStreamOrder, getViewSegments } from './schema.js'
-
-let passed = 0
-let failed = 0
-
-function test(label, fn) {
-  try {
-    fn()
-    console.log(`  ✓ ${label}`)
-    passed++
-  } catch (e) {
-    console.log(`  ✗ ${label}`)
-    console.log(`    ${e.message}`)
-    failed++
-  }
-}
-
-function assert(condition, msg) {
-  if (!condition) throw new Error(msg || 'Assertion failed')
-}
-
-function assertErrors(spec, ...expectedFragments) {
-  const { valid, errors } = validateSpec(spec)
-  assert(!valid, 'Expected spec to be invalid but it passed')
-  for (const fragment of expectedFragments) {
-    const found = errors.some(e => e.includes(fragment))
-    assert(found, `Expected error containing "${fragment}" but got:\n    ${errors.join('\n    ')}`)
-  }
-}
-
-function assertValid(spec) {
-  const { valid, errors } = validateSpec(spec)
-  assert(valid, `Expected spec to be valid but got errors:\n  ${errors.join('\n  ')}`)
-}
-
-// ---------------------------------------------------------------------------
-
-console.log('\nSpec validation\n')
-
-test('rejects non-object', () => {
-  assertErrors(null, 'must be a plain object')
-  assertErrors('string', 'must be a plain object')
-})
-
-test('route is optional (derived server-side by convention)', () => {
-  const { valid } = validateSpec({ state: {}, view: () => '' })
-  assert(valid, 'spec without route should be valid for client-side use')
-})
-
-test('rejects route that does not start with /', () => {
-  assertErrors({ route: 'contact', state: {}, view: () => '' }, 'must start with "/"')
-})
-
-test('state is optional — omitting it is valid', () => {
-  const { valid, errors } = validateSpec({ route: '/contact', view: () => '' })
-  if (!valid) throw new Error(`Expected valid but got: ${errors.join(', ')}`)
-})
-
-test('state must be a plain object when provided', () => {
-  assertErrors({ route: '/contact', state: 'bad', view: () => '' }, 'spec.state must be a plain object')
-})
-
-test('requires view', () => {
-  assertErrors({ route: '/contact', state: {} }, 'spec.view is required')
-})
-
-test('accepts function view', () => {
-  assertValid({ route: '/contact', state: {}, view: () => '<div/>' })
-})
-
-test('accepts segmented view', () => {
-  assertValid({
-    route: '/contact',
-    state: {},
-    view: {
-      header: () => '<header/>',
-      form:   () => '<form/>'
-    }
-  })
-})
-
-test('rejects view segment that is not a function', () => {
-  assertErrors(
-    { route: '/contact', state: {}, view: { header: '<header/>' } },
-    'spec.view.header must be a function'
-  )
-})
-
-test('rejects stream referencing undefined segment', () => {
-  assertErrors(
-    {
-      route: '/contact',
-      state: {},
-      view:  { header: () => '' },
-      stream: { shell: ['header', 'missing'] }
-    },
-    'spec.stream references "missing"'
-  )
-})
-
-test('rejects stream.shell that is not an array', () => {
-  assertErrors(
-    { route: '/contact', state: {}, view: () => '', stream: { shell: 'header' } },
-    'spec.stream.shell must be an array'
-  )
-})
-
-test('accepts valid stream.scope', () => {
-  const spec = {
-    route: '/s',
-    state: {},
-    server: { user: async () => {}, posts: async () => {} },
-    stream: {
-      shell:    ['header'],
-      deferred: ['feed'],
-      scope:    { header: ['user'], feed: ['posts'] },
-    },
-    view: { header: () => '', feed: () => '' },
-  }
-  const { valid } = validateSpec(spec)
-  assert(valid, 'Expected valid spec with stream.scope')
-})
-
-test('rejects stream.scope referencing unknown segment', () => {
-  assertErrors(
-    {
-      route: '/s',
-      state: {},
-      server: { user: async () => {} },
-      stream: { shell: ['header'], scope: { unknown: ['user'] } },
-      view: { header: () => '' },
-    },
-    'spec.stream.scope references unknown segment "unknown"'
-  )
-})
-
-test('rejects stream.scope referencing unknown server key', () => {
-  assertErrors(
-    {
-      route: '/s',
-      state: {},
-      server: { user: async () => {} },
-      stream: { shell: ['header'], scope: { header: ['missing'] } },
-      view: { header: () => '' },
-    },
-    'spec.stream.scope["header"] references unknown server key "missing"'
-  )
-})
-
-test('rejects stream.scope with non-array value', () => {
-  assertErrors(
-    {
-      route: '/s',
-      state: {},
-      server: { user: async () => {} },
-      stream: { shell: ['header'], scope: { header: 'user' } },
-      view: { header: () => '' },
-    },
-    'spec.stream.scope["header"] must be an array'
-  )
-})
-
-test('rejects mutations with non-function values', () => {
-  assertErrors(
-    { route: '/x', state: {}, view: () => '', mutations: { inc: 'not a function' } },
-    'spec.mutations.inc must be a function'
-  )
-})
-
-test('rejects action missing run', () => {
-  assertErrors(
-    {
-      route: '/x', state: {}, view: () => '',
-      actions: { send: { onSuccess: () => {}, onError: () => {} } }
-    },
-    'spec.actions.send.run must be'
-  )
-})
-
-test('rejects action missing onSuccess', () => {
-  assertErrors(
-    {
-      route: '/x', state: {}, view: () => '',
-      actions: { send: { run: async () => {}, onError: () => {} } }
-    },
-    'spec.actions.send.onSuccess must be'
-  )
-})
-
-test('rejects unknown validation rule', () => {
-  assertErrors(
-    {
-      route: '/x', state: {}, view: () => '',
-      validation: { 'fields.email': { required: true, unknown: true } }
-    },
-    'unknown is not a recognised rule'
-  )
-})
-
-test('accepts full valid spec', () => {
-  assertValid({
-    route: '/contact',
-    stream: {
-      shell:    ['header', 'form'],
-      deferred: ['recent']
-    },
-    server: {
-      recent: async () => []
-    },
-    state: {
-      fields: { name: '', email: '', message: '' },
-      status: 'idle'
-    },
-    validation: {
-      'fields.name':    { required: true, minLength: 2 },
-      'fields.email':   { required: true, format: 'email' },
-      'fields.message': { required: true, minLength: 10, maxLength: 1000 }
-    },
-    view: {
-      header: () => '<header/>',
-      form:   (state) => `<form>${state.status}</form>`,
-      recent: (state, server) => `<aside>${server.recent.length}</aside>`
-    },
-    mutations: {
-      updateField: (state, e) => ({ fields: { ...state.fields, [e.target.name]: e.target.value } })
-    },
-    actions: {
-      sendMessage: {
-        validate:  true,
-        run:       async (state) => {},
-        onSuccess: () => ({ status: 'success' }),
-        onError:   () => ({ status: 'error' })
-      }
-    },
-    meta: { title: 'Contact Us' }
-  })
-})
-
-// ---------------------------------------------------------------------------
-
-console.log('\nRaw content specs (contentType)\n')
-
-test('accepts a valid raw content spec', () => {
-  assertValid({
-    route:       '/feed.xml',
-    contentType: 'application/rss+xml; charset=utf-8',
-    render:      (ctx, server) => `<rss/>`
-  })
-})
-
-test('raw spec does not require state or view', () => {
-  const { valid } = validateSpec({
-    route:       '/sitemap.xml',
-    contentType: 'application/xml',
-    render:      () => `<?xml?>`
-  })
-  assert(valid, 'raw spec without state/view should be valid')
-})
-
-test('raw spec accepts server data', () => {
-  assertValid({
-    route:       '/feed.json',
-    contentType: 'application/json',
-    server:      { posts: async () => [] },
-    render:      (ctx, server) => JSON.stringify(server.posts)
-  })
-})
-
-test('rejects raw spec missing render', () => {
-  assertErrors(
-    { route: '/feed.xml', contentType: 'application/rss+xml' },
-    'spec.render is required'
-  )
-})
-
-test('rejects raw spec with empty contentType', () => {
-  assertErrors(
-    { route: '/feed.xml', contentType: '', render: () => '' },
-    'spec.contentType must be a non-empty string'
-  )
-})
-
-// ---------------------------------------------------------------------------
-
-console.log('\ngetViewSegments\n')
-
-test('function view returns ["default"]', () => {
-  const segments = getViewSegments({ view: () => '' })
-  assert(segments.length === 1 && segments[0] === 'default', `Got ${segments}`)
-})
-
-test('segmented view returns keys', () => {
-  const segments = getViewSegments({ view: { header: () => '', form: () => '' } })
-  assert(segments.includes('header') && segments.includes('form'), `Got ${segments}`)
-})
-
-// ---------------------------------------------------------------------------
-
-console.log('\ngetStreamOrder\n')
-
-test('no stream config — all segments in shell', () => {
-  const order = getStreamOrder({ view: { header: () => '', form: () => '' } })
-  assert(order.shell.includes('header'), 'header should be in shell')
-  assert(order.deferred.length === 0, 'deferred should be empty')
-})
-
-test('stream config is respected', () => {
-  const order = getStreamOrder({
-    view:   { header: () => '', form: () => '', recent: () => '' },
-    stream: { shell: ['header', 'form'], deferred: ['recent'] }
-  })
-  assert(order.shell.includes('header'), 'header in shell')
-  assert(order.shell.includes('form'), 'form in shell')
-  assert(order.deferred.includes('recent'), 'recent in deferred')
-})
-
-// ---------------------------------------------------------------------------
-// guard
-// ---------------------------------------------------------------------------
-
-test('accepts a valid guard function', () => {
-  const { valid, errors } = validateSpec({
-    route: '/admin',
-    state: {},
-    view:  () => '<main id="main-content">Admin</main>',
-    guard: async (ctx) => { if (!ctx.cookies.session) return { redirect: '/login' } },
-  })
-  assert(valid, `Expected valid spec, got errors: ${errors.join(', ')}`)
-})
-
-test('rejects guard that is not a function', () => {
-  assertErrors(
-    { route: '/admin', state: {}, view: () => '', guard: '/login' },
-    'spec.guard must be a function'
-  )
-})
-
-test('rejects guard that is an object', () => {
-  assertErrors(
-    { route: '/admin', state: {}, view: () => '', guard: { redirect: '/login' } },
-    'spec.guard must be a function'
-  )
-})
-
-// ---------------------------------------------------------------------------
-// assertValidSpec — framework-injected hydrate must not produce a warning
-// ---------------------------------------------------------------------------
-
-console.log('\nassertValidSpec\n')
-
-test('does not warn when hydrate is framework-injected', () => {
-  // The server injects hydrate onto specs that need it. assertValidSpec is called
-  // on every render — it must not print a false-positive warning about hydrate.
-  const warnings = []
-  const orig = console.warn
-  console.warn = (...args) => warnings.push(args.join(' '))
-  try {
-    assertValidSpec({
-      route:    '/entry',
-      hydrate:  '/src/pages/entry.js',
-      state:    { editing: false },
-      view:     () => '<main id="main-content"></main>',
-      mutations: { startEdit: () => ({ editing: true }) },
-      meta:     { title: 'Entry', description: 'A page' },
-    })
-  } finally {
-    console.warn = orig
-  }
-  const hydrateWarning = warnings.some(w => w.includes('hydrate'))
-  assert(!hydrateWarning, `Unexpected hydrate warning: ${warnings.join('; ')}`)
-})
-
-test('validateSpec still warns when hydrate is set manually in source', () => {
-  // validateSpec (used by the MCP tool on raw source files) should still warn.
-  const { warnings } = validateSpec({
-    route:   '/entry',
-    hydrate: '/src/pages/entry.js',
-    view:    () => '<main id="main-content"></main>',
-    meta:    { title: 'Entry', description: 'A page' },
-  })
-  assert(warnings.some(w => w.includes('hydrate')), 'Expected hydrate warning from validateSpec')
-})
-
-// meta.theme warnings
-test('warns when meta.theme is not set', () => {
-  const { warnings } = validateSpec({
-    route: '/entry',
-    view:  () => '<main id="main-content"></main>',
-    meta:  { title: 'Entry', description: 'A page' },
-  })
-  assert(warnings.some(w => w.includes('meta.theme')), 'Expected meta.theme warning')
-})
-
-test('does not warn when meta.theme is a string', () => {
-  const { warnings } = validateSpec({
-    route: '/entry',
-    view:  () => '<main id="main-content"></main>',
-    meta:  { title: 'Entry', description: 'A page', theme: 'dark' },
-  })
-  assert(!warnings.some(w => w.includes('meta.theme')), 'Unexpected meta.theme warning when theme is set')
-})
-
-test('does not warn when meta.theme is a function', () => {
-  const { warnings } = validateSpec({
-    route: '/entry',
-    view:  () => '<main id="main-content"></main>',
-    meta:  { title: 'Entry', description: 'A page', theme: (ctx) => ctx.brand?.theme ?? 'dark' },
-  })
-  assert(!warnings.some(w => w.includes('meta.theme')), 'Unexpected meta.theme warning when theme is a function')
-})
-
-// --- route '*', submit, csrf ------------------------------------------------
-
-test('route "*" (custom not-found page) is valid', () => {
-  const { valid, errors } = validateSpec({ route: '*', view: () => '<main id="main-content">404</main>' })
-  assert(valid, `Expected valid, got: ${errors.join('; ')}`)
-})
-
-test('non-"/" routes other than "*" are still rejected', () => {
-  const { valid } = validateSpec({ route: 'about', view: () => '' })
-  assert(!valid, 'Expected route without leading / to be invalid')
-})
-
-test('submit must be a function', () => {
-  const { valid, errors } = validateSpec({ route: '/x', view: () => '', submit: 'nope' })
-  assert(!valid && errors.some(e => e.includes('submit')), 'Expected submit type error')
-})
-
-test('a valid submit function passes', () => {
-  const { valid } = validateSpec({ route: '/x', view: () => '', submit: async () => ({ redirect: '/' }) })
-  assert(valid, 'Expected spec with submit function to be valid')
-})
-
-test('csrf must be a boolean', () => {
-  const { valid, errors } = validateSpec({ route: '/x', view: () => '', csrf: 'off' })
-  assert(!valid && errors.some(e => e.includes('csrf')), 'Expected csrf type error')
-})
-
-test('csrf: false with submit warns about unprotected POSTs', () => {
-  const { valid, warnings } = validateSpec({ route: '/x', view: () => '', submit: async () => {}, csrf: false })
-  assert(valid, 'csrf: false is valid')
-  assert(warnings.some(w => w.includes('CSRF')), 'Expected a warning about disabled CSRF protection')
-})
-
-// --- sitemap ------------------------------------------------------------------
-
-test('sitemap accepts boolean, array, and function', () => {
-  for (const v of [true, false, ['/a', { path: '/b', lastmod: '2026-01-01' }], async () => ['/a']]) {
-    const { valid, errors } = validateSpec({ route: '/x', view: () => '', sitemap: v })
-    assert(valid, `Expected sitemap ${typeof v} to be valid: ${errors.join('; ')}`)
-  }
-})
-
-test('sitemap rejects invalid types and malformed array entries', () => {
-  const { valid: v1 } = validateSpec({ route: '/x', view: () => '', sitemap: 'yes' })
-  assert(!v1, 'Expected string sitemap to be invalid')
-  const { valid: v2, errors } = validateSpec({ route: '/x', view: () => '', sitemap: ['no-slash'] })
-  assert(!v2 && errors.some(e => e.includes('sitemap')), 'Expected malformed array entry to be invalid')
-})
-
-// ---------------------------------------------------------------------------
-
-console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`)
-if (failed > 0) process.exit(1)

package/src/store/store.test.js

@@ -1,210 +0,0 @@
-/**
- * Pulse — Store tests
- * run: node src/store/store.test.js
- */
-
-import { validateStore, resolveStoreState } from './index.js'
-
-let passed = 0
-let failed = 0
-
-async function test(label, fn) {
-  try {
-    await fn()
-    console.log(`  ✓ ${label}`)
-    passed++
-  } catch (e) {
-    console.log(`  ✗ ${label}`)
-    console.log(`    ${e.message}`)
-    failed++
-  }
-}
-
-function assert(condition, msg) {
-  if (!condition) throw new Error(msg || 'Assertion failed')
-}
-
-function assertEqual(a, b, msg) {
-  if (a !== b) throw new Error(msg || `Expected ${JSON.stringify(a)} === ${JSON.stringify(b)}`)
-}
-
-// ---------------------------------------------------------------------------
-
-console.log('\nvalidateStore\n')
-
-await test('accepts a valid store with state and server', () => {
-  const { valid } = validateStore({
-    state:  { user: null },
-    server: { user: async () => null },
-  })
-  assert(valid, 'Expected valid store')
-})
-
-await test('accepts a store with only state', () => {
-  const { valid } = validateStore({ state: { theme: 'dark' } })
-  assert(valid)
-})
-
-await test('accepts a store with only server', () => {
-  const { valid } = validateStore({ server: { user: async () => null } })
-  assert(valid)
-})
-
-await test('accepts a store with mutations', () => {
-  const { valid } = validateStore({
-    state:     { count: 0 },
-    mutations: { increment: (s) => ({ count: s.count + 1 }) },
-  })
-  assert(valid)
-})
-
-await test('accepts a store with hydrate', () => {
-  const { valid } = validateStore({ state: {}, hydrate: '/pulse.store.js' })
-  assert(valid)
-})
-
-await test('rejects null', () => {
-  const { valid, errors } = validateStore(null)
-  assert(!valid)
-  assert(errors.length > 0)
-})
-
-await test('rejects a non-object', () => {
-  const { valid } = validateStore('not an object')
-  assert(!valid)
-})
-
-await test('rejects an array', () => {
-  const { valid } = validateStore([])
-  assert(!valid)
-})
-
-await test('rejects state that is an array', () => {
-  const { valid, errors } = validateStore({ state: [] })
-  assert(!valid)
-  assert(errors.some(e => e.includes('state')), `Expected state error in: ${errors}`)
-})
-
-await test('rejects state that is a string', () => {
-  const { valid } = validateStore({ state: 'bad' })
-  assert(!valid)
-})
-
-await test('rejects server that is an array', () => {
-  const { valid, errors } = validateStore({ server: ['fn'] })
-  assert(!valid)
-  assert(errors.some(e => e.includes('server')), `Expected server error in: ${errors}`)
-})
-
-await test('rejects a server entry that is not a function', () => {
-  const { valid, errors } = validateStore({ server: { user: 42 } })
-  assert(!valid)
-  assert(errors.some(e => e.includes('store.server.user')), `Expected named error in: ${errors}`)
-})
-
-await test('rejects mutations that is an array', () => {
-  const { valid, errors } = validateStore({ mutations: [() => {}] })
-  assert(!valid)
-  assert(errors.some(e => e.includes('mutations')), `Expected mutations error in: ${errors}`)
-})
-
-await test('rejects a mutation entry that is not a function', () => {
-  const { valid, errors } = validateStore({ mutations: { toggle: 'bad' } })
-  assert(!valid)
-  assert(errors.some(e => e.includes('store.mutations.toggle')), `Expected named error in: ${errors}`)
-})
-
-await test('rejects hydrate that does not start with /', () => {
-  const { valid, errors } = validateStore({ hydrate: 'pulse.store.js' })
-  assert(!valid)
-  assert(errors.some(e => e.includes('hydrate')), `Expected hydrate error in: ${errors}`)
-})
-
-await test('rejects hydrate that is not a string', () => {
-  const { valid } = validateStore({ hydrate: 42 })
-  assert(!valid)
-})
-
-await test('returns all errors for multiple violations', () => {
-  const { valid, errors } = validateStore({ state: [], server: { x: 'not-a-fn' } })
-  assert(!valid)
-  assert(errors.length >= 2, `Expected >= 2 errors, got ${errors.length}: ${errors.join(', ')}`)
-})
-
-// ---------------------------------------------------------------------------
-
-console.log('\nresolveStoreState\n')
-
-await test('returns state defaults when no server fetchers', async () => {
-  const result = await resolveStoreState({ state: { user: null, theme: 'dark' } }, {})
-  assertEqual(result.theme, 'dark')
-  assert(result.user === null)
-})
-
-await test('resolves server fetchers and returns their results', async () => {
-  const result = await resolveStoreState({
-    state:  { user: null, settings: {} },
-    server: {
-      user:     async () => ({ id: 1, name: 'Alice' }),
-      settings: async () => ({ theme: 'light' }),
-    },
-  }, {})
-  assertEqual(result.user.name, 'Alice')
-  assertEqual(result.settings.theme, 'light')
-})
-
-await test('server values override state defaults', async () => {
-  const result = await resolveStoreState({
-    state:  { user: 'default' },
-    server: { user: async () => 'from-server' },
-  }, {})
-  assertEqual(result.user, 'from-server')
-})
-
-await test('state defaults are preserved for keys not covered by server', async () => {
-  const result = await resolveStoreState({
-    state:  { user: null, nav: [1, 2, 3] },
-    server: { user: async () => ({ id: 1 }) },
-  }, {})
-  assertEqual(result.nav.length, 3)
-})
-
-await test('passes ctx to server fetchers', async () => {
-  let received
-  await resolveStoreState({
-    server: { data: async (ctx) => { received = ctx; return null } },
-  }, { cookies: { session: 'abc' } })
-  assertEqual(received.cookies.session, 'abc')
-})
-
-await test('returns empty object when store has no state and no server', async () => {
-  const result = await resolveStoreState({}, {})
-  assert(typeof result === 'object' && result !== null)
-  assertEqual(Object.keys(result).length, 0)
-})
-
-await test('timeout rejects if a fetcher exceeds fetcherTimeout', async () => {
-  let threw = false
-  try {
-    await resolveStoreState({
-      server: { slow: async () => new Promise(r => setTimeout(r, 200)) },
-    }, { fetcherTimeout: 20 })
-  } catch (e) {
-    threw = true
-    assert(e.message.includes('slow'), `Expected fetcher name in error: ${e.message}`)
-    assert(e.message.toLowerCase().includes('timed out'), `Expected timeout message: ${e.message}`)
-  }
-  assert(threw, 'Expected timeout to throw')
-})
-
-await test('no timeout when fetcherTimeout is not set', async () => {
-  const result = await resolveStoreState({
-    server: { fast: async () => 'ok' },
-  }, {})
-  assertEqual(result.fast, 'ok')
-})
-
-// ---------------------------------------------------------------------------
-
-console.log(`\n${passed} passed, ${failed} failed\n`)
-if (failed > 0) process.exit(1)