Enhance runPublisher to log detailed steps and summarize loaded records

Author: m-houston

packages/ddb-publisher/src/__tests__/run.test.ts

@@ -149,4 +149,73 @@ describe("runPublisher", () => {
 
     expect(publish.publishRecords).toHaveBeenCalledTimes(1);
   });
+
+  it("should publish when audit reports no blocking items", async () => {
+    const store: LoadedConfigStore = {
+      rootPath: "/tmp",
+      records: [],
+    };
+    fileStore.loadConfigStore.mockResolvedValue(store);
+    fileStore.validateConfigStore.mockReturnValue({ ok: true, issues: [] });
+
+    audit.auditBeforeLoad.mockResolvedValue({
+      blocking: [],
+    });
+
+    await runPublisher({
+      sourcePath: "/tmp",
+      env: "draft",
+      tableName: "tbl",
+      dryRun: false,
+      force: false,
+    });
+
+    expect(publish.publishRecords).toHaveBeenCalledTimes(1);
+  });
+
+  it("should log entity summary when records are loaded", async () => {
+    const writeSpy = jest
+      .spyOn(process.stdout, "write")
+      .mockImplementation(() => true);
+
+    const store: LoadedConfigStore = {
+      rootPath: "/tmp",
+      records: [
+        {
+          entity: "supplier",
+          sourceFilePath: "/tmp/supplier/1.json",
+          id: "1",
+          data: {},
+        },
+        {
+          entity: "channel",
+          sourceFilePath: "/tmp/channel/1.json",
+          id: "1",
+          data: {},
+        },
+        {
+          entity: "supplier",
+          sourceFilePath: "/tmp/supplier/2.json",
+          id: "2",
+          data: {},
+        },
+      ],
+    };
+
+    fileStore.loadConfigStore.mockResolvedValue(store);
+    fileStore.validateConfigStore.mockReturnValue({ ok: true, issues: [] });
+
+    await runPublisher({
+      sourcePath: "/tmp",
+      env: "draft",
+      tableName: "tbl",
+      dryRun: true,
+      force: false,
+    });
+
+    const logOutput = writeSpy.mock.calls.map(([msg]) => String(msg)).join("\n");
+    expect(logOutput).toContain("Loaded 3 records (channel=1, supplier=2).\n");
+
+    writeSpy.mockRestore();
+  });
 });

packages/ddb-publisher/src/run.ts

@@ -5,7 +5,7 @@ import {
   loadConfigStore,
   validateConfigStore,
 } from "@supplier-config/file-store";
-import type { ValidationIssue } from "@supplier-config/file-store";
+import type { ConfigRecord, ValidationIssue } from "@supplier-config/file-store";
 
 import { auditBeforeLoad } from "./ddb/audit";
 import { publishRecords } from "./ddb/publish";
@@ -21,11 +21,40 @@ function issueLabel(i: {
   return `${i.entity} ${i.sourceFilePath}${pathPart} - ${i.message}`;
 }
 
+function logStep(message: string): void {
+  process.stdout.write(`[ddb-publisher] ${message}\n`);
+}
+
+function summarizeEntities(records: ConfigRecord[]): string {
+  const counts = new Map<string, number>();
+
+  for (const r of records) {
+    counts.set(r.entity, (counts.get(r.entity) ?? 0) + 1);
+  }
+
+  return [...counts.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([entity, count]) => `${entity}=${count}`)
+    .join(", ");
+}
+
 async function runPublisher(plan: LoadPlan): Promise<void> {
+  logStep(
+    `Starting publish run source='${plan.sourcePath}' env='${plan.env}' table='${plan.tableName}' force=${plan.force} dryRun=${plan.dryRun}`,
+  );
+
+  logStep("Loading config store from disk...");
   const store = await loadConfigStore(plan.sourcePath);
+  logStep(
+    `Loaded ${store.records.length} records${store.records.length > 0 ? ` (${summarizeEntities(store.records)})` : ""}.`,
+  );
+
+  logStep("Validating loaded records against schemas...");
   const validation = validateConfigStore(store);
 
   if (!validation.ok) {
+    logStep(`Validation failed with ${validation.issues.length} issue(s).`);
+
     const summary = validation.issues
       .slice(0, 20)
       .map((i: ValidationIssue) => issueLabel(i))
@@ -36,22 +65,32 @@ async function runPublisher(plan: LoadPlan): Promise<void> {
     );
   }
 
-  if (plan.dryRun) return;
+  logStep("Validation passed.");
+
+  if (plan.dryRun) {
+    logStep("Dry-run enabled; skipping DynamoDB audit and publish.");
+    return;
+  }
 
+  logStep("Initialising DynamoDB client...");
   const client = new DynamoDBClient({});
   const ddb = DynamoDBDocumentClient.from(client, {
     marshallOptions: {
       removeUndefinedValues: true,
     },
   });
 
+  logStep("Auditing existing DynamoDB records...");
   const audit = await auditBeforeLoad({
     ddb,
     tableName: plan.tableName,
     localRecords: store.records,
   });
+  logStep(`Audit completed. blockingRecords=${audit.blocking.length}`);
 
   if (audit.blocking.length > 0 && !plan.force) {
+    logStep("Blocking records found and --force not set; aborting publish.");
+
     const examples = audit.blocking
       .slice(0, 20)
       .map(
@@ -65,12 +104,19 @@ async function runPublisher(plan: LoadPlan): Promise<void> {
     );
   }
 
+  if (audit.blocking.length > 0 && plan.force) {
+    logStep("Blocking records found but --force enabled; continuing.");
+  }
+
+  logStep(`Publishing ${store.records.length} record(s) to DynamoDB...`);
   await publishRecords({
     ddb,
     tableName: plan.tableName,
     env: plan.env,
     records: store.records,
   });
+
+  logStep("Publish completed successfully.");
 }
 
 export default runPublisher;