@nmakarov/cli-toolkit 0.43.0 → 0.44.0

package/dist/index.js

@@ -2283,23 +2283,18 @@ function defaultFileSynopsisFunction(fileEntry, data) {
   const timestamps = [];
   const statusCounts = {};
   for (const item of data) {
-    let ts = null;
-    let status = null;
+    if (!item || typeof item !== "object") continue;
     for (const [key, value] of Object.entries(item)) {
       const k = key.toLowerCase();
-      if (k === "modificationtimestamp") {
-        ts = new Date(value).getTime();
+      if (k.endsWith("modificationtimestamp") && value != null && value !== "") {
+        const ts = new Date(value).getTime();
+        if (!Number.isNaN(ts)) timestamps.push(ts);
       }
-      if (k === "standardstatus") {
-        status = value;
+      if (k === "standardstatus" && value != null && value !== "") {
+        const status = String(value);
+        statusCounts[status] = (statusCounts[status] || 0) + 1;
       }
     }
-    if (ts && !isNaN(ts)) {
-      timestamps.push(ts);
-    }
-    if (status !== null && status !== void 0) {
-      statusCounts[status] = (statusCounts[status] || 0) + 1;
-    }
   }
   const result = { ...fileEntry };
   if (timestamps.length) {
@@ -2318,27 +2313,38 @@ function defaultVersionSynopsisFunction(metadata) {
   const timestamps = [];
   const statusCounts = {};
   for (const file of metadata.files) {
-    if (file.minModificationTimestamp) {
+    if (file?.minModificationTimestamp) {
       const minTs = new Date(file.minModificationTimestamp).getTime();
-      if (!isNaN(minTs)) timestamps.push(minTs);
+      if (!Number.isNaN(minTs)) timestamps.push(minTs);
     }
-    if (file.maxModificationTimestamp) {
+    if (file?.maxModificationTimestamp) {
       const maxTs = new Date(file.maxModificationTimestamp).getTime();
-      if (!isNaN(maxTs)) timestamps.push(maxTs);
+      if (!Number.isNaN(maxTs)) timestamps.push(maxTs);
     }
-    if (file.StandardStatuses && typeof file.StandardStatuses === "object") {
+    if (file?.StandardStatuses && typeof file.StandardStatuses === "object") {
       for (const [status, count] of Object.entries(file.StandardStatuses)) {
-        statusCounts[status] = (statusCounts[status] || 0) + count;
+        statusCounts[status] = (statusCounts[status] || 0) + Number(count || 0);
       }
     }
   }
   const result = { ...metadata };
+  const synopsis = {
+    ...metadata.synopsis && typeof metadata.synopsis === "object" ? metadata.synopsis : {}
+  };
   if (timestamps.length) {
-    result.minModificationTimestamp = new Date(Math.min(...timestamps)).toISOString();
-    result.maxModificationTimestamp = new Date(Math.max(...timestamps)).toISOString();
+    const minIso = new Date(Math.min(...timestamps)).toISOString();
+    const maxIso = new Date(Math.max(...timestamps)).toISOString();
+    result.minModificationTimestamp = minIso;
+    result.maxModificationTimestamp = maxIso;
+    synopsis.minModificationTimestamp = minIso;
+    synopsis.maxModificationTimestamp = maxIso;
   }
   if (Object.keys(statusCounts).length > 0) {
     result.StandardStatuses = statusCounts;
+    synopsis.StandardStatuses = statusCounts;
+  }
+  if (Object.keys(synopsis).length) {
+    result.synopsis = synopsis;
   }
   return result;
 }
@@ -6321,22 +6327,46 @@ async function ensureTaskTables(context, options = {}) {
       }
     }
     const { actions } = await ensureSchema(db, spec, { dryRun, logger: context.logger });
+    const legacyDrops = await dropLegacyTaskNameColumn(db, [tasksTable, historyTable], {
+      dryRun,
+      log,
+      label
+    });
+    const allActions = [...actions, ...legacyDrops];
     if (dryRun) {
-      if (actions.length === 0) {
+      if (allActions.length === 0) {
         log.info?.(`[tasks-schema] dryRun \u2014 ${label}: queue "${queueName}" already up to date; no DDL`);
       } else {
         log.info?.(
-          `[tasks-schema] dryRun \u2014 ${label}: would run ${actions.length} statement(s) for queue "${queueName}":`
+          `[tasks-schema] dryRun \u2014 ${label}: would run ${allActions.length} statement(s) for queue "${queueName}":`
         );
-        for (const s of actions) log.info?.(`  - ${s}`);
+        for (const s of allActions) log.info?.(`  - ${s}`);
       }
-    } else if (actions.length > 0) {
+    } else if (allActions.length > 0) {
       log.info?.(
-        `[tasks-schema] ${label}: applied ${actions.length} DDL statement(s) for queue "${queueName}"`
+        `[tasks-schema] ${label}: applied ${allActions.length} DDL statement(s) for queue "${queueName}"`
       );
     }
   }
 }
+async function dropLegacyTaskNameColumn(db, tableNames, { dryRun, log, label }) {
+  const actions = [];
+  for (const table of tableNames) {
+    if (!await db.tableExists(table).catch(() => false)) continue;
+    const hasTask = await db.schema.hasColumn(table, "task");
+    const hasName = await db.schema.hasColumn(table, "name");
+    if (!hasTask || !hasName) continue;
+    const sql = `ALTER TABLE "${table}" DROP COLUMN IF EXISTS "task"`;
+    actions.push(sql);
+    if (dryRun) {
+      log?.info?.(`[tasks-schema] dryRun \u2014 ${label}: ${sql}`);
+    } else {
+      await db.raw(sql);
+      log?.info?.(`[tasks-schema] ${label}: dropped legacy column ${table}.task`);
+    }
+  }
+  return actions;
+}
 async function enqueueTask(context, options) {
   const db = getDb(context);
   const queueName = options.queueName ?? "tasks";
@@ -6353,7 +6383,7 @@ async function enqueueTask(context, options) {
   } else if (schedule) {
     nextRunAt = nextTimeMatch(schedule, /* @__PURE__ */ new Date());
   }
-  await db(tasksTable).insert({
+  const row = {
     id,
     name,
     params: toJsonColumn(options.params ?? null),
@@ -6367,9 +6397,21 @@ async function enqueueTask(context, options) {
     server_name: options.serverName ?? null,
     status: "idle",
     status_changed_at: db.fn.now()
-  });
+  };
+  if (await tableHasLegacyTaskColumn(db, tasksTable)) {
+    row.task = name;
+  }
+  await db(tasksTable).insert(row);
   return id;
 }
+var legacyTaskColumnCache = /* @__PURE__ */ new Map();
+async function tableHasLegacyTaskColumn(db, tableName) {
+  const key = `${db?.config?.name ?? "db"}:${tableName}`;
+  if (!legacyTaskColumnCache.has(key)) {
+    legacyTaskColumnCache.set(key, await db.schema.hasColumn(tableName, "task"));
+  }
+  return legacyTaskColumnCache.get(key);
+}
 async function updateTaskProgress(context, tasksTable, taskId, progress) {
   const db = getDb(context);
   await db(tasksTable).where({ id: taskId }).update({