@meyicloud/meyi-cost-server 1.8.0 → 1.8.2

package/package.json

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

package/src/repositories/cost-analysis-report.repository.js

@@ -7,7 +7,6 @@ export class CostAnalysisReportRepository {
     this.db = db;
     this.schedules = `${qSchema}.cost_ai_report_schedules`;
     this.reports = `${qSchema}.cost_ai_reports`;
-    this.incidentTickets = `${qSchema}.cost_ai_incident_tickets`;
   }
 
   async getSchedule(tenantId) {
@@ -110,43 +109,6 @@ export class CostAnalysisReportRepository {
     `));
   }
 
-  async stageIncidentTickets(report, tickets) {
-    for (const ticket of tickets) {
-      await this.db.execute(sql`
-        INSERT INTO ${sql.raw(this.incidentTickets)}
-          (tenant_id, ticket_id, report_id, payload)
-        VALUES (${report.tenant_id}, ${ticket.ticket_id}, ${report.id}, ${JSON.stringify(ticket)}::jsonb)
-        ON CONFLICT (tenant_id, ticket_id) DO UPDATE SET
-          payload = EXCLUDED.payload, report_id = EXCLUDED.report_id, updated_at = now()
-      `);
-    }
-  }
-
-  async listUnsyncedIncidentTickets(reportId) {
-    return rows(await this.db.execute(sql`
-      SELECT * FROM ${sql.raw(this.incidentTickets)}
-      WHERE report_id = ${reportId} AND sync_status IN ('PENDING', 'FAILED')
-      ORDER BY created_at ASC
-    `));
-  }
-
-  async markIncidentTicketSynced(tenantId, ticketId, incidentId) {
-    await this.db.execute(sql`
-      UPDATE ${sql.raw(this.incidentTickets)}
-      SET incident_id = ${incidentId}, sync_status = 'COMPLETED', sync_error = NULL,
-          synced_at = now(), updated_at = now()
-      WHERE tenant_id = ${tenantId} AND ticket_id = ${ticketId}
-    `);
-  }
-
-  async markIncidentTicketFailed(tenantId, ticketId, error) {
-    await this.db.execute(sql`
-      UPDATE ${sql.raw(this.incidentTickets)}
-      SET sync_status = 'FAILED', sync_error = ${String(error?.message || error).slice(0, 2000)}, updated_at = now()
-      WHERE tenant_id = ${tenantId} AND ticket_id = ${ticketId}
-    `);
-  }
-
   async setIncidentSyncState(reportId, status, error = null) {
     await this.db.execute(sql`
       UPDATE ${sql.raw(this.reports)}

package/src/schema/cost-analysis-report.schema.js

@@ -67,18 +67,5 @@ export async function installCostAnalysisReportSchema(db, qSchema) {
   await db.execute(sql.raw(`UPDATE ${qSchema}.cost_ai_reports
     SET ticket_count = (result->>'ticketCount')::integer
     WHERE ticket_count = 0 AND result ? 'ticketCount' AND (result->>'ticketCount') ~ '^[0-9]+$'`));
-  await db.execute(sql.raw(`CREATE TABLE IF NOT EXISTS ${qSchema}.cost_ai_incident_tickets (
-    tenant_id text NOT NULL,
-    ticket_id text NOT NULL,
-    report_id text NOT NULL REFERENCES ${qSchema}.cost_ai_reports(id) ON DELETE CASCADE,
-    payload jsonb NOT NULL,
-    incident_id text,
-    sync_status text NOT NULL DEFAULT 'PENDING' CHECK (sync_status IN ('PENDING', 'COMPLETED', 'FAILED')),
-    sync_error text,
-    synced_at timestamptz,
-    created_at timestamptz NOT NULL DEFAULT now(),
-    updated_at timestamptz NOT NULL DEFAULT now(),
-    PRIMARY KEY (tenant_id, ticket_id)
-  )`));
-  await db.execute(sql.raw(`CREATE INDEX IF NOT EXISTS cost_ai_incident_tickets_report_idx ON ${qSchema}.cost_ai_incident_tickets (report_id, sync_status)`));
+  await db.execute(sql.raw(`DROP TABLE IF EXISTS ${qSchema}.cost_ai_incident_tickets`));
 }

package/src/services/cost-analyser.service.js

@@ -175,6 +175,7 @@ export class CostAnalyserService {
     if (!athena.enabled) throw Object.assign(new Error("CUR discovery has not produced a queryable Athena table for this tenant"), { name: "CurDataNotReadyError", statusCode: 503 });
     const targetRoleArn = required(customer.meta?.payerRoleArn, "customer TARGET_ROLE_ARN");
     const targetAccountId = required(customer.meta?.managementAccountId || customer.accounts?.[0]?.id, "customer management account ID");
+    const targetAccountName = customer.accounts?.find((account) => account.id === targetAccountId)?.name || targetAccountId;
     const prefix = `tenants/${tenantId}/reports/${reportId}`;
     let providerSecretArn;
     try {
@@ -189,6 +190,7 @@ export class CostAnalyserService {
         REPORT_BUCKET: this.reportBucket,
         REPORT_BUCKET_REGION: this.region,
         TARGET_ACCOUNT_ID: targetAccountId,
+        TARGET_ACCOUNT_NAME: targetAccountName,
         TARGET_ROLE_ARN: targetRoleArn,
         TARGET_ROLE_EXTERNAL_ID: customer.meta?.externalId,
         TARGET_REGIONS: this.targetRegions,

package/src/services/cost-incident-sync.service.js

@@ -17,22 +17,15 @@ export class CostIncidentSyncService {
     if (!this.incidentSink) return false;
     try {
       const key = this.ticketsKey(report);
-      if (!report.artifact_bucket || !key) throw new Error("FinOps ticket artifact location is missing");
+      if (!report.artifact_bucket || !key) throw new Error("Cost ticket artifact location is missing");
       const data = await this.artifactService.get(report.artifact_bucket, key);
-      if (!data) throw new Error("FinOps ticket artifact is empty");
+      if (!data) throw new Error("Cost ticket artifact is empty");
       const parsed = JSON.parse(data.toString("utf8"));
       const tickets = Array.isArray(parsed?.tickets) ? parsed.tickets.filter((ticket) => ticket?.ticket_id) : [];
-      await this.repository.stageIncidentTickets(report, tickets);
 
-      for (const row of await this.repository.listUnsyncedIncidentTickets(report.id)) {
-        try {
-          const result = await this.incidentSink({ tenantId: report.tenant_id, report, ticket: row.payload });
-          if (!result?.id) throw new Error("Incident integration did not return an incident ID");
-          await this.repository.markIncidentTicketSynced(report.tenant_id, row.ticket_id, result.id);
-        } catch (error) {
-          await this.repository.markIncidentTicketFailed(report.tenant_id, row.ticket_id, error);
-          throw error;
-        }
+      for (const ticket of tickets) {
+        const result = await this.incidentSink({ tenantId: report.tenant_id, report, ticket });
+        if (!result?.id) throw new Error(`Incident integration did not return an incident ID for ${ticket.ticket_id}`);
       }
 
       await this.repository.setIncidentSyncState(report.id, "COMPLETED");