@fayz-ai/plugin-forms 0.1.1

package/src/data/supabase.ts

@@ -0,0 +1,405 @@
+import { getFormsTenantId } from '../lib/tenant'
+import type { CustomFormsDataProvider } from './types'
+import type {
+  FormTemplate,
+  FormDocument,
+  DocumentFile,
+  TemplateQuery,
+  DocumentQuery,
+  PaginatedResult,
+  CreateTemplateInput,
+  UpdateTemplateInput,
+  CreateDocumentInput,
+  UpdateDocumentInput,
+} from '../types'
+import { getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core'
+
+function getTenantId(): string {
+  // Local override wins; else use the app's active tenant so writes pass RLS.
+  return getFormsTenantId() ?? getActiveTenantId() ?? ''
+}
+
+function getClient() {
+  const supabase = getSupabaseClientOptional() as any
+  if (!supabase) throw new Error('Supabase not initialized')
+  return supabase
+}
+
+
+function mapTemplate(r: any): FormTemplate {
+  return {
+    id: r.id,
+    tenantId: r.tenant_id,
+    name: r.name,
+    description: r.description,
+    category: r.category,
+    version: r.version,
+    isCurrent: r.is_current,
+    parentId: r.parent_id,
+    schema: r.schema,
+    specialty: r.specialty,
+    tags: r.tags ?? [],
+    metadata: r.metadata ?? {},
+    isActive: r.is_active,
+    isDeleted: r.is_deleted,
+    createdBy: r.created_by,
+    updatedBy: r.updated_by,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+  }
+}
+
+function mapDocument(r: any): FormDocument {
+  return {
+    id: r.id,
+    tenantId: r.tenant_id,
+    templateId: r.template_id ?? '',
+    templateName: r.template_name,
+    templateCategory: r.template_category,
+    personId: r.person_id,
+    personName: r.person_name,
+    title: r.title,
+    data: r.form_data ?? {},
+    status: r.status,
+    signedAt: r.signed_at,
+    signedBy: r.signed_by,
+    notes: r.notes,
+    metadata: r.metadata ?? {},
+    isDeleted: false,
+    createdBy: r.created_by,
+    updatedBy: r.updated_by,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    // Extra fields from core document
+    kind: r.kind,
+    fileUrl: r.file_url,
+    fileName: r.file_name,
+    fileSize: r.file_size,
+    mimeType: r.mime_type,
+  }
+}
+
+function mapFile(r: any): DocumentFile {
+  return {
+    id: r.id,
+    tenantId: r.tenant_id,
+    documentId: r.document_id,
+    fieldKey: r.field_key,
+    fileUrl: r.file_url,
+    fileName: r.file_name,
+    fileSize: r.file_size,
+    mimeType: r.mime_type,
+    sortOrder: r.sort_order,
+    metadata: r.metadata ?? {},
+    createdAt: r.created_at,
+  }
+}
+
+export function createSupabaseFormsProvider(): CustomFormsDataProvider {
+  return {
+    // ── Templates ──────────────────────────────────────────
+
+    async getTemplates(query: TemplateQuery): Promise<PaginatedResult<FormTemplate>> {
+      const db = getClient()
+      let qb = db
+        .from('frm_templates')
+        .select('*', { count: 'exact' })
+        .eq('tenant_id', getTenantId())
+        .eq('is_current', true)
+        .eq('is_deleted', false)
+
+      if (query.category) qb = qb.eq('category', query.category)
+      if (query.search) qb = qb.ilike('name', `%${query.search}%`)
+
+      const page = query.page ?? 1
+      const pageSize = query.pageSize ?? 25
+      qb = qb
+        .order('updated_at', { ascending: false })
+        .range((page - 1) * pageSize, page * pageSize - 1)
+
+      const { data, count, error } = await qb
+      if (error) throw new Error(error.message)
+      return { data: (data ?? []).map(mapTemplate), total: count ?? 0 }
+    },
+
+    async getTemplateById(id: string): Promise<FormTemplate | null> {
+      const db = getClient()
+      const { data, error } = await db
+        .from('frm_templates')
+        .select('*')
+        .eq('id', id)
+        .eq('is_deleted', false)
+        .single()
+      if (error || !data) return null
+      return mapTemplate(data)
+    },
+
+    async createTemplate(input: CreateTemplateInput): Promise<FormTemplate> {
+      const db = getClient()
+      const tenantId = getTenantId()
+      const { data, error } = await db
+        .from('frm_templates')
+        .insert({
+          tenant_id: tenantId,
+          name: input.name,
+          description: input.description,
+          category: input.category,
+          schema: input.schema,
+          specialty: input.specialty,
+          tags: input.tags ?? [],
+          metadata: input.metadata ?? {},
+        })
+        .select()
+        .single()
+      if (error) throw new Error(error.message)
+      return mapTemplate(data)
+    },
+
+    async updateTemplate(id: string, input: UpdateTemplateInput): Promise<FormTemplate> {
+      const db = getClient()
+      const tenantId = getTenantId()
+
+      const { count } = await db
+        .from('frm_documents')
+        .select('document_id', { count: 'exact', head: true })
+        .eq('template_id', id)
+
+      const hasDocuments = (count ?? 0) > 0
+
+      if (hasDocuments && input.schema) {
+        const existing = await this.getTemplateById(id)
+        if (!existing) throw new Error('Template not found')
+
+        const { data: newRow, error: insertError } = await db
+          .from('frm_templates')
+          .insert({
+            tenant_id: tenantId,
+            name: input.name ?? existing.name,
+            description: input.description ?? existing.description,
+            category: input.category ?? existing.category,
+            schema: input.schema,
+            specialty: input.specialty ?? existing.specialty,
+            tags: input.tags ?? existing.tags,
+            metadata: input.metadata ?? existing.metadata,
+            is_active: input.isActive ?? existing.isActive,
+            version: existing.version + 1,
+            is_current: true,
+            parent_id: existing.parentId ?? existing.id,
+          })
+          .select()
+          .single()
+        if (insertError) throw new Error(insertError.message)
+
+        await db
+          .from('frm_templates')
+          .update({ is_current: false, updated_at: new Date().toISOString() })
+          .eq('id', id)
+
+        return mapTemplate(newRow)
+      }
+
+      const updates: Record<string, unknown> = { updated_at: new Date().toISOString() }
+      if (input.name !== undefined) updates.name = input.name
+      if (input.description !== undefined) updates.description = input.description
+      if (input.category !== undefined) updates.category = input.category
+      if (input.schema !== undefined) updates.schema = input.schema
+      if (input.specialty !== undefined) updates.specialty = input.specialty
+      if (input.tags !== undefined) updates.tags = input.tags
+      if (input.metadata !== undefined) updates.metadata = input.metadata
+      if (input.isActive !== undefined) updates.is_active = input.isActive
+
+      const { data, error } = await db
+        .from('frm_templates')
+        .update(updates)
+        .eq('id', id)
+        .select()
+        .single()
+      if (error) throw new Error(error.message)
+      return mapTemplate(data)
+    },
+
+    async deleteTemplate(id: string): Promise<void> {
+      const db = getClient()
+      const { error } = await db
+        .from('frm_templates')
+        .update({ is_deleted: true, updated_at: new Date().toISOString() })
+        .eq('id', id)
+      if (error) throw new Error(error.message)
+    },
+
+    // ── Documents (saas_core.documents + frm_documents extension) ──
+
+    async getDocuments(query: DocumentQuery): Promise<PaginatedResult<FormDocument>> {
+      const db = getClient()
+      // Query through the v_documents view (joins core + form extension)
+      let qb = db
+        .from('v_documents')
+        .select('*', { count: 'exact' })
+        .eq('tenant_id', getTenantId())
+        .eq('is_active', true)
+
+      if (query.personId) qb = qb.eq('person_id', query.personId)
+      if (query.templateId) qb = qb.eq('template_id', query.templateId)
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status]
+        qb = qb.in('status', statuses)
+      }
+      if (query.search) qb = qb.or(`title.ilike.%${query.search}%,template_name.ilike.%${query.search}%`)
+
+      const page = query.page ?? 1
+      const pageSize = query.pageSize ?? 50
+      qb = qb
+        .order('created_at', { ascending: false })
+        .range((page - 1) * pageSize, page * pageSize - 1)
+
+      const { data, count, error } = await qb
+      if (error) throw new Error(error.message)
+      return { data: (data ?? []).map(mapDocument), total: count ?? 0 }
+    },
+
+    async getDocumentById(id: string): Promise<FormDocument | null> {
+      const db = getClient()
+      const { data, error } = await db
+        .from('v_documents')
+        .select('*')
+        .eq('id', id)
+        .single()
+      if (error || !data) return null
+      return mapDocument(data)
+    },
+
+    async createDocument(input: CreateDocumentInput): Promise<FormDocument> {
+      const tenantId = getTenantId()
+      const isForm = !!input.templateId
+
+      // Step 1: Insert into saas_core.documents
+      const { data: coreDoc, error: coreError } = await getClient()
+        .from('frm_core_documents')
+        .insert({
+          tenant_id: tenantId,
+          kind: input.kind ?? (isForm ? 'form' : 'attachment'),
+          person_id: input.personId,
+          title: input.title,
+          status: input.status ?? 'draft',
+          file_url: input.fileUrl,
+          file_name: input.fileName,
+          file_size: input.fileSize,
+          mime_type: input.mimeType,
+          metadata: {},
+        })
+        .select()
+        .single()
+      if (coreError) throw new Error(coreError.message)
+
+      // Step 2: For form documents, insert extension row
+      if (isForm && input.templateId) {
+        const db = getClient()
+        const { error: extError } = await db
+          .from('frm_documents')
+          .insert({
+            document_id: coreDoc.id,
+            tenant_id: tenantId,
+            template_id: input.templateId,
+            data: input.data ?? {},
+          })
+        if (extError) {
+          // Rollback core insert
+          await getClient().from('frm_core_documents').delete().eq('id', coreDoc.id)
+          throw new Error(extError.message)
+        }
+      }
+
+      // Fetch via view to get joined data
+      const doc = await this.getDocumentById(coreDoc.id)
+      return doc!
+    },
+
+    async updateDocument(id: string, input: UpdateDocumentInput): Promise<FormDocument> {
+      const now = new Date().toISOString()
+
+      // Update core document fields
+      const coreUpdates: Record<string, unknown> = { updated_at: now }
+      if (input.status !== undefined) coreUpdates.status = input.status
+      if (input.title !== undefined) coreUpdates.title = input.title
+      if (input.notes !== undefined) coreUpdates.notes = input.notes
+
+      const { error: coreError } = await getClient()
+        .from('frm_core_documents')
+        .update(coreUpdates)
+        .eq('id', id)
+      if (coreError) throw new Error(coreError.message)
+
+      // Update form extension if data is provided
+      if (input.data !== undefined) {
+        const db = getClient()
+        await db
+          .from('frm_documents')
+          .update({ data: input.data, updated_at: now })
+          .eq('document_id', id)
+      }
+
+      const doc = await this.getDocumentById(id)
+      return doc!
+    },
+
+    async deleteDocument(id: string): Promise<void> {
+      const { error } = await getClient()
+        .from('frm_core_documents')
+        .update({ is_active: false, updated_at: new Date().toISOString() })
+        .eq('id', id)
+      if (error) throw new Error(error.message)
+    },
+
+    // ── Files ──────────────────────────────────────────────
+
+    async getDocumentFiles(documentId: string): Promise<DocumentFile[]> {
+      const db = getClient()
+      const { data, error } = await db
+        .from('frm_document_files')
+        .select('*')
+        .eq('document_id', documentId)
+        .order('sort_order')
+      if (error) throw new Error(error.message)
+      return (data ?? []).map(mapFile)
+    },
+
+    async uploadFile(documentId: string, fieldKey: string, file: File): Promise<DocumentFile> {
+      const db = getClient()
+      const tenantId = getTenantId()
+      const ext = file.name.split('.').pop() ?? 'bin'
+      const storagePath = `${tenantId}/forms/${documentId}/${fieldKey}/${crypto.randomUUID()}.${ext}`
+
+      const { error: uploadError } = await db.storage
+        .from('documents')
+        .upload(storagePath, file, { contentType: file.type })
+      if (uploadError) throw new Error(uploadError.message)
+
+      const { data: urlData } = db.storage.from('documents').getPublicUrl(storagePath)
+
+      const { data, error } = await db
+        .from('frm_document_files')
+        .insert({
+          tenant_id: tenantId,
+          document_id: documentId,
+          field_key: fieldKey,
+          file_url: urlData.publicUrl,
+          file_name: file.name,
+          file_size: file.size,
+          mime_type: file.type,
+        })
+        .select()
+        .single()
+      if (error) throw new Error(error.message)
+      return mapFile(data)
+    },
+
+    async deleteFile(fileId: string): Promise<void> {
+      const db = getClient()
+      const { error } = await db
+        .from('frm_document_files')
+        .delete()
+        .eq('id', fileId)
+      if (error) throw new Error(error.message)
+    },
+  }
+}

