@beignet/cli 0.0.6 → 0.0.8

package/src/inspect.ts

@@ -18,6 +18,17 @@ import {
   formatGithubAnnotation,
   type GithubAnnotationSeverity,
 } from "./github-annotations.js";
+import {
+  type AppendResult,
+  appendToArrayExpression,
+  appendToNamedArray,
+  appendToOutboxRegistryArray,
+  arrayInitializerInfo,
+  identifiersFromArrayExpression,
+  insertAfterImports,
+  matchingDelimiterIndex,
+  outboxRegistryValueInfo,
+} from "./registry-edits.js";
 import { getCliVersion } from "./version.js";
 
 type InspectAppOptions = {
@@ -225,6 +236,23 @@ export async function applyDoctorFixes(
   );
   if (routeGroupFix) fixes.push(routeGroupFix);
 
+  const drift = await workflowRegistrationDrift(targetDir, files, config);
+
+  const scheduleFix = await fixUnregisteredSchedules(
+    targetDir,
+    files,
+    drift,
+    config,
+  );
+  if (scheduleFix) fixes.push(scheduleFix);
+
+  const taskFix = await fixUnregisteredTasks(targetDir, files, drift, config);
+  if (taskFix) fixes.push(taskFix);
+
+  fixes.push(
+    ...(await fixUnregisteredOutboxEntries(targetDir, files, drift, config)),
+  );
+
   const openApiFix = await fixDirectOpenApiArrayDrift(
     targetDir,
     files,
@@ -1300,6 +1328,12 @@ async function inspectDiagnostics(
       config,
       convention,
     )),
+    ...(await inspectWorkflowRegistrationDrift(
+      targetDir,
+      files,
+      config,
+      convention,
+    )),
     ...(await inspectResourceSlices(
       targetDir,
       files,
@@ -2847,6 +2881,463 @@ function containsCallExpression(source: string, name: string): boolean {
   ).test(source);
 }
 
+type WorkflowRegistryKind =
+  | "schedules"
+  | "tasks"
+  | "events"
+  | "jobs"
+  | "listeners";
+
+type FeatureWorkflowRegistry = {
+  kind: WorkflowRegistryKind;
+  registryName: string;
+  indexFile: string;
+  members: string[];
+  memberFiles: Map<string, string>;
+};
+
+type UnregisteredWorkflowRegistry = {
+  registry: FeatureWorkflowRegistry;
+  missingMembers: string[];
+  /** True when no member is individually registered either. */
+  fullyUnregistered: boolean;
+};
+
+type WorkflowRegistrationDrift = {
+  schedules: {
+    centralExists: boolean;
+    unregistered: UnregisteredWorkflowRegistry[];
+  };
+  tasks: {
+    centralExists: boolean;
+    unregistered: UnregisteredWorkflowRegistry[];
+  };
+  outbox: {
+    exists: boolean;
+    events: UnregisteredWorkflowRegistry[];
+    jobs: UnregisteredWorkflowRegistry[];
+  };
+  listeners: {
+    unregistered: UnregisteredWorkflowRegistry[];
+    wiringFile?: string;
+    eventBusFile?: string;
+  };
+};
+
+const workflowRegistrySuffixes: Record<WorkflowRegistryKind, string> = {
+  schedules: "Schedules",
+  tasks: "Tasks",
+  events: "Events",
+  jobs: "Jobs",
+  listeners: "Listeners",
+};
+
+async function inspectWorkflowRegistrationDrift(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+  convention: InspectConvention,
+): Promise<InspectDiagnostic[]> {
+  if (!convention.resourceGenerator) return [];
+
+  const drift = await workflowRegistrationDrift(targetDir, files, config);
+  const diagnostics: InspectDiagnostic[] = [];
+
+  for (const kind of ["schedules", "tasks"] as const) {
+    const { centralExists, unregistered } = drift[kind];
+    const centralFile =
+      kind === "schedules" ? config.paths.schedules : config.paths.tasks;
+    const code =
+      kind === "schedules"
+        ? "BEIGNET_SCHEDULE_UNREGISTERED"
+        : "BEIGNET_TASK_UNREGISTERED";
+    const registrationTarget =
+      kind === "schedules" ? "the schedules array" : "defineTasks([...])";
+    const makeCommand =
+      kind === "schedules" ? "beignet make schedule" : "beignet make task";
+    const noun = kind === "schedules" ? "schedule" : "task";
+
+    for (const { registry, missingMembers } of unregistered) {
+      for (const member of missingMembers) {
+        diagnostics.push({
+          severity: "error",
+          code,
+          file: centralExists ? centralFile : registry.indexFile,
+          message: centralExists
+            ? `${workflowArtifactOrigin(registry, member)}, but it is not registered in ${registrationTarget} in ${centralFile}, so the ${noun} never runs. Import ${registry.registryName} and spread it into the ${kind} list.`
+            : `${workflowArtifactOrigin(registry, member)}, but ${centralFile} does not exist, so the ${noun} never runs. Register ${registry.registryName} in ${centralFile} (or run \`${makeCommand}\` to create it).`,
+        });
+      }
+    }
+  }
+
+  if (drift.outbox.exists) {
+    for (const { registry, missingMembers } of drift.outbox.events) {
+      for (const member of missingMembers) {
+        diagnostics.push({
+          severity: "warning",
+          code: "BEIGNET_OUTBOX_EVENT_UNREGISTERED",
+          file: config.paths.outbox,
+          message: `${workflowArtifactOrigin(registry, member)} and listeners react to it, but it is not registered in the events list of defineOutboxRegistry({...}) in ${config.paths.outbox}, so outbox drain cannot deliver it. Import ${registry.registryName} and spread it into the events list.`,
+        });
+      }
+    }
+
+    for (const { registry, missingMembers } of drift.outbox.jobs) {
+      for (const member of missingMembers) {
+        diagnostics.push({
+          severity: "warning",
+          code: "BEIGNET_OUTBOX_JOB_UNREGISTERED",
+          file: config.paths.outbox,
+          message: `${workflowArtifactOrigin(registry, member)}, but it is not registered in the jobs list of defineOutboxRegistry({...}) in ${config.paths.outbox}, so outbox drain cannot deliver it. Import ${registry.registryName} and spread it into the jobs list.`,
+        });
+      }
+    }
+  }
+
+  const infraDir = directoryPath(
+    path.dirname(config.paths.infrastructurePorts),
+  );
+  const listenerTarget = drift.listeners.wiringFile
+    ? `${drift.listeners.wiringFile}, which already calls registerListeners(...)`
+    : drift.listeners.eventBusFile
+      ? `${drift.listeners.eventBusFile}, which creates the event bus`
+      : `an infra provider under ${infraDir}/`;
+  for (const { registry, missingMembers } of drift.listeners.unregistered) {
+    for (const member of missingMembers) {
+      diagnostics.push({
+        severity: "warning",
+        code: "BEIGNET_LISTENER_UNREGISTERED",
+        file:
+          drift.listeners.wiringFile ??
+          drift.listeners.eventBusFile ??
+          registry.indexFile,
+        message: `${workflowArtifactOrigin(registry, member)}, but no registerListeners(...) call references it, so the listener never receives events. Register ${registry.registryName} with registerListeners(...) in ${listenerTarget}.`,
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+function workflowArtifactOrigin(
+  registry: FeatureWorkflowRegistry,
+  member: string,
+): string {
+  const memberFile = registry.memberFiles.get(member) ?? registry.indexFile;
+  if (memberFile === registry.indexFile) {
+    return `${registry.indexFile} declares ${member} in ${registry.registryName}`;
+  }
+  return `${memberFile} declares ${member} (exported through ${registry.registryName} in ${registry.indexFile})`;
+}
+
+async function workflowRegistrationDrift(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<WorkflowRegistrationDrift> {
+  const registries = await readFeatureWorkflowRegistries(
+    targetDir,
+    files,
+    config,
+  );
+  const byKind = (kind: WorkflowRegistryKind) =>
+    registries.filter((registry) => registry.kind === kind);
+
+  const drift: WorkflowRegistrationDrift = {
+    schedules: {
+      centralExists: files.includes(config.paths.schedules),
+      unregistered: [],
+    },
+    tasks: {
+      centralExists: files.includes(config.paths.tasks),
+      unregistered: [],
+    },
+    outbox: {
+      exists: files.includes(config.paths.outbox),
+      events: [],
+      jobs: [],
+    },
+    listeners: { unregistered: [] },
+  };
+  if (registries.length === 0) return drift;
+
+  for (const kind of ["schedules", "tasks"] as const) {
+    const kindRegistries = byKind(kind);
+    if (kindRegistries.length === 0) continue;
+
+    const central = drift[kind];
+    const registered = central.centralExists
+      ? registeredWorkflowIdentifiers(
+          await readFile(
+            path.join(
+              targetDir,
+              kind === "schedules"
+                ? config.paths.schedules
+                : config.paths.tasks,
+            ),
+            "utf8",
+          ),
+          kind,
+        )
+      : new Set<string>();
+    central.unregistered = unregisteredWorkflowRegistries(
+      kindRegistries,
+      registered,
+    );
+  }
+
+  if (drift.outbox.exists) {
+    const eventRegistries = byKind("events");
+    const jobRegistries = byKind("jobs");
+    if (eventRegistries.length > 0 || jobRegistries.length > 0) {
+      const outboxSource = await readFile(
+        path.join(targetDir, config.paths.outbox),
+        "utf8",
+      );
+
+      if (eventRegistries.length > 0) {
+        // Events without listeners have nothing to deliver on drain, so only
+        // record-only events stay out of the registry without a warning.
+        const listened = await listenedEventNames(targetDir, files, config);
+        const value = outboxRegistryValueInfo(outboxSource, "events");
+        const registered = value
+          ? identifiersFromArrayExpression(value.text)
+          : new Set<string>();
+        drift.outbox.events = unregisteredWorkflowRegistries(
+          eventRegistries,
+          registered,
+          (member) => listened.has(member),
+        );
+      }
+
+      if (jobRegistries.length > 0) {
+        const value = outboxRegistryValueInfo(outboxSource, "jobs");
+        const registered = value
+          ? identifiersFromArrayExpression(value.text)
+          : new Set<string>();
+        drift.outbox.jobs = unregisteredWorkflowRegistries(
+          jobRegistries,
+          registered,
+        );
+      }
+    }
+  }
+
+  const listenerRegistries = byKind("listeners");
+  if (listenerRegistries.length > 0) {
+    const wiring = await listenerWiringReferences(targetDir, files);
+    drift.listeners = {
+      unregistered: unregisteredWorkflowRegistries(
+        listenerRegistries,
+        wiring.identifiers,
+      ),
+      wiringFile: wiring.wiringFile,
+      eventBusFile: wiring.eventBusFile,
+    };
+  }
+
+  return drift;
+}
+
+function unregisteredWorkflowRegistries(
+  registries: FeatureWorkflowRegistry[],
+  registered: Set<string>,
+  memberApplies: (member: string) => boolean = () => true,
+): UnregisteredWorkflowRegistry[] {
+  const unregistered: UnregisteredWorkflowRegistry[] = [];
+
+  for (const registry of registries) {
+    if (registered.has(registry.registryName)) continue;
+
+    const missingMembers = registry.members.filter(
+      (member) => !registered.has(member) && memberApplies(member),
+    );
+    if (missingMembers.length === 0) continue;
+
+    unregistered.push({
+      registry,
+      missingMembers,
+      fullyUnregistered: registry.members.every(
+        (member) => !registered.has(member),
+      ),
+    });
+  }
+
+  return unregistered;
+}
+
+async function readFeatureWorkflowRegistries(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<FeatureWorkflowRegistry[]> {
+  const registries: FeatureWorkflowRegistry[] = [];
+  const featuresPath = directoryPath(config.paths.features);
+  const kinds: WorkflowRegistryKind[] = [
+    "schedules",
+    "tasks",
+    "events",
+    "jobs",
+    "listeners",
+  ];
+
+  for (const kind of kinds) {
+    const folder = kind === "events" ? "domain/events" : kind;
+    const pattern = new RegExp(
+      `^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index\\.ts$`,
+    );
+
+    for (const file of files) {
+      if (!pattern.test(file)) continue;
+
+      const source = await readFile(path.join(targetDir, file), "utf8");
+      const memberFiles = exportedMemberFiles(source, file, files);
+      const exportRegex = new RegExp(
+        `(?:^|\\n)export const\\s+([A-Za-z_$][\\w$]*${workflowRegistrySuffixes[kind]})\\s*=`,
+        "g",
+      );
+
+      for (const exportMatch of source.matchAll(exportRegex)) {
+        const registryName = exportMatch[1];
+        const info = arrayInitializerInfo(source, registryName);
+        if (!info) continue;
+
+        const members = [...identifiersFromArrayExpression(info.text)];
+        if (members.length === 0) continue;
+
+        registries.push({
+          kind,
+          registryName,
+          indexFile: file,
+          members,
+          memberFiles,
+        });
+      }
+    }
+  }
+
+  return registries;
+}
+
+function exportedMemberFiles(
+  source: string,
+  indexFile: string,
+  files: string[],
+): Map<string, string> {
+  const memberFiles = new Map<string, string>();
+  const referenceRegex =
+    /(?:import|export)\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+
+  for (const match of source.matchAll(referenceRegex)) {
+    const resolved = sourceFileFromImport(match[2], indexFile, files);
+    if (!resolved || !files.includes(resolved)) continue;
+
+    for (const member of match[1].split(",")) {
+      const parsed = parseImportMember(member);
+      if (parsed) memberFiles.set(parsed.localName, resolved);
+    }
+  }
+
+  return memberFiles;
+}
+
+function registeredWorkflowIdentifiers(
+  source: string,
+  kind: "schedules" | "tasks",
+): Set<string> {
+  if (kind === "tasks") {
+    const call = /\bdefineTasks\s*(?:<[^>]*>\s*)?\(/.exec(source);
+    if (call) {
+      const firstArg = firstCallArgInfo(source, call.index + call[0].length);
+      if (firstArg) return identifiersFromArrayExpression(firstArg.text);
+    }
+  }
+
+  const info = arrayInitializerInfo(
+    source,
+    kind === "tasks" ? "tasks" : "schedules",
+  );
+  return info ? identifiersFromArrayExpression(info.text) : new Set<string>();
+}
+
+async function listenedEventNames(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<Set<string>> {
+  const featuresPath = directoryPath(config.paths.features);
+  const listenerPattern = new RegExp(
+    `^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+\\.ts$`,
+  );
+  const listened = new Set<string>();
+
+  for (const file of files) {
+    if (!listenerPattern.test(file) || isWorkflowTestFile(file)) continue;
+
+    const source = await readFile(path.join(targetDir, file), "utf8");
+    for (const match of source.matchAll(
+      /\bdefineListener\s*(?:<[^>]*>\s*)?\(\s*([A-Za-z_$][\w$]*)/g,
+    )) {
+      listened.add(match[1]);
+    }
+  }
+
+  return listened;
+}
+
+async function listenerWiringReferences(
+  targetDir: string,
+  files: string[],
+): Promise<{
+  identifiers: Set<string>;
+  wiringFile?: string;
+  eventBusFile?: string;
+}> {
+  const identifiers = new Set<string>();
+  let wiringFile: string | undefined;
+  let eventBusFile: string | undefined;
+
+  for (const file of files) {
+    if (!file.endsWith(".ts") && !file.endsWith(".tsx")) continue;
+    if (file.endsWith(".d.ts") || isWorkflowTestFile(file)) continue;
+
+    const source = await readFile(path.join(targetDir, file), "utf8");
+    let foundCall = false;
+
+    for (const match of source.matchAll(/\bregisterListeners\s*\(/g)) {
+      const openParen = (match.index ?? 0) + match[0].length - 1;
+      const closeParen = matchingDelimiterIndex(source, openParen, "(", ")");
+      const argsText =
+        closeParen === -1
+          ? source.slice(openParen)
+          : source.slice(openParen + 1, closeParen);
+
+      foundCall = true;
+      for (const identifier of identifiersFromArrayExpression(argsText)) {
+        identifiers.add(identifier);
+      }
+    }
+
+    if (foundCall) {
+      wiringFile ??= file;
+    } else if (!eventBusFile && /\bcreate\w*EventBus\s*\(/.test(source)) {
+      eventBusFile = file;
+    }
+  }
+
+  return { identifiers, wiringFile, eventBusFile };
+}
+
+function isWorkflowTestFile(file: string): boolean {
+  return (
+    file.endsWith(".test.ts") ||
+    file.endsWith(".test.tsx") ||
+    file.startsWith("tests/") ||
+    file.includes("/tests/")
+  );
+}
+
 async function inspectServerlessFootguns(
   targetDir: string,
   files: string[],
@@ -4057,6 +4548,162 @@ async function fixUnregisteredRouteGroups(
   };
 }
 
+async function fixUnregisteredSchedules(
+  targetDir: string,
+  files: string[],
+  drift: WorkflowRegistrationDrift,
+  config: ResolvedBeignetConfig,
+): Promise<InspectFix | undefined> {
+  if (!drift.schedules.centralExists) return undefined;
+
+  return applyWorkflowRegistryFix({
+    targetDir,
+    files,
+    centralFile: config.paths.schedules,
+    unregistered: drift.schedules.unregistered,
+    code: "BEIGNET_SCHEDULE_UNREGISTERED",
+    listName: "the schedules array",
+    importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+    append: (source, entry, importLine) =>
+      appendToNamedArray(source, "schedules", entry, importLine),
+  });
+}
+
+async function fixUnregisteredTasks(
+  targetDir: string,
+  files: string[],
+  drift: WorkflowRegistrationDrift,
+  config: ResolvedBeignetConfig,
+): Promise<InspectFix | undefined> {
+  if (!drift.tasks.centralExists) return undefined;
+
+  return applyWorkflowRegistryFix({
+    targetDir,
+    files,
+    centralFile: config.paths.tasks,
+    unregistered: drift.tasks.unregistered,
+    code: "BEIGNET_TASK_UNREGISTERED",
+    listName: "defineTasks([...])",
+    importSpecifier: (indexFile) =>
+      relativeModule(config.paths.tasks, indexFile),
+    append: (source, entry, importLine) =>
+      appendToNamedArray(source, "tasks", entry, importLine),
+  });
+}
+
+async function fixUnregisteredOutboxEntries(
+  targetDir: string,
+  files: string[],
+  drift: WorkflowRegistrationDrift,
+  config: ResolvedBeignetConfig,
+): Promise<InspectFix[]> {
+  if (!drift.outbox.exists) return [];
+
+  const fixes: InspectFix[] = [];
+
+  const eventFix = await applyWorkflowRegistryFix({
+    targetDir,
+    files,
+    centralFile: config.paths.outbox,
+    unregistered: drift.outbox.events,
+    code: "BEIGNET_OUTBOX_EVENT_UNREGISTERED",
+    listName: "the outbox events list",
+    importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+    append: (source, entry, importLine) =>
+      appendToOutboxRegistryArray(source, "events", entry, importLine),
+  });
+  if (eventFix) fixes.push(eventFix);
+
+  const jobFix = await applyWorkflowRegistryFix({
+    targetDir,
+    files,
+    centralFile: config.paths.outbox,
+    unregistered: drift.outbox.jobs,
+    code: "BEIGNET_OUTBOX_JOB_UNREGISTERED",
+    listName: "the outbox jobs list",
+    importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+    append: (source, entry, importLine) =>
+      appendToOutboxRegistryArray(source, "jobs", entry, importLine),
+  });
+  if (jobFix) fixes.push(jobFix);
+
+  return fixes;
+}
+
+/**
+ * Append `...<feature><Kind>` registry spreads to an existing central
+ * registry file.
+ *
+ * Bails without writing when an import for the registry name resolves to a
+ * different file, when the registry anchor is missing or unparseable, or when
+ * some members are already individually registered (appending the registry
+ * spread would run those members twice). The diagnostic stays in that case.
+ */
+async function applyWorkflowRegistryFix(options: {
+  targetDir: string;
+  files: string[];
+  centralFile: string;
+  unregistered: UnregisteredWorkflowRegistry[];
+  code: string;
+  listName: string;
+  importSpecifier: (indexFile: string) => string;
+  append: (source: string, entry: string, importLine?: string) => AppendResult;
+}): Promise<InspectFix | undefined> {
+  const candidates = options.unregistered.filter(
+    (entry) => entry.fullyUnregistered,
+  );
+  if (candidates.length === 0) return undefined;
+
+  const centralPath = path.join(options.targetDir, options.centralFile);
+  let original: string;
+  try {
+    original = await readFile(centralPath, "utf8");
+  } catch {
+    return undefined;
+  }
+
+  let next = original;
+  const registeredNames: string[] = [];
+
+  for (const { registry } of candidates) {
+    const imported = parseNamedImportSources(next).get(registry.registryName);
+    let importLine: string | undefined;
+
+    if (imported) {
+      const importedFile = sourceFileFromImport(
+        imported.sourcePath,
+        options.centralFile,
+        options.files,
+      );
+      if (importedFile !== registry.indexFile) return undefined;
+    } else {
+      importLine = `import { ${registry.registryName} } from "${options.importSpecifier(
+        registry.indexFile,
+      )}";`;
+    }
+
+    const result = options.append(
+      next,
+      `...${registry.registryName}`,
+      importLine,
+    );
+    if (result.kind === "missing") return undefined;
+    if (result.kind === "updated") {
+      next = result.source;
+      registeredNames.push(registry.registryName);
+    }
+  }
+
+  if (next === original || registeredNames.length === 0) return undefined;
+
+  await writeFile(centralPath, next);
+  return {
+    code: options.code,
+    file: options.centralFile,
+    message: `Registered ${registeredNames.join(", ")} in ${options.listName}.`,
+  };
+}
+
 function routeRegistryFileFromServerSource(
   source: string,
   serverFile: string,
@@ -4315,64 +4962,7 @@ function trimmedSlice(
   };
 }
 
-function contractsFromArrayExpression(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,
-    ),
-  );
-}
-
-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}`;
-}
-
-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");
-}
+const contractsFromArrayExpression = identifiersFromArrayExpression;
 
 function hasImportedIdentifier(source: string, identifier: string): boolean {
   const importRegex = /import\s+\{([^}]+)\}\s+from\s+["'][^"']+["']/g;