@fayz-ai/core 0.9.0 → 0.11.0

package/src/types/crud.ts

@@ -1,184 +0,0 @@
-import type React from 'react'
-import type { EntityArchetype } from './entities'
-
-export type FieldType =
-  | 'text' | 'email' | 'phone' | 'url' | 'image'
-  | 'number' | 'currency'
-  | 'select' | 'multiselect' | 'segmented'
-  | 'relation'
-  | 'date' | 'datetime' | 'time'
-  | 'boolean' | 'textarea' | 'markdown'
-  | 'color' | 'computed'
-
-/** Foreign-key source for a `relation` field: the option list is loaded from a
- *  table at runtime ({value→label}) so the stored value is a real id (e.g. a
- *  uuid), not a static string. Use for FK columns the user must pick from a
- *  seeded/managed table (e.g. payment_method_type_id → payment_method_types). */
-export interface FieldRelation {
-  /** Table to read options from (e.g. 'payment_method_types'). */
-  table: string
-  /** Column stored as the field value. Default 'id'. */
-  valueField?: string
-  /** Column shown as the option label. Default 'name'. */
-  labelField?: string
-  /** Scope options to the active tenant via tenant_id. Default true. */
-  tenantScoped?: boolean
-  /** Schema the table lives in (rarely needed now core is in public). Default public. */
-  schema?: string
-  /** Extra equality filters applied to the option query. */
-  filter?: Record<string, unknown>
-}
-
-/** Read-only display produced by a `computed` field's `compute()`. */
-export interface ComputedFieldValue {
-  display: string
-  /** Drives the value colour (green / red / muted). Default: neutral. */
-  tone?: 'positive' | 'negative' | 'neutral'
-}
-
-export interface FieldDef {
-  key: string
-  label: string
-  type: FieldType
-  required?: boolean
-  placeholder?: string
-  /** Small helper text shown under the field input. */
-  hint?: string
-  /** Options for `select` / `multiselect` / `segmented`. The optional
-   *  `description` is shown under the label on `segmented` radio-cards. */
-  options?: string[] | { label: string; value: string; description?: string }[]
-  /** Required for `relation` fields — where to load the option list from. */
-  relation?: FieldRelation
-  min?: number
-  max?: number
-  /** ISO currency code for `currency` fields (e.g. 'BRL'). */
-  currency?: string
-  /** Symbol/locale for the `currency` field's CurrencyInput. Default 'R$' / 'pt-BR'. */
-  currencySymbol?: string
-  currencyLocale?: string
-  showInTable?: boolean
-  showInForm?: boolean
-  showInDetail?: boolean
-  sortable?: boolean
-  searchable?: boolean
-  /** Custom cell renderer (code escape hatch). For a serializable EntityDef in
-   *  an AppManifest, reference a registered cell renderer by id instead. */
-  renderCell?: (value: unknown, row: unknown) => React.ReactNode
-  renderCellId?: string
-  /** Derives a read-only value from the other form values (for `computed`
-   *  fields, e.g. margin). Returns null to render an em-dash. */
-  compute?: (values: Record<string, unknown>) => ComputedFieldValue | null
-  defaultValue?: unknown
-  group?: string
-  span?: 1 | 2
-  inlineToggle?: boolean
-}
-
-export interface FieldGroup {
-  id: string
-  label: string
-  description?: string
-  columns?: 1 | 2 | 3
-  /** Renders an image slot to the left of the group's fields. Functional when
-   *  the EntityDef supplies `image`; a plain placeholder otherwise. */
-  imageSlot?: boolean
-}
-
-export interface DetailTab {
-  id: string
-  label: string
-  icon?: string
-  /** Legacy or compatibility route ids that should resolve to this tab. */
-  aliases?: string[]
-  /** Hide an inherited/archetype tab while still allowing the app to override it by id. */
-  hidden?: boolean
-  /** Tab content component, or a registered component id (componentId) for a
-   *  serializable EntityDef. Exactly one is expected. */
-  component?: React.ComponentType<{ item: unknown; entityDef: EntityDef; [key: string]: unknown }>
-  componentId?: string
-  visibleFor?: string[]
-  props?: Record<string, unknown>
-  /** Only show this tab when a plugin has contributed a widget to this zone (e.g. a
-   *  financial plugin enabling a per-person statement tab). Hidden when no widget. */
-  requiresWidgetZone?: string
-}
-
-export type FormLayout = 'person' | 'product' | 'service' | 'location' | 'order' | 'subject' | 'generic'
-
-/**
- * Makes a field group's `imageSlot` functional. Without this the slot renders as
- * a decorative placeholder — it always did, which is why product forms showed an
- * empty thumbnail even for products that have images.
- *
- * Upload needs the record to exist (the file is attached to its id), so the slot
- * stays read-only in create mode and becomes editable after the first save.
- */
-export interface EntityImageConfig {
-  // Rows are loosely typed here on purpose: EntityDef<T> is consumed as
-  // EntityDef<Record<string, unknown>> by the generic CRUD machinery, and a
-  // T-parameterised callback makes the whole EntityDef invariant in T.
-  /** Current image URL for this record, if any. */
-  get: (row: Record<string, any>) => string | undefined
-  /** Persist a new image and return its URL. Omit to keep the slot read-only. */
-  upload?: (file: File, row: Record<string, any>) => Promise<string>
-  /** Remove the current image. Omit to hide the remove affordance. */
-  remove?: (row: Record<string, any>) => Promise<void>
-  /** Accepted mime types. Defaults to image/*. */
-  accept?: string
-}
-
-export interface EntityDef<T = Record<string, unknown>> {
-  name: string
-  namePlural?: string
-  icon: string
-  layout?: FormLayout
-  fields: FieldDef[]
-  fieldGroups?: FieldGroup[]
-  /** Wiring for the `imageSlot` of whichever field group declares one. */
-  image?: EntityImageConfig
-  detailTabs?: DetailTab[]
-  data?: {
-    table: string
-    schema?: string
-    tenantScoped?: boolean
-    tenantIdColumn?: string
-    searchColumns?: string[]
-    selectColumns?: string
-    columnMap?: Record<string, string>
-    archetype?: EntityArchetype
-    archetypeKind?: string
-    filters?: Record<string, string>
-    defaults?: Record<string, unknown>
-    cacheTTL?: number
-  }
-  defaultSort?: string
-  defaultSortDir?: 'asc' | 'desc'
-  displayField?: string
-  subtitleField?: string
-  imageField?: string
-  /** Faceted filters shown as pills below the list search box. Each references a
-   *  field whose `options` supply the pills; an "All" pill clears the filter. */
-  facets?: { field: string; allLabel?: string }[]
-  /**
-   * Plan quantity-limit key gating creation of this entity (matches a
-   * `PlanEntitlements.limits` key + a `LimitDeclaration`). When set, the CRUD
-   * engine gates the "+ New" button (LimitGate), guards the create-form submit
-   * and the CSV import (useLimitGuard) against the plan cap, and invalidates the
-   * live count after a successful create. Absent ⇒ no plan gating (RBAC only).
-   */
-  limitKey?: string
-  /**
-   * Permission required to READ this entity through the agent's generic data
-   * primitives (searchRecords/queryData) — checked per TARGET at execution
-   * time, so one generic tool still honors per-user access. Absent ⇒ readable
-   * by any signed-in member (same as the CRUD list today).
-   */
-  permission?: { feature: string; action: string }
-  /**
-   * Exclude this entity from the agent's data primitives. For entities whose
-   * table is an extension/join shape the generic provider can't read usefully
-   * (e.g. staff_members without a name column) — expose a queryEntities
-   * read-model instead and hide the raw one here.
-   */
-  agentHidden?: boolean
-}

