@fayz-ai/core 0.1.6

package/src/data/supabase.ts

@@ -0,0 +1,169 @@
+import type { DataProvider, CrudQuery, CrudResult } from './types'
+
+export interface SupabaseProviderConfig {
+  schema?: string
+  tenantId?: string | (() => string | undefined)
+  tenantIdColumn?: string
+  searchColumns?: string[]
+  selectColumns?: string
+  columnMap?: Record<string, string>
+  filters?: Record<string, string>
+  defaults?: Record<string, unknown>
+  supabaseClient?: unknown
+}
+
+function camelToSnake(str: string): string {
+  return str.replace(/[A-Z]/g, (c) => '_' + c.toLowerCase())
+}
+
+function snakeToCamel(str: string): string {
+  return str.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+}
+
+function mapRow<T>(row: Record<string, unknown>, columnMap?: Record<string, string>): T {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(row)) {
+    const camelKey = columnMap?.[key] ?? snakeToCamel(key)
+    result[camelKey] = value
+  }
+  return result as T
+}
+
+function mapEntity(entity: Record<string, unknown>, columnMap?: Record<string, string>): Record<string, unknown> {
+  const reverseMap: Record<string, string> = {}
+  if (columnMap) {
+    for (const [snake, camel] of Object.entries(columnMap)) {
+      reverseMap[camel] = snake
+    }
+  }
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(entity)) {
+    if (key === 'id' || key === 'createdAt' || key === 'updatedAt' || key === 'tenantId') continue
+    const snakeKey = reverseMap[key] ?? camelToSnake(key)
+    result[snakeKey] = value
+  }
+  return result
+}
+
+// Global Supabase client registry — set once via createFayzApp
+let _globalSupabaseClient: unknown | null = null
+
+export function setGlobalSupabaseClient(client: unknown): void {
+  _globalSupabaseClient = client
+}
+
+export function getSupabaseClientOptional(): unknown | null {
+  return _globalSupabaseClient
+}
+
+export function createSupabaseProvider<T extends { id: string }>(
+  table: string,
+  config?: SupabaseProviderConfig,
+): DataProvider<T> {
+  const schema = config?.schema ?? 'public'
+  const tenantIdCol = config?.tenantIdColumn ?? 'tenant_id'
+  const searchCols = config?.searchColumns ?? []
+  const selectCols = config?.selectColumns ?? '*'
+  const columnMap = config?.columnMap
+
+  function resolveTenantId(): string | undefined {
+    if (!config?.tenantId) return undefined
+    return typeof config.tenantId === 'function' ? config.tenantId() : config.tenantId
+  }
+
+  function getClient() {
+    const supabase = (config?.supabaseClient ?? _globalSupabaseClient) as {
+      schema: (s: string) => unknown
+      from: (t: string) => unknown
+    } | null
+    if (!supabase) throw new Error(`[@fayz-ai/core] Supabase client not available. Call createFayzApp with a provider first.`)
+    return schema === 'public' ? (supabase as { from: (t: string) => unknown }) : (supabase.schema(schema) as { from: (t: string) => unknown })
+  }
+
+  return {
+    async list(query: CrudQuery): Promise<CrudResult<T>> {
+      let q = (getClient().from(table) as { select: (...args: unknown[]) => unknown })
+        .select(selectCols, { count: 'exact' }) as Record<string, unknown>
+
+      const tenantId = resolveTenantId()
+      if (tenantId) q = (q as { eq: (col: string, val: string) => unknown }).eq(tenantIdCol, tenantId) as Record<string, unknown>
+
+      if (config?.filters) {
+        for (const [col, val] of Object.entries(config.filters)) {
+          q = (q as { eq: (c: string, v: string) => unknown }).eq(col, val) as Record<string, unknown>
+        }
+      }
+
+      // Faceted / dynamic filters from the query (equality, mapped to columns).
+      if (query.filters) {
+        for (const [key, val] of Object.entries(query.filters)) {
+          if (val == null || val === '') continue
+          const col = columnMap?.[key] ?? camelToSnake(key)
+          q = (q as { eq: (c: string, v: unknown) => unknown }).eq(col, val) as Record<string, unknown>
+        }
+      }
+
+      if (query.search && searchCols.length > 0) {
+        const term = `%${query.search}%`
+        const orClause = searchCols.map((col) => `${camelToSnake(col)}.ilike.${term}`).join(',')
+        q = (q as { or: (c: string) => unknown }).or(orClause) as Record<string, unknown>
+      }
+
+      if (query.sortBy) {
+        q = (q as { order: (col: string, opts: unknown) => unknown })
+          .order(camelToSnake(query.sortBy), { ascending: query.sortDir !== 'desc' }) as Record<string, unknown>
+      } else {
+        q = (q as { order: (col: string, opts: unknown) => unknown })
+          .order('created_at', { ascending: false }) as Record<string, unknown>
+      }
+
+      const page = query.page ?? 1
+      const pageSize = query.pageSize ?? 50
+      const from = (page - 1) * pageSize
+      q = (q as { range: (f: number, t: number) => unknown }).range(from, from + pageSize - 1) as Record<string, unknown>
+
+      const { data, error, count } = await q as { data: Record<string, unknown>[] | null; error: unknown; count: number | null }
+      if (error) throw error
+
+      return {
+        data: (data ?? []).map((row) => mapRow<T>(row, columnMap)),
+        total: count ?? 0,
+      }
+    },
+
+    async create(data) {
+      const row = mapEntity(data as Record<string, unknown>, columnMap)
+      const tenantId = resolveTenantId()
+      if (tenantId) row[tenantIdCol] = tenantId
+      if (config?.defaults) {
+        for (const [col, val] of Object.entries(config.defaults)) {
+          if (row[col] === undefined) row[col] = val
+        }
+      }
+
+      const { data: created, error } = (await (getClient().from(table) as {
+        insert: (r: unknown) => { select: () => { single: () => Promise<{ data: unknown; error: unknown }> } }
+      }).insert(row).select().single()) as { data: Record<string, unknown> | null; error: unknown }
+
+      if (error) throw error
+      return mapRow<T>(created!, columnMap)
+    },
+
+    async update(id, data) {
+      const row = mapEntity(data as Record<string, unknown>, columnMap)
+      const { data: updated, error } = (await (getClient().from(table) as {
+        update: (r: unknown) => { eq: (c: string, v: string) => { select: () => { single: () => Promise<{ data: unknown; error: unknown }> } } }
+      }).update(row).eq('id', id).select().single()) as { data: Record<string, unknown> | null; error: unknown }
+
+      if (error) throw error
+      return mapRow<T>(updated!, columnMap)
+    },
+
+    async remove(id) {
+      const { error } = (await (getClient().from(table) as {
+        delete: () => { eq: (c: string, v: string) => Promise<{ error: unknown }> }
+      }).delete().eq('id', id)) as { error: unknown }
+      if (error) throw error
+    },
+  }
+}

