@fayz-ai/core 0.9.0 → 0.11.0

package/src/data/filters.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { parseRangeFilter, isFilterObject, matchesRange, applyRangeToQuery } from './filters'
-
-describe('parseRangeFilter', () => {
-  it('reads the {from,to} dialect', () => {
-    expect(parseRangeFilter({ from: 1, to: 5 })).toEqual({ gte: 1, lte: 5 })
-  })
-
-  it('reads the Mongo dialect the models actually emit', () => {
-    // The exact filter that answered "não há compromissos hoje" over a booked day.
-    expect(
-      parseRangeFilter({ $gte: '2026-07-27T00:00:00Z', $lt: '2026-07-28T00:00:00Z' }),
-    ).toEqual({ gte: '2026-07-27T00:00:00Z', lt: '2026-07-28T00:00:00Z' })
-  })
-
-  it('reads bare comparison keys', () => {
-    expect(parseRangeFilter({ gte: 10, lt: 20 })).toEqual({ gte: 10, lt: 20 })
-  })
-
-  it('returns null for plain values, so they stay equality filters', () => {
-    expect(parseRangeFilter('open')).toBeNull()
-    expect(parseRangeFilter(3)).toBeNull()
-    expect(parseRangeFilter(null)).toBeNull()
-  })
-
-  it('returns null for an object with no recognised bound — never a silent match-nothing', () => {
-    expect(parseRangeFilter({ equals: 'open' })).toBeNull()
-    expect(isFilterObject({ equals: 'open' })).toBe(true)
-  })
-})
-
-describe('matchesRange', () => {
-  const day = { gte: '2026-07-27T00:00:00Z', lt: '2026-07-28T00:00:00Z' }
-
-  it('keeps a timestamp inside the window', () => {
-    expect(matchesRange('2026-07-27T18:00:00+00:00', day)).toBe(true)
-  })
-
-  it('drops the bounds it should', () => {
-    expect(matchesRange('2026-07-28T00:00:00Z', day)).toBe(false)
-    expect(matchesRange('2026-07-26T23:59:59Z', day)).toBe(false)
-  })
-
-  it('honours inclusive upper bounds', () => {
-    expect(matchesRange(5, { gte: 1, lte: 5 })).toBe(true)
-    expect(matchesRange(5, { gte: 1, lt: 5 })).toBe(false)
-  })
-
-  it('rejects values that are not comparable instead of letting them through', () => {
-    expect(matchesRange(null, day)).toBe(false)
-    expect(matchesRange('não é data', day)).toBe(false)
-  })
-})
-
-describe('applyRangeToQuery', () => {
-  it('emits one PostgREST call per bound', () => {
-    const calls: Array<[string, string, unknown]> = []
-    const builder = {
-      gte(c: string, v: unknown) { calls.push(['gte', c, v]); return this },
-      gt(c: string, v: unknown) { calls.push(['gt', c, v]); return this },
-      lte(c: string, v: unknown) { calls.push(['lte', c, v]); return this },
-      lt(c: string, v: unknown) { calls.push(['lt', c, v]); return this },
-    }
-    applyRangeToQuery(builder, 'starts_at', { gte: 'a', lt: 'b' })
-    expect(calls).toEqual([
-      ['gte', 'starts_at', 'a'],
-      ['lt', 'starts_at', 'b'],
-    ])
-  })
-})

package/src/data/filters.ts

