Persistência e views

type ReportStorageAdapter = {
  /** Config global salva, ou `null` quando nada foi salvo ainda (chamador aplica
   *  seu próprio default nesse caso). */
  loadGlobalConfig(): Promise<ReportGlobalConfig | null>;
  saveGlobalConfig(config: ReportGlobalConfig): Promise<void>;

  /** Lista as views; `slug` filtra por relatório, omitido retorna todas. */
  listViews(slug?: string): Promise<ReportView[]>;
  getView(id: string): Promise<ReportView | null>;
  /** Upsert por `id`. */
  saveView(view: ReportView): Promise<void>;
  /** Lança se a view for `isSystem` (view do sistema é somente leitura). */
  deleteView(id: string): Promise<void>;
  /** Marca `viewId` como default do `slug` e zera `isDefault` das demais
   *  views do mesmo slug. */
  setDefaultView(slug: string, viewId: string): Promise<void>;

  listDefinitions(): Promise<SerializableReportDefinition[]>;
  getDefinition(slug: string): Promise<SerializableReportDefinition | null>;
  /** Upsert por `slug`. */
  saveDefinition(definition: SerializableReportDefinition): Promise<void>;
  /** Remove a definição E todas as views associadas ao seu `slug`. */
  deleteDefinition(slug: string): Promise<void>;
};

import { createReportRegistry, ensureReportViews } from "cosmemilton-report";
import { relatorioVendas, relatorioPorVendedor } from "@/lib/demo-data";
import { adapter } from "@/lib/report-adapter";

const registry = createReportRegistry([relatorioVendas, relatorioPorVendedor]);

// Seguro chamar em todo boot do servidor (ou lazy, na primeira requisição):
// só cria o que falta, nunca duplica.
const { created, existing } = await ensureReportViews({ registry, adapter });

// Duas tabelas bastam: a definição (quando criada no designer) e as
// views. columns/header/style/summary não têm formato fixo por coluna
// no banco — vão inteiros como JSON, no mesmo shape do pacote.

model ReportDefinition {
  slug        String   @id
  name        String
  description String?
  dataSource  String?
  // columns, summary, header, style, group — SerializableReportDefinition
  // menos slug/name/description/dataSource, que já são colunas próprias.
  payload     Json
  updatedAt   DateTime @updatedAt

  @@map("report_definitions")
}

model ReportView {
  id        String   @id
  slug      String
  name      String
  isSystem  Boolean  @default(false)
  isDefault Boolean  @default(false)
  // columns, header, style, summary — ReportView menos os campos acima.
  payload   Json
  updatedAt DateTime @updatedAt

  @@index([slug])
  @@map("report_views")
}

import { PrismaClient } from "@prisma/client";
import type {
  ReportGlobalConfig,
  ReportStorageAdapter,
  ReportView,
  SerializableReportDefinition,
} from "cosmemilton-report";

const prisma = new PrismaClient();

// Remonta uma linha da tabela report_views no shape de ReportView.
function rowToView(row: {
  id: string;
  slug: string;
  name: string;
  isSystem: boolean;
  isDefault: boolean;
  payload: unknown;
  updatedAt: Date;
}): ReportView {
  return {
    id: row.id,
    slug: row.slug,
    name: row.name,
    isSystem: row.isSystem,
    isDefault: row.isDefault,
    updatedAt: row.updatedAt.toISOString(),
    ...(row.payload as object), // columns/header/style/summary
  };
}

// Idem para report_definitions → SerializableReportDefinition.
function rowToDefinition(row: {
  slug: string;
  name: string;
  description: string | null;
  dataSource: string | null;
  payload: unknown;
}): SerializableReportDefinition {
  return {
    slug: row.slug,
    name: row.name,
    description: row.description ?? undefined,
    dataSource: row.dataSource ?? undefined,
    columns: [],
    ...(row.payload as object), // columns real, summary, header, style, group
  };
}

export function createPrismaReportAdapter(): ReportStorageAdapter {
  return {
    // Sem tabela própria neste esqueleto: grave/leia de uma linha
    // "singleton" na tabela de settings do seu app.
    async loadGlobalConfig() {
      return null;
    },
    async saveGlobalConfig(_config: ReportGlobalConfig) {
      // await prisma.appSettings.upsert(...)
    },

    async listViews(slug) {
      const rows = await prisma.reportView.findMany({ where: slug ? { slug } : undefined });
      return rows.map(rowToView);
    },
    async getView(id) {
      const row = await prisma.reportView.findUnique({ where: { id } });
      return row ? rowToView(row) : null;
    },
    async saveView(view: ReportView) {
      const { id, slug, name, isSystem, isDefault, updatedAt: _updatedAt, ...rest } = view;
      await prisma.reportView.upsert({
        where: { id },
        create: { id, slug, name, isSystem, isDefault, payload: rest },
        update: { name, isSystem, isDefault, payload: rest },
      });
    },
    async deleteView(id) {
      const view = await prisma.reportView.findUnique({ where: { id } });
      if (view?.isSystem) throw new Error("View de sistema é somente leitura.");
      await prisma.reportView.delete({ where: { id } });
    },
    async setDefaultView(slug, viewId) {
      // Transação: zera o default das demais views do slug e marca a nova.
      await prisma.$transaction([
        prisma.reportView.updateMany({ where: { slug }, data: { isDefault: false } }),
        prisma.reportView.update({ where: { id: viewId }, data: { isDefault: true } }),
      ]);
    },

    async listDefinitions() {
      const rows = await prisma.reportDefinition.findMany();
      return rows.map(rowToDefinition);
    },
    async getDefinition(slug) {
      const row = await prisma.reportDefinition.findUnique({ where: { slug } });
      return row ? rowToDefinition(row) : null;
    },
    async saveDefinition(definition: SerializableReportDefinition) {
      const { slug, name, description, dataSource, ...rest } = definition;
      await prisma.reportDefinition.upsert({
        where: { slug },
        create: { slug, name, description, dataSource, payload: rest },
        update: { name, description, dataSource, payload: rest },
      });
    },
    async deleteDefinition(slug) {
      // Sem cascade no schema acima de propósito: apaga views e definição
      // juntas, numa transação, para não depender de configuração do banco.
      await prisma.$transaction([
        prisma.reportView.deleteMany({ where: { slug } }),
        prisma.reportDefinition.delete({ where: { slug } }),
      ]);
    },
  };
}