@fayz-ai/plugin-reports 0.9.0 → 0.9.1

package/src/data/supabase.ts

@@ -1,200 +0,0 @@
-import { getSupabaseClientOptional } from '@fayz-ai/core'
-import type { ReportDef, ReportQueryState } from '../types'
-import type { ReportDataProvider, ReportResult } from './types'
-
-// ---------------------------------------------------------------------------
-// Case conversion
-// ---------------------------------------------------------------------------
-
-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) => c.toUpperCase())
-}
-
-function mapRow(row: Record<string, unknown>, columnMap?: Record<string, string>): Record<string, any> {
-  const result: Record<string, unknown> = {}
-  for (const [key, value] of Object.entries(row)) {
-    const camelKey = columnMap?.[key] ?? snakeToCamel(key)
-    result[camelKey] = value
-  }
-  return result
-}
-
-// ---------------------------------------------------------------------------
-// Provider factory
-// ---------------------------------------------------------------------------
-
-export interface SupabaseReportProviderConfig {
-  tenantId: string | (() => string | undefined)
-  tenantIdColumn?: string
-  schema?: string
-}
-
-export function createSupabaseReportProvider(config: SupabaseReportProviderConfig): ReportDataProvider {
-  const schema = config.schema ?? 'public'
-  const tenantIdCol = config.tenantIdColumn ?? 'tenant_id'
-
-  function resolveTenantId(): string | undefined {
-    return typeof config.tenantId === 'function' ? config.tenantId() : config.tenantId
-  }
-
-  function getClient() {
-    const supabase = getSupabaseClientOptional() as any
-    if (!supabase) throw new Error('Supabase client not available')
-    return schema === 'public' ? supabase : supabase.schema(schema)
-  }
-
-  return {
-    async fetch(reportDef: ReportDef, query: ReportQueryState): Promise<ReportResult> {
-      const { dataSource } = reportDef
-      const columnMap = dataSource.columnMap
-
-      if (dataSource.kind === 'rpc') {
-        return fetchViaRpc(reportDef, query, getClient, resolveTenantId, columnMap)
-      }
-
-      return fetchViaView(reportDef, query, getClient, resolveTenantId, tenantIdCol, columnMap)
-    },
-  }
-}
-
-// ---------------------------------------------------------------------------
-// View-based fetch
-// ---------------------------------------------------------------------------
-
-async function fetchViaView(
-  reportDef: ReportDef,
-  query: ReportQueryState,
-  getClient: () => any,
-  resolveTenantId: () => string | undefined,
-  tenantIdCol: string,
-  columnMap?: Record<string, string>,
-): Promise<ReportResult> {
-  const { dataSource } = reportDef
-  let q = getClient().from(dataSource.name).select('*', { count: 'exact' })
-
-  // Tenant scoping
-  const tenantId = resolveTenantId()
-  if (tenantId) {
-    q = q.eq(tenantIdCol, tenantId)
-  }
-
-  // Date range
-  const dateCol = dataSource.dateColumn ?? 'created_at'
-  if (query.dateRange.from) {
-    q = q.gte(dateCol, query.dateRange.from)
-  }
-  if (query.dateRange.to) {
-    // For date-type columns, plain date string is sufficient.
-    // For timestamptz columns, extend to end of day.
-    const toValue = dateCol === 'created_at' || dateCol.endsWith('_at')
-      ? query.dateRange.to + 'T23:59:59'
-      : query.dateRange.to
-    q = q.lte(dateCol, toValue)
-  }
-
-  // Custom filters
-  for (const [key, value] of Object.entries(query.filters)) {
-    if (value == null || value === '') continue
-    const col = camelToSnake(key)
-    if (Array.isArray(value)) {
-      q = q.in(col, value)
-    } else {
-      q = q.eq(col, value)
-    }
-  }
-
-  // Search
-  if (query.search) {
-    const searchableCols = reportDef.columns
-      .filter((c) => c.type === 'text' || c.type === 'email')
-      .map((c: any) => camelToSnake(c.key))
-    if (searchableCols.length > 0) {
-      const term = `%${query.search}%`
-      const orClause = searchableCols.map((col) => `${col}.ilike.${term}`).join(',')
-      q = q.or(orClause)
-    }
-  }
-
-  // Sort
-  const sortCol = query.sortBy
-    ? camelToSnake(query.sortBy)
-    : dataSource.defaultSort
-      ? camelToSnake(dataSource.defaultSort)
-      : dateCol
-  const ascending = query.sortDir
-    ? query.sortDir === 'asc'
-    : dataSource.defaultSortDir
-      ? dataSource.defaultSortDir === 'asc'
-      : false
-  q = q.order(sortCol, { ascending })
-
-  // Pagination
-  const from = (query.page - 1) * query.pageSize
-  const to = from + query.pageSize - 1
-  q = q.range(from, to)
-
-  const { data, error, count } = await q
-
-  if (error) throw error
-
-  return {
-    data: (data ?? []).map((row: any) => mapRow(row, columnMap)),
-    total: count ?? 0,
-  }
-}
-
-// ---------------------------------------------------------------------------
-// RPC-based fetch
-// ---------------------------------------------------------------------------
-
-async function fetchViaRpc(
-  reportDef: ReportDef,
-  query: ReportQueryState,
-  getClient: () => any,
-  resolveTenantId: () => string | undefined,
-  columnMap?: Record<string, string>,
-): Promise<ReportResult> {
-  const { dataSource } = reportDef
-  const tenantId = resolveTenantId()
-
-  const params: Record<string, any> = {
-    p_tenant_id: tenantId,
-    p_from: query.dateRange.from,
-    p_to: query.dateRange.to,
-    p_page: query.page,
-    p_page_size: query.pageSize,
-  }
-
-  // Custom filters
-  for (const [key, value] of Object.entries(query.filters)) {
-    if (value == null || value === '') continue
-    params[`p_${camelToSnake(key)}`] = value
-  }
-
-  if (query.sortBy) {
-    params.p_sort_by = camelToSnake(query.sortBy)
-    params.p_sort_dir = query.sortDir ?? 'desc'
-  }
-
-  const { data, error } = await getClient().rpc(dataSource.name, params)
-  if (error) throw error
-
-  // RPC expected to return { data: [...], total: number }
-  if (data && typeof data === 'object' && 'data' in data) {
-    return {
-      data: (data.data ?? []).map((row: any) => mapRow(row, columnMap)),
-      total: data.total ?? 0,
-    }
-  }
-
-  // Fallback: RPC returns a plain array
-  const rows = Array.isArray(data) ? data : []
-  return {
-    data: rows.map((row: any) => mapRow(row, columnMap)),
-    total: rows.length,
-  }
-}