@@ -1,90 +0,0 @@
-/**
- * ONE filter grammar, shared by the providers and by the agent's data tools.
- *
- * Models express ranges in whatever dialect they were trained on — `{from,to}`,
- * `{gte,lte}`, Mongo's `{$gte,$lt}`. When only some of those are recognised the
- * unrecognised one falls through to an equality compare against
- * "[object Object]", which matches nothing and reads as "there are no
- * appointments today" instead of "I did not understand that filter".
- */
-
-export interface RangeFilter {
-  gte?: unknown
-  gt?: unknown
-  lte?: unknown
-  lt?: unknown
-}
-
-const LOWER_INCLUSIVE = ['from', 'gte', 'start', 'after', 'since', 'min']
-const LOWER_EXCLUSIVE = ['gt']
-const UPPER_INCLUSIVE = ['to', 'lte', 'end', 'until', 'before', 'max']
-const UPPER_EXCLUSIVE = ['lt']
-
-function pick(source: Record<string, unknown>, names: string[]): unknown {
-  for (const name of names) {
-    if (source[name] !== undefined && source[name] !== null) return source[name]
-    const dollar = `$${name}`
-    if (source[dollar] !== undefined && source[dollar] !== null) return source[dollar]
-  }
-  return undefined
-}
-
-/**
- * Parse a filter value into a range, or return null when it is a plain
- * (equality) value. An object that looks like a filter but carries no
- * recognised bound returns `null` too — callers treat that as "invalid",
- * never as "matches nothing".
- */
-export function parseRangeFilter(value: unknown): RangeFilter | null {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) return null
-  const source = value as Record<string, unknown>
-  const range: RangeFilter = {}
-  const gte = pick(source, LOWER_INCLUSIVE)
-  const gt = pick(source, LOWER_EXCLUSIVE)
-  const lte = pick(source, UPPER_INCLUSIVE)
-  const lt = pick(source, UPPER_EXCLUSIVE)
-  if (gte !== undefined) range.gte = gte
-  if (gt !== undefined) range.gt = gt
-  if (lte !== undefined) range.lte = lte
-  if (lt !== undefined) range.lt = lt
-  return Object.keys(range).length ? range : null
-}
-
-/** True for any object value — including ones no bound could be read from. */
-export function isFilterObject(value: unknown): boolean {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function comparable(value: unknown): number {
-  if (typeof value === 'number') return value
-  if (value instanceof Date) return value.getTime()
-  const ts = Date.parse(String(value))
-  if (!Number.isNaN(ts)) return ts
-  return Number(value)
-}
-
-/** Client-side counterpart of the range a provider would push to SQL. */
-export function matchesRange(raw: unknown, range: RangeFilter): boolean {
-  const value = comparable(raw)
-  if (Number.isNaN(value)) return false
-  if (range.gte !== undefined && value < comparable(range.gte)) return false
-  if (range.gt !== undefined && value <= comparable(range.gt)) return false
-  if (range.lte !== undefined && value > comparable(range.lte)) return false
-  if (range.lt !== undefined && value >= comparable(range.lt)) return false
-  return true
-}
-
-/** Apply a range to a PostgREST query builder. */
-export function applyRangeToQuery<Q>(
-  query: Q,
-  column: string,
-  range: RangeFilter,
-): Q {
-  let q = query as Record<string, (c: string, v: unknown) => unknown>
-  for (const op of ['gte', 'gt', 'lte', 'lt'] as const) {
-    const bound = range[op]
-    if (bound === undefined) continue
-    q = q[op](column, bound) as Record<string, (c: string, v: unknown) => unknown>
-  }
-  return q as Q
-}

package/src/data/index.ts

@@ -1,11 +0,0 @@
-export { createSupabaseProvider, setGlobalSupabaseClient, getSupabaseClientOptional } from './supabase'
-export { countByTenant, invalidateCount } from './count'
-export type { CountByTenantOptions } from './count'
-export { createFayzApiProvider } from './platform-api'
-export { createMockProvider } from './mock'
-export { bulkCreate } from './bulk'
-export { resolveDataProvider } from './resolve'
-export type { DataProvider, CrudQuery, CrudResult, BulkWriteOptions, BulkWriteResult } from './types'
-export type { SupabaseProviderConfig } from './supabase'
-export type { FayzApiProviderConfig } from './platform-api'
-export type { ResolveDataProviderOptions } from './resolve'

package/src/data/mock.ts

@@ -1,90 +0,0 @@
-import type { DataProvider, CrudQuery, CrudResult } from './types'
-import type { EntityDef } from '../types/crud'
-import { matchesRange, parseRangeFilter } from './filters'
-
-export function createMockProvider<T extends { id: string; [key: string]: unknown }>(
-  entityDefOrSearchKeys: EntityDef<T> | string[],
-  initialData: T[] = [],
-): DataProvider<T> {
-  let items = [...initialData]
-
-  const searchableKeys = Array.isArray(entityDefOrSearchKeys)
-    ? entityDefOrSearchKeys
-    : entityDefOrSearchKeys.fields.filter((f) => f.searchable).map((f) => f.key)
-
-  const defaultSort = Array.isArray(entityDefOrSearchKeys) ? undefined : entityDefOrSearchKeys.defaultSort
-  const defaultSortDir = Array.isArray(entityDefOrSearchKeys) ? 'asc' : (entityDefOrSearchKeys.defaultSortDir ?? 'asc')
-
-  return {
-    async list(query: CrudQuery): Promise<CrudResult<T>> {
-      let filtered = [...items]
-
-      if (query.search && searchableKeys.length > 0) {
-        const term = query.search.toLowerCase()
-        filtered = filtered.filter((item) =>
-          searchableKeys.some((key) => {
-            const val = item[key]
-            return typeof val === 'string' && val.toLowerCase().includes(term)
-          }),
-        )
-      }
-
-      // Faceted / dynamic filters — same grammar the SQL providers speak, so a
-      // date window behaves identically on mock data instead of silently
-      // matching nothing (a range object is never `===` anything).
-      if (query.filters) {
-        for (const [key, val] of Object.entries(query.filters)) {
-          if (val == null || val === '') continue
-          const range = parseRangeFilter(val)
-          filtered = range
-            ? filtered.filter((item) => matchesRange(item[key], range))
-            : filtered.filter((item) => item[key] === val)
-        }
-      }
-
-      const sortBy = query.sortBy ?? defaultSort
-      const sortDir = query.sortDir ?? defaultSortDir
-      if (sortBy) {
-        filtered.sort((a, b) => {
-          const av = a[sortBy] ?? ''
-          const bv = b[sortBy] ?? ''
-          const cmp = typeof av === 'number' && typeof bv === 'number'
-            ? av - bv
-            : String(av).localeCompare(String(bv))
-          return sortDir === 'desc' ? -cmp : cmp
-        })
-      }
-
-      const total = filtered.length
-      const page = query.page ?? 1
-      const pageSize = query.pageSize ?? 50
-      const start = (page - 1) * pageSize
-      const data = filtered.slice(start, start + pageSize)
-      return { data, total }
-    },
-
-    async create(data) {
-      const now = new Date().toISOString()
-      const item = {
-        ...data,
-        id: crypto.randomUUID(),
-        tenantId: 'mock-tenant',
-        createdAt: now,
-        updatedAt: now,
-      } as unknown as T
-      items.unshift(item)
-      return item
-    },
-
-    async update(id, data) {
-      const idx = items.findIndex((i) => i.id === id)
-      if (idx === -1) throw new Error(`[@fayz-ai/core] Mock provider: item not found: ${id}`)
-      items[idx] = { ...items[idx], ...data, updatedAt: new Date().toISOString() }
-      return items[idx]!
-    },
-
-    async remove(id) {
-      items = items.filter((i) => i.id !== id)
-    },
-  }
-}

package/src/data/platform-api.ts

@@ -1,209 +0,0 @@
-import type { CrudQuery, CrudResult, DataProvider } from './types'
-import { parseRangeFilter } from './filters'
-
-type FayzApiFilterOperator = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'ilike' | 'is_null' | 'is_not_null'
-
-interface FayzApiTableFilter {
-  column: string
-  operator: FayzApiFilterOperator
-  value?: unknown
-}
-
-export interface FayzApiProviderConfig {
-  baseUrl?: string
-  projectId?: string
-  tenantId?: string | (() => string | undefined)
-  tenantIdColumn?: string | false
-  entityKey?: string
-  table?: string
-  schema?: string
-  idColumn?: string
-  searchColumns?: string[]
-  runtimeToken?: string | (() => string | undefined | Promise<string | undefined>)
-  headers?: () => HeadersInit | Promise<HeadersInit>
-  fetcher?: typeof fetch
-}
-
-function resolveTenantId(config?: FayzApiProviderConfig): string | undefined {
-  const tenantId = config?.tenantId
-  return typeof tenantId === 'function' ? tenantId() : tenantId
-}
-
-async function resolveRuntimeToken(config?: FayzApiProviderConfig): Promise<string | undefined> {
-  const runtimeToken = config?.runtimeToken
-  return typeof runtimeToken === 'function' ? runtimeToken() : runtimeToken
-}
-
-function trimTrailingSlash(value: string): string {
-  return value.replace(/\/+$/, '')
-}
-
-function appendQuery(
-  url: URL,
-  query: CrudQuery,
-  tenantId?: string,
-  tenantIdColumn = 'tenant_id',
-  searchColumns: string[] = [],
-): void {
-  const filters = normalizeFilters(query.filters)
-  if (query.search && searchColumns[0]) {
-    filters.push({ column: searchColumns[0], operator: 'ilike', value: `%${query.search}%` })
-  }
-  if (query.sortBy) url.searchParams.set('sortColumn', query.sortBy)
-  if (query.sortDir) url.searchParams.set('sortDirection', query.sortDir)
-  if (query.page != null) url.searchParams.set('page', String(query.page))
-  if (query.pageSize != null) url.searchParams.set('limit', String(query.pageSize))
-  if (tenantId) filters.push({ column: tenantIdColumn, operator: 'eq', value: tenantId })
-  if (filters.length > 0) url.searchParams.set('filters', JSON.stringify(filters))
-}
-
-async function parseResponse<T>(response: Response): Promise<T> {
-  if (!response.ok) {
-    const text = await response.text().catch(() => '')
-    throw new Error(`[@fayz-ai/core] Fayz API request failed (${response.status}): ${text || response.statusText}`)
-  }
-  return response.json() as Promise<T>
-}
-
-function isFilterOperator(value: unknown): value is FayzApiFilterOperator {
-  return typeof value === 'string' && [
-    'eq',
-    'neq',
-    'gt',
-    'lt',
-    'gte',
-    'lte',
-    'like',
-    'ilike',
-    'is_null',
-    'is_not_null',
-  ].includes(value)
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function normalizeFilters(filters?: Record<string, unknown>): FayzApiTableFilter[] {
-  if (!filters) return []
-  return Object.entries(filters).flatMap(([column, raw]): FayzApiTableFilter[] => {
-    if (isRecord(raw) && isFilterOperator(raw.operator)) {
-      return [{ column, operator: raw.operator, value: raw.value }]
-    }
-    // A range is TWO bounds on one column — sending it as a single `eq` filter
-    // compared the column against an object and matched nothing.
-    const range = parseRangeFilter(raw)
-    if (range) {
-      return (['gte', 'gt', 'lte', 'lt'] as const)
-        .filter((op) => range[op] !== undefined)
-        .map((op) => ({ column, operator: op, value: range[op] }))
-    }
-    return [{ column, operator: 'eq', value: raw }]
-  })
-}
-
-export function createFayzApiProvider<T extends { id: string }>(
-  entityOrTable: string,
-  config: FayzApiProviderConfig = {},
-): DataProvider<T> {
-  const fetcher = config.fetcher ?? fetch
-  const baseUrl = trimTrailingSlash(config.baseUrl ?? '')
-  const projectId = config.projectId
-  const table = config.table ?? entityOrTable
-  const idColumn = config.idColumn ?? 'id'
-
-  async function headers(runtimeToken?: string): Promise<HeadersInit> {
-    return {
-      'Content-Type': 'application/json',
-      ...(config.headers ? await config.headers() : {}),
-      ...(runtimeToken ? { Authorization: `Bearer ${runtimeToken}` } : {}),
-    }
-  }
-
-  function tableRowsUrl(runtime = false): URL {
-    const prefix = baseUrl || (typeof window !== 'undefined' ? window.location.origin : 'http://localhost')
-    const encodedProjectId = encodeURIComponent(projectId ?? 'current')
-    const encodedTable = encodeURIComponent(table)
-    const route = runtime
-      ? `/api/v1/runtime/projects/${encodedProjectId}/database/tables/${encodedTable}/rows`
-      : `/api/projects/${encodedProjectId}/database/tables/${encodedTable}/rows`
-    const url = new URL(route, prefix)
-    if (config.schema) url.searchParams.set('schema', config.schema)
-    return url
-  }
-
-  function withTenant(data: Record<string, unknown>, runtime = false): Record<string, unknown> {
-    if (runtime) return data
-    const tenantId = resolveTenantId(config)
-    if (!tenantId || config.tenantIdColumn === false) return data
-    return { ...data, [config.tenantIdColumn ?? 'tenant_id']: tenantId }
-  }
-
-  function primaryKeys(id: string): Record<string, unknown> {
-    return { [idColumn]: id }
-  }
-
-  async function listRows(query: CrudQuery): Promise<CrudResult<T>> {
-    const runtimeToken = await resolveRuntimeToken(config)
-    const runtime = Boolean(runtimeToken)
-    const url = tableRowsUrl(runtime)
-    appendQuery(
-      url,
-      query,
-      runtime || config.tenantIdColumn === false ? undefined : resolveTenantId(config),
-      config.tenantIdColumn || undefined,
-      config.searchColumns,
-    )
-    const result = await parseResponse<{ rows: T[]; total: number }>(await fetcher(url, { headers: await headers(runtimeToken) }))
-    return { data: result.rows, total: result.total }
-  }
-
-  async function assertTenantScopedRowExists(id: string, runtime = false): Promise<void> {
-    if (runtime) return
-    const tenantId = config.tenantIdColumn === false ? undefined : resolveTenantId(config)
-    if (!tenantId) return
-
-    const result = await listRows({ filters: { [idColumn]: id }, page: 1, pageSize: 1 })
-    if (result.data.length === 0) {
-      throw new Error(`[@fayz-ai/core] Row "${id}" was not found for the active tenant.`)
-    }
-  }
-
-  return {
-    async list(query: CrudQuery): Promise<CrudResult<T>> {
-      return listRows(query)
-    },
-
-    async create(data) {
-      const runtimeToken = await resolveRuntimeToken(config)
-      const runtime = Boolean(runtimeToken)
-      return parseResponse<T>(await fetcher(tableRowsUrl(runtime), {
-        method: 'POST',
-        headers: await headers(runtimeToken),
-        body: JSON.stringify(withTenant(data as Record<string, unknown>, runtime)),
-      }))
-    },
-
-    async update(id, data) {
-      const runtimeToken = await resolveRuntimeToken(config)
-      const runtime = Boolean(runtimeToken)
-      await assertTenantScopedRowExists(id, runtime)
-      return parseResponse<T>(await fetcher(tableRowsUrl(runtime), {
-        method: 'PATCH',
-        headers: await headers(runtimeToken),
-        body: JSON.stringify({ primaryKeys: primaryKeys(id), data }),
-      }))
-    },
-
-    async remove(id) {
-      const runtimeToken = await resolveRuntimeToken(config)
-      const runtime = Boolean(runtimeToken)
-      await assertTenantScopedRowExists(id, runtime)
-      await parseResponse<{ deletedCount: number }>(await fetcher(tableRowsUrl(runtime), {
-        method: 'DELETE',
-        headers: await headers(runtimeToken),
-        body: JSON.stringify({ rows: [primaryKeys(id)] }),
-      }))
-    },
-  }
-}

package/src/data/refresh.ts

@@ -1,115 +0,0 @@
-import * as React from 'react'
-import { eventBus } from '../events'
-import { globalCache } from '../lib/cache'
-import { getActiveTenantId } from '../tenant'
-
-// ---------------------------------------------------------------------------
-// Data refresh bus — "something wrote; whoever is showing it should reload".
-//
-// A write that happens OUTSIDE the list showing it (the assistant creating an
-// appointment, a webhook, another tab) used to leave the screen stale until the
-// user reloaded by hand. Providers already invalidate their own read cache on
-// create/update/remove, but a mounted list holds its rows in a store — nothing
-// told it to fetch again.
-//
-// This is the missing half: one broadcast, every surface that renders the
-// affected data listens. Deliberately coarse — a table name, not a row diff.
-// Refetching a page of rows is cheap; a stale screen after "criei o
-// agendamento" is not.
-// ---------------------------------------------------------------------------
-
-export const DATA_CHANGED_EVENT = 'data:changed'
-
-export interface DataChangedPayload {
-  /** Physical table the write touched, when the writer knows it. */
-  table?: string
-  /** Registered entity key (deriveEntityKey), when the writer knows it. */
-  entityKey?: string
-  /** Archetype the record belongs to (`person:client`), when known. */
-  archetype?: string
-  op?: 'create' | 'update' | 'delete' | 'unknown'
-  /** Affected record id, when known. */
-  id?: string
-  /** What caused the write — lets a surface ignore its own UI writes. */
-  source?: 'agent' | 'ui' | 'remote'
-}
-
-/** What a subscriber renders. Any field left out matches everything. */
-export interface DataChangedMatch {
-  table?: string
-  entityKey?: string
-  archetype?: string
-}
-
-/**
- * A write with NO table/entityKey is a write we could not attribute (a plugin
- * tool, an RPC). Subscribers still refresh for it: a redundant refetch costs a
- * request, a missed one costs the user's trust in what the screen shows.
- */
-export function matchesDataChange(match: DataChangedMatch, payload: DataChangedPayload): boolean {
-  const attributed = payload.table ?? payload.entityKey ?? payload.archetype
-  if (!attributed) return true
-  if (match.table && payload.table && match.table === payload.table) return true
-  if (match.entityKey && payload.entityKey && match.entityKey === payload.entityKey) return true
-  if (match.archetype && payload.archetype && match.archetype === payload.archetype) return true
-  // A subscriber that declared nothing listens to everything.
-  return !match.table && !match.entityKey && !match.archetype
-}
-
-// One agent turn can write twice (create + link). Coalesce so the lists behind
-// it fetch once, after the turn settles, instead of once per call.
-let pending: DataChangedPayload[] = []
-let flushTimer: ReturnType<typeof setTimeout> | null = null
-
-function flush(): void {
-  const batch = pending
-  pending = []
-  flushTimer = null
-  for (const payload of batch) eventBus.emit(DATA_CHANGED_EVENT, payload)
-}
-
-/**
- * Announce a write. Invalidates the provider read cache for the affected table
- * (an unattributed write clears it wholesale — a stale hit would defeat the
- * refetch it just triggered) and broadcasts to mounted surfaces.
- */
-export function emitDataChanged(payload: DataChangedPayload = {}): void {
-  if (payload.table) {
-    const tenant = getActiveTenantId() ?? '_'
-    // The base table and its read-model view are the SAME data under two cache
-    // namespaces (appointments / v_appointments). Invalidating only the one the
-    // writer names leaves the other serving a snapshot that predates the write
-    // — which is how the assistant kept reporting an empty agenda after a
-    // booking was created on the agenda screen.
-    const sibling = payload.table.startsWith('v_')
-      ? payload.table.slice(2)
-      : `v_${payload.table}`
-    globalCache.invalidate(`${tenant}:${payload.table}`)
-    globalCache.invalidate(`${tenant}:${sibling}`)
-  } else {
-    globalCache.clear()
-  }
-  pending.push({ op: 'unknown', source: 'agent', ...payload })
-  if (flushTimer) return
-  flushTimer = setTimeout(flush, 120)
-}
-
-/** Subscribe for the lifetime of the component. The latest handler always runs. */
-export function useDataChanged(
-  match: DataChangedMatch,
-  handler: (payload: DataChangedPayload) => void,
-  deps: React.DependencyList = [],
-): void {
-  const handlerRef = React.useRef(handler)
-  handlerRef.current = handler
-  const { table, entityKey, archetype } = match
-
-  React.useEffect(
-    () =>
-      eventBus.on<DataChangedPayload>(DATA_CHANGED_EVENT, (payload) => {
-        if (matchesDataChange({ table, entityKey, archetype }, payload)) handlerRef.current(payload)
-      }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [table, entityKey, archetype, ...deps],
-  )
-}