@fayz-ai/plugin-marketing 0.2.0 → 0.8.0

package/src/data/contentMock.ts

@@ -0,0 +1,253 @@
+import type {
+  ContentPlan,
+  ContentPlannerProvider,
+  ContentPost,
+  SocialAccount,
+} from './contentTypes'
+
+// ---------------------------------------------------------------------------
+// Mock content-planner provider — in-memory CRUD seeded with a realistic
+// 8-week clinic plan (2 reels + 1 static per week) so the surface demos well
+// without Supabase. Same shape the beauty seed uses in production.
+// ---------------------------------------------------------------------------
+
+let counter = 0
+const nextId = (prefix: string) => `${prefix}-${++counter}`
+
+const SAMPLE_SCRIPT = `# 5 sinais de que sua queda capilar não é normal
+
+**TEMA:** 5 SINAIS DE QUE SUA QUEDA CAPILAR NÃO É NORMAL
+**Formato:** Reel · **Duração:** 45 a 60 segundos
+
+---
+
+## TAKE 1 – GANCHO (0s a 5s)
+
+*Dra. andando até a câmera.*
+
+**Texto na tela:** ⚠️ 5 sinais de alerta
+
+**Fala:** "Seu cabelo está caindo e você não sabe se isso é normal? Existem sinais que merecem atenção."
+
+---
+
+## TAKE 2 – SINAL 1 (5s a 12s)
+
+*Mostrar a Dra. segurando alguns fios de cabelo ou imagem ilustrativa.*
+
+**Texto na tela:** Excesso de fios caindo.
+
+**Fala:** "Primeiro sinal: você percebe muitos fios no travesseiro, no banho ou ao pentear os cabelos."
+
+---
+
+## TAKE 3 – CTA (40s a 60s)
+
+**Fala:** "Se você se identificou com algum desses sinais, agende uma avaliação capilar."
+
+**CTA:** Agende sua avaliação
+`
+
+const WEEK_TITLES: Array<[string, string]> = [
+  ['5 sinais de que sua queda capilar não é normal', 'Antes e depois de tratamento capilar'],
+  ['O que é DHT?', 'Tour pela clínica'],
+  ['3 erros que aceleram a calvície', 'Depoimento de paciente'],
+  ['Como funciona uma avaliação capilar', 'Mitos sobre queda de cabelo'],
+  ['Por que seu tratamento anterior não funcionou?', 'Ozonioterapia para gordura localizada'],
+  ['Diferença entre dermatologista e tricologista', 'Caso real de evolução'],
+  ['Alopecia feminina explicada', 'Bastidores da clínica'],
+  ['Quando procurar ajuda para queda capilar', 'Convite para avaliação gratuita'],
+]
+
+function buildSeed() {
+  const account: SocialAccount = {
+    id: nextId('acc'),
+    name: 'Conta demo',
+    handle: '@clinica.demo',
+    platforms: ['instagram'],
+    isActive: true,
+  }
+  const plan: ContentPlan = {
+    id: nextId('plan'),
+    accountId: account.id,
+    name: 'Plano de conteúdo — 8 semanas',
+    status: 'active',
+    weeksCount: 8,
+    objective: 'Atrair pacientes qualificados para avaliação capilar',
+    tone: 'Autoridade acessível — técnica, mas em linguagem simples',
+    pillars: ['Educação', 'Autoridade', 'Prova social', 'Bastidores', 'Conversão'],
+    formats: ['reel', 'static'],
+    weeklyFrequency: 3,
+    briefMd: '## Objetivo\n\nPosicionar a especialista como referência em saúde capilar e gerar agendamentos de avaliação.\n\n## Estratégia\n\n- 2 reels educativos/prova social por semana\n- 1 post estático por semana\n- CTA recorrente: agendar avaliação',
+  }
+  const posts: ContentPost[] = []
+  WEEK_TITLES.forEach(([reel1, reel2], i) => {
+    const week = i + 1
+    posts.push(
+      {
+        id: nextId('post'), planId: plan.id, weekNumber: week, position: 0,
+        title: reel1, format: 'reel', status: week === 1 ? 'script' : 'idea',
+        platforms: [], checklist: [], contentMd: week === 1 ? SAMPLE_SCRIPT : '',
+      },
+      {
+        id: nextId('post'), planId: plan.id, weekNumber: week, position: 1,
+        title: reel2, format: 'reel', status: 'idea', platforms: [], checklist: [], contentMd: '',
+      },
+      {
+        id: nextId('post'), planId: plan.id, weekNumber: week, position: 2,
+        title: 'Estático', format: 'static', status: 'idea', platforms: [], checklist: [], contentMd: '',
+      },
+    )
+  })
+  return { accounts: [account], plans: [plan], posts }
+}
+
+export function createMockContentPlannerProvider(): ContentPlannerProvider {
+  const db = buildSeed()
+
+  return {
+    async listAccounts() {
+      return [...db.accounts]
+    },
+
+    async saveAccount(input) {
+      if (input.id) {
+        const acc = db.accounts.find((a) => a.id === input.id)
+        if (!acc) throw new Error('Account not found')
+        Object.assign(acc, {
+          name: input.name ?? acc.name,
+          handle: input.handle ?? acc.handle,
+          platforms: input.platforms ?? acc.platforms,
+          isActive: input.isActive ?? acc.isActive,
+        })
+        return { ...acc }
+      }
+      const acc: SocialAccount = {
+        id: nextId('acc'),
+        name: input.name,
+        handle: input.handle,
+        platforms: input.platforms ?? ['instagram'],
+        isActive: input.isActive ?? true,
+      }
+      db.accounts.push(acc)
+      return { ...acc }
+    },
+
+    async deleteAccount(id) {
+      db.accounts = db.accounts.filter((a) => a.id !== id)
+      const planIds = new Set(db.plans.filter((p) => p.accountId === id).map((p) => p.id))
+      db.plans = db.plans.filter((p) => p.accountId !== id)
+      db.posts = db.posts.filter((p) => !planIds.has(p.planId))
+    },
+
+    async listPlans(accountId) {
+      return db.plans.filter((p) => p.accountId === accountId).map((p) => ({ ...p }))
+    },
+
+    async getPlan(id) {
+      const plan = db.plans.find((p) => p.id === id)
+      return plan ? { ...plan } : null
+    },
+
+    async savePlan(input) {
+      if (input.id) {
+        const plan = db.plans.find((p) => p.id === input.id)
+        if (!plan) throw new Error('Plan not found')
+        Object.assign(plan, {
+          ...(input.name !== undefined && { name: input.name }),
+          ...(input.status !== undefined && { status: input.status }),
+          ...(input.weeksCount !== undefined && { weeksCount: input.weeksCount }),
+          ...(input.startDate !== undefined && { startDate: input.startDate ?? undefined }),
+          ...(input.objective !== undefined && { objective: input.objective }),
+          ...(input.tone !== undefined && { tone: input.tone }),
+          ...(input.pillars !== undefined && { pillars: input.pillars }),
+          ...(input.formats !== undefined && { formats: input.formats }),
+          ...(input.weeklyFrequency !== undefined && { weeklyFrequency: input.weeklyFrequency }),
+          ...(input.briefMd !== undefined && { briefMd: input.briefMd }),
+        })
+        return { ...plan }
+      }
+      if (!input.accountId) throw new Error('accountId is required')
+      const plan: ContentPlan = {
+        id: nextId('plan'),
+        accountId: input.accountId,
+        name: input.name ?? 'Novo plano',
+        status: input.status ?? 'draft',
+        weeksCount: input.weeksCount ?? 4,
+        startDate: input.startDate ?? undefined,
+        objective: input.objective,
+        tone: input.tone,
+        pillars: input.pillars ?? [],
+        formats: input.formats ?? ['reel', 'static'],
+        weeklyFrequency: input.weeklyFrequency ?? 3,
+        briefMd: input.briefMd ?? '',
+      }
+      db.plans.push(plan)
+      return { ...plan }
+    },
+
+    async deletePlan(id) {
+      db.plans = db.plans.filter((p) => p.id !== id)
+      db.posts = db.posts.filter((p) => p.planId !== id)
+    },
+
+    async listPosts(planId) {
+      return db.posts
+        .filter((p) => p.planId === planId)
+        .sort((a, b) => a.weekNumber - b.weekNumber || a.position - b.position)
+        .map((p) => ({ ...p }))
+    },
+
+    async getPost(id) {
+      const post = db.posts.find((p) => p.id === id)
+      return post ? { ...post } : null
+    },
+
+    async savePost(input) {
+      if (input.id) {
+        const post = db.posts.find((p) => p.id === input.id)
+        if (!post) throw new Error('Post not found')
+        Object.assign(post, {
+          ...(input.weekNumber !== undefined && { weekNumber: input.weekNumber }),
+          ...(input.position !== undefined && { position: input.position }),
+          ...(input.title !== undefined && { title: input.title }),
+          ...(input.format !== undefined && { format: input.format }),
+          ...(input.status !== undefined && { status: input.status }),
+          ...(input.scheduledDate !== undefined && { scheduledDate: input.scheduledDate ?? undefined }),
+          ...(input.platforms !== undefined && { platforms: input.platforms }),
+          ...(input.checklist !== undefined && { checklist: input.checklist }),
+          ...(input.mediaUrl !== undefined && { mediaUrl: input.mediaUrl ?? undefined }),
+          ...(input.hook !== undefined && { hook: input.hook }),
+          ...(input.cta !== undefined && { cta: input.cta }),
+          ...(input.contentMd !== undefined && { contentMd: input.contentMd }),
+        })
+        return { ...post }
+      }
+      if (!input.planId) throw new Error('planId is required')
+      const week = input.weekNumber ?? 1
+      const siblings = db.posts.filter((p) => p.planId === input.planId && p.weekNumber === week)
+      const post: ContentPost = {
+        id: nextId('post'),
+        planId: input.planId,
+        weekNumber: week,
+        position: input.position ?? siblings.length,
+        title: input.title ?? '',
+        format: input.format ?? 'reel',
+        status: input.status ?? 'idea',
+        scheduledDate: input.scheduledDate ?? undefined,
+        platforms: input.platforms ?? [],
+        checklist: input.checklist ?? [],
+        mediaUrl: input.mediaUrl ?? undefined,
+        hook: input.hook,
+        cta: input.cta,
+        contentMd: input.contentMd ?? '',
+      }
+      db.posts.push(post)
+      return { ...post }
+    },
+
+    async deletePost(id) {
+      db.posts = db.posts.filter((p) => p.id !== id)
+    },
+  }
+}