package/src/data/types.ts

@@ -1,10 +0,0 @@
-import type { ReportDef, ReportQueryState } from '../types'
-
-export interface ReportResult {
-  data: Record<string, any>[]
-  total: number
-}
-
-export interface ReportDataProvider {
-  fetch(reportDef: ReportDef, query: ReportQueryState): Promise<ReportResult>
-}

package/src/export/csv.ts

@@ -1,21 +0,0 @@
-import { exportCSV } from '@fayz-ai/core'
-import type { CSVColumn } from '@fayz-ai/core'
-import type { ReportColumnDef } from '../types'
-import { formatValuePlain } from '../lib/columns'
-
-export function exportToCsv(
-  columns: ReportColumnDef[],
-  data: Record<string, any>[],
-  filename: string,
-  currency?: string,
-): void {
-  const visibleCols = columns.filter((c) => c.visible !== false)
-
-  const csvColumns: CSVColumn[] = visibleCols.map((col) => ({
-    key: col.key,
-    label: col.label,
-    format: (value: any) => formatValuePlain(value, col, currency),
-  }))
-
-  exportCSV(csvColumns, data, filename)
-}

package/src/export/excel.ts

@@ -1,42 +0,0 @@
-import type { ReportColumnDef } from '../types'
-import { formatValuePlain } from '../lib/columns'
-
-// Opaque dynamic import — hidden from Vite's static analysis so it won't
-// fail when xlsx is not installed (it's an optional peer dependency).
-const load = (m: string) => new Function('m', 'return import(m)')(m) as Promise<any>
-
-export async function exportToExcel(
-  columns: ReportColumnDef[],
-  data: Record<string, any>[],
-  filename: string,
-  currency?: string,
-): Promise<void> {
-  const XLSX = await load('xlsx')
-  const visibleCols = columns.filter((c) => c.visible !== false)
-
-  const header = visibleCols.map((c) => c.label)
-  const rows = data.map((row) =>
-    visibleCols.map((col) => {
-      const value = row[col.key]
-      if (col.type === 'number' || col.type === 'currency') {
-        const num = typeof value === 'number' ? value : parseFloat(value)
-        return isNaN(num) ? '' : num
-      }
-      return formatValuePlain(value, col, currency)
-    }),
-  )
-
-  const ws = XLSX.utils.aoa_to_sheet([header, ...rows])
-  const wb = XLSX.utils.book_new()
-  XLSX.utils.book_append_sheet(wb, ws, 'Report')
-  XLSX.writeFile(wb, `${filename}.xlsx`)
-}
-
-export async function isExcelAvailable(): Promise<boolean> {
-  try {
-    await load('xlsx')
-    return true
-  } catch {
-    return false
-  }
-}