package/src/types/entities.ts

@@ -1,142 +0,0 @@
-export type EntityArchetype = 'person' | 'category' | 'product' | 'service' | 'order' | 'transaction' | 'schedule' | 'location'
-
-export interface BaseEntity {
-  id: string
-  tenantId: string
-  createdAt: string
-  updatedAt: string
-}
-
-export interface PersonEntity extends BaseEntity {
-  archetype: 'person'
-  kind: string
-  name: string
-  email?: string
-  phone?: string
-  documentNumber?: string
-  avatarUrl?: string
-  dateOfBirth?: string
-  address?: string
-  city?: string
-  state?: string
-  country: string
-  postalCode?: string
-  tags: string[]
-  isActive: boolean
-  notes?: string
-  metadata: Record<string, unknown>
-}
-
-export interface CategoryEntity extends BaseEntity {
-  archetype: 'category'
-  kind: string
-  name: string
-  slug?: string
-  parentId?: string
-  icon?: string
-  color?: string
-  sortOrder: number
-  isActive: boolean
-  metadata: Record<string, unknown>
-}
-
-export interface ProductEntity extends BaseEntity {
-  archetype: 'product'
-  categoryId?: string
-  name: string
-  description?: string
-  sku?: string
-  price?: number
-  cost?: number
-  currency: string
-  unit?: string
-  imageUrl?: string
-  stock?: number
-  minStock?: number
-  status: string
-  isActive: boolean
-  tags: string[]
-  metadata: Record<string, unknown>
-}
-
-export interface ServiceEntity extends BaseEntity {
-  archetype: 'service'
-  categoryId?: string
-  name: string
-  description?: string
-  price?: number
-  cost?: number
-  currency: string
-  durationMinutes?: number
-  imageUrl?: string
-  status: string
-  isActive: boolean
-  tags: string[]
-  metadata: Record<string, unknown>
-}
-
-export interface OrderEntity extends BaseEntity {
-  archetype: 'order'
-  kind: string
-  referenceNumber?: string
-  status: string
-  partyId?: string
-  assigneeId?: string
-  locationId?: string
-  subtotal: number
-  discount: number
-  tax: number
-  total: number
-  currency: string
-  dueAt?: string
-  completedAt?: string
-  notes?: string
-  tags: string[]
-  metadata: Record<string, unknown>
-}
-
-export interface TransactionEntity extends BaseEntity {
-  archetype: 'transaction'
-  kind: string
-  orderId?: string
-  partyId?: string
-  amount: number
-  currency: string
-  paymentMethod?: string
-  reference?: string
-  status: string
-  transactedAt: string
-  notes?: string
-  metadata: Record<string, unknown>
-}
-
-export interface LocationEntity extends BaseEntity {
-  archetype: 'location'
-  kind: string
-  name: string
-  email?: string
-  phone?: string
-  address?: string
-  city?: string
-  state?: string
-  country: string
-  postalCode?: string
-  isHeadquarters: boolean
-  isActive: boolean
-  tags: string[]
-  notes?: string
-  metadata: Record<string, unknown>
-}
-
-export interface ScheduleEntity extends BaseEntity {
-  archetype: 'schedule'
-  kind: string
-  assigneeId?: string
-  locationId?: string
-  dayOfWeek?: number
-  specificDate?: string
-  startsAt: string
-  endsAt: string
-  isActive: boolean
-  metadata: Record<string, unknown>
-}