package/src/data/types.ts

@@ -0,0 +1,20 @@
+export interface CrudQuery {
+  search?: string
+  sortBy?: string
+  sortDir?: 'asc' | 'desc'
+  page?: number
+  pageSize?: number
+  filters?: Record<string, unknown>
+}
+
+export interface CrudResult<T> {
+  data: T[]
+  total: number
+}
+
+export interface DataProvider<T extends { id: string } = { id: string }> {
+  list(query: CrudQuery): Promise<CrudResult<T>>
+  create(data: Omit<T, 'id' | 'createdAt' | 'updatedAt' | 'tenantId'>): Promise<T>
+  update(id: string, data: Partial<T>): Promise<T>
+  remove(id: string): Promise<void>
+}

package/src/entity/index.ts

@@ -0,0 +1,2 @@
+export { registerEntity, getEntityByKey, getAllEntities, clearEntityRegistry, deriveEntityKey } from './registry'
+export type { RegisteredEntity } from './registry'

package/src/entity/registry.ts

@@ -0,0 +1,42 @@
+import type { EntityDef } from '../types/crud'
+import type { EntityArchetype } from '../types/entities'
+
+export interface RegisteredEntity {
+  entityKey: string
+  label: string
+  labelPlural: string
+  icon?: string
+  fields: EntityDef['fields']
+  source: 'app' | 'plugin'
+  archetype?: EntityArchetype
+  pluginId?: string
+  pluginName?: string
+  pluginIcon?: string
+}
+
+const entityRegistry = new Map<string, RegisteredEntity>()
+
+export function registerEntity(entry: RegisteredEntity): void {
+  entityRegistry.set(entry.entityKey, entry)
+}
+
+export function getEntityByKey(key: string): RegisteredEntity | undefined {
+  return entityRegistry.get(key)
+}
+
+export function getAllEntities(): RegisteredEntity[] {
+  return Array.from(entityRegistry.values())
+}
+
+export function clearEntityRegistry(): void {
+  entityRegistry.clear()
+}
+
+export function deriveEntityKey(entityDef: EntityDef): string {
+  const name = entityDef.name.toLowerCase().replace(/\s+/g, '-')
+  if (entityDef.data?.archetype && entityDef.data?.archetypeKind) {
+    return `${entityDef.data.archetype}:${entityDef.data.archetypeKind}`
+  }
+  if (entityDef.data?.archetype) return entityDef.data.archetype
+  return name
+}

