@meyicloud/meyi-cost-server 1.8.2 → 1.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meyicloud/meyi-cost-server",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "description": "Tenant-aware AWS CUR and Athena cost plugin server for MeyiConnect",
   "type": "module",
   "main": "./index.js",

package/src/controllers/cost.controller.js

@@ -3,6 +3,9 @@ import {
   getCurOverview,
   getCurReport,
   getCurTags,
+  mergeCurFilterOptions,
+  mergeCurOverview,
+  mergeCurReports,
 } from "../services/cur.service.js";
 import { dateRange, iso, listParam } from "../lib/cost-utils.js";
 
@@ -18,9 +21,10 @@ export class CostController {
     try {
       const ctx = await this.contextService.resolve(req);
       const names = new Map(ctx.accounts.map((item) => [item.id, item.name]));
-      const report = await this.curProvider.run(ctx, (client, config) => getCurReport({
+      const reports = await this.curProvider.run(ctx, (client, config) => getCurReport({
         client, config, tenant: ctx.tenant, range: dateRange(req.query), groupBy: "account", accountNames: names,
       }));
+      const report = mergeCurReports(reports);
       return res.json({
         accounts: report.summary.map((item) => ({ id: item.accountId || item.key, name: item.label, region: "global", status: "active" })),
         dataSource: "aws-cur-athena",
@@ -37,7 +41,7 @@ export class CostController {
       const trendStart = trendMode === "monthly" ? new Date(`${range.End}T00:00:00Z`) : new Date(`${range.Start}T00:00:00Z`);
       if (trendMode === "monthly") trendStart.setUTCMonth(0, 1);
       const names = new Map(ctx.accounts.map((item) => [item.id, item.name]));
-      const result = await this.curProvider.run(ctx, (client, config) => getCurOverview({
+      const results = await this.curProvider.run(ctx, (client, config) => getCurOverview({
         client,
         config,
         tenant: ctx.tenant,
@@ -46,6 +50,7 @@ export class CostController {
         trendMode,
         accountNames: names,
       }));
+      const result = mergeCurOverview(results);
       return res.json(result);
     } catch (error) { return next(error); }
   }
@@ -54,7 +59,7 @@ export class CostController {
     try {
       const ctx = await this.contextService.resolve(req);
       const names = new Map(ctx.accounts.map((item) => [item.id, item.name]));
-      const result = await this.curProvider.run(ctx, (client, config) => getCurFilterOptions({
+      const results = await this.curProvider.run(ctx, (client, config) => getCurFilterOptions({
         client,
         config,
         tenant: ctx.tenant,
@@ -62,6 +67,7 @@ export class CostController {
         tagKey: String(req.query.tagKey || "").trim(),
         accountNames: names,
       }));
+      const result = mergeCurFilterOptions(results);
       return res.json({ ...result, tenantId: ctx.tenant, updatedAt: new Date().toISOString() });
     } catch (error) { return next(error); }
   }
@@ -81,7 +87,7 @@ export class CostController {
         tagKey: String(req.query.filterTagKey || "").trim(),
         tagValues: listParam(req.query.tagValues),
       };
-      const result = await this.curProvider.run(ctx, (client, config) => getCurReport({
+      const results = await this.curProvider.run(ctx, (client, config) => getCurReport({
         client,
         config,
         tenant: ctx.tenant,
@@ -93,6 +99,7 @@ export class CostController {
         filters,
         includeBreakdown: true,
       }));
+      const result = mergeCurReports(results);
       return res.json({ ...result, tenantId: ctx.tenant, updatedAt: new Date().toISOString() });
     } catch (error) { return next(error); }
   }
@@ -100,7 +107,8 @@ export class CostController {
   async tags(req, res, next) {
     try {
       const ctx = await this.contextService.resolve(req);
-      const tags = await this.curProvider.run(ctx, (client, config) => getCurTags({ client, config, tenant: ctx.tenant }));
+      const tagSets = await this.curProvider.run(ctx, (client, config) => getCurTags({ client, config, tenant: ctx.tenant }));
+      const tags = [...new Set(tagSets.flat())].sort();
       return res.json({ tags, dataSource: "aws-cur-athena", accessMode: "cur-readonly" });
     } catch (error) { return next(error); }
   }

package/src/models/cur-data-status.model.js

@@ -1,5 +1,5 @@
-export class CurDataStatus {
-  constructor({ configured, required = true, ready = false, state, action = null, credentialMode = "saas-runtime", ingestionMode = "central", sourceConfigured = false, lastDataAt = null, recordCount = 0, message = null, discovery = null }) {
+export class CurDataStatus {
+  constructor({ configured, required = true, ready = false, state, action = null, credentialMode = "saas-runtime", ingestionMode = "central", sourceConfigured = false, lastDataAt = null, recordCount = 0, message = null, discovery = null, sources = [], managementAccountId = null, connectionId = null }) {
     this.configured = Boolean(configured);
     this.required = Boolean(required);
     this.ready = Boolean(ready);
@@ -11,7 +11,10 @@ export class CurDataStatus {
     this.lastDataAt = lastDataAt;
     this.recordCount = Number(recordCount || 0);
     this.message = message;
-    this.discovery = discovery ? Object.freeze({ ...discovery }) : null;
+    this.discovery = discovery ? Object.freeze({ ...discovery }) : null;
+    this.sources = Object.freeze(sources.map((source) => Object.freeze({ ...source })));
+    this.managementAccountId = managementAccountId;
+    this.connectionId = connectionId;
     Object.freeze(this);
   }
 }

package/src/models/customer-aws-context.model.js

@@ -6,10 +6,16 @@ const normalizeAccount = (account = {}) => Object.freeze({
 });
 
 export class CustomerAwsContext {
-  constructor({ tenant, accounts = [], meta = {} }) {
-    this.tenant = String(tenant || "default").trim() || "default";
-    this.accounts = Object.freeze(accounts.map(normalizeAccount).filter((account) => account.id));
+  constructor({ tenant, accounts = [], meta = {}, sources = [] }) {
+    this.tenant = String(tenant || "default").trim() || "default";
+    this.accounts = Object.freeze(accounts.map(normalizeAccount).filter((account) => account.id));
     this.meta = Object.freeze({ ...meta });
-    Object.freeze(this);
-  }
-}
+    this.sources = Object.freeze(sources.map((source) => Object.freeze({
+      managementAccountId: String(source.managementAccountId || "").trim(),
+      connectionId: String(source.connectionId || "").trim(),
+      accounts: Object.freeze((source.accounts || []).map(normalizeAccount).filter((account) => account.id)),
+      meta: Object.freeze({ ...(source.meta || {}) }),
+    })).filter((source) => source.connectionId));
+    Object.freeze(this);
+  }
+}

package/src/repositories/aws-onboarding.repository.js

@@ -11,7 +11,7 @@ export class AwsOnboardingRepository {
     this.curDiscoveryTable = `"${schema}".cost_cur_discovery_jobs`;
   }
 
-  async findCostAccess(tenant) {
+  async findCostAccess(tenant, managementAccountId = undefined) {
     const relations = rows(await this.db.execute(sql`
       SELECT
         to_regclass(${`${this.schema}.aws_connections`}) AS connections_table,
@@ -22,115 +22,103 @@ export class AwsOnboardingRepository {
 
     if (!relations.connections_table) return { accounts: [], meta: {} };
 
-    const connection = rows(await this.db.execute(sql`
-      SELECT
+    const connections = rows(await this.db.execute(sql`
+      SELECT
         connection_id,
         role_arn,
         external_id,
         management_account_id
       FROM ${sql.raw(this.connectionsTable)}
       WHERE tenant_id::text = ${tenant}
-        AND status = 'CONNECTED'
-        AND plugins ? 'Cost'
-        AND COALESCE(verification_checks->>'costAccess', 'false') = 'true'
-      ORDER BY connected_at DESC NULLS LAST, created_at DESC
-      LIMIT 1
-    `))[0];
-
-    if (!connection) return { accounts: [], meta: {} };
-
-    const curConfig = relations.cur_config_table ? rows(await this.db.execute(sql`
-      SELECT export_arn, bucket, prefix, region, tenant_partition, status, last_data_at
-      FROM ${sql.raw(this.curConfigTable)}
-      WHERE tenant_id::text = ${tenant}
-        AND connection_id = ${connection.connection_id}
-      LIMIT 1
-    `))[0] || {} : {};
-
-    const curDiscovery = relations.cur_discovery_table ? rows(await this.db.execute(sql`
-      SELECT id, status, attempt_count, glue_database, glue_table, table_location,
-             cur_s3_uri, last_data_at, last_error, last_started_at, last_finished_at, next_run_at
-      FROM ${sql.raw(this.curDiscoveryTable)}
-      WHERE tenant_id = ${tenant}
-        AND connection_id = ${connection.connection_id}
-      LIMIT 1
-    `))[0] || {} : {};
-
-    const accounts = relations.accounts_table ? rows(await this.db.execute(sql`
-      SELECT account_id, account_name, status
-      FROM ${sql.raw(this.accountsTable)}
-      WHERE tenant_id::text = ${tenant}
-        AND connection_id = ${connection.connection_id}
-        AND LOWER(status) = 'active'
-      ORDER BY account_name
-    `)) : [];
-
-    return {
-      accounts: accounts.map((item) => ({
-        id: item.account_id,
-        name: item.account_name || item.account_id,
-        region: "global",
-        status: item.status,
-      })),
-      meta: {
-        payerRoleArn: connection.role_arn,
+        AND status = 'CONNECTED'
+        AND plugins ? 'Cost'
+        AND COALESCE(verification_checks->>'costAccess', 'false') = 'true'
+        AND (${managementAccountId || null}::text IS NULL OR management_account_id = ${managementAccountId || null})
+      ORDER BY connected_at DESC NULLS LAST, created_at DESC
+    `));
+
+    if (!connections.length) return { accounts: [], meta: {}, sources: [] };
+
+    const connectionIds = connections.map((connection) => connection.connection_id);
+    const curConfigs = relations.cur_config_table ? rows(await this.db.execute(sql`
+      SELECT export_arn, bucket, prefix, region, tenant_partition, status, last_data_at
+             , connection_id
+      FROM ${sql.raw(this.curConfigTable)}
+      WHERE tenant_id::text = ${tenant} AND connection_id = ANY(${connectionIds})
+    `)) : [];
+
+    const discoveries = relations.cur_discovery_table ? rows(await this.db.execute(sql`
+      SELECT id, status, attempt_count, glue_database, glue_table, table_location,
+             cur_s3_uri, last_data_at, last_error, last_started_at, last_finished_at, next_run_at, connection_id
+      FROM ${sql.raw(this.curDiscoveryTable)}
+      WHERE tenant_id = ${tenant} AND connection_id = ANY(${connectionIds})
+    `)) : [];
+
+    const allAccounts = relations.accounts_table ? rows(await this.db.execute(sql`
+      SELECT connection_id, account_id, account_name, status
+      FROM ${sql.raw(this.accountsTable)}
+      WHERE tenant_id::text = ${tenant}
+        AND connection_id = ANY(${connectionIds})
+        AND LOWER(status) = 'active'
+      ORDER BY account_name
+    `)) : [];
+
+    const configByConnection = new Map(curConfigs.map((item) => [item.connection_id, item]));
+    const discoveryByConnection = new Map(discoveries.map((item) => [item.connection_id, item]));
+    const sources = connections.map((connection) => {
+      const curConfig = configByConnection.get(connection.connection_id) || {};
+      const curDiscovery = discoveryByConnection.get(connection.connection_id) || {};
+      const accounts = allAccounts.filter((account) => account.connection_id === connection.connection_id).map((item) => ({
+        id: item.account_id, name: item.account_name || item.account_id, region: "global", status: item.status,
+      }));
+      return {
         managementAccountId: connection.management_account_id,
-        externalId: connection.external_id,
-        connectionId: connection.connection_id,
-        curExportArn: curConfig.export_arn,
-        curSourceBucket: curConfig.bucket,
-        curSourcePrefix: curConfig.prefix,
-        curSourceRegion: curConfig.region,
-        curTenantPartition: curConfig.tenant_partition || tenant,
-        curIngestionMode: "central",
-        curStatus: curConfig.status,
-        curLastDataAt: curConfig.last_data_at,
-        curDiscoveredTable: curDiscovery.status === "READY" ? curDiscovery.glue_table : undefined,
-        curDiscovery: curDiscovery.id ? {
-          jobId: String(curDiscovery.id),
-          status: curDiscovery.status,
-          attemptCount: Number(curDiscovery.attempt_count || 0),
-          database: curDiscovery.glue_database,
-          table: curDiscovery.glue_table,
-          tableLocation: curDiscovery.table_location,
-          curS3Uri: curDiscovery.cur_s3_uri,
-          lastDataAt: curDiscovery.last_data_at,
-          lastError: curDiscovery.last_error,
-          lastStartedAt: curDiscovery.last_started_at,
-          lastFinishedAt: curDiscovery.last_finished_at,
-          nextRunAt: curDiscovery.next_run_at,
-        } : null,
-      },
-    };
-  }
+        connectionId: connection.connection_id,
+        accounts,
+        meta: {
+          payerRoleArn: connection.role_arn, managementAccountId: connection.management_account_id,
+          externalId: connection.external_id, connectionId: connection.connection_id,
+          curExportArn: curConfig.export_arn, curSourceBucket: curConfig.bucket, curSourcePrefix: curConfig.prefix,
+          curSourceRegion: curConfig.region, curTenantPartition: curConfig.tenant_partition || tenant,
+          curIngestionMode: "central", curStatus: curConfig.status, curLastDataAt: curConfig.last_data_at,
+          curDiscoveredTable: curDiscovery.status === "READY" ? curDiscovery.glue_table : undefined,
+          curDiscovery: curDiscovery.id ? {
+            jobId: String(curDiscovery.id), status: curDiscovery.status, attemptCount: Number(curDiscovery.attempt_count || 0),
+            database: curDiscovery.glue_database, table: curDiscovery.glue_table, tableLocation: curDiscovery.table_location,
+            curS3Uri: curDiscovery.cur_s3_uri, lastDataAt: curDiscovery.last_data_at, lastError: curDiscovery.last_error,
+            lastStartedAt: curDiscovery.last_started_at, lastFinishedAt: curDiscovery.last_finished_at, nextRunAt: curDiscovery.next_run_at,
+          } : null,
+        },
+      };
+    });
+
+    return {
+      accounts: sources.flatMap((source) => source.accounts),
+      meta: sources[0].meta,
+      sources,
+    };
+  }
 
-  async updateCurStatus(tenant, status) {
+  async updateCurStatus(tenant, status) {
     const relation = rows(await this.db.execute(sql`
       SELECT to_regclass(${`${this.schema}.cost_cur_config`}) AS cur_config_table
     `))[0];
     if (!relation?.cur_config_table) return;
-    const curStatus = status.ready
-      ? "READY"
-      : status.state === "pending_data"
-        ? "WAITING_FOR_DATA"
-        : status.state === "unavailable"
-          ? "FAILED"
-          : "PROVISIONING";
-    await this.db.execute(sql`
-      UPDATE ${sql.raw(this.curConfigTable)}
-      SET status = ${curStatus},
-          last_data_at = ${status.lastDataAt || null},
-          verified_at = now(),
-          updated_at = now()
-      WHERE connection_id = (
-        SELECT connection_id
-        FROM ${sql.raw(this.connectionsTable)}
-        WHERE tenant_id::text = ${tenant}
-          AND status = 'CONNECTED'
-          AND plugins ? 'Cost'
-        ORDER BY connected_at DESC NULLS LAST, created_at DESC
-        LIMIT 1
-      )
-    `);
-  }
-}
+    const sources = status.sources?.length ? status.sources : [];
+    for (const source of sources) {
+      if (!source.connectionId) continue;
+      const curStatus = source.ready
+        ? "READY"
+        : source.state === "pending_data"
+          ? "WAITING_FOR_DATA"
+          : source.state === "unavailable"
+            ? "FAILED"
+            : "PROVISIONING";
+      await this.db.execute(sql`
+        UPDATE ${sql.raw(this.curConfigTable)}
+        SET status = ${curStatus}, last_data_at = ${source.lastDataAt || null}, verified_at = now(), updated_at = now()
+        WHERE tenant_id::text = ${tenant} AND connection_id = ${source.connectionId}
+      `);
+    }
+  }
+}

package/src/services/cur-provider.service.js

@@ -1,20 +1,32 @@
-import { CurDataStatus } from "../models/cur-data-status.model.js";
-import { getCurDataStatus } from "./cur.service.js";
-
+import { CurDataStatus } from "../models/cur-data-status.model.js";
+import { getCurDataStatus } from "./cur.service.js";
+
 export class CurProviderService {
-  constructor({ athenaContextService, logger = console, env = process.env } = {}) {
-    this.athenaContextService = athenaContextService;
-    this.logger = logger;
-    this.statusCache = new Map();
-    this.statusCacheMs = Math.max(Number(env.COST_CUR_STATUS_CACHE_MS || 300000), 0);
-  }
-
+  constructor({ athenaContextService, logger = console, env = process.env } = {}) {
+    this.athenaContextService = athenaContextService;
+    this.logger = logger;
+    this.statusCache = new Map();
+    this.statusCacheMs = Math.max(Number(env.COST_CUR_STATUS_CACHE_MS || 300000), 0);
+  }
+
+  sourceContexts(customerContext) {
+    const sources = customerContext.sources?.length ? customerContext.sources : [{
+      managementAccountId: customerContext.meta?.managementAccountId || "",
+      connectionId: customerContext.meta?.connectionId || "",
+      accounts: customerContext.accounts,
+      meta: customerContext.meta,
+    }];
+    return sources.map((source) => ({
+      source,
+      context: this.athenaContextService.resolve({ tenant: customerContext.tenant, accounts: source.accounts, meta: source.meta }),
+    }));
+  }
+
   async run(customerContext, action) {
-    const context = this.athenaContextService.resolve(customerContext);
     const readiness = await this.status(customerContext);
     if (!readiness.ready) throw this.notReadyError(readiness);
     try {
-      return await action(context.client, context.config);
+      return await Promise.all(this.sourceContexts(customerContext).map(({ source, context }) => action(context.client, context.config, source)));
     } catch (error) {
       this.logger.error?.("[Cost] CUR/Athena query failed", error);
       const unavailable = new Error("CUR is configured, but its Athena data could not be queried. Review the CUR discovery status, Glue table, Athena output location, and IAM permissions.");
@@ -36,60 +48,66 @@ export class CurProviderService {
     error.dataStatus = readiness;
     return error;
   }
-
-  async status(customerContext) {
-    const context = this.athenaContextService.resolve(customerContext);
+
+  async statusForSource(tenant, source, context) {
+    const base = { managementAccountId: source.managementAccountId, connectionId: source.connectionId };
     if (!context.config.enabled) {
-      const discovery = customerContext.meta?.curDiscovery || null;
+      const discovery = source.meta?.curDiscovery || null;
       const sourceConfigured = context.ingestion.sourceConfigured;
       return new CurDataStatus({
-        configured: false,
-        required: true,
-        credentialMode: context.credentialMode,
-        ingestionMode: context.ingestion.mode,
-        sourceConfigured,
+        ...base, configured: false, required: true, credentialMode: context.credentialMode,
+        ingestionMode: context.ingestion.mode, sourceConfigured,
         state: discovery?.status ? String(discovery.status).toLowerCase() : "not_configured",
-        action: discovery || sourceConfigured ? "review_cur_discovery" : "connect_source",
-        discovery,
+        action: discovery || sourceConfigured ? "review_cur_discovery" : "connect_source", discovery,
         message: context.config.disabledReason || (discovery || sourceConfigured
           ? "CUR discovery has not produced a queryable Glue table yet. Review its status and resolve any reported error."
           : "CUR is not configured for this tenant. Connect an AWS cost source and deploy the CUR setup."),
-      });
-    }
-    const cacheKey = `${customerContext.tenant}:${context.config.tenantPartition}`;
-    const cached = this.statusCache.get(cacheKey);
-    if (cached && Date.now() - cached.createdAt < this.statusCacheMs) return cached.status;
-    try {
-      const result = await getCurDataStatus({ client: context.client, config: context.config, tenant: customerContext.tenant });
-      const status = new CurDataStatus({
-        configured: true,
-        required: true,
-        ready: result.recordCount > 0,
-        state: result.recordCount > 0 ? "ready" : "pending_data",
-        action: result.recordCount > 0 ? null : "review_cur_discovery",
-        credentialMode: context.credentialMode,
-        ingestionMode: context.ingestion.mode,
-        sourceConfigured: context.ingestion.sourceConfigured,
-        lastDataAt: result.lastDataAt,
-        recordCount: result.recordCount,
-        message: result.recordCount > 0 ? null : "CUR is configured, but no report rows are available for this tenant yet. Verify that AWS delivered report files and that discovery completed for the tenant partition.",
-        discovery: customerContext.meta?.curDiscovery || null,
-      });
-      this.statusCache.set(cacheKey, { createdAt: Date.now(), status });
-      return status;
-    } catch (error) {
+      });
+    }
+    try {
+      const result = await getCurDataStatus({ client: context.client, config: context.config, tenant });
+      return new CurDataStatus({
+        ...base, configured: true, required: true, ready: result.recordCount > 0,
+        state: result.recordCount > 0 ? "ready" : "pending_data", action: result.recordCount > 0 ? null : "review_cur_discovery",
+        credentialMode: context.credentialMode, ingestionMode: context.ingestion.mode,
+        sourceConfigured: context.ingestion.sourceConfigured, lastDataAt: result.lastDataAt, recordCount: result.recordCount,
+        message: result.recordCount > 0 ? null : "CUR is configured, but no report rows are available for this management account yet.",
+        discovery: source.meta?.curDiscovery || null,
+      });
+    } catch (error) {
       this.logger.warn?.("[Cost] CUR readiness check failed", error.message);
       return new CurDataStatus({
-        configured: true,
-        required: true,
-        state: "unavailable",
-        action: "review_cur_discovery",
-        credentialMode: context.credentialMode,
-        ingestionMode: context.ingestion.mode,
-        sourceConfigured: context.ingestion.sourceConfigured,
+        ...base, configured: true, required: true, state: "unavailable", action: "review_cur_discovery",
+        credentialMode: context.credentialMode, ingestionMode: context.ingestion.mode,
+        sourceConfigured: context.ingestion.sourceConfigured,
         message: "CUR is configured, but its Athena data is unavailable. Review the discovery error, Glue table, Athena output location, and IAM permissions.",
-        discovery: customerContext.meta?.curDiscovery || null,
-      });
-    }
-  }
-}
+        discovery: source.meta?.curDiscovery || null,
+      });
+    }
+  }
+
+  async status(customerContext) {
+    const contexts = this.sourceContexts(customerContext);
+    if (!contexts.length) return new CurDataStatus({ configured: false, required: true, state: "not_configured", action: "connect_source", message: "CUR is not configured for this tenant. Connect an AWS cost source and deploy the CUR setup." });
+    const cacheKey = `${customerContext.tenant}:${contexts.map(({ source }) => source.connectionId).sort().join(",")}`;
+    const cached = this.statusCache.get(cacheKey);
+    if (cached && Date.now() - cached.createdAt < this.statusCacheMs) return cached.status;
+    const statuses = await Promise.all(contexts.map(({ source, context }) => this.statusForSource(customerContext.tenant, source, context)));
+    const ready = statuses.every((status) => status.ready);
+    const status = new CurDataStatus({
+      configured: statuses.some((item) => item.configured), required: true, ready,
+      state: ready ? "ready" : statuses.some((item) => item.state === "unavailable") ? "unavailable" : statuses.some((item) => item.state === "not_configured") ? "not_configured" : "pending_data",
+      action: ready ? null : statuses.some((item) => item.action === "connect_source") ? "connect_source" : "review_cur_discovery",
+      credentialMode: statuses[0]?.credentialMode || "saas-runtime-identity", ingestionMode: "central",
+      sourceConfigured: statuses.some((item) => item.sourceConfigured),
+      lastDataAt: statuses.map((item) => item.lastDataAt).filter(Boolean).sort().at(-1) || null,
+      recordCount: statuses.reduce((total, item) => total + item.recordCount, 0),
+      message: ready ? null : statuses.length === 1
+        ? statuses[0].message
+        : "One or more selected management-account CUR sources are not ready. Review Cost Sources and CUR Discovery before viewing aggregated costs.",
+      sources: statuses.map((item) => ({ managementAccountId: item.managementAccountId, connectionId: item.connectionId, state: item.state, ready: item.ready, lastDataAt: item.lastDataAt, recordCount: item.recordCount, message: item.message })),
+    });
+    this.statusCache.set(cacheKey, { createdAt: Date.now(), status });
+    return status;
+  }
+}

package/src/services/cur.service.js

@@ -312,7 +312,7 @@ export async function getCurTags({ client, config, tenant }) {
   return rows.map((row) => String(row.tag_key || "").replace(/^user:/, "")).filter(Boolean);
 }
 
-export async function getCurFilterOptions({ client, config, tenant, range, tagKey, accountNames = new Map() }) {
+export async function getCurFilterOptions({ client, config, tenant, range, tagKey, accountNames = new Map() }) {
   const distinct = async (column) => execute(client, config, `
     SELECT DISTINCT CAST("${column}" AS VARCHAR) AS value
     FROM ${table(config)}
@@ -342,7 +342,7 @@ export async function getCurFilterOptions({ client, config, tenant, range, tagKe
     `)).map((row) => row.value).filter(Boolean);
   }
   const options = (items, type) => items.map((item) => ({ value: item.value, label: type === "account" ? accountNames.get(item.value) || item.value : item.value }));
-  return {
+  return {
     services: options(services),
     regions: options(regions),
     accounts: options(accounts, "account"),
@@ -350,5 +350,91 @@ export async function getCurFilterOptions({ client, config, tenant, range, tagKe
     tagValues,
     dataSource: "aws-cur-athena",
     accessMode: "cur-readonly",
-  };
-}
+  };
+}
+
+function mergeRelations(items = []) {
+  const totals = new Map();
+  for (const item of items) totals.set(item.key, { ...item, amount: (totals.get(item.key)?.amount || 0) + amount(item.amount) });
+  return [...totals.values()].map((item) => ({ ...item, amount: round(item.amount) })).sort((a, b) => b.amount - a.amount);
+}
+
+function mergeSummary(items = []) {
+  const totals = new Map();
+  for (const item of items) {
+    const key = item.key || item.accountId || item.label;
+    const current = totals.get(key) || { ...item, key, amount: 0, accounts: [], regions: [] };
+    current.amount += amount(item.amount);
+    current.accounts = mergeRelations([...current.accounts, ...(item.accounts || [])]);
+    current.regions = mergeRelations([...current.regions, ...(item.regions || [])]);
+    totals.set(key, current);
+  }
+  const total = [...totals.values()].reduce((sum, item) => sum + item.amount, 0);
+  return [...totals.values()].map((item) => ({ ...item, amount: round(item.amount), percentage: total ? round(item.amount / total * 100) : 0 }))
+    .sort((a, b) => b.amount - a.amount);
+}
+
+export function mergeCurReports(reports = []) {
+  const first = reports[0];
+  if (!first) return null;
+  const timeline = new Map();
+  for (const report of reports) for (const period of report.timeline || []) {
+    const current = timeline.get(period.start) || { start: period.start, end: period.end, groups: [] };
+    current.groups.push(...(period.groups || []));
+    timeline.set(period.start, current);
+  }
+  const mergedTimeline = [...timeline.values()].map((period) => {
+    const groups = mergeSummary(period.groups);
+    return { ...period, groups, total: round(groups.reduce((sum, item) => sum + item.amount, 0)) };
+  }).sort((a, b) => a.start.localeCompare(b.start));
+  const summary = mergeSummary(reports.flatMap((report) => report.summary || []));
+  return {
+    ...first,
+    totalCost: round(reports.reduce((sum, report) => sum + amount(report.totalCost), 0)),
+    count: summary.length,
+    summary,
+    timeline: mergedTimeline,
+    message: reports.map((report) => report.message).filter(Boolean).join(" ") || undefined,
+  };
+}
+
+export function mergeCurOverview(overviews = []) {
+  const first = overviews[0];
+  if (!first) return null;
+  const accounts = new Map();
+  for (const overview of overviews) for (const account of overview.accounts || []) accounts.set(account.id, account);
+  const trends = new Map();
+  for (const overview of overviews) for (const trend of overview.trends || []) {
+    trends.set(trend.month, { ...trend, amount: (trends.get(trend.month)?.amount || 0) + amount(trend.amount) });
+  }
+  const grossCost = round(overviews.reduce((sum, overview) => sum + amount(overview.grossCost), 0));
+  const netCost = round(overviews.reduce((sum, overview) => sum + amount(overview.netCost), 0));
+  return {
+    ...first,
+    accounts: [...accounts.values()],
+    totalCost: grossCost,
+    grossCost,
+    netCost,
+    creditsAndAdjustments: round(netCost - grossCost),
+    activeAccounts: accounts.size,
+    activeResources: overviews.reduce((sum, overview) => sum + Number(overview.activeResources || 0), 0),
+    trends: [...trends.values()].map((trend) => ({ ...trend, amount: round(trend.amount) })).sort((a, b) => a.month.localeCompare(b.month)),
+    topServices: mergeSummary(overviews.flatMap((overview) => overview.topServices || [])).slice(0, 10),
+    topAccounts: mergeSummary(overviews.flatMap((overview) => overview.topAccounts || [])).slice(0, 10),
+    topRegions: mergeSummary(overviews.flatMap((overview) => overview.topRegions || [])).slice(0, 10),
+  };
+}
+
+export function mergeCurFilterOptions(options = []) {
+  const mergeOptions = (key) => {
+    const merged = new Map();
+    for (const option of options) for (const item of option[key] || []) merged.set(item.value, item);
+    return [...merged.values()].sort((a, b) => a.label.localeCompare(b.label));
+  };
+  return {
+    services: mergeOptions("services"), regions: mergeOptions("regions"), accounts: mergeOptions("accounts"),
+    tagKeys: [...new Set(options.flatMap((option) => option.tagKeys || []))].sort(),
+    tagValues: [...new Set(options.flatMap((option) => option.tagValues || []))].sort(),
+    dataSource: "aws-cur-athena", accessMode: "cur-readonly",
+  };
+}

package/src/services/customer-aws-context.service.js

@@ -10,13 +10,19 @@ export class CustomerAwsContextService {
     return String(req.user?.tenant_id || req.user?.tenantId || req.headers["x-tenant-id"] || this.defaultTenant).trim() || this.defaultTenant;
   }
 
-  async resolve(req) {
-    const tenant = this.tenantId(req);
-    const stored = await this.repository.findCostAccess(tenant);
+  async resolve(req) {
+    const tenant = this.tenantId(req);
+    const managementAccountId = String(req.query?.managementAccountId || "").trim();
+    if (managementAccountId && !/^\d{12}$/.test(managementAccountId)) {
+      const error = new Error("managementAccountId must contain exactly 12 digits");
+      error.statusCode = 400;
+      throw error;
+    }
+    const stored = await this.repository.findCostAccess(tenant, managementAccountId || undefined);
     const accounts = stored.accounts;
     const meta = stored.meta;
-    return new CustomerAwsContext({ tenant, accounts, meta });
-  }
+    return new CustomerAwsContext({ tenant, accounts, meta, sources: stored.sources || [] });
+  }
 
   async recordCurStatus(tenant, status) {
     if (typeof this.repository.updateCurStatus === "function") {