package/src/types/entitlements.ts

@@ -1,45 +0,0 @@
-/**
- * Entitlements — the plan side of the access decision (the role side lives in
- * permissions.ts). A plan grants FEATURES (gate a page/module) and caps LIMITS
- * (quantity ceilings). Feature ids are the SAME id space as RBAC/nav
- * (`permission.feature`), so a single id threads role → nav → plan.
- */
-export interface PlanEntitlements {
-  /**
-   * feature id (same id as RBAC/nav) → whether the plan grants it. Absent = the
-   * plan does not gate the feature (allowed). Only an explicit `false` denies —
-   * this keeps plans additive: features unknown to a plan stay open.
-   */
-  features?: Record<string, boolean>
-  /**
-   * limitKey → cap. `-1` = unlimited. Keys are app/plugin-defined (e.g.
-   * `clients`, `users`, `locations`, `bookings_month`). A key absent here means
-   * "no cap on this plan" (unlimited). See {@link LimitDeclaration} for how a
-   * key is bound to a countable table.
-   */
-  limits?: Record<string, number>
-}
-
-/**
- * Declares HOW a limit key is counted. Contributed by plugins via
- * `PluginManifest.declaredLimits` (aggregated by the plugin runtime) and/or
- * overridden per-app via `billing.limitDeclarations`. The access engine reads a
- * declaration to resolve a `limitKey` → a live `count(*)` against `table` for
- * the active tenant, with no per-entity code.
- */
-export interface LimitDeclaration {
-  /** Limit key — matches a key in {@link PlanEntitlements.limits}. */
-  key: string
-  /** Human label for paywalls / usage banners (e.g. "Patients"). */
-  label: string
-  /** Table the count runs against (tenant-scoped via `tenant_id`). */
-  table: string
-  /** Optional `kind` column filter for tables that hold several entity kinds. */
-  kindFilter?: string
-  /**
-   * Counting window. `'month'` counts rows created since the start of the
-   * current month (recurring quotas like bookings/month); `'total'` (default)
-   * counts every row (stock quantities like clients/users).
-   */
-  period?: 'month' | 'total'
-}

package/src/types/i18n.ts

@@ -1,7 +0,0 @@
-export interface LocaleConfig {
-  default: string
-  supported: string[]
-  translations?: Record<string, Record<string, string>>
-  /** ISO 4217 currency code for money formatting (e.g. 'BRL', 'USD'). */
-  currency?: string
-}

package/src/types/index.ts

