@pilotiq/pilotiq 0.6.2 → 0.7.0

package/src/fields/RepeaterField.ts

@@ -51,6 +51,52 @@ export interface RepeaterRelationshipMeta {
   orderColumn?: string
 }
 
+/**
+ * Mode of the underlying relation, derived from the parent's `static
+ * relations` map at submit time. Surfaced on `RepeaterRowContext.mode`
+ * so per-row hooks can branch when needed (e.g. an `afterDelete` that
+ * runs cleanup only when the child record was actually removed, not
+ * when a pivot row was detached).
+ */
+export type RepeaterRelationMode =
+  | 'hasMany'
+  | 'morphMany'
+  | 'belongsToMany'
+  | 'morphToMany'
+  | 'morphedByMany'
+
+/**
+ * Context passed to `Repeater.afterCreate / afterUpdate / afterDelete`
+ * hooks. One invocation per row; `parent` is the post-save parent record
+ * (PK already set), `record` carries the persisted child.
+ *
+ * For M2M modes (`belongsToMany / morphToMany / morphedByMany`)
+ * `afterDelete` fires after `accessor.detach(...)` — the child record
+ * may still exist (other parents may link to it). Branch on `ctx.mode`
+ * if your cleanup depends on physical deletion vs detach.
+ */
+export interface RepeaterRowContext<P = unknown> {
+  /** Post-save parent record (the same `record` the surrounding form's
+   *  `afterSave` would see). */
+  parent:   P
+  /** Convenience — `parent[primaryKey]`. */
+  parentId: string | number
+  /** The Repeater field's `name`. */
+  field:    string
+  /** 0-based index of the row in the submitted set; `-1` for `afterDelete`
+   *  since deleted rows aren't in the submitted set. */
+  index:    number
+  /** Underlying relation mode — see above for `afterDelete` semantics
+   *  on M2M. */
+  mode:     RepeaterRelationMode
+}
+
+/** Handler signature shared by the three after-hooks. */
+export type RepeaterRowAfterHandler<C = unknown, P = unknown> = (
+  record: C,
+  ctx:    RepeaterRowContext<P>,
+) => void | Promise<void>
+
 /**
  * Function evaluated once per row at meta-build to derive a human-readable
  * label for the collapsed-row header. Called with the row's submitted values
@@ -295,6 +341,9 @@ export class RepeaterField extends Field {
   private _tableColumns?:    RepeaterTableColumn[]
   private _buttons:          { [K in RowButtonKind]?: RowButton } = {}
   private _relationship?:    RepeaterRelationshipConfig
+  private _afterCreate?:     RepeaterRowAfterHandler
+  private _afterUpdate?:     RepeaterRowAfterHandler
+  private _afterDelete?:     RepeaterRowAfterHandler
 
   private constructor(name: string) {
     super(name, 'repeater')
@@ -560,6 +609,57 @@ export class RepeaterField extends Field {
     return this
   }
 
+  /**
+   * Per-row hook that fires after each newly created child record is
+   * persisted in `relationship()` mode. Receives the created record
+   * (with its primary key set) and a `RepeaterRowContext` carrying
+   * the parent record + row index + relation mode. Errors propagate
+   * — a throwing handler aborts the rest of the persist diff (the
+   * parent + any earlier rows have already saved; v1 is non-
+   * transactional).
+   *
+   * No-op outside `relationship()` mode. Use `Form.afterCreate(...)`
+   * for hooks that fire on the parent record's create.
+   */
+  afterCreate(fn: RepeaterRowAfterHandler): this {
+    if (!this._relationship) {
+      throw new Error(
+        `[Pilotiq] Repeater "${this.name}": afterCreate() requires relationship() to be configured first.`,
+      )
+    }
+    this._afterCreate = fn
+    return this
+  }
+
+  /** Per-row hook that fires after each existing child record is
+   *  updated. Receives the updated record from the child model's
+   *  `update()` return (or the post-update reload when `update`
+   *  returns void). See `afterCreate` notes for error semantics. */
+  afterUpdate(fn: RepeaterRowAfterHandler): this {
+    if (!this._relationship) {
+      throw new Error(
+        `[Pilotiq] Repeater "${this.name}": afterUpdate() requires relationship() to be configured first.`,
+      )
+    }
+    this._afterUpdate = fn
+    return this
+  }
+
+  /** Per-row hook that fires after each removed row is processed.
+   *  For `hasMany / morphMany` modes the child record was physically
+   *  deleted via `model.delete()`; for M2M modes only the pivot row
+   *  was detached and the child may still exist. Branch on
+   *  `ctx.mode` when that distinction matters. */
+  afterDelete(fn: RepeaterRowAfterHandler): this {
+    if (!this._relationship) {
+      throw new Error(
+        `[Pilotiq] Repeater "${this.name}": afterDelete() requires relationship() to be configured first.`,
+      )
+    }
+    this._afterDelete = fn
+    return this
+  }
+
   /**
    * Customize the bottom Add button's chrome (label / icon / color /
    * tooltip). Equivalent to `addActionLabel()` plus icon + color
@@ -692,6 +792,10 @@ export class RepeaterField extends Field {
   /** Resolved relationship config (`undefined` when not configured). */
   getRelationship(): RepeaterRelationshipConfig | undefined { return this._relationship }
   isRelationship(): boolean { return this._relationship !== undefined }
