@voyant-travel/reporting 0.2.3 → 0.3.0

package/dist/service.d.ts

@@ -2,7 +2,7 @@ import type { createReportDefinitionSchema, ReportParameters, updateReportDefini
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import type { z } from "zod";
 import type { ReportingRegistry } from "./registry.js";
-import { type ReportDefinitionRow, type ReportRunOutput } from "./schema.js";
+import { type ReportDefinitionRow } from "./schema.js";
 export type CreateReportDefinitionInput = z.infer<typeof createReportDefinitionSchema>;
 export type UpdateReportDefinitionInput = z.infer<typeof updateReportDefinitionSchema>;
 export declare class ReportDefinitionRevisionConflictError extends Error {
@@ -11,9 +11,6 @@ export declare class ReportDefinitionRevisionConflictError extends Error {
 export declare class ReportingRecordNotFoundError extends Error {
     constructor(record: string);
 }
-export declare class ReportDefinitionRetentionConflictError extends Error {
-    constructor();
-}
 export declare function createReportingService(registry: ReportingRegistry): {
     list(db: PostgresJsDatabase, input: {
         limit: number;
@@ -390,120 +387,42 @@ export declare function createReportingService(registry: ReportingRegistry): {
         updatedAt: Date;
     }>;
     remove(db: PostgresJsDatabase, id: string): Promise<boolean>;
-    createVersion(db: PostgresJsDatabase, reportDefinitionId: string, expectedRevision: number, actorId?: string): Promise<{
-        id: string;
-        version: number;
-        description: string | null;
-        name: string;
-        createdByUserId: string | null;
-        createdAt: Date;
-        reportDefinitionId: string;
-        definitionRevision: number;
-        snapshot: {
-            parameters: Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
-            widgets: {
-                id: string;
-                source: {
-                    kind: "preset";
-                    widgetId: string;
-                    version?: number | undefined;
-                } | {
-                    kind: "custom";
-                    definition: {
-                        id: string;
-                        version: number;
-                        label: string;
-                        query: {
-                            dataset: {
-                                id: string;
-                                version?: number | undefined;
-                            };
-                            select: ({
-                                kind: "field";
-                                field: string;
-                                as?: string | undefined;
-                            } | {
-                                kind: "aggregate";
-                                operation: "minimum" | "maximum" | "count" | "countDistinct" | "sum" | "average";
-                                as: string;
-                                field?: string | undefined;
-                            })[];
-                            filters: {
-                                field: string;
-                                operator: "in" | "equal" | "notEqual" | "notIn" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "between" | "contains" | "isNull" | "isNotNull";
-                                value?: {
-                                    kind: "literal";
-                                    value: string | number | boolean | (string | number | boolean | null)[] | null;
-                                } | {
-                                    kind: "parameter";
-                                    name: string;
-                                } | undefined;
-                            }[];
-                            groupBy: {
-                                field: string;
-                                timeGrain?: "day" | "week" | "month" | "quarter" | "year" | undefined;
-                            }[];
-                            orderBy: {
-                                by: string;
-                                direction: "ascending" | "descending";
-                            }[];
-                            limit?: number | undefined;
-                        };
-                        visualization: {
-                            type: "kpi" | "table" | "line" | "bar" | "pie";
-                            options: Record<string, unknown>;
-                        };
-                        defaultSize: {
-                            width: number;
-                            height: number;
-                        };
-                        description?: string | undefined;
-                        minimumSize?: {
-                            width: number;
-                            height: number;
-                        } | undefined;
-                        maximumSize?: {
-                            width: number;
-                            height: number;
-                        } | undefined;
-                    };
-                };
-                layout: {
-                    width: number;
-                    height: number;
-                    x: number;
-                    y: number;
-                };
-                title?: string | undefined;
-            }[];
-        };
-    }>;
-    runVersion(db: PostgresJsDatabase, versionId: string, parameters: ReportParameters, context: {
+    /**
+     * Execute every widget in a report and return its tabular data, ready to be
+     * serialized to CSV / XLSX / PDF. Widgets that fail (unavailable, scope, or
+     * query error) become a section carrying the error message rather than
+     * aborting the whole export.
+     */
+    exportReport(db: PostgresJsDatabase, id: string, parameters: ReportParameters, context: {
         actorId?: string;
         grantedScopes: readonly string[];
         signal?: AbortSignal;
-    }): Promise<{
-        output: ReportRunOutput | null;
-        parameters: Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
+    }): Promise<ReportExport | null>;
+};
+/** Presentation hints carried from a widget's visualization options into export. */
+export interface ReportExportSectionFormat {
+    /** Currency values are stored in minor units (cents) and must be divided by 100. */
+    readonly minorUnit: boolean;
+    /** Column whose value holds the ISO currency code for each row. */
+    readonly currencyField?: string;
+    /** Fallback ISO currency when a row has no {@link currencyField}. */
+    readonly currency?: string;
+}
+/** A single widget's tabular data within an exported report. */
+export interface ReportExportSection {
+    readonly title: string;
+    readonly columns: ReadonlyArray<{
         id: string;
-        createdAt: Date;
-        reportVersionId: string;
-        status: "succeeded" | "failed" | "running";
-        error: string | null;
-        triggeredByUserId: string | null;
-        startedAt: Date;
-        completedAt: Date | null;
+        label: string;
+        valueType: string;
     }>;
-    getRun(db: PostgresJsDatabase, id: string, grantedScopes: readonly string[]): Promise<{
-        id: string;
-        reportVersionId: string;
-        status: "succeeded" | "failed" | "running";
-        parameters: Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
-        output: ReportRunOutput | null;
-        error: string | null;
-        triggeredByUserId: string | null;
-        startedAt: Date;
-        completedAt: Date | null;
-        createdAt: Date;
-    } | null>;
-};
+    readonly rows: ReadonlyArray<Record<string, unknown>>;
+    readonly format?: ReportExportSectionFormat;
+    readonly error?: string;
+}
+/** A report resolved to plain tabular sections for file export. */
+export interface ReportExport {
+    readonly name: string;
+    readonly description: string | null;
+    readonly sections: readonly ReportExportSection[];
+}

package/dist/service.js

@@ -1,5 +1,5 @@
 import { and, desc, eq, sql } from "drizzle-orm";
-import { reportDefinitions, reportRuns, reportVersions, } from "./schema.js";
+import { reportDefinitions } from "./schema.js";
 export class ReportDefinitionRevisionConflictError extends Error {
     constructor() {
         super("The report draft changed since it was loaded.");
@@ -12,12 +12,6 @@ export class ReportingRecordNotFoundError extends Error {
         this.name = "ReportingRecordNotFoundError";
     }
 }
-export class ReportDefinitionRetentionConflictError extends Error {
-    constructor() {
-        super("Reports with retained execution history cannot be deleted.");
-        this.name = "ReportDefinitionRetentionConflictError";
-    }
-}
 export function createReportingService(registry) {
     return {
         async list(db, input) {
@@ -83,177 +77,67 @@ export function createReportingService(registry) {
             throw new ReportDefinitionRevisionConflictError();
         },
         async remove(db, id) {
-            return db.transaction(async (transaction) => {
-                const [definition] = await transaction
-                    .select({ id: reportDefinitions.id })
-                    .from(reportDefinitions)
-                    .where(eq(reportDefinitions.id, id))
-                    .limit(1)
-                    .for("update");
-                if (!definition)
-                    return false;
-                await transaction
-                    .select({ id: reportVersions.id })
-                    .from(reportVersions)
-                    .where(eq(reportVersions.reportDefinitionId, id))
-                    .for("update");
-                const [retainedRun] = await transaction
-                    .select({ id: reportRuns.id })
-                    .from(reportRuns)
-                    .innerJoin(reportVersions, eq(reportRuns.reportVersionId, reportVersions.id))
-                    .where(eq(reportVersions.reportDefinitionId, id))
-                    .limit(1);
-                if (retainedRun)
-                    throw new ReportDefinitionRetentionConflictError();
-                await transaction.delete(reportDefinitions).where(eq(reportDefinitions.id, id));
-                return true;
-            });
-        },
-        async createVersion(db, reportDefinitionId, expectedRevision, actorId) {
-            return db.transaction(async (transaction) => {
-                const [definition] = await transaction
-                    .select()
-                    .from(reportDefinitions)
-                    .where(eq(reportDefinitions.id, reportDefinitionId))
-                    .limit(1)
-                    .for("update");
-                if (!definition)
-                    throw new ReportingRecordNotFoundError("Report definition");
-                if (definition.revision !== expectedRevision)
-                    throw new ReportDefinitionRevisionConflictError();
-                const [latest] = await transaction
-                    .select({ version: reportVersions.version })
-                    .from(reportVersions)
-                    .where(eq(reportVersions.reportDefinitionId, reportDefinitionId))
-                    .orderBy(desc(reportVersions.version))
-                    .limit(1);
-                const [version] = await transaction
-                    .insert(reportVersions)
-                    .values({
-                    reportDefinitionId,
-                    version: (latest?.version ?? 0) + 1,
-                    name: definition.name,
-                    description: definition.description,
-                    definitionRevision: definition.revision,
-                    snapshot: registry.snapshotDraft(definition.draft),
-                    createdByUserId: actorId,
-                })
-                    .returning();
-                if (!version)
-                    throw new Error("Report version insert returned no row.");
-                return version;
-            });
+            const deleted = await db
+                .delete(reportDefinitions)
+                .where(eq(reportDefinitions.id, id))
+                .returning({ id: reportDefinitions.id });
+            return deleted.length > 0;
         },
-        async runVersion(db, versionId, parameters, context) {
-            const execution = await db.transaction(async (transaction) => {
-                const [version] = await transaction
-                    .select()
-                    .from(reportVersions)
-                    .where(eq(reportVersions.id, versionId))
-                    .limit(1)
-                    .for("share");
-                if (!version)
-                    throw new ReportingRecordNotFoundError("Report version");
-                for (const resolved of registry.resolveDraft(version.snapshot, "edit")) {
-                    if (resolved.status === "missing" || !resolved.definition)
-                        continue;
-                    registry.validateQuery(resolved.definition.query, context.grantedScopes);
+        /**
+         * Execute every widget in a report and return its tabular data, ready to be
+         * serialized to CSV / XLSX / PDF. Widgets that fail (unavailable, scope, or
+         * query error) become a section carrying the error message rather than
+         * aborting the whole export.
+         */
+        async exportReport(db, id, parameters, context) {
+            const [definition] = await db
+                .select()
+                .from(reportDefinitions)
+                .where(eq(reportDefinitions.id, id))
+                .limit(1);
+            if (!definition)
+                return null;
+            const merged = { ...definition.draft.parameters, ...parameters };
+            const sections = [];
+            for (const resolved of registry.resolveDraft(definition.draft, "view")) {
+                const title = resolved.definition
+                    ? (resolved.instance.title ?? resolved.definition.label)
+                    : (resolved.instance.title ?? resolved.instance.id);
+                if (resolved.status === "missing" || !resolved.definition) {
+                    sections.push({ title, columns: [], rows: [], error: resolved.missingReason });
+                    continue;
+                }
+                try {
+                    const result = await registry.executeQuery({
+                        db,
+                        actorId: context.actorId,
+                        grantedScopes: context.grantedScopes,
+                        query: resolved.definition.query,
+                        parameters: merged,
+                        signal: context.signal,
+                    });
+                    const options = resolved.definition.visualization.options ?? {};
+                    sections.push({
+                        title,
+                        columns: result.columns,
+                        rows: result.rows,
+                        format: {
+                            minorUnit: options.minorUnit === true,
+                            currencyField: typeof options.currencyField === "string" ? options.currencyField : undefined,
+                            currency: typeof options.currency === "string" ? options.currency : undefined,
+                        },
+                    });
+                }
+                catch (error) {
+                    sections.push({
+                        title,
+                        columns: [],
+                        rows: [],
+                        error: error instanceof Error ? error.message : "Widget failed to export.",
+                    });
                 }
-                const [run] = await transaction
-                    .insert(reportRuns)
-                    .values({ reportVersionId: versionId, parameters, triggeredByUserId: context.actorId })
-                    .returning();
-                if (!run)
-                    throw new Error("Report run insert returned no row.");
-                return { run, version };
-            });
-            const { run, version } = execution;
-            try {
-                const executionSignal = context.signal
-                    ? AbortSignal.any([context.signal, AbortSignal.timeout(60_000)])
-                    : AbortSignal.timeout(60_000);
-                const output = await executeDraft(registry, db, version.snapshot, parameters, {
-                    ...context,
-                    signal: executionSignal,
-                });
-                const failed = output.widgets.some((widget) => widget.status === "failed");
-                const [completed] = await db
-                    .update(reportRuns)
-                    .set({
-                    status: failed ? "failed" : "succeeded",
-                    output,
-                    error: failed ? "One or more widgets failed." : null,
-                    completedAt: new Date(),
-                })
-                    .where(eq(reportRuns.id, run.id))
-                    .returning();
-                return completed ?? run;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "Report execution failed.";
-                const [failed] = await db
-                    .update(reportRuns)
-                    .set({ status: "failed", error: message, completedAt: new Date() })
-                    .where(eq(reportRuns.id, run.id))
-                    .returning();
-                return failed ?? run;
-            }
-        },
-        async getRun(db, id, grantedScopes) {
-            const [run] = await db.select().from(reportRuns).where(eq(reportRuns.id, id)).limit(1);
-            if (run) {
-                const requiredScopes = [
-                    ...new Set(run.output?.widgets.flatMap((widget) => widget.requiredScopes ?? []) ?? []),
-                ];
-                registry.requireScopes(requiredScopes, grantedScopes);
             }
-            return run ?? null;
+            return { name: definition.name, description: definition.description, sections };
         },
     };
 }
-async function executeDraft(registry, db, draft, runParameters, context) {
-    const parameters = { ...draft.parameters, ...runParameters };
-    const widgets = [];
-    for (const resolved of registry.resolveDraft(draft, "edit")) {
-        if (resolved.status === "missing" || !resolved.definition) {
-            widgets.push({
-                widgetInstanceId: resolved.instance.id,
-                status: "missing",
-                reason: resolved.missingReason ?? "Widget is unavailable.",
-            });
-            continue;
-        }
-        let provenance;
-        try {
-            const validation = registry.validateQuery(resolved.definition.query, context.grantedScopes);
-            provenance = {
-                datasetId: validation.dataset.definition.id,
-                datasetVersion: validation.dataset.definition.version,
-                requiredScopes: validation.requiredScopes,
-            };
-            const result = await registry.executeQuery({
-                db,
-                actorId: context.actorId,
-                grantedScopes: context.grantedScopes,
-                query: resolved.definition.query,
-                parameters,
-                signal: context.signal,
-            });
-            widgets.push({
-                widgetInstanceId: resolved.instance.id,
-                status: "succeeded",
-                ...provenance,
-                result,
-            });
-        }
-        catch (error) {
-            widgets.push({
-                widgetInstanceId: resolved.instance.id,
-                status: "failed",
-                ...provenance,
-                reason: error instanceof Error ? error.message : "Widget execution failed.",
-            });
-        }
-    }
-    return { widgets };
-}

package/migrations/20260719170000_drop_report_versioning.sql

@@ -0,0 +1,3 @@
+DROP TABLE "report_runs";--> statement-breakpoint
+DROP TABLE "report_versions";--> statement-breakpoint
+DROP TYPE "public"."report_run_status";

package/migrations/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1784365200000,
       "tag": "20260718090000_reporting_baseline",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1784480400000,
+      "tag": "20260719170000_drop_report_versioning",
+      "breakpoints": true
     }
   ]
 }