@@ -1,11 +0,0 @@
-// Re-export all core types
-export type { EntityArchetype, BaseEntity, PersonEntity, ProductEntity, ServiceEntity, OrderEntity, TransactionEntity, LocationEntity, ScheduleEntity, CategoryEntity } from './entities'
-export type { EntityDef, FieldDef, FieldType, FieldRelation, FieldGroup, DetailTab, FormLayout, ComputedFieldValue } from './crud'
-export type { PluginManifest, PluginScope, PluginStatus, ResolvedPluginManifest, PluginRuntime, PluginRuntimeContext, PluginWidgetZone, PluginWidgetDefinition, PluginNavigationEntry, PluginSettingsTab, PluginRouteDefinition, PluginAITool, AIToolMode, AIToolExecution, AgentRpcDeclaration, AIToolParameterProperty, AIToolParameters, AIToolSuggestion, PluginRegistryDef, PluginMigration, PluginDiagnostic, VerticalId, ScaffoldType } from './plugins'
-export type { AuthAdapter, AuthUser, AuthSession } from './auth'
-export type { OrgAdapter, Organization, OrgMember } from './org'
-export type { PermissionsConfig, FeatureDeclaration, PermissionAction, PermissionProfile, SystemPermission } from './permissions'
-export type { Plan, BillingConfig, BillingCheckoutFn } from './billing'
-export type { PlanEntitlements, LimitDeclaration } from './entitlements'
-export type { ThemeBrand, ThemeRadius, ThemeMode } from './theme'
-export type { LocaleConfig } from './i18n'

package/src/types/org.ts

@@ -1,137 +0,0 @@
-import type { PermissionProfile } from './permissions'
-
-export interface Organization {
-  id: string
-  name: string
-  slug: string
-  logoUrl?: string
-  verticalId?: string
-  plan?: string
-  settings?: Record<string, unknown>
-  createdAt: string
-  updatedAt: string
-}
-
-export interface OrgMember {
-  id: string
-  userId: string
-  orgId: string
-  profileId: string
-  profileName: string
-  user: {
-    id: string
-    email: string
-    fullName: string
-    avatarUrl?: string
-  }
-  joinedAt: string
-}
-
-export interface OrgMembership {
-  orgId: string
-  orgName: string
-  orgSlug: string
-  orgLogoUrl?: string
-  profileId: string
-  profileName: string
-}
-
-/**
- * A team member in the Person-first model: a person (of a configured team kind)
- * with an OPTIONAL access overlay. `membership` is present only when the person
- * has login + RBAC role (a `tenant_members` row linked by `person_id`).
- *
- * The inverse also exists: a membership with no person behind it (the owner who
- * created the workspace). Those rows carry `membership` and no `personId`/`kind`.
- */
-export interface TeamPerson {
-  /** Absent on a login-only row: a member with no person record behind it. */
-  personId?: string
-  name: string
-  /** Absent on a login-only row. */
-  kind?: string
-  email?: string
-  avatarUrl?: string
-  isActive: boolean
-  membership?: {
-    memberId: string
-    userId: string
-    /** RBAC role key (tenant_members.role). */
-    profileId: string
-    profileName?: string
-    joinedAt?: string
-  }
-}
-
-export interface Location {
-  id: string
-  tenantId: string
-  name: string
-  address?: string
-  city?: string
-  state?: string
-  country?: string
-  phone?: string
-  isHeadquarters: boolean
-  isActive: boolean
-  createdAt: string
-  updatedAt: string
-}
-
-export interface Invite {
-  id: string
-  orgId: string
-  email: string
-  profileId: string
-  profileName: string
-  invitedBy: string
-  token: string
-  status: 'pending' | 'accepted' | 'expired'
-  createdAt: string
-  expiresAt: string
-}
-
-export interface CreateOrgOptions {
-  verticalId?: string
-  timezone?: string
-  currency?: string
-  locale?: string
-  teamSize?: string
-}
-
-export interface OrgAdapter {
-  listUserOrgs(userId: string): Promise<OrgMembership[]>
-  /**
-   * Redeem any invite addressed to the signed-in user, turning it into a real
-   * membership. Called once per sign-in, BEFORE `listUserOrgs` — without it an
-   * invitee looks org-less and the auto-create path invents a personal org
-   * instead of putting them in the org that invited them. Returns how many
-   * invites were accepted. Optional so adapters can adopt it incrementally.
-   */
-  acceptPendingInvites?(): Promise<number>
-  getOrg(orgId: string): Promise<Organization>
-  createOrg(name: string, userId: string, options?: CreateOrgOptions): Promise<Organization>
-  updateOrg(orgId: string, data: Partial<Organization>): Promise<Organization>
-  listMembers(orgId: string): Promise<OrgMember[]>
-  /**
-   * Person-first team list: people whose `kind` is in `personKinds`, each with an
-   * optional membership overlay (login + role) linked by `tenant_members.person_id`,
-   * PLUS the memberships that match no such person (they'd otherwise be invisible).
-   * Optional so adapters can adopt it incrementally; the Team screen falls back to
-   * `listMembers` when absent or when no `personKinds` are configured.
-   */
-  listTeam?(orgId: string, personKinds: string[]): Promise<TeamPerson[]>
-  updateMemberProfile(orgId: string, memberId: string, profileId: string): Promise<void>
-  removeMember(orgId: string, memberId: string): Promise<void>
-  listProfiles(orgId: string): Promise<PermissionProfile[]>
-  createProfile(orgId: string, profile: Omit<PermissionProfile, 'id' | 'isSystem'>): Promise<PermissionProfile>
-  updateProfile(orgId: string, profileId: string, data: Partial<PermissionProfile>): Promise<PermissionProfile>
-  deleteProfile(orgId: string, profileId: string): Promise<void>
-  listInvites(orgId: string): Promise<Invite[]>
-  createInvite(orgId: string, email: string, profileId: string, invitedBy: string): Promise<Invite>
-  bulkInvite(orgId: string, emails: string[], profileId: string, invitedBy: string): Promise<Invite[]>
-  revokeInvite(orgId: string, inviteId: string): Promise<void>
-  resendInvite(orgId: string, inviteId: string): Promise<Invite>
-  listLocations(orgId: string): Promise<Location[]>
-  createLocation(orgId: string, data: { name: string; address?: string; city?: string; state?: string; country?: string; phone?: string; isHeadquarters?: boolean }): Promise<Location>
-}

