@fayz-ai/plugin-marketing 0.2.1 → 0.8.1

package/src/integrations/ranklayer/connectorDef.tsx

@@ -0,0 +1,98 @@
+// RankLayer as a unified ConnectorDefinition, surfaced in Marketing → settings
+// → Integrações (rendered by the shared ConnectorsHub). SCAFFOLD: the hub gives
+// us the API-key form + Test/Save; the ExtraPanel below explains that automated
+// SEO content sync is being prepared. The real sync lands via an external PR —
+// see ./RANKLAYER.md.
+import React, { useEffect, useState } from 'react'
+import { Sparkles, History, CheckCircle2, AlertCircle } from 'lucide-react'
+import type { ConnectorDefinition } from '@fayz-ai/core'
+import { createRankLayerProvider } from './data/supabase'
+import type { RankLayerIntegration, RankLayerSyncLogEntry } from './types'
+
+const provider = createRankLayerProvider()
+
+function RankLayerExtraPanel() {
+  const [integration, setIntegration] = useState<RankLayerIntegration | null>(null)
+  const [log, setLog] = useState<RankLayerSyncLogEntry[]>([])
+  const [loaded, setLoaded] = useState(false)
+
+  useEffect(() => {
+    let cancelled = false
+    ;(async () => {
+      try {
+        const found = await provider.getIntegration()
+        if (cancelled) return
+        setIntegration(found)
+        if (found) setLog(await provider.getSyncLog(found.id))
+      } catch {
+        /* not connected / no client — nothing to show */
+      } finally {
+        if (!cancelled) setLoaded(true)
+      }
+    })()
+    return () => { cancelled = true }
+  }, [])
+
+  if (!loaded || !integration) return null // nothing until the connection is saved
+
+  return (
+    <div className="space-y-4 border-t pt-4">
+      <div className="flex items-start gap-3 rounded-md border border-dashed p-3">
+        <Sparkles className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
+        <div className="space-y-1">
+          <h4 className="text-sm font-semibold">Sincronização de conteúdo — em breve</h4>
+          <p className="text-xs text-muted-foreground">
+            A publicação automática de páginas e artigos de SEO com a RankLayer está em preparação.
+            {integration.siteDomain ? ` Domínio configurado: ${integration.siteDomain}.` : ''} Assim que a
+            integração estiver ativa, o histórico de sincronizações aparece aqui.
+          </p>
+        </div>
+      </div>
+
+      {log.length > 0 && (
+        <div className="space-y-2">
+          <div className="flex items-center gap-2">
+            <History className="h-4 w-4 text-muted-foreground" />
+            <h4 className="text-sm font-semibold">Histórico</h4>
+          </div>
+          <div className="divide-y rounded-md border text-sm">
+            {log.map((r) => (
+              <div key={r.id} className="flex items-center gap-3 px-3 py-2">
+                <span className="text-xs text-muted-foreground">{new Date(r.createdAt).toLocaleString('pt-BR')}</span>
+                <span className="ml-auto text-xs">{r.written}/{r.fetched} publicadas</span>
+                {r.status === 'success'
+                  ? <CheckCircle2 className="h-3.5 w-3.5 text-success" />
+                  : <AlertCircle className="h-3.5 w-3.5 text-warning" />}
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export const ranklayerConnectorDef: ConnectorDefinition = {
+  id: 'ranklayer',
+  hostPluginId: 'marketing',
+  name: 'RankLayer',
+  description: 'Publicação de conteúdo e páginas de SEO por serviço/bairro para ser encontrado no Google e em assistentes de IA.',
+  icon: 'Search',
+  authKind: 'api-key',
+  fields: [
+    { key: 'apiKey', label: 'API Key', type: 'password', placeholder: '••••••••' },
+    { key: 'siteDomain', label: 'Domínio do site', type: 'text', placeholder: 'exemplo.com.br' },
+  ],
+  async getStatus() {
+    try {
+      const found = await provider.getIntegration()
+      return { connected: !!found?.apiKey, detail: found?.siteDomain }
+    } catch {
+      return { connected: false }
+    }
+  },
+  testConnection: (values) => provider.testConnection({ apiKey: values.apiKey }),
+  saveConnection: async (values) => { await provider.saveIntegration({ apiKey: values.apiKey, siteDomain: values.siteDomain }) },
+  disconnect: () => provider.disconnect(),
+  ExtraPanel: RankLayerExtraPanel,
+}

package/src/integrations/ranklayer/data/supabase.ts

@@ -0,0 +1,106 @@
+import { getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core'
+import type { TestConnectionResult } from '@fayz-ai/core'
+import type { RankLayerIntegration, RankLayerSyncLogEntry } from '../types'
+
+// ---------------------------------------------------------------------------
+// RankLayer connector — control-plane client (SCAFFOLD).
+//
+// Reads/writes the connection row (plg_marketing_ranklayer_integrations) and
+// reads the sync log. `testConnection` and `sync` are stubbed: RankLayer has no
+// public API wired yet, so the real work (an edge function calling RankLayer)
+// lands via an external PR — see ../RANKLAYER.md. Everything here is safe to
+// ship: it only persists the tenant's API key + domain and surfaces status.
+// ---------------------------------------------------------------------------
+
+const INTEGRATIONS = 'plg_marketing_ranklayer_integrations'
+const SYNC_LOG = 'plg_marketing_ranklayer_sync_log'
+
+function getClient() {
+  const supabase = getSupabaseClientOptional() as { from: (t: string) => any } | null
+  if (!supabase) throw new Error('[ranklayer] Supabase not initialized')
+  return supabase
+}
+
+function requireTenantId(): string {
+  const tenantId = getActiveTenantId()
+  if (!tenantId) throw new Error('[ranklayer] No active tenant')
+  return tenantId
+}
+
+function toIntegration(row: Record<string, any>): RankLayerIntegration {
+  return {
+    id: row.id,
+    apiKey: row.api_key ?? undefined,
+    siteDomain: row.site_domain ?? undefined,
+    active: row.active ?? true,
+    lastSyncAt: row.last_sync_at ?? undefined,
+  }
+}
+
+export function createRankLayerProvider() {
+  return {
+    async getIntegration(): Promise<RankLayerIntegration | null> {
+      const tenantId = getActiveTenantId()
+      if (!tenantId) return null
+      const { data } = await getClient()
+        .from(INTEGRATIONS)
+        .select('*')
+        .eq('tenant_id', tenantId)
+        .maybeSingle()
+      return data ? toIntegration(data) : null
+    },
+
+    async saveIntegration(values: { apiKey: string; siteDomain?: string }): Promise<RankLayerIntegration> {
+      const tenantId = requireTenantId()
+      const payload = {
+        tenant_id: tenantId,
+        api_key: values.apiKey,
+        site_domain: values.siteDomain ?? null,
+        active: true,
+        updated_at: new Date().toISOString(),
+      }
+      // Upsert on the unique tenant_id.
+      const { data, error } = await getClient()
+        .from(INTEGRATIONS)
+        .upsert(payload, { onConflict: 'tenant_id' })
+        .select('*')
+        .single()
+      if (error) throw error
+      return toIntegration(data)
+    },
+
+    async disconnect(): Promise<void> {
+      const tenantId = getActiveTenantId()
+      if (!tenantId) return
+      await getClient().from(INTEGRATIONS).delete().eq('tenant_id', tenantId)
+    },
+
+    // SCAFFOLD: no RankLayer API yet — accept any non-empty key so the connect
+    // flow can be exercised. Replace with a real credential check in the PR.
+    async testConnection(values: { apiKey: string }): Promise<TestConnectionResult> {
+      if (!values.apiKey || values.apiKey.trim().length < 8) {
+        return { ok: false, message: 'Informe uma API Key válida da RankLayer.' }
+      }
+      return { ok: true, message: 'Chave aceita (validação real pendente — integração em preparação).' }
+    },
+
+    async getSyncLog(integrationId: string): Promise<RankLayerSyncLogEntry[]> {
+      const { data } = await getClient()
+        .from(SYNC_LOG)
+        .select('*')
+        .eq('integration_id', integrationId)
+        .order('created_at', { ascending: false })
+        .limit(20)
+      return (data ?? []).map((r: Record<string, any>) => ({
+        id: r.id,
+        createdAt: r.created_at,
+        status: r.status,
+        message: r.message ?? undefined,
+        fetched: r.fetched ?? 0,
+        written: r.written ?? 0,
+      }))
+    },
+  }
+}
+
+export type RankLayerProvider = ReturnType<typeof createRankLayerProvider>

package/src/integrations/ranklayer/types.ts

@@ -0,0 +1,16 @@
+export interface RankLayerIntegration {
+  id: string
+  apiKey?: string
+  siteDomain?: string
+  active: boolean
+  lastSyncAt?: string
+}
+
+export interface RankLayerSyncLogEntry {
+  id: string
+  createdAt: string
+  status: 'success' | 'partial' | 'error'
+  message?: string
+  fetched: number
+  written: number
+}

package/src/migrations/000_plg_rename.sql

@@ -0,0 +1,15 @@
+-- 000_plg_rename.sql — rename legacy marketing tables to plg_marketing_* for pools
+-- provisioned before the industry-pool rename. Guarded: fires only when legacy
+-- name exists and target does not, so fresh pools skip every branch.
+DO $$
+BEGIN
+  IF to_regclass('public.mkt_social_accounts') IS NOT NULL AND to_regclass('public.plg_marketing_social_accounts') IS NULL THEN
+    ALTER TABLE public.mkt_social_accounts RENAME TO plg_marketing_social_accounts;
+  END IF;
+  IF to_regclass('public.mkt_content_plans') IS NOT NULL AND to_regclass('public.plg_marketing_content_plans') IS NULL THEN
+    ALTER TABLE public.mkt_content_plans RENAME TO plg_marketing_content_plans;
+  END IF;
+  IF to_regclass('public.mkt_content_posts') IS NOT NULL AND to_regclass('public.plg_marketing_content_posts') IS NULL THEN
+    ALTER TABLE public.mkt_content_posts RENAME TO plg_marketing_content_posts;
+  END IF;
+END $$;

package/src/migrations/001_content_planner.sql

@@ -1,10 +1,10 @@
 -- Marketing Plugin: Content Planner
--- Prefix: mkt_
+-- Prefix: plg_marketing_
 -- Social accounts + content plans + posts (Notion-style markdown pages).
 
-CREATE TABLE IF NOT EXISTS public.mkt_social_accounts (
+CREATE TABLE IF NOT EXISTS public.plg_marketing_social_accounts (
   id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  tenant_id uuid NOT NULL REFERENCES saas_core.tenants(id) ON DELETE CASCADE,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
   name text NOT NULL,
   handle text,
   platform text NOT NULL DEFAULT 'instagram'
@@ -12,13 +12,13 @@ CREATE TABLE IF NOT EXISTS public.mkt_social_accounts (
   is_active boolean NOT NULL DEFAULT true,
   created_at timestamptz NOT NULL DEFAULT now()
 );
-ALTER TABLE public.mkt_social_accounts ENABLE ROW LEVEL SECURITY;
-CREATE INDEX IF NOT EXISTS idx_mkt_social_accounts_tenant ON public.mkt_social_accounts(tenant_id);
+ALTER TABLE public.plg_marketing_social_accounts ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_social_accounts_tenant ON public.plg_marketing_social_accounts(tenant_id);
 
-CREATE TABLE IF NOT EXISTS public.mkt_content_plans (
+CREATE TABLE IF NOT EXISTS public.plg_marketing_content_plans (
   id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  tenant_id uuid NOT NULL REFERENCES saas_core.tenants(id) ON DELETE CASCADE,
-  account_id uuid NOT NULL REFERENCES public.mkt_social_accounts(id) ON DELETE CASCADE,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  account_id uuid NOT NULL REFERENCES public.plg_marketing_social_accounts(id) ON DELETE CASCADE,
   name text NOT NULL,
   status text NOT NULL DEFAULT 'active'
     CHECK (status IN ('draft', 'active', 'archived')),
@@ -33,14 +33,14 @@ CREATE TABLE IF NOT EXISTS public.mkt_content_plans (
   created_at timestamptz NOT NULL DEFAULT now(),
   updated_at timestamptz NOT NULL DEFAULT now()
 );
-ALTER TABLE public.mkt_content_plans ENABLE ROW LEVEL SECURITY;
-CREATE INDEX IF NOT EXISTS idx_mkt_content_plans_tenant ON public.mkt_content_plans(tenant_id);
-CREATE INDEX IF NOT EXISTS idx_mkt_content_plans_account ON public.mkt_content_plans(account_id);
+ALTER TABLE public.plg_marketing_content_plans ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_content_plans_tenant ON public.plg_marketing_content_plans(tenant_id);
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_content_plans_account ON public.plg_marketing_content_plans(account_id);
 
-CREATE TABLE IF NOT EXISTS public.mkt_content_posts (
+CREATE TABLE IF NOT EXISTS public.plg_marketing_content_posts (
   id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  tenant_id uuid NOT NULL REFERENCES saas_core.tenants(id) ON DELETE CASCADE,
-  plan_id uuid NOT NULL REFERENCES public.mkt_content_plans(id) ON DELETE CASCADE,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  plan_id uuid NOT NULL REFERENCES public.plg_marketing_content_plans(id) ON DELETE CASCADE,
   week_number integer NOT NULL DEFAULT 1,
   position integer NOT NULL DEFAULT 0,
   title text NOT NULL,
@@ -55,40 +55,40 @@ CREATE TABLE IF NOT EXISTS public.mkt_content_posts (
   created_at timestamptz NOT NULL DEFAULT now(),
   updated_at timestamptz NOT NULL DEFAULT now()
 );
-ALTER TABLE public.mkt_content_posts ENABLE ROW LEVEL SECURITY;
-CREATE INDEX IF NOT EXISTS idx_mkt_content_posts_tenant ON public.mkt_content_posts(tenant_id);
-CREATE INDEX IF NOT EXISTS idx_mkt_content_posts_plan ON public.mkt_content_posts(plan_id, week_number, position);
-CREATE INDEX IF NOT EXISTS idx_mkt_content_posts_status ON public.mkt_content_posts(tenant_id, status);
+ALTER TABLE public.plg_marketing_content_posts ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_content_posts_tenant ON public.plg_marketing_content_posts(tenant_id);
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_content_posts_plan ON public.plg_marketing_content_posts(plan_id, week_number, position);
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_content_posts_status ON public.plg_marketing_content_posts(tenant_id, status);
 
--- RLS policies for mkt_social_accounts
-DROP POLICY IF EXISTS mkt_social_accounts_select ON public.mkt_social_accounts;
-DROP POLICY IF EXISTS mkt_social_accounts_insert ON public.mkt_social_accounts;
-DROP POLICY IF EXISTS mkt_social_accounts_update ON public.mkt_social_accounts;
-DROP POLICY IF EXISTS mkt_social_accounts_delete ON public.mkt_social_accounts;
-CREATE POLICY mkt_social_accounts_select ON public.mkt_social_accounts FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_social_accounts_insert ON public.mkt_social_accounts FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_social_accounts_update ON public.mkt_social_accounts FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_social_accounts_delete ON public.mkt_social_accounts FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-GRANT SELECT, INSERT, UPDATE, DELETE ON public.mkt_social_accounts TO authenticated;
+-- RLS policies for plg_marketing_social_accounts
+DROP POLICY IF EXISTS plg_marketing_social_accounts_select ON public.plg_marketing_social_accounts;
+DROP POLICY IF EXISTS plg_marketing_social_accounts_insert ON public.plg_marketing_social_accounts;
+DROP POLICY IF EXISTS plg_marketing_social_accounts_update ON public.plg_marketing_social_accounts;
+DROP POLICY IF EXISTS plg_marketing_social_accounts_delete ON public.plg_marketing_social_accounts;
+CREATE POLICY plg_marketing_social_accounts_select ON public.plg_marketing_social_accounts FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_social_accounts_insert ON public.plg_marketing_social_accounts FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_social_accounts_update ON public.plg_marketing_social_accounts FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_social_accounts_delete ON public.plg_marketing_social_accounts FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_marketing_social_accounts TO authenticated;
 
--- RLS policies for mkt_content_plans
-DROP POLICY IF EXISTS mkt_content_plans_select ON public.mkt_content_plans;
-DROP POLICY IF EXISTS mkt_content_plans_insert ON public.mkt_content_plans;
-DROP POLICY IF EXISTS mkt_content_plans_update ON public.mkt_content_plans;
-DROP POLICY IF EXISTS mkt_content_plans_delete ON public.mkt_content_plans;
-CREATE POLICY mkt_content_plans_select ON public.mkt_content_plans FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_content_plans_insert ON public.mkt_content_plans FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_content_plans_update ON public.mkt_content_plans FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_content_plans_delete ON public.mkt_content_plans FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-GRANT SELECT, INSERT, UPDATE, DELETE ON public.mkt_content_plans TO authenticated;
+-- RLS policies for plg_marketing_content_plans
+DROP POLICY IF EXISTS plg_marketing_content_plans_select ON public.plg_marketing_content_plans;
+DROP POLICY IF EXISTS plg_marketing_content_plans_insert ON public.plg_marketing_content_plans;
+DROP POLICY IF EXISTS plg_marketing_content_plans_update ON public.plg_marketing_content_plans;
+DROP POLICY IF EXISTS plg_marketing_content_plans_delete ON public.plg_marketing_content_plans;
+CREATE POLICY plg_marketing_content_plans_select ON public.plg_marketing_content_plans FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_content_plans_insert ON public.plg_marketing_content_plans FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_content_plans_update ON public.plg_marketing_content_plans FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_content_plans_delete ON public.plg_marketing_content_plans FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_marketing_content_plans TO authenticated;
 
--- RLS policies for mkt_content_posts
-DROP POLICY IF EXISTS mkt_content_posts_select ON public.mkt_content_posts;
-DROP POLICY IF EXISTS mkt_content_posts_insert ON public.mkt_content_posts;
-DROP POLICY IF EXISTS mkt_content_posts_update ON public.mkt_content_posts;
-DROP POLICY IF EXISTS mkt_content_posts_delete ON public.mkt_content_posts;
-CREATE POLICY mkt_content_posts_select ON public.mkt_content_posts FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_content_posts_insert ON public.mkt_content_posts FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_content_posts_update ON public.mkt_content_posts FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-CREATE POLICY mkt_content_posts_delete ON public.mkt_content_posts FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
-GRANT SELECT, INSERT, UPDATE, DELETE ON public.mkt_content_posts TO authenticated;
+-- RLS policies for plg_marketing_content_posts
+DROP POLICY IF EXISTS plg_marketing_content_posts_select ON public.plg_marketing_content_posts;
+DROP POLICY IF EXISTS plg_marketing_content_posts_insert ON public.plg_marketing_content_posts;
+DROP POLICY IF EXISTS plg_marketing_content_posts_update ON public.plg_marketing_content_posts;
+DROP POLICY IF EXISTS plg_marketing_content_posts_delete ON public.plg_marketing_content_posts;
+CREATE POLICY plg_marketing_content_posts_select ON public.plg_marketing_content_posts FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_content_posts_insert ON public.plg_marketing_content_posts FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_content_posts_update ON public.plg_marketing_content_posts FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_content_posts_delete ON public.plg_marketing_content_posts FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_marketing_content_posts TO authenticated;

package/src/migrations/002_multi_platform.sql

@@ -3,7 +3,7 @@
 -- YouTube, TikTok, ...). Posts optionally narrow the target platforms; an
 -- empty array means "inherit the account's platforms".
 
-ALTER TABLE public.mkt_social_accounts
+ALTER TABLE public.plg_marketing_social_accounts
   ADD COLUMN IF NOT EXISTS platforms text[] NOT NULL DEFAULT '{instagram}';
 
 -- Backfill from the legacy single-platform column, then drop it (also drops
@@ -12,14 +12,14 @@ DO $$
 BEGIN
   IF EXISTS (
     SELECT 1 FROM information_schema.columns
-    WHERE table_schema = 'public' AND table_name = 'mkt_social_accounts' AND column_name = 'platform'
+    WHERE table_schema = 'public' AND table_name = 'plg_marketing_social_accounts' AND column_name = 'platform'
   ) THEN
-    UPDATE public.mkt_social_accounts
+    UPDATE public.plg_marketing_social_accounts
       SET platforms = ARRAY[platform]
       WHERE platform IS NOT NULL AND platforms = '{instagram}';
-    ALTER TABLE public.mkt_social_accounts DROP COLUMN platform;
+    ALTER TABLE public.plg_marketing_social_accounts DROP COLUMN platform;
   END IF;
 END $$;
 
-ALTER TABLE public.mkt_content_posts
+ALTER TABLE public.plg_marketing_content_posts
   ADD COLUMN IF NOT EXISTS platforms text[] NOT NULL DEFAULT '{}';

package/src/migrations/003_recording_ops.sql

@@ -3,10 +3,10 @@
 -- companion for recording day. media_url: uploaded asset (static posts get a
 -- caption + final art instead of a script).
 
-ALTER TABLE public.mkt_content_posts
+ALTER TABLE public.plg_marketing_content_posts
   ADD COLUMN IF NOT EXISTS checklist jsonb NOT NULL DEFAULT '[]';
 
-ALTER TABLE public.mkt_content_posts
+ALTER TABLE public.plg_marketing_content_posts
   ADD COLUMN IF NOT EXISTS media_url text;
 
 -- Public media bucket for content assets (mirrors the avatars-bucket pattern:
@@ -15,11 +15,11 @@ INSERT INTO storage.buckets (id, name, public)
   VALUES ('mkt-media', 'mkt-media', true)
   ON CONFLICT (id) DO NOTHING;
 
-DROP POLICY IF EXISTS mkt_media_read ON storage.objects;
-DROP POLICY IF EXISTS mkt_media_insert ON storage.objects;
-DROP POLICY IF EXISTS mkt_media_update ON storage.objects;
-DROP POLICY IF EXISTS mkt_media_delete ON storage.objects;
-CREATE POLICY mkt_media_read ON storage.objects FOR SELECT TO public USING (bucket_id = 'mkt-media');
-CREATE POLICY mkt_media_insert ON storage.objects FOR INSERT TO authenticated WITH CHECK (bucket_id = 'mkt-media');
-CREATE POLICY mkt_media_update ON storage.objects FOR UPDATE TO authenticated USING (bucket_id = 'mkt-media');
-CREATE POLICY mkt_media_delete ON storage.objects FOR DELETE TO authenticated USING (bucket_id = 'mkt-media');
+DROP POLICY IF EXISTS plg_marketing_media_read ON storage.objects;
+DROP POLICY IF EXISTS plg_marketing_media_insert ON storage.objects;
+DROP POLICY IF EXISTS plg_marketing_media_update ON storage.objects;
+DROP POLICY IF EXISTS plg_marketing_media_delete ON storage.objects;
+CREATE POLICY plg_marketing_media_read ON storage.objects FOR SELECT TO public USING (bucket_id = 'mkt-media');
+CREATE POLICY plg_marketing_media_insert ON storage.objects FOR INSERT TO authenticated WITH CHECK (bucket_id = 'mkt-media');
+CREATE POLICY plg_marketing_media_update ON storage.objects FOR UPDATE TO authenticated USING (bucket_id = 'mkt-media');
+CREATE POLICY plg_marketing_media_delete ON storage.objects FOR DELETE TO authenticated USING (bucket_id = 'mkt-media');

package/src/migrations/004_ranklayer.sql

@@ -0,0 +1,50 @@
+-- Marketing Plugin: RankLayer integration (SEO content publishing).
+-- Control-plane state for the RankLayer connector rendered in Marketing →
+-- Integrações. Prefix: plg_marketing_ranklayer_. Scaffold: the real sync
+-- (edge function + RankLayer API calls) lands via an external PR — see
+-- src/integrations/ranklayer/RANKLAYER.md.
+
+CREATE TABLE IF NOT EXISTS public.plg_marketing_ranklayer_integrations (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  api_key text,
+  site_domain text,
+  active boolean NOT NULL DEFAULT true,
+  last_sync_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_marketing_ranklayer_integrations ENABLE ROW LEVEL SECURITY;
+CREATE UNIQUE INDEX IF NOT EXISTS uq_plg_marketing_ranklayer_integrations_tenant
+  ON public.plg_marketing_ranklayer_integrations(tenant_id);
+
+CREATE TABLE IF NOT EXISTS public.plg_marketing_ranklayer_sync_log (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  integration_id uuid REFERENCES public.plg_marketing_ranklayer_integrations(id) ON DELETE CASCADE,
+  status text NOT NULL DEFAULT 'success' CHECK (status IN ('success', 'partial', 'error')),
+  message text,
+  fetched integer NOT NULL DEFAULT 0,
+  written integer NOT NULL DEFAULT 0,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_marketing_ranklayer_sync_log ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_marketing_ranklayer_sync_log_tenant
+  ON public.plg_marketing_ranklayer_sync_log(tenant_id, created_at DESC);
+
+-- RLS: authenticated tenant CRUD
+DROP POLICY IF EXISTS plg_marketing_ranklayer_integrations_select ON public.plg_marketing_ranklayer_integrations;
+DROP POLICY IF EXISTS plg_marketing_ranklayer_integrations_insert ON public.plg_marketing_ranklayer_integrations;
+DROP POLICY IF EXISTS plg_marketing_ranklayer_integrations_update ON public.plg_marketing_ranklayer_integrations;
+DROP POLICY IF EXISTS plg_marketing_ranklayer_integrations_delete ON public.plg_marketing_ranklayer_integrations;
+CREATE POLICY plg_marketing_ranklayer_integrations_select ON public.plg_marketing_ranklayer_integrations FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_ranklayer_integrations_insert ON public.plg_marketing_ranklayer_integrations FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_ranklayer_integrations_update ON public.plg_marketing_ranklayer_integrations FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_ranklayer_integrations_delete ON public.plg_marketing_ranklayer_integrations FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_marketing_ranklayer_integrations TO authenticated;
+
+DROP POLICY IF EXISTS plg_marketing_ranklayer_sync_log_select ON public.plg_marketing_ranklayer_sync_log;
+DROP POLICY IF EXISTS plg_marketing_ranklayer_sync_log_insert ON public.plg_marketing_ranklayer_sync_log;
+CREATE POLICY plg_marketing_ranklayer_sync_log_select ON public.plg_marketing_ranklayer_sync_log FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY plg_marketing_ranklayer_sync_log_insert ON public.plg_marketing_ranklayer_sync_log FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT ON public.plg_marketing_ranklayer_sync_log TO authenticated;