package/src/data/contentSupabase.ts

@@ -0,0 +1,263 @@
+import { getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core'
+import type {
+  ContentPlan,
+  ContentPlannerProvider,
+  ContentPost,
+  SocialAccount,
+} from './contentTypes'
+import { T } from './tables'
+
+// ---------------------------------------------------------------------------
+// Supabase content-planner provider. Tables: plg_marketing_social_accounts,
+// plg_marketing_content_plans, plg_marketing_content_posts (see src/migrations/001_content_planner.sql).
+// RLS scopes rows to the user's tenants; we still filter tenant_id explicitly
+// on reads so multi-tenant sessions see only the active tenant.
+// ---------------------------------------------------------------------------
+
+function getClient() {
+  const supabase = getSupabaseClientOptional() as any
+  if (!supabase) throw new Error('Supabase not initialized')
+  return supabase
+}
+
+function requireTenantId(): string {
+  const tenantId = getActiveTenantId()
+  if (!tenantId) throw new Error('No active tenant')
+  return tenantId
+}
+
+function snakeToCamel(obj: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(obj)) {
+    result[key.replace(/_([a-z])/g, (_, c) => c.toUpperCase())] = value ?? undefined
+  }
+  return result
+}
+
+function toAccount(row: Record<string, unknown>): SocialAccount {
+  const account = snakeToCamel(row) as unknown as SocialAccount
+  if (!Array.isArray(account.platforms)) account.platforms = []
+  return account
+}
+
+function toPlan(row: Record<string, unknown>): ContentPlan {
+  const plan = snakeToCamel(row) as unknown as ContentPlan
+  if (!Array.isArray(plan.pillars)) plan.pillars = []
+  if (!Array.isArray(plan.formats)) plan.formats = []
+  plan.briefMd = plan.briefMd ?? ''
+  return plan
+}
+
+function toPost(row: Record<string, unknown>): ContentPost {
+  const post = snakeToCamel(row) as unknown as ContentPost
+  post.contentMd = post.contentMd ?? ''
+  if (!Array.isArray(post.platforms)) post.platforms = []
+  if (!Array.isArray(post.checklist)) post.checklist = []
+  return post
+}
+
+export function createSupabaseContentPlannerProvider(): ContentPlannerProvider {
+  return {
+    async listAccounts() {
+      const tenantId = getActiveTenantId()
+      if (!tenantId) return []
+      const { data } = await getClient()
+        .from(T.socialAccounts)
+        .select('*')
+        .eq('tenant_id', tenantId)
+        .eq('is_active', true)
+        .order('created_at', { ascending: true })
+      return (data ?? []).map(toAccount)
+    },
+
+    async saveAccount(input) {
+      if (input.id) {
+        const payload: Record<string, unknown> = {}
+        if (input.name !== undefined) payload.name = input.name
+        if (input.handle !== undefined) payload.handle = input.handle
+        if (input.platforms !== undefined) payload.platforms = input.platforms
+        if (input.isActive !== undefined) payload.is_active = input.isActive
+        const { data, error } = await getClient()
+          .from(T.socialAccounts)
+          .update(payload)
+          .eq('id', input.id)
+          .select('*')
+          .single()
+        if (error) throw error
+        return toAccount(data)
+      }
+      const { data, error } = await getClient()
+        .from(T.socialAccounts)
+        .insert({
+          tenant_id: requireTenantId(),
+          name: input.name,
+          handle: input.handle ?? null,
+          platforms: input.platforms ?? ['instagram'],
+          is_active: input.isActive ?? true,
+        })
+        .select('*')
+        .single()
+      if (error) throw error
+      return toAccount(data)
+    },
+
+    async deleteAccount(id) {
+      const { error } = await getClient().from(T.socialAccounts).delete().eq('id', id)
+      if (error) throw error
+    },
+
+    async listPlans(accountId) {
+      const tenantId = getActiveTenantId()
+      if (!tenantId) return []
+      const { data } = await getClient()
+        .from(T.contentPlans)
+        .select('*')
+        .eq('tenant_id', tenantId)
+        .eq('account_id', accountId)
+        .order('created_at', { ascending: false })
+      return (data ?? []).map(toPlan)
+    },
+
+    async getPlan(id) {
+      const { data } = await getClient()
+        .from(T.contentPlans)
+        .select('*')
+        .eq('id', id)
+        .maybeSingle()
+      return data ? toPlan(data) : null
+    },
+
+    async savePlan(input) {
+      if (input.id) {
+        const payload: Record<string, unknown> = { updated_at: new Date().toISOString() }
+        if (input.name !== undefined) payload.name = input.name
+        if (input.status !== undefined) payload.status = input.status
+        if (input.weeksCount !== undefined) payload.weeks_count = input.weeksCount
+        if (input.startDate !== undefined) payload.start_date = input.startDate
+        if (input.objective !== undefined) payload.objective = input.objective
+        if (input.tone !== undefined) payload.tone = input.tone
+        if (input.pillars !== undefined) payload.pillars = input.pillars
+        if (input.formats !== undefined) payload.formats = input.formats
+        if (input.weeklyFrequency !== undefined) payload.weekly_frequency = input.weeklyFrequency
+        if (input.briefMd !== undefined) payload.brief_md = input.briefMd
+        const { data, error } = await getClient()
+          .from(T.contentPlans)
+          .update(payload)
+          .eq('id', input.id)
+          .select('*')
+          .single()
+        if (error) throw error
+        return toPlan(data)
+      }
+      if (!input.accountId) throw new Error('accountId is required')
+      const { data, error } = await getClient()
+        .from(T.contentPlans)
+        .insert({
+          tenant_id: requireTenantId(),
+          account_id: input.accountId,
+          name: input.name ?? 'Novo plano',
+          status: input.status ?? 'draft',
+          weeks_count: input.weeksCount ?? 4,
+          start_date: input.startDate ?? null,
+          objective: input.objective ?? null,
+          tone: input.tone ?? null,
+          pillars: input.pillars ?? [],
+          formats: input.formats ?? ['reel', 'static'],
+          weekly_frequency: input.weeklyFrequency ?? 3,
+          brief_md: input.briefMd ?? '',
+        })
+        .select('*')
+        .single()
+      if (error) throw error
+      return toPlan(data)
+    },
+
+    async deletePlan(id) {
+      await getClient().from(T.contentPlans).delete().eq('id', id)
+    },
+
+    async listPosts(planId) {
+      const { data } = await getClient()
+        .from(T.contentPosts)
+        .select('*')
+        .eq('plan_id', planId)
+        .order('week_number', { ascending: true })
+        .order('position', { ascending: true })
+      return (data ?? []).map(toPost)
+    },
+
+    async getPost(id) {
+      const { data } = await getClient()
+        .from(T.contentPosts)
+        .select('*')
+        .eq('id', id)
+        .maybeSingle()
+      return data ? toPost(data) : null
+    },
+
+    async savePost(input) {
+      if (input.id) {
+        const payload: Record<string, unknown> = { updated_at: new Date().toISOString() }
+        if (input.weekNumber !== undefined) payload.week_number = input.weekNumber
+        if (input.position !== undefined) payload.position = input.position
+        if (input.title !== undefined) payload.title = input.title
+        if (input.format !== undefined) payload.format = input.format
+        if (input.status !== undefined) payload.status = input.status
+        if (input.scheduledDate !== undefined) payload.scheduled_date = input.scheduledDate
+        if (input.platforms !== undefined) payload.platforms = input.platforms
+        if (input.checklist !== undefined) payload.checklist = input.checklist
+        if (input.mediaUrl !== undefined) payload.media_url = input.mediaUrl
+        if (input.hook !== undefined) payload.hook = input.hook
+        if (input.cta !== undefined) payload.cta = input.cta
+        if (input.contentMd !== undefined) payload.content_md = input.contentMd
+        const { data, error } = await getClient()
+          .from(T.contentPosts)
+          .update(payload)
+          .eq('id', input.id)
+          .select('*')
+          .single()
+        if (error) throw error
+        return toPost(data)
+      }
+      if (!input.planId) throw new Error('planId is required')
+      const week = input.weekNumber ?? 1
+
+      // Next position within the (plan, week) group.
+      const { data: maxData } = await getClient()
+        .from(T.contentPosts)
+        .select('position')
+        .eq('plan_id', input.planId)
+        .eq('week_number', week)
+        .order('position', { ascending: false })
+        .limit(1)
+      const maxPos = maxData?.[0]?.position ?? -1
+
+      const { data, error } = await getClient()
+        .from(T.contentPosts)
+        .insert({
+          tenant_id: requireTenantId(),
+          plan_id: input.planId,
+          week_number: week,
+          position: input.position ?? maxPos + 1,
+          title: input.title ?? '',
+          format: input.format ?? 'reel',
+          status: input.status ?? 'idea',
+          scheduled_date: input.scheduledDate ?? null,
+          platforms: input.platforms ?? [],
+          checklist: input.checklist ?? [],
+          media_url: input.mediaUrl ?? null,
+          hook: input.hook ?? null,
+          cta: input.cta ?? null,
+          content_md: input.contentMd ?? '',
+        })
+        .select('*')
+        .single()
+      if (error) throw error
+      return toPost(data)
+    },
+
+    async deletePost(id) {
+      await getClient().from(T.contentPosts).delete().eq('id', id)
+    },
+  }
+}

package/src/data/contentTypes.ts

@@ -0,0 +1,138 @@
+// ---------------------------------------------------------------------------
+// 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/tables.ts

@@ -0,0 +1,7 @@
+// Physical table names for the marketing plugin (plg_marketing_* prefix). Import T
+// and reference T.<key> in the data providers so a rename lands in one place.
+export const T = {
+  socialAccounts: 'plg_marketing_social_accounts',
+  contentPlans: 'plg_marketing_content_plans',
+  contentPosts: 'plg_marketing_content_posts',
+} as const