+
+  getAfterCreate(): RepeaterRowAfterHandler | undefined { return this._afterCreate }
+  getAfterUpdate(): RepeaterRowAfterHandler | undefined { return this._afterUpdate }
+  getAfterDelete(): RepeaterRowAfterHandler | undefined { return this._afterDelete }
   /** The configured customizer for a given slot, or `undefined`. */
   getButton(kind: RowButtonKind): RowButton | undefined { return this._buttons[kind] }
   /**

package/src/fields/RepeaterRelationship.test.ts

@@ -1628,3 +1628,176 @@ describe('Repeater.relationship — pivotColumns', () => {
     assert.deepEqual(rows, [])
   })
 })
+
+describe('Repeater.relationship — afterCreate / afterUpdate / afterDelete hooks', () => {
+  it('afterCreate fires once per created child with parent + index + mode in ctx', async () => {
+    const child = makeFakeChildModel([])
+    const parent = makeFakeParentModel({
+      childModel:   child.model,
+      childRows:    child.rows,
+      relationName: 'items',
+      foreignKey:   'orderId',
+    })
+
+    const calls: Array<{ record: unknown; ctx: Record<string, unknown> }> = []
+    const form = Form.make()
+      .schema([
+        RepeaterField.make('items')
+          .relationship('items')
+          .schema([TextField.make('label').required()])
+          .afterCreate((record, ctx) => {
+            calls.push({ record, ctx: { ...ctx } as Record<string, unknown> })
+          }),
+      ])
+      .save(async () => ({ id: 'p1', title: 'Order' }))
+
+    await dispatchFormSubmit(
+      form,
+      { items: [{ label: 'A' }, { label: 'B' }] },
+      { values: { items: [{ label: 'A' }, { label: 'B' }] }, parentModel: parent },
+    )
+
+    assert.equal(calls.length, 2)
+    assert.equal((calls[0]!.record as Record<string, unknown>)['label'], 'A')
+    assert.equal((calls[1]!.record as Record<string, unknown>)['label'], 'B')
+    assert.equal(calls[0]!.ctx['index'], 0)
+    assert.equal(calls[1]!.ctx['index'], 1)
+    assert.equal(calls[0]!.ctx['field'], 'items')
+    assert.equal(calls[0]!.ctx['mode'],  'hasMany')
+    assert.equal(calls[0]!.ctx['parentId'], 'p1')
+    assert.deepEqual(calls[0]!.ctx['parent'], { id: 'p1', title: 'Order' })
+  })
+
+  it('afterUpdate fires per updated child (skipping pure-create rows)', async () => {
+    const child = makeFakeChildModel([
+      { id: 'c1', orderId: 'p1', label: 'old A' },
+    ])
+    const parent = makeFakeParentModel({
+      childModel:   child.model,
+      childRows:    child.rows,
+      relationName: 'items',
+      foreignKey:   'orderId',
+    })
+
+    const updates: Array<{ record: unknown; index: number }> = []
+    const creates: Array<{ record: unknown; index: number }> = []
+    const form = Form.make()
+      .schema([
+        RepeaterField.make('items')
+          .relationship('items')
+          .schema([TextField.make('label').required()])
+          .afterCreate((record, ctx) => { creates.push({ record, index: ctx.index }) })
+          .afterUpdate((record, ctx) => { updates.push({ record, index: ctx.index }) }),
+      ])
+      .save(async () => ({ id: 'p1' }))
+
+    await dispatchFormSubmit(
+      form,
+      { items: [{ __id: 'c1', label: 'new A' }, { label: 'fresh B' }] },
+      {
+        values: { items: [{ __id: 'c1', label: 'new A' }, { label: 'fresh B' }] },
+        record: { id: 'p1' },
+        parentModel: parent,
+      },
+    )
+
+    assert.equal(updates.length, 1)
+    assert.equal((updates[0]!.record as Record<string, unknown>)['label'], 'new A')
+    assert.equal(updates[0]!.index, 0)
+    assert.equal(creates.length, 1)
+    assert.equal((creates[0]!.record as Record<string, unknown>)['label'], 'fresh B')
+    assert.equal(creates[0]!.index, 1)
+  })
+
+  it('afterDelete fires once per removed child with the previous row data', async () => {
+    const child = makeFakeChildModel([
+      { id: 'c1', orderId: 'p1', label: 'A' },
+      { id: 'c2', orderId: 'p1', label: 'B' },
+      { id: 'c3', orderId: 'p1', label: 'C' },
+    ])
+    const parent = makeFakeParentModel({
+      childModel:   child.model,
+      childRows:    child.rows,
+      relationName: 'items',
+      foreignKey:   'orderId',
+    })
+
+    const removed: Array<{ record: unknown; ctx: Record<string, unknown> }> = []
+    const form = Form.make()
+      .schema([
+        RepeaterField.make('items')
+          .relationship('items')
+          .schema([TextField.make('label').required()])
+          .afterDelete((record, ctx) => {
+            removed.push({ record, ctx: { ...ctx } as Record<string, unknown> })
+          }),
+      ])
+      .save(async () => ({ id: 'p1' }))
+
+    // Submit only c1 — c2 and c3 disappear.
+    await dispatchFormSubmit(
+      form,
+      { items: [{ __id: 'c1', label: 'A' }] },
+      {
+        values: { items: [{ __id: 'c1', label: 'A' }] },
+        record: { id: 'p1' },
+        parentModel: parent,
+      },
+    )
+
+    assert.equal(removed.length, 2)
+    const labels = removed.map(r => (r.record as Record<string, unknown>)['label']).sort()
+    assert.deepEqual(labels, ['B', 'C'])
+    assert.equal(removed[0]!.ctx['index'], -1)
+    assert.equal(removed[0]!.ctx['mode'],  'hasMany')
+    assert.equal(removed[0]!.ctx['parentId'], 'p1')
+  })
+
+  it('hooks are no-op outside relationship() mode (throw at config time)', () => {
+    assert.throws(() =>
+      RepeaterField.make('json').afterCreate(() => {}),
+      /requires relationship/,
+    )
+    assert.throws(() =>
+      RepeaterField.make('json').afterUpdate(() => {}),
+      /requires relationship/,
+    )
+    assert.throws(() =>
+      RepeaterField.make('json').afterDelete(() => {}),
+      /requires relationship/,
+    )
+  })
+
+  it('throwing handler propagates and aborts the rest of the persist diff', async () => {
+    const child = makeFakeChildModel([])
+    const parent = makeFakeParentModel({
+      childModel:   child.model,
+      childRows:    child.rows,
+      relationName: 'items',
+      foreignKey:   'orderId',
+    })
+
+    const form = Form.make()
+      .schema([
+        RepeaterField.make('items')
+          .relationship('items')
+          .schema([TextField.make('label').required()])
+          .afterCreate((record) => {
+            const r = record as Record<string, unknown>
+            if (r['label'] === 'B') throw new Error('reject B')
+          }),
+      ])
+      .save(async () => ({ id: 'p1' }))
+
+    await assert.rejects(
+      () => dispatchFormSubmit(
+        form,
+        { items: [{ label: 'A' }, { label: 'B' }, { label: 'C' }] },
+        { values: { items: [{ label: 'A' }, { label: 'B' }, { label: 'C' }] }, parentModel: parent },
+      ),
+      /reject B/,
+    )
+    // Two creates fired before the throw — no rollback (v1 isn't transactional).
+    assert.equal(child.calls.filter(c => c.kind === 'create').length, 2)
+  })
+})

package/src/nestedRelationManagerData.test.ts

@@ -446,6 +446,27 @@ describe('Phase A relation-view — surfaces nested-manager tabs (Phase B polish
     const strips = schema.filter(s => s['type'] === 'relation-tabs')
     assert.equal(strips.length, 1, 'expected only the post-scope strip; the comment-scope strip should be absent')
   })
+
+  it('hides a nested sibling tab when N.canViewAny returns false', async () => {
+    const { panel } = buildNestedWorld({
+      nestedOverrides: {
+        async canViewAny() { return false },
+      } as unknown as Partial<typeof RelationManager>,
+    })
+    const out = await relationManagerData(panel, {
+      kind: 'relation-view', slug: 'posts',
+      recordId:    'po1',
+      relationship:'comments',
+      childId:     'c1',
+    })
+    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
+    const strips = schema.filter(s => s['type'] === 'relation-tabs') as Array<Record<string, unknown>>
+    // Post-scope strip still here; comment-scope strip is gone because
+    // the only nested manager (CommentRepliesManager) was gated away,
+    // collapsing the strip to just the back-link `__view` — under the
+    // empty-strip drop threshold.
+    assert.equal(strips.length, 1, 'expected only the post-scope strip after sibling gating')
+  })
 })
 
 describe('nestedRelationManagerData (Phase B) — RelationTabs strip', () => {

package/src/orm/modelDefaults.ts

@@ -298,6 +298,19 @@ export function modelTableRecords(R: ResourceLike, table: Table): TableRecordsHa
     // and lets a tab's narrower `where` win on collision.
     if (ctx.tabQuery) q = ctx.tabQuery(q)
 
+    // Apply group drill-in scoper when the user clicked a banded heading.
+    // Runs after filters + tab so the bucket narrowing composes on top of
+    // whatever scope the page already had. User-supplied
+    // `TableGroup.scopeQueryByKey(fn)` wins over the framework default
+    // (exact-match `where(column, '=', key)` / whole-day range for date
+    // groups); throwing scopers propagate so a config bug surfaces loudly
+    // rather than silently rendering every row.
+    if (ctx.groupScope) {
+      const scope = ctx.groupScope
+      const scoper = scope.group.resolveScoper<ModelQuery>()
+      q = scoper(q, scope.key)
+    }
+
     if (ctx.sort) {
       q = q.orderBy(ctx.sort.column, ctx.sort.direction === 'desc' ? 'DESC' : 'ASC')
     }
@@ -619,6 +632,14 @@ export function modelRelationTableRecords(
 
     if (ctx.tabQuery) q = ctx.tabQuery(q)
 
+    // Group drill-in scoper — same shape as `modelTableRecords`. Composes
+    // with `relatedQuery` since the scoper just chains another `where`.
+    if (ctx.groupScope) {
+      const scope  = ctx.groupScope
+      const scoper = scope.group.resolveScoper<ModelQuery>()
+      q = scoper(q, scope.key)
+    }
+
     if (ctx.sort) {
       q = q.orderBy(ctx.sort.column, ctx.sort.direction === 'desc' ? 'DESC' : 'ASC')
     }