@fayz-ai/plugin-marketing 0.9.0-next.1 → 0.9.1

package/src/data/contentTypes.ts

@@ -1,138 +0,0 @@
-// ---------------------------------------------------------------------------
-// Content planner — domain types + provider seam. Deliberately separate from
-// MarketingDataProvider: analytics is mock-until-bridges, while the planner is
-// a real CRUD surface (Supabase-backed via createSafeDataProvider). The
-// interface must stay methods-only (the safe-provider Proxy turns every
-// property access into a call).
-// ---------------------------------------------------------------------------
-
-export type PostFormat = 'reel' | 'static' | 'carousel' | 'story' | 'video' | 'live' | 'article'
-
-/** Platforms an account can publish to. UI-driven list (the DB stores plain
- *  text[]), so growing it is a one-line change here. */
-export const PLATFORMS = [
-  'instagram',
-  'tiktok',
-  'youtube',
-  'facebook',
-  'linkedin',
-  'x',
-  'pinterest',
-  'threads',
-] as const
-export type Platform = (typeof PLATFORMS)[number]
-
-export type PostStatus = 'idea' | 'script' | 'recording' | 'editing' | 'scheduled' | 'published'
-
-export const POST_STATUS_ORDER: PostStatus[] = ['idea', 'script', 'recording', 'editing', 'scheduled', 'published']
-
-export interface SocialAccount {
-  id: string
-  name: string
-  handle?: string
-  /** Platforms this account/brand publishes to (one account, many connections). */
-  platforms: string[]
-  isActive: boolean
-}
-
-export interface ContentPlan {
-  id: string
-  accountId: string
-  name: string
-  status: 'draft' | 'active' | 'archived'
-  weeksCount: number
-  startDate?: string
-  /** Structured "what we want" config — feeds chips + future AI drafting. */
-  objective?: string
-  tone?: string
-  pillars: string[]
-  formats: PostFormat[]
-  weeklyFrequency: number
-  /** Free-form brief/strategy document (markdown). */
-  briefMd: string
-}
-
-/** Recording-day checklist item (on-set companion). */
-export interface ChecklistItem {
-  id: string
-  text: string
-  done: boolean
-}
-
-export interface ContentPost {
-  id: string
-  planId: string
-  weekNumber: number
-  position: number
-  title: string
-  format: PostFormat
-  status: PostStatus
-  scheduledDate?: string
-  /** Target platforms for this post; empty = inherit the account's platforms. */
-  platforms: string[]
-  /** Recording-day checklist — persisted as the crew checks items off. */
-  checklist: ChecklistItem[]
-  /** Uploaded asset URL (static posts: caption + final art instead of a script). */
-  mediaUrl?: string
-  hook?: string
-  cta?: string
-  /** The Notion-style page body — the script/plan in markdown. */
-  contentMd: string
-  updatedAt?: string
-}
-
-export interface SaveSocialAccountInput {
-  id?: string
-  name: string
-  handle?: string
-  platforms?: string[]
-  isActive?: boolean
-}
-
-export interface SaveContentPlanInput {
-  id?: string
-  accountId?: string
-  name?: string
-  status?: ContentPlan['status']
-  weeksCount?: number
-  startDate?: string | null
-  objective?: string
-  tone?: string
-  pillars?: string[]
-  formats?: PostFormat[]
-  weeklyFrequency?: number
-  briefMd?: string
-}
-
-export interface SaveContentPostInput {
-  id?: string
-  planId?: string
-  weekNumber?: number
-  position?: number
-  title?: string
-  format?: PostFormat
-  status?: PostStatus
-  scheduledDate?: string | null
-  platforms?: string[]
-  checklist?: ChecklistItem[]
-  mediaUrl?: string | null
-  hook?: string
-  cta?: string
-  contentMd?: string
-}
-
-export interface ContentPlannerProvider {
-  listAccounts(): Promise<SocialAccount[]>
-  saveAccount(input: SaveSocialAccountInput): Promise<SocialAccount>
-  /** Hard delete — plans and posts cascade with the account. */
-  deleteAccount(id: string): Promise<void>
-  listPlans(accountId: string): Promise<ContentPlan[]>
-  getPlan(id: string): Promise<ContentPlan | null>
-  savePlan(input: SaveContentPlanInput): Promise<ContentPlan>
-  deletePlan(id: string): Promise<void>
-  /** Ordered by week_number then position. */
-  listPosts(planId: string): Promise<ContentPost[]>
-  getPost(id: string): Promise<ContentPost | null>
-  savePost(input: SaveContentPostInput): Promise<ContentPost>
-  deletePost(id: string): Promise<void>
-}