package/src/data/types.ts

@@ -0,0 +1,33 @@
+import type {
+  FormTemplate,
+  FormDocument,
+  DocumentFile,
+  TemplateQuery,
+  DocumentQuery,
+  PaginatedResult,
+  CreateTemplateInput,
+  UpdateTemplateInput,
+  CreateDocumentInput,
+  UpdateDocumentInput,
+} from '../types'
+
+export interface CustomFormsDataProvider {
+  // Templates
+  getTemplates(query: TemplateQuery): Promise<PaginatedResult<FormTemplate>>
+  getTemplateById(id: string): Promise<FormTemplate | null>
+  createTemplate(input: CreateTemplateInput): Promise<FormTemplate>
+  updateTemplate(id: string, input: UpdateTemplateInput): Promise<FormTemplate>
+  deleteTemplate(id: string): Promise<void>
+
+  // Documents
+  getDocuments(query: DocumentQuery): Promise<PaginatedResult<FormDocument>>
+  getDocumentById(id: string): Promise<FormDocument | null>
+  createDocument(input: CreateDocumentInput): Promise<FormDocument>
+  updateDocument(id: string, input: UpdateDocumentInput): Promise<FormDocument>
+  deleteDocument(id: string): Promise<void>
+
+  // Files
+  getDocumentFiles(documentId: string): Promise<DocumentFile[]>
+  uploadFile(documentId: string, fieldKey: string, file: File): Promise<DocumentFile>
+  deleteFile(fileId: string): Promise<void>
+}