package/src/events/index.tsx

@@ -0,0 +1,82 @@
+import * as React from 'react'
+
+// ---------------------------------------------------------------------------
+// Event bus — the substrate for cross-plugin behavior. Replaces the bespoke
+// `window.dispatchEvent('agenda:open-booking')` hack and the imperative
+// financial bridge: plugins emit named events, others subscribe, and the
+// AppManifest can declare event→action bindings as data. Plugins describe the
+// events they emit via PluginManifest.events (see types/plugins) so the
+// platform can introspect and wire automations.
+// ---------------------------------------------------------------------------
+
+export type EventHandler<T = unknown> = (payload: T) => void
+
+export interface EventBus {
+  emit<T = unknown>(event: string, payload?: T): void
+  on<T = unknown>(event: string, handler: EventHandler<T>): () => void
+  once<T = unknown>(event: string, handler: EventHandler<T>): () => void
+  off<T = unknown>(event: string, handler: EventHandler<T>): void
+  clear(event?: string): void
+}
+
+export function createEventBus(): EventBus {
+  const handlers = new Map<string, Set<EventHandler>>()
+  const bus: EventBus = {
+    emit(event, payload) {
+      const set = handlers.get(event)
+      if (!set) return
+      // Snapshot so handlers can subscribe/unsubscribe during dispatch.
+      for (const handler of Array.from(set)) {
+        try {
+          handler(payload)
+        } catch (err) {
+          // A misbehaving subscriber must not break the emitter or its peers.
+          console.error(`[fayz] event handler for "${event}" threw:`, err)
+        }
+      }
+    },
+    on(event, handler) {
+      let set = handlers.get(event)
+      if (!set) {
+        set = new Set()
+        handlers.set(event, set)
+      }
+      set.add(handler as EventHandler)
+      return () => bus.off(event, handler)
+    },
+    once(event, handler) {
+      const wrapped: EventHandler = (payload) => {
+        bus.off(event, wrapped)
+        ;(handler as EventHandler)(payload)
+      }
+      return bus.on(event, wrapped)
+    },
+    off(event, handler) {
+      handlers.get(event)?.delete(handler as EventHandler)
+    },
+    clear(event) {
+      if (event) handlers.delete(event)
+      else handlers.clear()
+    },
+  }
+  return bus
+}
+
+/** The app-wide default bus. One per app runtime (repo-per-app). */
+export const eventBus: EventBus = createEventBus()
+
+/** Subscribe to an event for the lifetime of the component. The latest handler
+ *  is always invoked, so closures over fresh props/state work without resubscribing. */
+export function useOnEvent<T = unknown>(
+  event: string,
+  handler: EventHandler<T>,
+  deps: React.DependencyList = [],
+): void {
+  const ref = React.useRef(handler)
+  ref.current = handler
+  React.useEffect(
+    () => eventBus.on<T>(event, (payload) => ref.current(payload)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [event, ...deps],
+  )
+}

package/src/i18n/index.ts

@@ -0,0 +1,250 @@
+import * as React from 'react'
+import { shellTranslations } from './shell-translations'
+
+export interface I18nConfig {
+  defaultLocale: string
+  supported: string[]
+  translations: Record<string, Record<string, string>>
+}
+
+const I18nContext = React.createContext<I18nConfig>({
+  defaultLocale: 'en',
+  supported: ['en'],
+  translations: {},
+})
+
+export const I18nProvider = I18nContext.Provider
+
+export function useI18nConfig(): I18nConfig {
+  return React.useContext(I18nContext)
+}
+
+export function useTranslation(): (key: string, params?: Record<string, string | number>) => string {
+  const config = React.useContext(I18nContext)
+  const localeStore = useLocaleStore()
+  const locale = localeStore.locale
+
+  return React.useCallback(
+    (key: string, params?: Record<string, string | number>): string => {
+      const localizedTranslations = config.translations[locale] ?? {}
+      const fallback = config.translations[config.defaultLocale] ?? {}
+      // Global fallback lets plugins register their locales independently of any
+      // I18nProvider — needed when a de-bridged plugin runs under a host shell
+      // that doesn't mount @fayz-ai/core's I18nProvider (incremental de-bridge), and
+      // for manifest apps where plugins self-register translations.
+      const gLocale = _globalTranslations[locale] ?? {}
+      const gFallback = _globalTranslations[config.defaultLocale] ?? {}
+      let raw = localizedTranslations[key] ?? gLocale[key] ?? fallback[key] ?? gFallback[key] ?? key
+
+      if (params) {
+        for (const [k, v] of Object.entries(params)) {
+          raw = raw.replace(new RegExp(`\\{\\{${k}\\}\\}`, 'g'), String(v))
+        }
+      }
+      return raw
+    },
+    [config, locale],
+  )
+}
+
+// Minimal locale store (avoids circular dep with stores package)
+interface LocaleStore {
+  locale: string
+  setLocale: (locale: string) => void
+}
+
+let _localeStore: LocaleStore = {
+  locale: 'en',
+  setLocale: (l) => { _localeStore.locale = l },
+}
+
+export function setLocaleStore(store: LocaleStore): void {
+  _localeStore = store
+}
+
+function useLocaleStore(): LocaleStore {
+  const [, rerender] = React.useReducer((n: number) => n + 1, 0)
+  React.useEffect(() => {
+    const prev = _localeStore.setLocale
+    _localeStore.setLocale = (l) => {
+      prev(l)
+      rerender()
+    }
+    return () => { _localeStore.setLocale = prev }
+  }, [])
+  return _localeStore
+}
+
+export function getCurrentLocale(): string {
+  return _localeStore.locale
+}
+
+export function setCurrentLocale(locale: string): void {
+  _localeStore.setLocale(locale)
+}
+
+// Core built-in translations
+export const coreTranslations: Record<string, Record<string, string>> = {
+  en: {
+    'common.save': 'Save',
+    'common.saveChanges': 'Save Changes',
+    'common.saving': 'Saving...',
+    'common.cancel': 'Cancel',
+    'common.delete': 'Delete',
+    'common.edit': 'Edit',
+    'common.close': 'Close',
+    'common.confirm': 'Confirm',
+    'common.discard': 'Discard',
+    'common.back': 'Back',
+    'common.formIncomplete': 'Fill in the required fields before saving.',
+    'saveBar.unsaved': 'Unsaved changes',
+    'common.add': 'Add',
+    'common.loading': 'Loading...',
+    'common.error': 'Something went wrong',
+    'common.noResults': 'No results found.',
+    'common.search': 'Search',
+    'common.actions': 'Actions',
+    'common.continue': 'Continue',
+    'common.done': 'Done',
+    'common.yes': 'Yes',
+    'common.no': 'No',
+    'common.active': 'Active',
+    'common.inactive': 'Inactive',
+    'common.overview': 'Overview',
+    'common.settings': 'Settings',
+    'common.plugins': 'Plugins',
+    'common.new': 'New',
+    'common.filter': 'Filter',
+    'common.export': 'Export',
+    'common.import': 'Import',
+    'common.preview': 'Preview',
+    'common.total': 'Total',
+    'crud.newItem': 'New {{name}}',
+    'crud.editItem': 'Edit {{name}}',
+    'crud.deleteConfirm': 'Delete {{name}}?',
+    'crud.deleteMessage': 'This action cannot be undone.',
+    'crud.created': '{{name}} created',
+    'crud.updated': '{{name}} updated',
+    'crud.deleted': '{{name}} deleted',
+    'crud.noItems': 'No {{namePlural}} yet.',
+    'auth.login.title': 'Sign in',
+    'auth.login.subtitle': 'Enter your credentials to access your account',
+    'auth.login.emailLabel': 'Email',
+    'auth.login.passwordLabel': 'Password',
+    'auth.login.submit': 'Sign in',
+    'auth.login.forgotPassword': 'Forgot password?',
+    'auth.login.noAccount': "Don't have an account?",
+    'auth.login.signUpLink': 'Sign up',
+    'auth.signup.title': 'Create account',
+    'auth.signup.submit': 'Create account',
+    'auth.signup.hasAccount': 'Already have an account?',
+    'auth.signup.signInLink': 'Sign in',
+    'settings.title': 'Settings',
+    'settings.company': 'Company',
+    'settings.branding': 'Branding',
+    'settings.security': 'Security',
+    'settings.team': 'Team',
+    'settings.billing': 'Billing',
+    'settings.locations': 'Locations',
+    'billing.title': 'Plans & Billing',
+    'billing.currentPlan': 'Current Plan',
+    'billing.upgrade': 'Upgrade',
+    'billing.manage': 'Manage Subscription',
+  },
+  'pt-BR': {
+    'common.save': 'Salvar',
+    'common.saveChanges': 'Salvar Alterações',
+    'common.saving': 'Salvando...',
+    'common.cancel': 'Cancelar',
+    'common.delete': 'Excluir',
+    'common.edit': 'Editar',
+    'common.close': 'Fechar',
+    'common.confirm': 'Confirmar',
+    'common.discard': 'Descartar',
+    'common.back': 'Voltar',
+    'common.formIncomplete': 'Preencha os campos obrigatórios antes de salvar.',
+    'saveBar.unsaved': 'Alterações não salvas',
+    'common.add': 'Adicionar',
+    'common.loading': 'Carregando...',
+    'common.error': 'Algo deu errado',
+    'common.noResults': 'Nenhum resultado encontrado.',
+    'common.search': 'Buscar',
+    'common.actions': 'Ações',
+    'common.continue': 'Continuar',
+    'common.done': 'Concluído',
+    'common.yes': 'Sim',
+    'common.no': 'Não',
+    'common.active': 'Ativo',
+    'common.inactive': 'Inativo',
+    'common.overview': 'Visão Geral',
+    'common.settings': 'Configurações',
+    'common.plugins': 'Plugins',
+    'common.new': 'Novo',
+    'common.filter': 'Filtrar',
+    'common.export': 'Exportar',
+    'common.import': 'Importar',
+    'common.preview': 'Pré-visualizar',
+    'common.total': 'Total',
+    'crud.newItem': 'Novo {{name}}',
+    'crud.editItem': 'Editar {{name}}',
+    'crud.deleteConfirm': 'Excluir {{name}}?',
+    'crud.deleteMessage': 'Esta ação não pode ser desfeita.',
+    'crud.created': '{{name}} criado',
+    'crud.updated': '{{name}} atualizado',
+    'crud.deleted': '{{name}} excluído',
+    'crud.noItems': 'Nenhum {{namePlural}} ainda.',
+    'auth.login.title': 'Entrar',
+    'auth.login.subtitle': 'Digite suas credenciais para acessar sua conta',
+    'auth.login.emailLabel': 'E-mail',
+    'auth.login.passwordLabel': 'Senha',
+    'auth.login.submit': 'Entrar',
+    'auth.login.forgotPassword': 'Esqueceu a senha?',
+    'auth.login.noAccount': 'Não tem uma conta?',
+    'auth.login.signUpLink': 'Cadastrar',
+    'auth.signup.title': 'Criar conta',
+    'auth.signup.submit': 'Criar conta',
+    'auth.signup.hasAccount': 'Já tem uma conta?',
+    'auth.signup.signInLink': 'Entrar',
+    'settings.title': 'Configurações',
+    'settings.company': 'Empresa',
+    'settings.branding': 'Identidade Visual',
+    'settings.security': 'Segurança',
+    'settings.team': 'Equipe',
+    'settings.billing': 'Faturamento',
+    'settings.locations': 'Localizações',
+    'billing.title': 'Planos e Faturamento',
+    'billing.currentPlan': 'Plano Atual',
+    'billing.upgrade': 'Fazer Upgrade',
+    'billing.manage': 'Gerenciar Assinatura',
+  },
+}
+
+// Global translation registry — plugins merge their locales here so keys resolve
+// regardless of which shell mounts the I18nProvider.
+let _globalTranslations: Record<string, Record<string, string>> = {}
+
+export function registerTranslations(translations?: Record<string, Record<string, string>>): void {
+  if (!translations) return
+  _globalTranslations = mergeTranslations(_globalTranslations, translations)
+}
+
+export function mergeTranslations(
+  base: Record<string, Record<string, string>>,
+  ...overrides: Array<Record<string, Record<string, string>> | undefined>
+): Record<string, Record<string, string>> {
+  const result = { ...base }
+  for (const override of overrides) {
+    if (!override) continue
+    for (const [locale, translations] of Object.entries(override)) {
+      result[locale] = { ...(result[locale] ?? {}), ...translations }
+    }
+  }
+  return result
+}
+
+// Seed the global fallback with core's own translations + the shared shell /
+// CRUD / framework translations (extracted from saas-core's central i18n), so
+// the native CRUD engine, framework UI and de-bridged plugins resolve their
+// keys even under a host shell that does not mount @fayz-ai/core's I18nProvider.
+registerTranslations(coreTranslations)
+registerTranslations(shellTranslations)