@beignet/cli 0.0.6 → 0.0.8

package/src/registry-edits.ts

@@ -0,0 +1,352 @@
+/**
+ * Shared string-edit helpers for registry files.
+ *
+ * `beignet make` generators and `beignet doctor --fix` both append entries to
+ * app-owned registry files such as `server/schedules.ts`, `server/tasks.ts`,
+ * and `server/outbox.ts`. Keeping the import insertion, array append, and
+ * membership primitives in one module keeps both write paths byte-compatible.
+ */
+
+/**
+ * Source slice for an initializer expression, with absolute offsets.
+ */
+export type InitializerInfo = {
+  text: string;
+  start: number;
+  end: number;
+};
+
+/**
+ * Result of appending an entry to a named registry.
+ *
+ * `missing` means the registry anchor could not be found or is not an array
+ * literal; callers should bail without writing.
+ */
+export type AppendResult =
+  | { kind: "updated"; source: string }
+  | { kind: "unchanged" }
+  | { kind: "missing" };
+
+/**
+ * Find the index of the delimiter closing the one at `openIndex`, skipping
+ * string literals.
+ */
+export function matchingDelimiterIndex(
+  source: string,
+  openIndex: number,
+  open: string,
+  close: string,
+): number {
+  let depth = 0;
+  let inString: string | undefined;
+  let escaped = false;
+
+  for (let index = openIndex; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    if (char === open) {
+      depth++;
+      continue;
+    }
+
+    if (char === close) {
+      depth--;
+      if (depth === 0) return index;
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Insert a line directly after the last top-level import statement.
+ */
+export function insertAfterImports(source: string, line: string): string {
+  const lines = source.split("\n");
+  let lastImportIndex = -1;
+
+  for (let index = 0; index < lines.length; index++) {
+    if (lines[index].startsWith("import ")) {
+      lastImportIndex = index;
+    }
+  }
+
+  if (lastImportIndex === -1) {
+    return `${line}\n${source}`;
+  }
+
+  lines.splice(lastImportIndex + 1, 0, line);
+  return lines.join("\n");
+}
+
+/**
+ * Collect every identifier referenced inside an array (or object) expression.
+ */
+export function identifiersFromArrayExpression(
+  expression: string,
+): Set<string> {
+  const withoutBrackets = expression.replace(/^\[/, "").replace(/\]$/, "");
+
+  return new Set(
+    Array.from(
+      withoutBrackets.matchAll(/\b[A-Za-z_$][\w$]*\b/g),
+      ([name]) => name,
+    ),
+  );
+}
+
+/**
+ * Append entries to an array literal, preserving single-line and multiline
+ * formatting plus trailing commas.
+ */
+export function appendToArrayExpression(
+  expression: string,
+  names: string[],
+): string {
+  const closingBracket = /\]\s*$/.exec(expression);
+  if (!closingBracket) return expression;
+
+  const beforeClosingBracket = expression.slice(0, closingBracket.index);
+  const closingBracketText = expression.slice(closingBracket.index);
+  const inner = beforeClosingBracket.replace(/^\[/, "");
+  if (!inner.trim()) return `[${names.join(", ")}]`;
+
+  if (!expression.includes("\n")) {
+    const separator = /,\s*$/.test(inner) ? " " : ", ";
+    return `${beforeClosingBracket}${separator}${names.join(", ")}${closingBracketText}`;
+  }
+
+  const itemIndent =
+    inner
+      .split("\n")
+      .find((line) => line.trim())
+      ?.match(/^[\t ]*/)?.[0] ?? "\t";
+  const closingIndent = inner.match(/\n([\t ]*)$/)?.[1] ?? "";
+  const trimmedBeforeClosingBracket = beforeClosingBracket.replace(/\s*$/, "");
+  const appendedNames = names.join(`,\n${itemIndent}`);
+
+  if (/,\s*$/.test(inner)) {
+    return `${trimmedBeforeClosingBracket}\n${itemIndent}${appendedNames},\n${closingIndent}${closingBracketText}`;
+  }
+
+  return `${trimmedBeforeClosingBracket},\n${itemIndent}${appendedNames}${closingBracketText}`;
+}
+
+/**
+ * Locate the array literal initializing `const <constName> = ...`.
+ *
+ * Wrapping calls such as `defineTasks([...])` are tolerated because the first
+ * `[` after the assignment is used.
+ */
+export function arrayInitializerInfo(
+  source: string,
+  constName: string,
+): InitializerInfo | undefined {
+  const match = new RegExp(`\\bconst\\s+${constName}\\s*=`).exec(source);
+  if (!match) return undefined;
+
+  const openBracket = source.indexOf("[", match.index);
+  if (openBracket === -1) return undefined;
+
+  const closeBracket = matchingDelimiterIndex(source, openBracket, "[", "]");
+  if (closeBracket === -1) return undefined;
+
+  return {
+    text: source.slice(openBracket, closeBracket + 1),
+    start: openBracket,
+    end: closeBracket + 1,
+  };
+}
+
+/**
+ * Append `entry` to the array initializing `const <constName> = [...]` and
+ * insert `importLine` after the imports when it is not already present.
+ *
+ * Generalizes the `server/schedules.ts` and `server/tasks.ts` registry update
+ * used by `beignet make`. Returns `missing` without touching the source when
+ * the array cannot be found, so callers never partially write.
+ */
+export function appendToNamedArray(
+  source: string,
+  constName: string,
+  entry: string,
+  importLine?: string,
+): AppendResult {
+  const registry = arrayInitializerInfo(source, constName);
+  if (!registry) return { kind: "missing" };
+
+  return appendEntry(source, registry, entry, importLine, (next) =>
+    arrayInitializerInfo(next, constName),
+  );
+}
+
+/**
+ * Locate the `events` or `jobs` value inside `defineOutboxRegistry({...})`.
+ */
+export function outboxRegistryValueInfo(
+  source: string,
+  property: "events" | "jobs",
+): InitializerInfo | undefined {
+  const call = /\bdefineOutboxRegistry\s*(?:<[^>]*>\s*)?\(/.exec(source);
+  if (!call) return undefined;
+
+  const openBrace = source.indexOf("{", call.index);
+  if (openBrace === -1) return undefined;
+
+  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+  if (closeBrace === -1) return undefined;
+
+  const objectText = source.slice(openBrace, closeBrace + 1);
+  const propertyMatch = new RegExp(`\\b${property}\\s*:`).exec(objectText);
+  if (!propertyMatch) return undefined;
+
+  const valueStart = openBrace + propertyMatch.index + propertyMatch[0].length;
+  const value = topLevelValueSlice(source, valueStart, closeBrace);
+  if (!value) return undefined;
+
+  return value;
+}
+
+/**
+ * Append `entry` to the `events` or `jobs` array of
+ * `defineOutboxRegistry({...})` and insert `importLine` when needed.
+ *
+ * Returns `missing` without touching the source when the registry call or
+ * property is absent, or when the property value is not an array literal.
+ */
+export function appendToOutboxRegistryArray(
+  source: string,
+  property: "events" | "jobs",
+  entry: string,
+  importLine?: string,
+): AppendResult {
+  const value = outboxRegistryValueInfo(source, property);
+  if (!value) return { kind: "missing" };
+
+  const entryName = entryIdentifier(entry);
+  if (identifiersFromArrayExpression(value.text).has(entryName)) {
+    return appendEntry(source, value, entry, importLine, () => undefined, {
+      alreadyListed: true,
+    });
+  }
+
+  if (!value.text.startsWith("[")) return { kind: "missing" };
+
+  return appendEntry(source, value, entry, importLine, (next) =>
+    outboxRegistryValueInfo(next, property),
+  );
+}
+
+function entryIdentifier(entry: string): string {
+  return entry.replace(/^\.{3}/, "").trim();
+}
+
+function appendEntry(
+  source: string,
+  info: InitializerInfo,
+  entry: string,
+  importLine: string | undefined,
+  relocate: (next: string) => InitializerInfo | undefined,
+  options: { alreadyListed?: boolean } = {},
+): AppendResult {
+  const alreadyListed =
+    options.alreadyListed ??
+    identifiersFromArrayExpression(info.text).has(entryIdentifier(entry));
+  let next = source;
+
+  if (importLine && !next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  if (!alreadyListed) {
+    const target = next === source ? info : relocate(next);
+    if (!target) return { kind: "missing" };
+    const nextArray = appendToArrayExpression(target.text, [entry]);
+    next = `${next.slice(0, target.start)}${nextArray}${next.slice(target.end)}`;
+  }
+
+  if (next === source) return { kind: "unchanged" };
+  return { kind: "updated", source: next };
+}
+
+function topLevelValueSlice(
+  source: string,
+  valueStart: number,
+  hardEnd: number,
+): InitializerInfo | undefined {
+  let start = valueStart;
+  while (start < hardEnd && /\s/.test(source[start])) start++;
+  if (start >= hardEnd) return undefined;
+
+  let depth = 0;
+  let inString: string | undefined;
+  let escaped = false;
+
+  for (let index = start; index <= hardEnd; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    if (char === "[" || char === "(" || char === "{") {
+      depth++;
+      continue;
+    }
+
+    if (char === "]" || char === ")" || char === "}") {
+      if (depth === 0) {
+        return trimmedInfo(source, start, index);
+      }
+      depth--;
+      continue;
+    }
+
+    if (char === "," && depth === 0) {
+      return trimmedInfo(source, start, index);
+    }
+  }
+
+  return undefined;
+}
+
+function trimmedInfo(
+  source: string,
+  start: number,
+  end: number,
+): InitializerInfo {
+  let trimmedEnd = end;
+  while (trimmedEnd > start && /\s/.test(source[trimmedEnd - 1])) trimmedEnd--;
+
+  return {
+    text: source.slice(start, trimmedEnd),
+    start,
+    end: trimmedEnd,
+  };
+}