package/src/document-types.ts

@@ -0,0 +1,51 @@
+import type React from 'react'
+
+// ============================================================
+// Document Type Registry — extensible pattern for plugins
+// to contribute document types to the "Add Document" dropdown
+// ============================================================
+
+export interface DocumentTypeOption {
+  /** Unique id, e.g. 'custom_forms:template:abc123' or 'core:image' */
+  id: string
+  label: string
+  icon: React.ElementType
+  /** Group label for dropdown sections (e.g. 'Formulários', 'Arquivos') */
+  group: string
+  /** Group sort order — lower groups appear first */
+  groupOrder?: number
+  /** Sort order within group */
+  order?: number
+  /** Description shown below label */
+  description?: string
+}
+
+export interface DocumentTypeProvider {
+  /** Unique provider id, e.g. 'custom_forms', 'core_files' */
+  id: string
+  /** Returns available document types for a given person */
+  getTypes(personId: string): DocumentTypeOption[] | Promise<DocumentTypeOption[]>
+}
+
+// ── Global registry ────────────────────────────────────────
+
+const providers: DocumentTypeProvider[] = []
+
+export function registerDocumentTypeProvider(provider: DocumentTypeProvider) {
+  if (providers.find((p) => p.id === provider.id)) return
+  providers.push(provider)
+}
+
+export function getDocumentTypeProviders(): DocumentTypeProvider[] {
+  return providers
+}
+
+export async function getAllDocumentTypes(personId: string): Promise<DocumentTypeOption[]> {
+  const results = await Promise.all(
+    providers.map((p) => Promise.resolve(p.getTypes(personId))),
+  )
+  const all = results.flat()
+  // Sort by groupOrder then order within group
+  all.sort((a, b) => (a.groupOrder ?? 50) - (b.groupOrder ?? 50) || (a.order ?? 0) - (b.order ?? 0))
+  return all
+}

