@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/defaultViewPage.test.ts

@@ -1,147 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Resource } from './Resource.js'
-import { Page } from './Page.js'
-import { Form } from './elements/Form.js'
-import { Action } from './actions/Action.js'
-import { Section } from './schema/Section.js'
-import { Text } from './schema/Text.js'
-import { TextField } from './fields/TextField.js'
-import type { Element } from './schema/Element.js'
-import { defaultViewPage, defaultPages } from './defaultPages.js'
-
-describe('defaultViewPage', () => {
-  class ArticleResource extends Resource {
-    static override label         = 'Articles'
-    static override labelSingular = 'Article'
-    static override slug          = 'articles'
-    static override icon          = 'file-text'
-
-    static override form(form: Form): Form {
-      return form
-        .schema([TextField.make('title')])
-        .loadRecord(async (id) => ({ id, title: `Loaded ${id}` }))
-    }
-
-    static override detail(record: unknown): Element[] {
-      const r = record as { title?: string } | null
-      return [
-        Section.make('Body').schema([Text.make(r?.title ?? '(no record)')]),
-      ]
-    }
-  }
-
-  it('produces a view-mode Page with a `${slug}/view` slug', () => {
-    const ViewArticle = defaultViewPage(ArticleResource)
-    assert.equal(ViewArticle.getMode(), 'view')
-    assert.equal(ViewArticle.getResource(), ArticleResource)
-    assert.equal(ViewArticle.getSlug(), 'articles/view')
-  })
-
-  it('schema(ctx) loads the record via the form loader and renders detail() — no auto Edit/Delete', async () => {
-    const ViewArticle = defaultViewPage(ArticleResource)
-    const elements = await Promise.resolve(ViewArticle.schema({ recordId: '42', basePath: '/admin' }))
-    // [Heading, Section] — Filament-style: no auto-injected Edit/Delete
-    assert.equal(elements.length, 2)
-    const [heading, body] = elements
-    assert.equal(heading!.getType(), 'heading')
-    assert.equal(body!.getType(), 'section')
-
-    const sectionMeta = body!.toMeta() as { title?: string }
-    assert.equal(sectionMeta.title, 'Body')
-  })
-
-  it('handles missing record gracefully (loader returns null/throws)', async () => {
-    class NoLoad extends Resource {
-      static override label = 'X'
-      static override labelSingular = 'X'
-      static override slug = 'x'
-      static override detail(record: unknown): Element[] {
-        return [Text.make(record === null ? 'EMPTY' : 'HAS')]
-      }
-    }
-    const View = defaultViewPage(NoLoad)
-    const elements = await Promise.resolve(View.schema({ recordId: '1', basePath: '' }))
-    // Heading + detail Text (no auto Edit/Delete)
-    assert.equal(elements.length, 2)
-    const detailMeta = elements[1]!.toMeta() as { content?: string }
-    assert.equal(detailMeta.content, 'EMPTY')
-  })
-
-  it('omits Edit/Delete actions when no recordId is in context', async () => {
-    const ViewArticle = defaultViewPage(ArticleResource)
-    const elements = await Promise.resolve(ViewArticle.schema({}))
-    const types = elements.map(e => e.getType())
-    assert.deepEqual(types, ['heading', 'section'])
-  })
-
-  it('Resource.detail() may return Plan #16 entries — they reach the resolver record-aware', async () => {
-    const { TextEntry }  = await import('./entries/TextEntry.js')
-    const { BadgeEntry } = await import('./entries/BadgeEntry.js')
-    const { resolveSchema } = await import('./schema/resolveSchema.js')
-
-    class Post extends Resource {
-      static override label         = 'Posts'
-      static override labelSingular = 'Post'
-      static override slug          = 'posts'
-
-      static override form(form: Form): Form {
-        return form
-          .schema([TextField.make('title')])
-          .loadRecord(async (id) => ({ id, title: `Post ${id}`, status: 'published' }))
-      }
-
-      static override detail(_record: unknown): Element[] {
-        return [
-          TextEntry.make('title').weight('semibold'),
-          BadgeEntry.make('status').colors({ draft: 'gray', published: 'success' }),
-        ]
-      }
-    }
-
-    const ViewPost  = defaultViewPage(Post)
-    const elements  = await Promise.resolve(ViewPost.schema({ recordId: '42', basePath: '' }))
-    const record    = await Post.form(Form.make()).getLoadRecord()!('42', { values: {} })
-    const resolved  = await resolveSchema(elements, { record })
-
-    const titleEntry  = resolved.find(m => m['name'] === 'title')!
-    const statusEntry = resolved.find(m => m['name'] === 'status')!
-
-    assert.equal(titleEntry.type,             'entry')
-    assert.equal(titleEntry['entryType'],     'text')
-    assert.equal(titleEntry['value'],         'Post 42')
-    assert.equal(titleEntry['weight'],        'semibold')
-    assert.equal(statusEntry.type,            'entry')
-    assert.equal(statusEntry['entryType'],    'badge')
-    assert.equal(statusEntry['value'],        'published')
-    assert.deepEqual(statusEntry['colors'],   { draft: 'gray', published: 'success' })
-  })
-})
-
-describe('Resource.resolvePages — view key', () => {
-  class ResX extends Resource {
-    static override label = 'X'
-    static override labelSingular = 'X'
-    static override slug = 'x'
-  }
-
-  it('includes view by default', () => {
-    const pages = defaultPages(ResX)
-    assert.equal(typeof pages.view, 'function')
-    assert.equal(pages.view!.getMode(), 'view')
-  })
-
-  it('user-supplied view in pages() wins', () => {
-    class Custom extends Page {
-      static override getMode() { return 'view' as const }
-    }
-    class WithCustom extends ResX {
-      static override pages() { return { view: Custom } }
-    }
-    const resolved = WithCustom.resolvePages()
-    assert.equal(resolved.view, Custom)
-    // others fall through to defaults
-    assert.notEqual(resolved.index, undefined)
-  })
-})

