dxcomplete 0.2.0 → 0.2.2

package/scripts/dogfood-work-order.mjs

@@ -1,506 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { connectRuntime } from "../dist/runtime/mongo.js";
-import {
-  appendDxcompleteTicketReply,
-  archiveRecord,
-  COLLECTION_NAMES,
-  DXCOMPLETE_TICKET_COLLECTION_NAME
-} from "../dist/runtime/records.js";
-import { ensureWorkspaceBootstrap } from "../dist/runtime/auth.js";
-import { loadWorkspaceConfig } from "../dist/runtime/workspace.js";
-
-const defaultEnvFile = ".env.local";
-const runtimeActorId = "dxcomplete-runtime";
-
-const args = parseArgs(process.argv.slice(2));
-
-if (args.help || (!args.planPath && !args.modulePath)) {
-  printHelp();
-  process.exit(args.help ? 0 : 1);
-}
-
-const startedAt = Date.now();
-const runtime = await connectRuntime({ envFile: args.envFile ?? defaultEnvFile });
-
-try {
-  const workspaceConfig = await maybeLoadWorkspaceConfig(args.workspaceConfigPath);
-  const context = createContext(runtime, workspaceConfig);
-  const results = [];
-
-  if (args.planPath) {
-    results.push(await runPlan(await readPlan(args.planPath), context));
-  }
-
-  if (args.modulePath) {
-    results.push(await runModule(args.modulePath, context));
-  }
-
-  console.log(
-    JSON.stringify(
-      {
-        ok: true,
-        databaseName: runtime.config.databaseName,
-        workspaceId: workspaceConfig?.workspaceId,
-        elapsedSeconds: elapsedSeconds(startedAt),
-        results
-      },
-      null,
-      2
-    )
-  );
-} finally {
-  await runtime.close();
-}
-
-function parseArgs(argv) {
-  const parsed = {
-    help: false
-  };
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--help" || arg === "-h") {
-      parsed.help = true;
-      continue;
-    }
-
-    if (arg === "--plan") {
-      parsed.planPath = readRequiredArg(argv, index, "--plan");
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--plan=")) {
-      parsed.planPath = arg.slice("--plan=".length);
-      continue;
-    }
-
-    if (arg === "--module") {
-      parsed.modulePath = readRequiredArg(argv, index, "--module");
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--module=")) {
-      parsed.modulePath = arg.slice("--module=".length);
-      continue;
-    }
-
-    if (arg === "--env") {
-      parsed.envFile = readRequiredArg(argv, index, "--env");
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--env=")) {
-      parsed.envFile = arg.slice("--env=".length);
-      continue;
-    }
-
-    if (arg === "--workspace-config") {
-      parsed.workspaceConfigPath = readRequiredArg(argv, index, "--workspace-config");
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--workspace-config=")) {
-      parsed.workspaceConfigPath = arg.slice("--workspace-config=".length);
-      continue;
-    }
-
-    throw new Error(`Unknown argument: ${arg}`);
-  }
-
-  return parsed;
-}
-
-function readRequiredArg(argv, index, name) {
-  const value = argv[index + 1];
-  if (!value) {
-    throw new Error(`${name} requires a value.`);
-  }
-  return value;
-}
-
-async function maybeLoadWorkspaceConfig(configPath) {
-  try {
-    return await loadWorkspaceConfig(configPath ? { configPath } : {});
-  } catch (error) {
-    if (configPath) {
-      throw error;
-    }
-    return undefined;
-  }
-}
-
-function createContext(runtime, workspaceConfig) {
-  return {
-    runtime,
-    db: runtime.db,
-    workspaceConfig,
-    actorId: runtimeActorId,
-    helpers: {
-      appendDxcompleteTicketReply,
-      archiveRecord,
-      collectionNames: COLLECTION_NAMES,
-      dxcompleteTicketCollectionName: DXCOMPLETE_TICKET_COLLECTION_NAME,
-      ensureWorkspaceBootstrap,
-      getTicketOwnerActorId,
-      needsReplySummary,
-      verifyNoLinksToType
-    }
-  };
-}
-
-async function readPlan(planPath) {
-  const absolutePath = path.resolve(planPath);
-  return JSON.parse(await readFile(absolutePath, "utf8"));
-}
-
-async function runPlan(plan, context) {
-  if (!plan || typeof plan !== "object" || Array.isArray(plan)) {
-    throw new Error("Plan must be a JSON object.");
-  }
-
-  const started = Date.now();
-  const result = {
-    kind: "plan",
-    operations: []
-  };
-
-  if (plan.ensureWorkspaceBootstrap) {
-    if (!context.workspaceConfig) {
-      throw new Error("ensureWorkspaceBootstrap requires dxcomplete/workspace.json or --workspace-config.");
-    }
-    await ensureWorkspaceBootstrap(context.db, context.workspaceConfig, context.actorId);
-    result.operations.push({
-      operation: "ensureWorkspaceBootstrap",
-      workspaceId: context.workspaceConfig.workspaceId
-    });
-  }
-
-  if (plan.ticketSummary) {
-    result.operations.push({
-      operation: "ticketSummary",
-      ...(await needsReplySummary(context.db, plan.ticketSummary))
-    });
-  }
-
-  if (plan.getTickets) {
-    result.operations.push({
-      operation: "getTickets",
-      tickets: await getTickets(context.db, readStringArray(plan.getTickets, "getTickets"))
-    });
-  }
-
-  if (plan.appendTicketReplies) {
-    result.operations.push({
-      operation: "appendTicketReplies",
-      replies: await appendTicketReplies(context, readArray(plan.appendTicketReplies, "appendTicketReplies"))
-    });
-  }
-
-  if (plan.archiveRecords) {
-    result.operations.push({
-      operation: "archiveRecords",
-      archived: await archiveRecords(context, readArray(plan.archiveRecords, "archiveRecords"))
-    });
-  }
-
-  if (plan.verifyNoLinksToType) {
-    result.operations.push({
-      operation: "verifyNoLinksToType",
-      checks: await runNoLinkChecks(context, readArray(plan.verifyNoLinksToType, "verifyNoLinksToType"))
-    });
-  }
-
-  result.elapsedSeconds = elapsedSeconds(started);
-  return result;
-}
-
-async function runModule(modulePath, context) {
-  const started = Date.now();
-  const moduleUrl = pathToFileURL(path.resolve(modulePath)).href;
-  const module = await import(moduleUrl);
-
-  if (typeof module.run !== "function") {
-    throw new Error(`${modulePath} must export async function run(context).`);
-  }
-
-  return {
-    kind: "module",
-    modulePath,
-    result: await module.run(context),
-    elapsedSeconds: elapsedSeconds(started)
-  };
-}
-
-async function needsReplySummary(db, options = {}) {
-  const limit = readOptionalLimit(options.limit, 100);
-  const filter = {};
-
-  if (!options.includeArchived) {
-    filter.archivedAt = { $exists: false };
-  }
-
-  const tickets = await db
-    .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
-    .find(filter, { projection: { _id: 1, title: 1, updatedAt: 1, "fields.ownerActorId": 1, "fields.entries": 1 } })
-    .sort({ updatedAt: -1 })
-    .limit(limit)
-    .toArray();
-
-  const rows = tickets.map(ticketNeedsReplyRow);
-
-  return {
-    activeCount: tickets.length,
-    needsReplyCount: rows.filter((row) => row.needsReply).length,
-    needsReply: rows.filter((row) => row.needsReply)
-  };
-}
-
-async function getTickets(db, ids) {
-  const tickets = await db
-    .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
-    .find({ _id: { $in: ids } })
-    .toArray();
-  const byId = new Map(tickets.map((ticket) => [ticket._id, ticket]));
-
-  return ids.map((id) => {
-    const ticket = byId.get(id);
-    if (!ticket) {
-      return { id, found: false };
-    }
-
-    const entries = ticket.fields?.entries ?? [];
-    return {
-      id,
-      found: true,
-      title: ticket.title,
-      ownerActorId: ticket.fields?.ownerActorId,
-      updatedAt: ticket.updatedAt,
-      entries: entries.length,
-      lastEntry: entries.at(-1)
-    };
-  });
-}
-
-async function appendTicketReplies(context, replies) {
-  const results = [];
-
-  for (const reply of replies) {
-    if (!reply || typeof reply !== "object" || Array.isArray(reply)) {
-      throw new Error("Each appendTicketReplies entry must be an object.");
-    }
-
-    const id = readRequiredString(reply.id, "appendTicketReplies[].id");
-    const body = await readBody(reply, "appendTicketReplies[]");
-    const addressedToActorId =
-      typeof reply.addressedToActorId === "string" && reply.addressedToActorId.trim()
-        ? reply.addressedToActorId.trim()
-        : await getTicketOwnerActorId(context.db, id);
-
-    const updated = await appendDxcompleteTicketReply(
-      context.db,
-      {
-        id,
-        body,
-        addressedToActorId
-      },
-      context.actorId
-    );
-
-    results.push({
-      id,
-      addressedToActorId,
-      updatedAt: updated.updatedAt,
-      entries: Array.isArray(updated.fields?.entries) ? updated.fields.entries.length : undefined
-    });
-  }
-
-  return results;
-}
-
-async function archiveRecords(context, records) {
-  const results = [];
-
-  for (const record of records) {
-    if (!record || typeof record !== "object" || Array.isArray(record)) {
-      throw new Error("Each archiveRecords entry must be an object.");
-    }
-
-    const updated = await archiveRecord(
-      context.db,
-      {
-        recordType: readRequiredString(record.recordType, "archiveRecords[].recordType"),
-        id: readRequiredString(record.id, "archiveRecords[].id"),
-        workspaceId: typeof record.workspaceId === "string" ? record.workspaceId : context.workspaceConfig?.workspaceId,
-        reason: typeof record.reason === "string" ? record.reason : undefined,
-        supersededByType: typeof record.supersededByType === "string" ? record.supersededByType : undefined,
-        supersededById: typeof record.supersededById === "string" ? record.supersededById : undefined
-      },
-      context.actorId
-    );
-
-    results.push({
-      recordType: updated.recordType,
-      id: updated._id,
-      archivedAt: updated.archivedAt
-    });
-  }
-
-  return results;
-}
-
-async function runNoLinkChecks(context, checks) {
-  const results = [];
-
-  for (const check of checks) {
-    if (!check || typeof check !== "object" || Array.isArray(check)) {
-      throw new Error("Each verifyNoLinksToType entry must be an object.");
-    }
-
-    const toType = readRequiredString(check.toType, "verifyNoLinksToType[].toType");
-    const collections = check.collections
-      ? readStringArray(check.collections, "verifyNoLinksToType[].collections")
-      : [...COLLECTION_NAMES];
-    results.push(await verifyNoLinksToType(context.db, toType, collections));
-  }
-
-  return results;
-}
-
-async function verifyNoLinksToType(db, toType, collections = COLLECTION_NAMES) {
-  const residue = [];
-
-  for (const collectionName of collections) {
-    const count = await db.collection(collectionName).countDocuments({ "links.toType": toType });
-    if (count > 0) {
-      residue.push({ collectionName, count });
-    }
-  }
-
-  return {
-    toType,
-    ok: residue.length === 0,
-    residue
-  };
-}
-
-async function getTicketOwnerActorId(db, id) {
-  const ticket = await db
-    .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
-    .findOne({ _id: id }, { projection: { "fields.ownerActorId": 1 } });
-
-  if (!ticket) {
-    throw new Error(`DX Complete Ticket not found: ${id}`);
-  }
-
-  const ownerActorId = ticket.fields?.ownerActorId;
-  if (typeof ownerActorId !== "string" || !ownerActorId) {
-    throw new Error(`DX Complete Ticket owner actor is missing: ${id}`);
-  }
-
-  return ownerActorId;
-}
-
-function ticketNeedsReplyRow(ticket) {
-  const entries = ticket.fields?.entries ?? [];
-  const lastReply = [...entries].reverse().find((entry) => entry.direction === "dxcomplete_reply");
-  const lastSubmitter = [...entries].reverse().find((entry) => entry.direction === "submitter_entry");
-  const needsReply = Boolean(lastSubmitter && (!lastReply || lastSubmitter.createdAt > lastReply.createdAt));
-
-  return {
-    id: ticket._id,
-    title: ticket.title,
-    ownerActorId: ticket.fields?.ownerActorId,
-    updatedAt: ticket.updatedAt,
-    entries: entries.length,
-    needsReply,
-    lastSubmitterAt: lastSubmitter?.createdAt,
-    lastReplyAt: lastReply?.createdAt
-  };
-}
-
-async function readBody(input, label) {
-  if (typeof input.body === "string") {
-    return input.body;
-  }
-
-  if (typeof input.bodyFile === "string" && input.bodyFile.trim()) {
-    return readFile(path.resolve(input.bodyFile), "utf8");
-  }
-
-  throw new Error(`${label} requires body or bodyFile.`);
-}
-
-function readStringArray(value, label) {
-  const array = readArray(value, label);
-  return array.map((entry, index) => readRequiredString(entry, `${label}[${index}]`));
-}
-
-function readArray(value, label) {
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array.`);
-  }
-  return value;
-}
-
-function readRequiredString(value, label) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return value.trim();
-}
-
-function readOptionalLimit(value, fallback) {
-  if (value === undefined) {
-    return fallback;
-  }
-
-  if (!Number.isInteger(value) || value < 1 || value > 500) {
-    throw new Error("limit must be an integer from 1 to 500.");
-  }
-
-  return value;
-}
-
-function elapsedSeconds(started) {
-  return Number(((Date.now() - started) / 1000).toFixed(2));
-}
-
-function printHelp() {
-  console.log(`dogfood-work-order
-
-Usage:
-  node scripts/dogfood-work-order.mjs --plan ./work-order.json
-  node scripts/dogfood-work-order.mjs --module ./one-off.mjs
-
-Purpose:
-  Open Mongo once and batch dogfood reads, ticket replies, simple verification,
-  and optional one-off work-order modules.
-
-Plan shape:
-  {
-    "ensureWorkspaceBootstrap": true,
-    "ticketSummary": { "limit": 100 },
-    "getTickets": ["ticket-id"],
-    "appendTicketReplies": [
-      { "id": "ticket-id", "body": "Reply body" }
-    ],
-    "archiveRecords": [
-      { "recordType": "requirements", "id": "uuid", "reason": "Archived" }
-    ],
-    "verifyNoLinksToType": [
-      { "toType": "initiatives" }
-    ]
-  }
-
-Notes:
-  Ticket replies default to the ticket owner actor when addressedToActorId is omitted.
-  A module must export async function run(context).
-`);
-}