package/src/data/mock.ts

@@ -1,308 +0,0 @@
-import type { MarketingDataProvider, SaveCampaignInput, SaveLandingPageInput } from './types'
-import type {
-  AcquisitionChannel,
-  AcquisitionChannelKind,
-  Campaign,
-  ChannelPerformance,
-  ConversionModel,
-  DateRangeKey,
-  FunnelStage,
-  LandingPage,
-  LandingPagePerf,
-  MarketingOverview,
-  MarketingQuery,
-  MarketingSite,
-} from '../types'
-import { CAMPAIGN_NAME_SEEDS, type MarketingDomain } from '../presets'
-
-// ---------------------------------------------------------------------------
-// Deterministic seed knobs (no Date.now at module init for stable analytics).
-// ---------------------------------------------------------------------------
-
-const RANGE_FACTOR: Record<DateRangeKey, number> = { '7d': 0.25, '30d': 1, '90d': 3.05 }
-const BASE_REACH = [4200, 3100, 2600, 1900, 1500, 1200, 1000]
-
-const KIND_LEAD_RATE: Record<AcquisitionChannelKind, number> = {
-  paid: 0.18, social: 0.22, organic: 0.14, referral: 0.3, direct: 0.1, outbound: 0.16,
-}
-const KIND_CONV_RATE: Record<AcquisitionChannelKind, number> = {
-  paid: 0.28, social: 0.25, organic: 0.32, referral: 0.45, direct: 0.22, outbound: 0.24,
-}
-const KIND_SPEND30: Record<AcquisitionChannelKind, number> = {
-  paid: 2800, social: 900, outbound: 600, organic: 0, referral: 0, direct: 0,
-}
-
-interface ChannelBase {
-  channelId: string
-  kind: AcquisitionChannelKind
-  reach: number
-  leads: number
-  conversions: number
-  spend: number
-  value: number
-}
-
-export interface MockMarketingConfig {
-  channels: AcquisitionChannel[]
-  conversion: ConversionModel
-  domain: MarketingDomain
-}
-
-function channelBase30(channels: AcquisitionChannel[], conversion: ConversionModel): ChannelBase[] {
-  return channels.map((ch, i) => {
-    const reach = BASE_REACH[i % BASE_REACH.length]
-    const leads = Math.round(reach * KIND_LEAD_RATE[ch.kind])
-    const conversions = Math.round(leads * KIND_CONV_RATE[ch.kind])
-    const spend = KIND_SPEND30[ch.kind]
-    const value = Math.round(conversions * conversion.avgValue)
-    return { channelId: ch.id, kind: ch.kind, reach, leads, conversions, spend, value }
-  })
-}
-
-function scale(n: number, range: DateRangeKey): number {
-  return Math.round(n * RANGE_FACTOR[range])
-}
-
-function toPerformance(base: ChannelBase, range: DateRangeKey): ChannelPerformance {
-  const reach = scale(base.reach, range)
-  const leads = scale(base.leads, range)
-  const conversions = scale(base.conversions, range)
-  const spend = scale(base.spend, range)
-  const value = scale(base.value, range)
-  return {
-    channelId: base.channelId,
-    reach, leads, conversions, spend, value,
-    cvr: reach > 0 ? (conversions / reach) * 100 : 0,
-    cpa: conversions > 0 && spend > 0 ? spend / conversions : 0,
-  }
-}
-
-function seedCampaigns(cfg: MockMarketingConfig): Campaign[] {
-  const names = CAMPAIGN_NAME_SEEDS[cfg.domain]
-  const base = channelBase30(cfg.channels, cfg.conversion)
-  const statuses: Campaign['status'][] = ['active', 'active', 'paused', 'ended', 'draft']
-  const startDays = [12, 26, 40, 8, 3]
-  const baseDate = new Date('2026-06-16T00:00:00Z').getTime()
-
-  return names.map((name, i) => {
-    const ch = cfg.channels[i % cfg.channels.length]
-    const b = base[i % base.length]
-    const status = statuses[i % statuses.length]
-    const draft = status === 'draft'
-    const start = new Date(baseDate - startDays[i % startDays.length] * 86_400_000).toISOString()
-    // Campaigns carry a slice of their channel's volume so totals stay plausible.
-    const share = 0.55 + (i % 3) * 0.12
-    return {
-      id: `cmp-${i + 1}`,
-      name,
-      channelId: ch.id,
-      status,
-      start,
-      end: status === 'ended' ? new Date(baseDate - 2 * 86_400_000).toISOString() : undefined,
-      spend: draft ? 0 : Math.round(b.spend * share),
-      reach: draft ? 0 : Math.round(b.reach * share),
-      leads: draft ? 0 : Math.round(b.leads * share),
-      conversions: draft ? 0 : Math.round(b.conversions * share),
-      value: draft ? 0 : Math.round(b.value * share),
-    }
-  })
-}
-
-function scaleCampaign(c: Campaign, range: DateRangeKey): Campaign {
-  if (c.status === 'draft') return c
-  return {
-    ...c,
-    spend: scale(c.spend, range),
-    reach: scale(c.reach, range),
-    leads: scale(c.leads, range),
-    conversions: scale(c.conversions, range),
-    value: scale(c.value, range),
-  }
-}
-
-const MOCK_SITE: MarketingSite = {
-  id: 'site-1',
-  name: 'Site principal',
-  url: 'https://exemplo.com.br',
-  appId: 'app-demo',
-}
-
-const MOCK_LEAD_TAGS = [
-  { slug: 'lp-consulta', name: 'LP Consulta' },
-  { slug: 'lp-promo', name: 'LP Promo' },
-]
-
-interface MockLandingPage extends LandingPage {
-  /** 30d baseline; scaled per range at read time. */
-  visits: number
-  conversions: number
-}
-
-function seedLandingPages(): MockLandingPage[] {
-  return [
-    { id: 'lp-1', siteId: MOCK_SITE.id, name: 'Consulta gratuita', route: '/consulta', leadTags: ['lp-consulta'], status: 'live', isActive: true, visits: 3820, conversions: 474 },
-    { id: 'lp-2', siteId: MOCK_SITE.id, name: 'Promo da estação', route: '/promo', leadTags: ['lp-promo'], status: 'live', isActive: true, visits: 1560, conversions: 126 },
-  ]
-}
-
-function normalizeRoute(route: string): string {
-  const trimmed = route.trim().replace(/\/+$/, '')
-  if (!trimmed || trimmed === '/') return '/'
-  return trimmed.startsWith('/') ? trimmed : `/${trimmed}`
-}
-
-export function createMockMarketingProvider(cfg: MockMarketingConfig): MarketingDataProvider {
-  const base = channelBase30(cfg.channels, cfg.conversion)
-  const campaigns = seedCampaigns(cfg)
-  const landing = seedLandingPages()
-  let counter = 100
-
-  async function channelPerformance(query: MarketingQuery): Promise<ChannelPerformance[]> {
-    const list = base.map((b) => toPerformance(b, query.range))
-    return query.channelId ? list.filter((c) => c.channelId === query.channelId) : list
-  }
-
-  return {
-    channelPerformance,
-
-    async overview(query: MarketingQuery): Promise<MarketingOverview> {
-      const perf = await channelPerformance(query)
-      const reach = perf.reduce((s, c) => s + c.reach, 0)
-      const conversions = perf.reduce((s, c) => s + c.conversions, 0)
-      const spend = perf.reduce((s, c) => s + c.spend, 0)
-      const value = perf.reduce((s, c) => s + c.value, 0)
-      const cvr = reach > 0 ? (conversions / reach) * 100 : 0
-      const top = [...perf].sort((a, b) => b.conversions - a.conversions)[0]
-      return {
-        conversions,
-        conversionsPrev: Math.round(conversions * 0.86),
-        cvr,
-        cvrPrev: cvr * 0.94,
-        spend,
-        cpa: conversions > 0 && spend > 0 ? spend / conversions : 0,
-        value,
-        topChannelId: top?.channelId ?? null,
-        channelMix: perf.map((c) => ({ channelId: c.channelId, conversions: c.conversions })),
-      }
-    },
-
-    async funnel(query: MarketingQuery): Promise<FunnelStage[]> {
-      const perf = await channelPerformance(query)
-      const reach = perf.reduce((s, c) => s + c.reach, 0)
-      const leads = perf.reduce((s, c) => s + c.leads, 0)
-      const conversions = perf.reduce((s, c) => s + c.conversions, 0)
-      const qualified = Math.round(leads * 0.62)
-      return [
-        { id: 'reach', label: 'Reach / visits', count: reach, color: '#6366f1' },
-        { id: 'leads', label: 'Leads', count: leads, color: '#0ea5e9' },
-        { id: 'qualified', label: 'Qualified', count: qualified, color: '#14b8a6' },
-        { id: 'converted', label: cfg.conversion.labelPlural, count: conversions, color: '#22c55e' },
-      ]
-    },
-
-    async listCampaigns(query: MarketingQuery): Promise<Campaign[]> {
-      const list = query.channelId ? campaigns.filter((c) => c.channelId === query.channelId) : campaigns
-      return list.map((c) => scaleCampaign(c, query.range))
-    },
-
-    async getCampaign(id: string): Promise<Campaign | null> {
-      return campaigns.find((c) => c.id === id) ?? null
-    },
-
-    async saveCampaign(input: SaveCampaignInput): Promise<Campaign> {
-      if (input.id) {
-        const existing = campaigns.find((c) => c.id === input.id)
-        if (existing) {
-          Object.assign(existing, {
-            name: input.name, channelId: input.channelId, status: input.status,
-            start: input.start, end: input.end, spend: input.spend,
-          })
-          return existing
-        }
-      }
-      const b = base.find((x) => x.channelId === input.channelId) ?? base[0]
-      const active = input.status === 'active'
-      const created: Campaign = {
-        id: `cmp-${++counter}`,
-        name: input.name,
-        channelId: input.channelId,
-        status: input.status,
-        start: input.start,
-        end: input.end,
-        spend: input.spend,
-        // New campaigns ramp from a small slice of their channel's volume.
-        reach: active ? Math.round(b.reach * 0.15) : 0,
-        leads: active ? Math.round(b.leads * 0.15) : 0,
-        conversions: active ? Math.round(b.conversions * 0.15) : 0,
-        value: active ? Math.round(b.value * 0.15) : 0,
-      }
-      campaigns.unshift(created)
-      return created
-    },
-
-    async deleteCampaign(id: string): Promise<void> {
-      const idx = campaigns.findIndex((c) => c.id === id)
-      if (idx >= 0) campaigns.splice(idx, 1)
-    },
-
-    async landingPages(query: MarketingQuery): Promise<LandingPagePerf[]> {
-      return landing.map((p) => {
-        const visits = scale(p.visits, query.range)
-        const conversions = scale(p.conversions, query.range)
-        return {
-          ...p,
-          siteName: MOCK_SITE.name,
-          siteUrl: MOCK_SITE.url,
-          appId: MOCK_SITE.appId,
-          editorUrl: MOCK_SITE.editorUrl,
-          url: `${MOCK_SITE.url}${p.route}`,
-          visits,
-          conversions,
-          cvr: visits > 0 ? (conversions / visits) * 100 : null,
-        }
-      })
-    },
-
-    async saveLandingPage(input: SaveLandingPageInput): Promise<LandingPage> {
-      const route = normalizeRoute(input.route)
-      const existing = input.id ? landing.find((p) => p.id === input.id) : undefined
-      if (existing) {
-        Object.assign(existing, {
-          siteId: input.siteId, name: input.name, route,
-          leadTags: input.leadTags ?? existing.leadTags,
-          status: input.status ?? existing.status,
-          prompt: input.prompt,
-          isActive: input.isActive ?? existing.isActive,
-        })
-        return existing
-      }
-      const created: MockLandingPage = {
-        id: `lp-${++counter}`,
-        siteId: input.siteId,
-        name: input.name,
-        route,
-        leadTags: input.leadTags ?? [],
-        status: input.status ?? 'live',
-        prompt: input.prompt,
-        isActive: input.isActive ?? true,
-        visits: 0,
-        conversions: 0,
-      }
-      landing.push(created)
-      return created
-    },
-
-    async deleteLandingPage(id: string): Promise<void> {
-      const idx = landing.findIndex((p) => p.id === id)
-      if (idx >= 0) landing.splice(idx, 1)
-    },
-
-    async listSites(): Promise<MarketingSite[]> {
-      return [MOCK_SITE]
-    },
-
-    async listLeadTags(): Promise<Array<{ slug: string; name: string }>> {
-      return MOCK_LEAD_TAGS
-    },
-  }
-}