package/src/elements/Form.test.ts

@@ -1,223 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Form, _resetFormIdSeq } from './Form.js'
-import { TextField } from '../fields/TextField.js'
-import { EmailField } from '../fields/EmailField.js'
-import { Section } from '../schema/Section.js'
-import { Action } from '../actions/Action.js'
-import { resolveSchema } from '../schema/resolveSchema.js'
-import { required } from '../validation/index.js'
-
-describe('Form Element', () => {
-  beforeEach(() => _resetFormIdSeq())
-
-  describe('shape and toMeta', () => {
-    it('emits type=form and an auto-generated formId', () => {
-      const meta = Form.make().toMeta()
-      assert.equal(meta.type, 'form')
-      assert.equal(meta.formId, 'form-1')
-      assert.equal(meta.method, 'post')
-      assert.equal('action' in meta, false)
-      assert.equal('values' in meta, false)
-      assert.equal('errors' in meta, false)
-    })
-
-    it('respects explicit formId / method / action', () => {
-      const meta = Form.make()
-        .formId('article-form')
-        .method('put')
-        .action('/admin/articles/42')
-        .toMeta()
-      assert.equal(meta.formId, 'article-form')
-      assert.equal(meta.method, 'put')
-      assert.equal(meta.action, '/admin/articles/42')
-    })
-
-    it('emits values / errors when set via withValues / withErrors', () => {
-      const meta = Form.make()
-        .withValues({ title: 'Hello' })
-        .withErrors({ title: ['Required'] })
-        .toMeta()
-      assert.deepEqual(meta.values, { title: 'Hello' })
-      assert.deepEqual(meta.errors, { title: ['Required'] })
-    })
-
-    it('emits unique formIds across instances', () => {
-      const a = Form.make().toMeta()
-      const b = Form.make().toMeta()
-      assert.notEqual(a.formId, b.formId)
-    })
-  })
-
-  describe('children + resolver', () => {
-    it('children resolve recursively through the standard resolver', async () => {
-      const form = Form.make().schema([
-        TextField.make('title').required(),
-        Section.make('Body').schema([
-          TextField.make('body'),
-        ]),
-      ])
-      const [meta] = await resolveSchema([form])
-      assert.equal(meta!.type, 'form')
-      assert.equal((meta!.children as any[]).length, 2)
-      assert.equal((meta!.children as any[])[0].name, 'title')
-      assert.equal((meta!.children as any[])[1].type, 'section')
-      assert.equal((meta!.children as any[])[1].children.length, 1)
-    })
-
-    it('hidden fields inside the form are filtered by the resolver', async () => {
-      const form = Form.make().schema([
-        TextField.make('title'),
-        TextField.make('admin').hideFromCreate(),
-      ])
-      const [meta] = await resolveSchema([form], { mode: 'create' })
-      assert.equal((meta!.children as any[]).length, 1)
-      assert.equal((meta!.children as any[])[0].name, 'title')
-    })
-
-    it('Action children serialize alongside Fields', async () => {
-      const form = Form.make().schema([
-        EmailField.make('email'),
-        Action.make('save').label('Save'),
-      ])
-      const [meta] = await resolveSchema([form])
-      const kids = meta!.children as any[]
-      assert.equal(kids.length, 2)
-      assert.equal(kids[0].fieldType, 'email')
-      assert.equal(kids[1].type, 'action')
-    })
-  })
-
-  describe('lifecycle setters store handlers (no dispatch yet)', () => {
-    it('save / mutateData / redirectAfterSave round-trip via getters', () => {
-      const saveFn = async () => ({ id: 1 })
-      const mutateFn = (d: Record<string, unknown>) => d
-      const redirectFn = () => '/done'
-
-      const form = Form.make()
-        .save(saveFn)
-        .mutateData(mutateFn)
-        .redirectAfterSave(redirectFn)
-
-      assert.equal(form.getSave(), saveFn)
-      assert.equal(form.getMutateData(), mutateFn)
-      assert.equal(form.getRedirectAfterSave(), redirectFn)
-    })
-
-    it('validate() accumulates form-level validators', () => {
-      const v1 = required()
-      const v2 = required('also required')
-      const form = Form.make().validate(v1).validate(v2)
-      assert.deepEqual(form.getFormValidators(), [v1, v2])
-    })
-
-    it('handlers are not serialized in toMeta', () => {
-      const meta = Form.make()
-        .save(async () => ({}))
-        .mutateData(d => d)
-        .redirectAfterSave(() => '/x')
-        .toMeta()
-      assert.equal('save' in meta, false)
-      assert.equal('mutateData' in meta, false)
-      assert.equal('redirectAfterSave' in meta, false)
-    })
-
-    it('mode-specific lifecycle setters round-trip via getters', () => {
-      const beforeCreate = async () => {}
-      const beforeUpdate = async () => {}
-      const afterCreate  = async () => {}
-      const afterUpdate  = async () => {}
-      const handleCreate = async () => ({ id: 1 })
-      const handleUpdate = async () => ({ id: 2 })
-      const mutateBeforeCreate = (d: Record<string, unknown>) => d
-      const mutateBeforeUpdate = (d: Record<string, unknown>) => d
-
-      const form = Form.make()
-        .beforeCreate(beforeCreate).beforeUpdate(beforeUpdate)
-        .afterCreate(afterCreate).afterUpdate(afterUpdate)
-        .handleCreate(handleCreate).handleUpdate(handleUpdate)
-        .mutateDataBeforeCreate(mutateBeforeCreate)
-        .mutateDataBeforeUpdate(mutateBeforeUpdate)
-
-      assert.equal(form.getBeforeCreate(), beforeCreate)
-      assert.equal(form.getBeforeUpdate(), beforeUpdate)
-      assert.equal(form.getAfterCreate(), afterCreate)
-      assert.equal(form.getAfterUpdate(), afterUpdate)
-      assert.equal(form.getHandleCreate(), handleCreate)
-      assert.equal(form.getHandleUpdate(), handleUpdate)
-      assert.equal(form.getMutateDataBeforeCreate(), mutateBeforeCreate)
-      assert.equal(form.getMutateDataBeforeUpdate(), mutateBeforeUpdate)
-    })
-
-    it('fill-side mutators round-trip via getters', () => {
-      const before = (v: Record<string, unknown>) => v
-      const after  = (v: Record<string, unknown>) => v
-      const form = Form.make()
-        .mutateFormDataBeforeFill(before)
-        .mutateFormDataAfterFill(after)
-      assert.equal(form.getMutateFormDataBeforeFill(), before)
-      assert.equal(form.getMutateFormDataAfterFill(), after)
-    })
-
-    it('savedNotification accepts string / fn / null and getter passes through', () => {
-      const a = Form.make().savedNotification('Saved')
-      assert.equal(a.getSavedNotification(), 'Saved')
-
-      const fn = () => 'Saved'
-      const b = Form.make().savedNotification(fn)
-      assert.equal(b.getSavedNotification(), fn)
-
-      const c = Form.make().savedNotification(null)
-      assert.equal(c.getSavedNotification(), null)
-    })
-
-    it('createdNotification stores separately from savedNotification', () => {
-      const form = Form.make()
-        .savedNotification('Saved')
-        .createdNotification('Created')
-      assert.equal(form.getSavedNotification(), 'Saved')
-      assert.equal(form.getCreatedNotification(), 'Created')
-    })
-
-    it('disableSavedNotification flips the flag', () => {
-      const form = Form.make().disableSavedNotification()
-      assert.equal(form.isSavedNotificationDisabled(), true)
-    })
-
-    it('new lifecycle handlers are not serialized in toMeta', () => {
-      const meta = Form.make()
-        .beforeCreate(async () => {})
-        .afterUpdate(async () => {})
-        .handleCreate(async () => ({}))
-        .mutateFormDataBeforeFill(v => v)
-        .savedNotification('Saved')
-        .createdNotification('Created')
-        .toMeta()
-      assert.equal('beforeCreate' in meta, false)
-      assert.equal('afterUpdate' in meta, false)
-      assert.equal('handleCreate' in meta, false)
-      assert.equal('mutateFormDataBeforeFill' in meta, false)
-      assert.equal('savedNotification' in meta, false)
-      assert.equal('createdNotification' in meta, false)
-    })
-  })
-
-  describe('stateUrl (Plan #5)', () => {
-    it('toMeta omits stateUrl when not set', () => {
-      const meta = Form.make().toMeta()
-      assert.equal('stateUrl' in meta, false)
-    })
-
-    it('toMeta emits stateUrl when set', () => {
-      const meta = Form.make().withStateUrl('/admin/articles/_form/form-1/state').toMeta()
-      assert.equal(meta.stateUrl, '/admin/articles/_form/form-1/state')
-    })
-
-    it('withStateUrl(undefined) clears the value', () => {
-      const form = Form.make().withStateUrl('/x').withStateUrl(undefined)
-      assert.equal(form.getStateUrl(), undefined)
-      assert.equal('stateUrl' in form.toMeta(), false)
-    })
-  })
-})