package/src/export/pdf.ts

@@ -1,47 +0,0 @@
-import type { ReportColumnDef } from '../types'
-import { formatValuePlain } from '../lib/columns'
-
-// Opaque dynamic import — hidden from Vite's static analysis so it won't
-// fail when jspdf is not installed (it's an optional peer dependency).
-const load = (m: string) => new Function('m', 'return import(m)')(m) as Promise<any>
-
-export async function exportToPdf(
-  columns: ReportColumnDef[],
-  data: Record<string, any>[],
-  filename: string,
-  options?: { title?: string; currency?: string },
-): Promise<void> {
-  const { default: jsPDF } = await load('jspdf')
-  await load('jspdf-autotable')
-
-  const visibleCols = columns.filter((c) => c.visible !== false)
-
-  const doc = new jsPDF({ orientation: visibleCols.length > 6 ? 'landscape' : 'portrait' })
-
-  if (options?.title) {
-    doc.setFontSize(14)
-    doc.text(options.title, 14, 20)
-  }
-
-  ;(doc as any).autoTable({
-    startY: options?.title ? 30 : 14,
-    head: [visibleCols.map((c) => c.label)],
-    body: data.map((row) =>
-      visibleCols.map((col) => formatValuePlain(row[col.key], col, options?.currency)),
-    ),
-    styles: { fontSize: 8 },
-    headStyles: { fillColor: [100, 100, 100] },
-  })
-
-  doc.save(`${filename}.pdf`)
-}
-
-export async function isPdfAvailable(): Promise<boolean> {
-  try {
-    await load('jspdf')
-    await load('jspdf-autotable')
-    return true
-  } catch {
-    return false
-  }
-}

package/src/hooks/useReportData.ts