package/src/index.ts

@@ -0,0 +1,195 @@
+import React from 'react'
+import type { PluginManifest } from '@fayz-ai/core'
+import type { CustomFormsDataProvider } from './data/types'
+import { createMockFormsProvider } from './data/mock'
+import { createSupabaseFormsProvider } from './data/supabase'
+import { createSafeDataProvider, registerTranslations } from '@fayz-ai/core'
+import { createCustomFormsStore } from './store'
+import { customFormsLocales } from './locales'
+import { resolveConfig } from './config'
+import type { CustomFormsPluginOptions } from './config'
+import { CustomFormsSettingsTab } from './views/CustomFormsSettingsTab'
+import { PersonDocumentsWidget as PersonDocumentsWidgetImpl } from './components/PersonDocumentsWidget'
+import { registerDocumentTypeProvider } from './document-types'
+import { FileText as FileTextIcon, Image as ImageIcon, Paperclip } from 'lucide-react'
+
+function registerBuiltInProviders(formsProvider: CustomFormsDataProvider) {
+  // Templates from custom_forms
+  registerDocumentTypeProvider({
+    id: 'custom_forms:templates',
+    async getTypes() {
+      try {
+        const result = await formsProvider.getTemplates({})
+        return result.data.map((tpl) => ({
+          id: `template:${tpl.id}`,
+          label: tpl.name,
+          icon: FileTextIcon,
+          group: 'Formulários',
+          groupOrder: 10,
+          order: 0,
+          description: tpl.description,
+          _templateId: tpl.id,
+        })) as any[]
+      } catch {
+        return []
+      }
+    },
+  })
+
+  // Built-in file types
+  registerDocumentTypeProvider({
+    id: 'core:files',
+    getTypes() {
+      return [
+        { id: 'core:image', label: 'Imagem', icon: ImageIcon, group: 'Arquivos', groupOrder: 90, order: 0 },
+        { id: 'core:attachment', label: 'Anexo', icon: Paperclip, group: 'Arquivos', groupOrder: 90, order: 1 },
+      ]
+    },
+  })
+}
+
+export type { CustomFormsPluginOptions }
+export { registerDocumentTypeProvider, type DocumentTypeOption, type DocumentTypeProvider } from './document-types'
+
+export function createCustomFormsPlugin(options?: CustomFormsPluginOptions): PluginManifest {
+  registerTranslations(customFormsLocales)
+  const config = resolveConfig(options)
+  const provider = options?.dataProvider ?? createSafeDataProvider(
+    () => createSupabaseFormsProvider(),
+    () => createMockFormsProvider(),
+  )
+  const store = createCustomFormsStore(provider)
+
+  // Register built-in document type providers
+  registerBuiltInProviders(provider)
+
+
+  const formRegistries: import('@fayz-ai/core').PluginRegistryDef[] = [
+    {
+      id: 'form-categories',
+      entity: {
+        name: 'Category',
+        namePlural: 'Categories',
+        icon: 'FolderOpen',
+        displayField: 'name',
+        defaultSort: 'sort_order',
+        fields: [
+          { key: 'name', label: 'Name', type: 'text' as const, required: true, showInTable: true },
+          { key: 'icon', label: 'Icon', type: 'text' as const, showInTable: true },
+          { key: 'color', label: 'Color', type: 'color' as const, showInTable: true },
+          { key: 'sortOrder', label: 'Order', type: 'number' as const, showInTable: true, defaultValue: 0 },
+          { key: 'isActive', label: 'Active', type: 'boolean' as const, showInTable: true, defaultValue: true, inlineToggle: true },
+        ],
+        data: {
+          table: 'frm_categories',
+          tenantScoped: true,
+        },
+      },
+      icon: 'FolderOpen',
+      description: 'Categories for organizing form templates',
+      seedData: [
+        { name: 'Anamnese', sortOrder: 1, isActive: true },
+        { name: 'Evolução', sortOrder: 2, isActive: true },
+        { name: 'Laudo', sortOrder: 3, isActive: true },
+        { name: 'Contrato', sortOrder: 4, isActive: true },
+        { name: 'Geral', sortOrder: 5, isActive: true },
+      ],
+    },
+  ]
+
+  const SettingsComponent: React.FC = () =>
+    React.createElement(CustomFormsSettingsTab, { config, provider, store, registries: formRegistries })
+  SettingsComponent.displayName = 'CustomFormsSettingsTab'
+
+  const PersonDocumentsWidget: React.FC<any> = (props: any) =>
+    React.createElement(PersonDocumentsWidgetImpl, { ...props, config, provider, store })
+  PersonDocumentsWidget.displayName = 'PersonDocumentsWidget'
+
+  return {
+    id: 'custom_forms',
+    name: config.labels.pageTitle,
+    icon: 'FileText',
+    version: '1.0.0',
+    scope: options?.scope ?? 'universal',
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: [],
+    declaredFeatures: [
+      { id: 'custom_forms', label: config.labels.pageTitle, group: config.labels.pageTitle },
+    ],
+
+    navigation: [],
+
+    routes: [],
+
+    settings: [
+      {
+        id: 'custom_forms',
+        label: config.labels.settingsLabel,
+        icon: 'FileText',
+        component: SettingsComponent as unknown as React.ComponentType<unknown>,
+        order: 15,
+      },
+    ],
+
+    widgets: [
+      {
+        id: 'person-documents-tab',
+        zone: 'person.detail.documents',
+        component: PersonDocumentsWidget,
+        order: 0,
+      },
+    ],
+
+    registries: formRegistries,
+
+    aiTools: [
+      {
+        id: 'custom_forms.list-templates',
+        name: 'listFormTemplates',
+        description: 'Lists available form templates for the current tenant.',
+        icon: 'FileText',
+        mode: 'read' as const,
+        category: 'Forms',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            category: {
+              type: 'string' as const,
+              description: 'Filter by category: anamnesis, evolution, report, contract, general',
+            },
+          },
+        },
+        suggestions: [
+          { label: 'What forms do we have?' },
+          { label: 'Show me anamnesis templates' },
+        ],
+        permission: { feature: 'custom_forms', action: 'read' as const },
+      },
+      {
+        id: 'custom_forms.list-documents',
+        name: 'listDocuments',
+        description: 'Lists filled documents, optionally filtered by person or status.',
+        icon: 'FileText',
+        mode: 'read' as const,
+        category: 'Forms',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            personId: { type: 'string' as const, description: 'Person UUID to filter by' },
+            status: {
+              type: 'string' as const,
+              description: 'Status filter: draft, completed, signed, archived',
+            },
+          },
+        },
+        suggestions: [
+          { label: "Show this client's documents" },
+        ],
+        permission: { feature: 'custom_forms', action: 'read' as const },
+      },
+    ],
+
+    locales: customFormsLocales,
+  }
+}

package/src/lib/tenant.ts

@@ -0,0 +1,5 @@
+// Current tenant id holder (runtime DI), decoupling the plugin from saas-core's
+// organization.store. Defaults to undefined → Supabase RLS scopes by session.
+let currentTenantId: string | undefined
+export function setFormsTenantId(id: string | undefined): void { currentTenantId = id }
+export function getFormsTenantId(): string | undefined { return currentTenantId }