package/src/types/payment.ts

@@ -1,44 +0,0 @@
-// ---------------------------------------------------------------------------
-// Payment provider contract (SDK-level, gateway-agnostic). A booking/checkout
-// flow declares "collect X" and calls createCharge; the concrete provider (mock
-// Pix now, MercadoPago/Stripe later) decides HOW. Kept in core so any plugin can
-// depend on the interface without depending on a payments plugin.
-// ---------------------------------------------------------------------------
-
-export type PaymentMethod = 'pix' | (string & {})
-
-export type ChargeStatus = 'pending' | 'paid' | 'expired' | 'failed'
-
-export interface CreateChargeInput {
-  /** Amount in the currency's major unit (e.g. 220.00 = R$ 220,00). */
-  amount: number
-  /** ISO 4217 currency code, e.g. 'BRL'. */
-  currency: string
-  method: PaymentMethod
-  /** Human-readable description (statement/receipt). */
-  description?: string
-  /** The booking/order this charge settles, for reconciliation. */
-  orderId?: string
-  /** Payer contact, when known (name/email/phone). */
-  customer?: { name?: string; email?: string; phone?: string }
-}
-
-export interface PixCharge {
-  chargeId: string
-  status: ChargeStatus
-  amount: number
-  currency: string
-  /** QR image payload. For Pix this is the BR Code string encoded into the QR. */
-  pixQrCode: string
-  /** "Copia e cola" — the raw Pix BR Code the payer pastes into their bank app. */
-  pixCopyPaste: string
-  /** ISO datetime the charge/QR expires. */
-  expiresAt: string
-}
-
-export interface PaymentProvider {
-  /** Create a charge and return its payable artifacts (Pix QR + copia-e-cola). */
-  createCharge(input: CreateChargeInput): Promise<PixCharge>
-  /** Current status of a charge (polled by the UI, or driven by a webhook later). */
-  getChargeStatus(chargeId: string): Promise<ChargeStatus>
-}

package/src/types/permissions.ts

@@ -1,32 +0,0 @@
-export type PermissionAction = 'read' | 'create' | 'edit' | 'write' | 'delete' | 'manage' | (string & {})
-
-export type SystemPermission =
-  | 'manage_team'
-  | 'manage_billing'
-  | 'manage_settings'
-  | 'manage_permissions'
-
-export interface FeatureDeclaration {
-  id: string
-  label: string
-  description?: string
-  /** Settings group this feature appears under (matches saas-core runtime) */
-  group?: string
-  actions?: PermissionAction[]
-  pluginId?: string
-}
-
-export interface PermissionProfile {
-  id: string
-  name: string
-  description?: string
-  isSystem?: boolean
-  systemPermissions?: SystemPermission[]
-  /** feature key → allowed actions. The canonical permission map (saas-core shell name). */
-  grants: Record<string, PermissionAction[]>
-}
-
-export interface PermissionsConfig {
-  features: FeatureDeclaration[]
-  defaultProfiles?: PermissionProfile[]
-}