@@ -1,123 +0,0 @@
-import { useState, useCallback, useRef } from 'react'
-import type { ReportDef, ReportQueryState, ReportDateRange } from '../types'
-import type { ReportDataProvider, ReportResult } from '../data/types'
-import { dedup } from '@fayz-ai/saas'
-
-function defaultDateRange(): ReportDateRange {
-  const now = new Date()
-  const from = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-01`
-  const to = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`
-  return { from, to }
-}
-
-function buildDefaultFilters(report: ReportDef): Record<string, any> {
-  const filters: Record<string, any> = {}
-  for (const f of report.filters ?? []) {
-    if (f.defaultValue !== undefined) filters[f.key] = f.defaultValue
-  }
-  return filters
-}
-
-export interface UseReportDataReturn {
-  data: Record<string, any>[]
-  total: number
-  loading: boolean
-  generated: boolean
-  error: string | null
-  query: ReportQueryState
-  generate: () => void
-  setDateRange: (range: ReportDateRange) => void
-  setFilter: (key: string, value: any) => void
-  setSort: (sortBy: string) => void
-  setPage: (page: number) => void
-  setPageSize: (size: number) => void
-  setSearch: (search: string) => void
-}
-
-export function useReportData(
-  report: ReportDef,
-  provider: ReportDataProvider,
-  defaultPageSize: number = 50,
-): UseReportDataReturn {
-  const [query, setQuery] = useState<ReportQueryState>({
-    dateRange: defaultDateRange(),
-    filters: buildDefaultFilters(report),
-    sortBy: report.dataSource.defaultSort,
-    sortDir: report.dataSource.defaultSortDir ?? 'desc',
-    page: 1,
-    pageSize: defaultPageSize,
-  })
-
-  const [result, setResult] = useState<ReportResult>({ data: [], total: 0 })
-  const [loading, setLoading] = useState(false)
-  const [generated, setGenerated] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const queryRef = useRef(query)
-  queryRef.current = query
-
-  const fetchData = useCallback(async (q: ReportQueryState) => {
-    setLoading(true)
-    setError(null)
-    try {
-      const res = await dedup(`report:${report.id}:${JSON.stringify(q)}`, () =>
-        provider.fetch(report, q),
-      )
-      setResult(res)
-      setGenerated(true)
-    } catch (err: any) {
-      setError(err?.message ?? 'Failed to load report')
-      setResult({ data: [], total: 0 })
-    } finally {
-      setLoading(false)
-    }
-  }, [report, provider])
-
-  const generate = useCallback(() => {
-    fetchData(queryRef.current)
-  }, [fetchData])
-
-  const setDateRange = useCallback((dateRange: ReportDateRange) => {
-    setQuery((q) => ({ ...q, dateRange, page: 1 }))
-  }, [])
-
-  const setFilter = useCallback((key: string, value: any) => {
-    setQuery((q) => ({ ...q, filters: { ...q.filters, [key]: value }, page: 1 }))
-  }, [])
-
-  const setSort = useCallback((sortBy: string) => {
-    setQuery((q) => ({
-      ...q,
-      sortBy,
-      sortDir: q.sortBy === sortBy && q.sortDir === 'asc' ? 'desc' : 'asc',
-      page: 1,
-    }))
-  }, [])
-
-  const setPage = useCallback((page: number) => {
-    setQuery((q) => ({ ...q, page }))
-  }, [])
-
-  const setPageSize = useCallback((pageSize: number) => {
-    setQuery((q) => ({ ...q, pageSize, page: 1 }))
-  }, [])
-
-  const setSearch = useCallback((search: string) => {
-    setQuery((q) => ({ ...q, search, page: 1 }))
-  }, [])
-
-  return {
-    data: result.data,
-    total: result.total,
-    loading,
-    generated,
-    error,
-    query,
-    generate,
-    setDateRange,
-    setFilter,
-    setSort,
-    setPage,
-    setPageSize,
-    setSearch,
-  }
-}

package/src/index.ts

