@robosystems/client 0.2.48 → 0.3.0

package/extensions/ReportClient.d.ts

@@ -1,84 +1,13 @@
-export interface Report {
-    id: string;
-    name: string;
-    taxonomyId: string;
-    generationStatus: string;
-    periodType: string;
-    periodStart: string | null;
-    periodEnd: string | null;
-    comparative: boolean;
-    mappingId: string | null;
-    aiGenerated: boolean;
-    createdAt: string;
-    lastGenerated: string | null;
-    structures: Structure[];
-    /** Entity name (source company for shared reports, own entity for native) */
-    entityName: string | null;
-    /** Non-null when this report was shared from another graph */
-    sourceGraphId: string | null;
-    sourceReportId: string | null;
-    sharedAt: string | null;
-}
-import type { Structure } from './LedgerClient';
-export type { Structure } from './LedgerClient';
-export interface StatementPeriod {
-    start: string;
-    end: string;
-    label: string;
-}
-export interface StatementRow {
-    elementId: string;
-    elementQname: string;
-    elementName: string;
-    classification: string;
-    values: (number | null)[];
-    isSubtotal: boolean;
-    depth: number;
-}
-export interface StatementData {
-    reportId: string;
-    structureId: string;
-    structureName: string;
-    structureType: string;
-    periods: StatementPeriod[];
-    rows: StatementRow[];
-    validation: {
-        passed: boolean;
-        checks: string[];
-        failures: string[];
-        warnings: string[];
-    } | null;
-    unmappedCount: number;
-}
-export interface ShareResult {
-    reportId: string;
-    results: Array<{
-        targetGraphId: string;
-        status: 'shared' | 'error';
-        error: string | null;
-        factCount: number;
-    }>;
-}
-export interface PublishList {
-    id: string;
-    name: string;
-    description: string | null;
-    memberCount: number;
-    createdBy: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface PublishListDetail extends PublishList {
-    members: PublishListMember[];
-}
-export interface PublishListMember {
-    id: string;
-    targetGraphId: string;
-    targetGraphName: string | null;
-    targetOrgName: string | null;
-    addedBy: string;
-    addedAt: string;
-}
+import type { OperationEnvelope } from '../types.gen';
+import { type GetLedgerPublishListQuery, type GetLedgerReportQuery, type GetLedgerStatementQuery, type ListLedgerPublishListsQuery, type ListLedgerReportsQuery } from './graphql/generated/graphql';
+export type Report = NonNullable<GetLedgerReportQuery['report']>;
+export type ReportListItem = NonNullable<ListLedgerReportsQuery['reports']>['reports'][number];
+export type StatementData = NonNullable<GetLedgerStatementQuery['statement']>;
+export type StatementPeriod = StatementData['periods'][number];
+export type StatementRow = StatementData['rows'][number];
+export type PublishList = NonNullable<ListLedgerPublishListsQuery['publishLists']>['publishLists'][number];
+export type PublishListDetail = NonNullable<GetLedgerPublishListQuery['publishList']>;
+export type PublishListMember = PublishListDetail['members'][number];
 export interface PeriodSpecInput {
     start: string;
     end: string;
@@ -95,57 +24,90 @@ export interface CreateReportOptions {
     /** When set, overrides periodStart/periodEnd/comparative with N explicit periods. */
     periods?: PeriodSpecInput[];
 }
-export declare class ReportClient {
-    private config;
-    constructor(config: {
-        baseUrl: string;
-        credentials?: 'include' | 'same-origin' | 'omit';
-        headers?: Record<string, string>;
-        token?: string;
-    });
+/**
+ * Envelope around a report operation. `status === "completed"` means the
+ * backend produced the report synchronously — `result` contains the
+ * freshly-created report shape (same fields as `ReportListItem`), so
+ * consumers can read `result?.id` immediately. For pending/failed
+ * dispatches, `result` is null and consumers should subscribe to
+ * `/v1/operations/{operationId}/stream` for progress.
+ *
+ * The loose `{ id; name; ... }` shape here intentionally mirrors the
+ * GraphQL `report` field without pulling in every nullable child relation
+ * — `create_report` and `regenerate_report` return a freshly-generated
+ * row, not a fully-resolved GraphQL projection.
+ */
+export interface ReportOperationAck {
+    operationId: string;
+    status: OperationEnvelope['status'];
     /**
-     * Create a report — generates facts for all structures in the taxonomy.
+     * Synchronous command result. Populated for `status === "completed"`
+     * dispatches where the backend produced the report inline.
      */
-    create(graphId: string, options: CreateReportOptions): Promise<Report>;
-    /**
-     * List all reports for a graph (includes received shared reports).
-     */
-    list(graphId: string): Promise<Report[]>;
+    result: Record<string, unknown> | null;
+}
+interface ReportClientConfig {
+    baseUrl: string;
+    credentials?: 'include' | 'same-origin' | 'omit';
+    headers?: Record<string, string>;
+    token?: string;
+}
+export declare class ReportClient {
+    private config;
+    private gql;
+    constructor(config: ReportClientConfig);
     /**
-     * Get a report with its available structures.
+     * Kick off report creation (async). Use the returned `operationId` to
+     * subscribe to progress via SSE, then call `get()` once finished.
      */
-    get(graphId: string, reportId: string): Promise<Report>;
+    create(graphId: string, options: CreateReportOptions): Promise<ReportOperationAck>;
+    /** List all reports for a graph (includes received shared reports). */
+    list(graphId: string): Promise<ReportListItem[]>;
+    /** Get a single report with its period list + available structures. */
+    get(graphId: string, reportId: string): Promise<Report | null>;
     /**
      * Render a financial statement — facts viewed through a structure.
      *
      * @param structureType - income_statement, balance_sheet, cash_flow_statement
      */
-    statement(graphId: string, reportId: string, structureType: string): Promise<StatementData>;
+    statement(graphId: string, reportId: string, structureType: string): Promise<StatementData | null>;
     /**
-     * Regenerate a report with new period dates.
-     */
-    regenerate(graphId: string, reportId: string, periodStart: string, periodEnd: string): Promise<Report>;
-    /**
-     * Delete a report and its generated facts.
+     * Regenerate an existing report (async). Returns an operation id;
+     * subscribe via SSE for progress.
      */
+    regenerate(graphId: string, reportId: string, periodStart?: string, periodEnd?: string): Promise<ReportOperationAck>;
+    /** Delete a report and its generated facts. */
     delete(graphId: string, reportId: string): Promise<void>;
     /**
-     * Share a published report to all members of a publish list (snapshot copy).
+     * Share a published report to every member of a publish list (async).
+     * Each target graph receives a snapshot copy of the report's facts.
      */
-    share(graphId: string, reportId: string, publishListId: string): Promise<ShareResult>;
+    share(graphId: string, reportId: string, publishListId: string): Promise<ReportOperationAck>;
     /** Check if a report was received via sharing (vs locally created). */
     isSharedReport(report: Report): boolean;
-    listPublishLists(graphId: string): Promise<PublishList[]>;
-    createPublishList(graphId: string, name: string, description?: string): Promise<PublishList>;
-    getPublishList(graphId: string, listId: string): Promise<PublishListDetail>;
+    /** List publish lists with pagination. */
+    listPublishLists(graphId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<PublishList[]>;
+    /** Create a new publish list. */
+    createPublishList(graphId: string, name: string, description?: string): Promise<Record<string, unknown>>;
+    /** Get a single publish list with its full member list. */
+    getPublishList(graphId: string, listId: string): Promise<PublishListDetail | null>;
+    /** Update a publish list's name or description. */
     updatePublishList(graphId: string, listId: string, updates: {
         name?: string;
-        description?: string;
-    }): Promise<PublishList>;
+        description?: string | null;
+    }): Promise<Record<string, unknown>>;
+    /** Delete a publish list. */
     deletePublishList(graphId: string, listId: string): Promise<void>;
-    addMembers(graphId: string, listId: string, targetGraphIds: string[]): Promise<PublishListMember[]>;
-    removeMember(graphId: string, listId: string, memberId: string): Promise<void>;
-    private _toPublishList;
-    private _toMember;
-    private _toReport;
+    /** Add target graphs as members of a publish list. */
+    addMembers(graphId: string, listId: string, targetGraphIds: string[]): Promise<Record<string, unknown>>;
+    /** Remove a single member from a publish list. */
+    removeMember(graphId: string, listId: string, memberId: string): Promise<{
+        deleted: boolean;
+    }>;
+    private gqlQuery;
+    private callOperation;
 }
+export {};

package/extensions/ReportClient.js

@@ -2,21 +2,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReportClient = void 0;
-/**
- * Report Client for RoboSystems API
- *
- * High-level client for report lifecycle: create, list, view statements,
- * regenerate, share, and delete. Reports consume ledger data (mappings,
- * trial balance) as inputs — use LedgerClient for those concerns.
- */
+const graphql_request_1 = require("graphql-request");
 const sdk_gen_1 = require("../sdk.gen");
-// ── Client ──────────────────────────────────────────────────────────────
+const client_1 = require("./graphql/client");
+const graphql_1 = require("./graphql/generated/graphql");
 class ReportClient {
     constructor(config) {
         this.config = config;
+        this.gql = new client_1.GraphQLClientCache(config);
     }
+    // ── Reports ─────────────────────────────────────────────────────────
     /**
-     * Create a report — generates facts for all structures in the taxonomy.
+     * Kick off report creation (async). Use the returned `operationId` to
+     * subscribe to progress via SSE, then call `get()` once finished.
      */
     async create(graphId, options) {
         const body = {
@@ -31,39 +29,21 @@ class ReportClient {
         if (options.periods && options.periods.length > 0) {
             body.periods = options.periods;
         }
-        const response = await (0, sdk_gen_1.createReport)({
-            path: { graph_id: graphId },
-            body,
-        });
-        if (response.error) {
-            throw new Error(`Create report failed: ${JSON.stringify(response.error)}`);
-        }
-        return this._toReport(response.data);
+        const envelope = await this.callOperation('Create report', (0, sdk_gen_1.opCreateReport)({ path: { graph_id: graphId }, body }));
+        return {
+            operationId: envelope.operationId,
+            status: envelope.status,
+            result: envelope.result ?? null,
+        };
     }
-    /**
-     * List all reports for a graph (includes received shared reports).
-     */
+    /** List all reports for a graph (includes received shared reports). */
     async list(graphId) {
-        const response = await (0, sdk_gen_1.listReports)({
-            path: { graph_id: graphId },
-        });
-        if (response.error) {
-            throw new Error(`List reports failed: ${JSON.stringify(response.error)}`);
-        }
-        const data = response.data;
-        return (data.reports ?? []).map((r) => this._toReport(r));
+        const list = await this.gqlQuery(graphId, graphql_1.ListLedgerReportsDocument, undefined, 'List reports', (data) => data.reports);
+        return list?.reports ?? [];
     }
-    /**
-     * Get a report with its available structures.
-     */
+    /** Get a single report with its period list + available structures. */
     async get(graphId, reportId) {
-        const response = await (0, sdk_gen_1.getReport)({
-            path: { graph_id: graphId, report_id: reportId },
-        });
-        if (response.error) {
-            throw new Error(`Get report failed: ${JSON.stringify(response.error)}`);
-        }
-        return this._toReport(response.data);
+        return this.gqlQuery(graphId, graphql_1.GetLedgerReportDocument, { reportId }, 'Get report', (data) => data.report);
     }
     /**
      * Render a financial statement — facts viewed through a structure.
@@ -71,87 +51,50 @@ class ReportClient {
      * @param structureType - income_statement, balance_sheet, cash_flow_statement
      */
     async statement(graphId, reportId, structureType) {
-        const response = await (0, sdk_gen_1.getStatement)({
-            path: { graph_id: graphId, report_id: reportId, structure_type: structureType },
-        });
-        if (response.error) {
-            throw new Error(`Get statement failed: ${JSON.stringify(response.error)}`);
-        }
-        const data = response.data;
-        return {
-            reportId: data.report_id,
-            structureId: data.structure_id,
-            structureName: data.structure_name,
-            structureType: data.structure_type,
-            periods: (data.periods ?? []).map((p) => ({
-                start: p.start,
-                end: p.end,
-                label: p.label,
-            })),
-            rows: (data.rows ?? []).map((r) => ({
-                elementId: r.element_id,
-                elementQname: r.element_qname,
-                elementName: r.element_name,
-                classification: r.classification,
-                values: r.values ?? [],
-                isSubtotal: r.is_subtotal ?? false,
-                depth: r.depth ?? 0,
-            })),
-            validation: data.validation
-                ? {
-                    passed: data.validation.passed,
-                    checks: data.validation.checks,
-                    failures: data.validation.failures,
-                    warnings: data.validation.warnings,
-                }
-                : null,
-            unmappedCount: data.unmapped_count ?? 0,
-        };
+        return this.gqlQuery(graphId, graphql_1.GetLedgerStatementDocument, { reportId, structureType }, 'Get statement', (data) => data.statement);
     }
     /**
-     * Regenerate a report with new period dates.
+     * Regenerate an existing report (async). Returns an operation id;
+     * subscribe via SSE for progress.
      */
     async regenerate(graphId, reportId, periodStart, periodEnd) {
-        const response = await (0, sdk_gen_1.regenerateReport)({
-            path: { graph_id: graphId, report_id: reportId },
-            body: { period_start: periodStart, period_end: periodEnd },
-        });
-        if (response.error) {
-            throw new Error(`Regenerate report failed: ${JSON.stringify(response.error)}`);
-        }
-        return this._toReport(response.data);
+        const envelope = await this.callOperation('Regenerate report', (0, sdk_gen_1.opRegenerateReport)({
+            path: { graph_id: graphId },
+            body: {
+                report_id: reportId,
+                period_start: periodStart,
+                period_end: periodEnd,
+            },
+        }));
+        return {
+            operationId: envelope.operationId,
+            status: envelope.status,
+            result: envelope.result ?? null,
+        };
     }
-    /**
-     * Delete a report and its generated facts.
-     */
+    /** Delete a report and its generated facts. */
     async delete(graphId, reportId) {
-        const response = await (0, sdk_gen_1.deleteReport)({
-            path: { graph_id: graphId, report_id: reportId },
-        });
-        if (response.error) {
-            throw new Error(`Delete report failed: ${JSON.stringify(response.error)}`);
-        }
+        await this.callOperation('Delete report', (0, sdk_gen_1.opDeleteReport)({
+            path: { graph_id: graphId },
+            body: { report_id: reportId },
+        }));
     }
     /**
-     * Share a published report to all members of a publish list (snapshot copy).
+     * Share a published report to every member of a publish list (async).
+     * Each target graph receives a snapshot copy of the report's facts.
      */
     async share(graphId, reportId, publishListId) {
-        const response = await (0, sdk_gen_1.shareReport)({
-            path: { graph_id: graphId, report_id: reportId },
-            body: { publish_list_id: publishListId },
-        });
-        if (response.error) {
-            throw new Error(`Share report failed: ${JSON.stringify(response.error)}`);
-        }
-        const data = response.data;
+        const envelope = await this.callOperation('Share report', (0, sdk_gen_1.opShareReport)({
+            path: { graph_id: graphId },
+            body: {
+                report_id: reportId,
+                publish_list_id: publishListId,
+            },
+        }));
         return {
-            reportId: data.report_id,
-            results: (data.results ?? []).map((r) => ({
-                targetGraphId: r.target_graph_id,
-                status: r.status,
-                error: r.error ?? null,
-                factCount: r.fact_count ?? 0,
-            })),
+            operationId: envelope.operationId,
+            status: envelope.status,
+            result: envelope.result ?? null,
         };
     }
     /** Check if a report was received via sharing (vs locally created). */
@@ -159,120 +102,90 @@ class ReportClient {
         return report.sourceGraphId !== null;
     }
     // ── Publish Lists ────────────────────────────────────────────────────
-    async listPublishLists(graphId) {
-        const response = await (0, sdk_gen_1.listPublishLists)({
-            path: { graph_id: graphId },
-        });
-        if (response.error) {
-            throw new Error(`List publish lists failed: ${JSON.stringify(response.error)}`);
-        }
-        const data = response.data;
-        return (data.publish_lists ?? []).map((pl) => this._toPublishList(pl));
-    }
+    /** List publish lists with pagination. */
+    async listPublishLists(graphId, options) {
+        const list = await this.gqlQuery(graphId, graphql_1.ListLedgerPublishListsDocument, {
+            limit: options?.limit ?? 100,
+            offset: options?.offset ?? 0,
+        }, 'List publish lists', (data) => data.publishLists);
+        return list?.publishLists ?? [];
+    }
+    /** Create a new publish list. */
     async createPublishList(graphId, name, description) {
-        const response = await (0, sdk_gen_1.createPublishList)({
-            path: { graph_id: graphId },
-            body: { name, description: description ?? null },
-        });
-        if (response.error) {
-            throw new Error(`Create publish list failed: ${JSON.stringify(response.error)}`);
-        }
-        return this._toPublishList(response.data);
+        const body = {
+            name,
+            description: description ?? null,
+        };
+        const envelope = await this.callOperation('Create publish list', (0, sdk_gen_1.opCreatePublishList)({ path: { graph_id: graphId }, body }));
+        return (envelope.result ?? {});
     }
+    /** Get a single publish list with its full member list. */
     async getPublishList(graphId, listId) {
-        const response = await (0, sdk_gen_1.getPublishList)({
-            path: { graph_id: graphId, list_id: listId },
-        });
-        if (response.error) {
-            throw new Error(`Get publish list failed: ${JSON.stringify(response.error)}`);
-        }
-        const data = response.data;
-        return {
-            ...this._toPublishList(data),
-            members: (data.members ?? []).map((m) => this._toMember(m)),
-        };
+        return this.gqlQuery(graphId, graphql_1.GetLedgerPublishListDocument, { listId }, 'Get publish list', (data) => data.publishList);
     }
+    /** Update a publish list's name or description. */
     async updatePublishList(graphId, listId, updates) {
-        const response = await (0, sdk_gen_1.updatePublishList)({
-            path: { graph_id: graphId, list_id: listId },
-            body: updates,
-        });
-        if (response.error) {
-            throw new Error(`Update publish list failed: ${JSON.stringify(response.error)}`);
-        }
-        return this._toPublishList(response.data);
-    }
+        const envelope = await this.callOperation('Update publish list', (0, sdk_gen_1.opUpdatePublishList)({
+            path: { graph_id: graphId },
+            body: {
+                list_id: listId,
+                name: updates.name,
+                description: updates.description ?? null,
+            },
+        }));
+        return (envelope.result ?? {});
+    }
+    /** Delete a publish list. */
     async deletePublishList(graphId, listId) {
-        const response = await (0, sdk_gen_1.deletePublishList)({
-            path: { graph_id: graphId, list_id: listId },
-        });
-        if (response.error) {
-            throw new Error(`Delete publish list failed: ${JSON.stringify(response.error)}`);
-        }
+        await this.callOperation('Delete publish list', (0, sdk_gen_1.opDeletePublishList)({
+            path: { graph_id: graphId },
+            body: { list_id: listId },
+        }));
     }
+    /** Add target graphs as members of a publish list. */
     async addMembers(graphId, listId, targetGraphIds) {
-        const response = await (0, sdk_gen_1.addPublishListMembers)({
-            path: { graph_id: graphId, list_id: listId },
-            body: { target_graph_ids: targetGraphIds },
-        });
-        if (response.error) {
-            throw new Error(`Add members failed: ${JSON.stringify(response.error)}`);
-        }
-        return (response.data ?? []).map((m) => this._toMember(m));
-    }
+        const envelope = await this.callOperation('Add publish list members', (0, sdk_gen_1.opAddPublishListMembers)({
+            path: { graph_id: graphId },
+            body: {
+                list_id: listId,
+                target_graph_ids: targetGraphIds,
+            },
+        }));
+        return (envelope.result ?? {});
+    }
+    /** Remove a single member from a publish list. */
     async removeMember(graphId, listId, memberId) {
-        const response = await (0, sdk_gen_1.removePublishListMember)({
-            path: { graph_id: graphId, list_id: listId, member_id: memberId },
-        });
-        if (response.error) {
-            throw new Error(`Remove member failed: ${JSON.stringify(response.error)}`);
+        const envelope = await this.callOperation('Remove publish list member', (0, sdk_gen_1.opRemovePublishListMember)({
+            path: { graph_id: graphId },
+            body: { list_id: listId, member_id: memberId },
+        }));
+        return (envelope.result ?? { deleted: true });
+    }
+    // ── Internal helpers ────────────────────────────────────────────────
+    async gqlQuery(graphId, document, variables, label, pick) {
+        try {
+            const client = this.gql.get(graphId);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const raw = client.request;
+            const data = (await raw.call(client, document, variables));
+            return pick(data);
+        }
+        catch (err) {
+            if (err instanceof graphql_request_1.ClientError) {
+                throw new Error(`${label} failed: ${JSON.stringify(err.response.errors ?? err.message)}`);
+            }
+            throw err;
         }
     }
-    _toPublishList(pl) {
-        return {
-            id: pl.id,
-            name: pl.name,
-            description: pl.description ?? null,
-            memberCount: pl.member_count ?? 0,
-            createdBy: pl.created_by,
-            createdAt: pl.created_at,
-            updatedAt: pl.updated_at,
-        };
-    }
-    _toMember(m) {
-        return {
-            id: m.id,
-            targetGraphId: m.target_graph_id,
-            targetGraphName: m.target_graph_name ?? null,
-            targetOrgName: m.target_org_name ?? null,
-            addedBy: m.added_by,
-            addedAt: m.added_at,
-        };
-    }
-    _toReport(r) {
-        return {
-            id: r.id,
-            name: r.name,
-            taxonomyId: r.taxonomy_id,
-            generationStatus: r.generation_status,
-            periodType: r.period_type,
-            periodStart: r.period_start ?? null,
-            periodEnd: r.period_end ?? null,
-            comparative: r.comparative,
-            mappingId: r.mapping_id ?? null,
-            aiGenerated: r.ai_generated ?? false,
-            createdAt: r.created_at,
-            lastGenerated: r.last_generated ?? null,
-            structures: (r.structures ?? []).map((s) => ({
-                id: s.id,
-                name: s.name,
-                structureType: s.structure_type,
-            })),
-            entityName: r.entity_name ?? null,
-            sourceGraphId: r.source_graph_id ?? null,
-            sourceReportId: r.source_report_id ?? null,
-            sharedAt: r.shared_at ?? null,
-        };
+    async callOperation(label, call) {
+        const response = await call;
+        if (response.error !== undefined) {
+            throw new Error(`${label} failed: ${JSON.stringify(response.error)}`);
+        }
+        if (response.data === undefined) {
+            throw new Error(`${label} failed: empty response`);
+        }
+        return response.data;
     }
 }
 exports.ReportClient = ReportClient;