@@ -1,142 +0,0 @@
-import React from 'react'
-import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
-import { createSafeDataProvider, registerTranslations } from '@fayz-ai/core'
-import { ReportsPage } from './ReportsPage'
-import type { ReportDataProvider } from './data/types'
-import { createSupabaseReportProvider } from './data/supabase'
-import { createMockReportProvider } from './data/mock'
-import { getReportsTenantId } from './lib/tenant'
-import { reportsLocales } from './locales'
-import type {
-  ReportsPluginOptions,
-  ReportsPluginLabels,
-  ResolvedReportsConfig,
-} from './types'
-
-// ---------------------------------------------------------------------------
-// Defaults
-// ---------------------------------------------------------------------------
-
-const DEFAULT_LABELS: ReportsPluginLabels = {
-  pageTitle: 'Reports',
-  pageSubtitle: 'Access complete reports for analysis and decision making',
-  allReports: 'All Reports',
-  dateRange: 'Date Range',
-  from: 'From',
-  to: 'To',
-  export: 'Export',
-  exportCsv: 'Export CSV',
-  exportExcel: 'Export Excel',
-  exportPdf: 'Export PDF',
-  noResults: 'No results found.',
-  backToReports: 'Back',
-  reports: 'reports',
-  search: 'Search reports...',
-  today: 'Today',
-  yesterday: 'Yesterday',
-  last7Days: 'Last 7 days',
-  thisMonth: 'This month',
-  lastMonth: 'Last month',
-  thisQuarter: 'This quarter',
-  custom: 'Custom',
-  generate: 'Generate',
-  print: 'Print',
-  filterFrom: 'From',
-  filterTo: 'To',
-  filterResults: 'Results',
-  emptyStateTitle: 'Ready to generate',
-  emptyStateDescription: 'Select a date range and filters, then click Generate to view the report.',
-  unavailableTitle: 'Coming soon',
-  unavailableDescription: 'This report is not available yet. It will be enabled in a future update.',
-}
-
-const DEFAULT_CURRENCY = { code: 'BRL', locale: 'pt-BR', symbol: 'R$' }
-
-// ---------------------------------------------------------------------------
-// Config resolver
-// ---------------------------------------------------------------------------
-
-function resolveConfig(options: ReportsPluginOptions): ResolvedReportsConfig {
-  return {
-    labels: { ...DEFAULT_LABELS, ...options.labels },
-    currency: { ...DEFAULT_CURRENCY, ...options.currency },
-    reports: options.reports,
-    defaultPageSize: options.defaultPageSize ?? 50,
-    showHeader: options.showHeader !== false,
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createReportsPlugin(options: ReportsPluginOptions): PluginManifest {
-  const config = resolveConfig(options)
-  registerTranslations(reportsLocales)
-  const provider: ReportDataProvider = options.dataProvider ?? createSafeDataProvider(
-    () => createSupabaseReportProvider({ tenantId: () => getReportsTenantId() }),
-    () => createMockReportProvider(),
-  )
-
-  const PageComponent: React.FC<any> = () =>
-    React.createElement(ReportsPage, { config, provider })
-
-  return {
-    id: 'reports',
-    name: config.labels.pageTitle,
-    icon: 'BarChart3',
-    version: '1.0.0',
-    scope: options.scope ?? 'universal',
-    verticalId: options.verticalId,
-    defaultEnabled: true,
-    dependencies: [],
-    declaredFeatures: [
-      { id: 'reports', label: config.labels.pageTitle, group: config.labels.pageTitle },
-    ],
-    navigation: [
-      {
-        section: options.navSection ?? 'main',
-        position: options.navPosition ?? 9,
-        label: config.labels.pageTitle,
-        route: '/reports',
-        icon: 'BarChart3',
-        permission: { feature: 'reports', action: 'read' as const },
-      },
-    ],
-    routes: [
-      {
-        path: '/reports',
-        component: PageComponent,
-        permission: { feature: 'reports', action: 'read' as const },
-      },
-    ],
-    widgets: [],
-    registries: [],
-    locales: reportsLocales,
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Re-exports
-// ---------------------------------------------------------------------------
-
-export type {
-  ReportDef,
-  ReportColumnDef,
-  ReportFilterDef,
-  ReportDateRange,
-  ReportQueryState,
-  ReportBadge,
-  ReportDataSource,
-  ReportGrain,
-  ReportAllowedAction,
-  ReportFilterOption,
-  ReportsPluginOptions,
-  ReportsPluginLabels,
-  ResolvedReportsConfig,
-} from './types'
-
-export type { ReportDataProvider, ReportResult } from './data/types'
-export { createSupabaseReportProvider } from './data/supabase'
-export type { SupabaseReportProviderConfig } from './data/supabase'
-export { createMockReportProvider } from './data/mock'