Merge pull request #15 from Mermaid-Chart/feat/support-multiple-files-at-once-in-cli

feat(cli): support `pull`/`push`/`link` on multiple mermaid files at once

Author: aloisklink

packages/cli/package.json

@@ -53,6 +53,7 @@
   "dependencies": {
     "@commander-js/extra-typings": "^11.1.0",
     "@iarna/toml": "^2.2.5",
+    "@inquirer/confirm": "^2.0.15",
     "@inquirer/input": "^1.2.14",
     "@inquirer/select": "^1.3.1",
     "@mermaidchart/sdk": "workspace:^",

packages/cli/src/commander.test.ts

@@ -4,6 +4,7 @@ import { copyFile, mkdir, readFile, rm } from 'node:fs/promises';
 import type { Command, CommanderError, OutputConfiguration } from '@commander-js/extra-typings';
 import { MermaidChart } from '@mermaidchart/sdk';
 
+import confirm from '@inquirer/confirm';
 import input from '@inquirer/input';
 import select from '@inquirer/select';
 import type { MCDocument, MCProject, MCUser } from '@mermaidchart/sdk/dist/types.js';
@@ -186,9 +187,15 @@ describe('logout', () => {
 
 describe('link', () => {
   const diagram = 'test/output/unsynced.mmd';
+  const diagram2 = 'test/output/unsynced2.mmd';
+  const diagram3 = 'test/output/unsynced3.mmd';
 
   beforeEach(async () => {
-    await copyFile('test/fixtures/unsynced.mmd', diagram);
+    await Promise.all([
+      copyFile('test/fixtures/unsynced.mmd', diagram),
+      copyFile('test/fixtures/unsynced.mmd', diagram2),
+      copyFile('test/fixtures/unsynced.mmd', diagram3),
+    ]);
   });
 
   it('should create a new diagram on MermaidChart and add id to frontmatter', async () => {
@@ -214,13 +221,65 @@ describe('link', () => {
       `id: ${mockedEmptyDiagram.documentID}`,
     );
   });
+
+  for (const rememberProjectId of [true, false]) {
+    it(`should link multiple diagrams ${
+      rememberProjectId ? 'and remember project id' : ''
+    }`, async () => {
+      const { program } = mockedProgram();
+
+      vi.mock('@inquirer/confirm');
+      vi.mock('@inquirer/select');
+      vi.mocked(confirm).mockResolvedValue(rememberProjectId);
+      vi.mocked(select).mockResolvedValue(mockedProjects[0].id);
+
+      vi.mocked(MermaidChart.prototype.createDocument).mockResolvedValue(mockedEmptyDiagram);
+
+      await expect(readFile(diagram, { encoding: 'utf8' })).resolves.not.toContain(/^id:/);
+
+      await program.parseAsync(['--config', CONFIG_AUTHED, 'link', diagram, diagram2, diagram3], {
+        from: 'user',
+      });
+
+      if (rememberProjectId) {
+        expect(vi.mocked(confirm)).toHaveBeenCalledOnce();
+        expect(vi.mocked(select)).toHaveBeenCalledOnce();
+      } else {
+        // if the user didn't allow using the same project id for all diagrams,
+        // ask every time
+        expect(vi.mocked(confirm)).toHaveBeenCalledOnce();
+        expect(vi.mocked(select)).toHaveBeenCalledTimes(3);
+      }
+
+      // should have uploaded and created three files
+      expect(vi.mocked(MermaidChart.prototype.setDocument)).toHaveBeenCalledTimes(3);
+      expect(vi.mocked(MermaidChart.prototype.setDocument)).toHaveBeenCalledWith(
+        expect.objectContaining({
+          code: expect.not.stringContaining('id:'), // id: field should not be uploaded
+          title: diagram, // title should default to file name
+        }),
+      );
+
+      await Promise.all(
+        [diagram, diagram2, diagram3].map(async (file) => {
+          await expect(readFile(file, { encoding: 'utf8' })).resolves.toContain(
+            `id: ${mockedEmptyDiagram.documentID}`,
+          );
+        }),
+      );
+    });
+  }
 });
 
 describe('pull', () => {
   const diagram = 'test/output/connected-diagram.mmd';
+  const diagram2 = 'test/output/connected-diagram-2.mmd';
 
   beforeEach(async () => {
-    await copyFile('test/fixtures/connected-diagram.mmd', diagram);
+    await Promise.all([
+      copyFile('test/fixtures/connected-diagram.mmd', diagram),
+      copyFile('test/fixtures/connected-diagram.mmd', diagram2),
+    ]);
   });
 
   it('should fail if MermaidChart document has not yet been linked', async () => {
@@ -243,7 +302,7 @@ describe('pull', () => {
     ).rejects.toThrowError(`Diagram at ${diagram} has no code`);
   });
 
-  it('should pull document and add a `id:` field to frontmatter', async () => {
+  it('should pull documents and add a `id:` field to frontmatter', async () => {
     const { program } = mockedProgram();
 
     const mockedDiagram = {
@@ -255,22 +314,30 @@ title: My cool flowchart
       A[I've been updated!]`,
     };
 
-    vi.mocked(MermaidChart.prototype.getDocument).mockResolvedValueOnce(mockedDiagram);
+    vi.mocked(MermaidChart.prototype.getDocument).mockResolvedValue(mockedDiagram);
 
-    await program.parseAsync(['--config', CONFIG_AUTHED, 'pull', diagram], { from: 'user' });
+    await program.parseAsync(['--config', CONFIG_AUTHED, 'pull', diagram, diagram2], {
+      from: 'user',
+    });
 
-    const diagramContents = await readFile(diagram, { encoding: 'utf8' });
+    for (const file of [diagram, diagram2]) {
+      const diagramContents = await readFile(file, { encoding: 'utf8' });
 
-    expect(diagramContents).toContain(`id: ${mockedDiagram.documentID}`);
-    expect(diagramContents).toContain("flowchart TD\n      A[I've been updated!]");
+      expect(diagramContents).toContain(`id: ${mockedDiagram.documentID}`);
+      expect(diagramContents).toContain("flowchart TD\n      A[I've been updated!]");
+    }
   });
 });
 
 describe('push', () => {
   const diagram = 'test/output/connected-diagram.mmd';
+  const diagram2 = 'test/output/connected-diagram-2.mmd';
 
   beforeEach(async () => {
-    await copyFile('test/fixtures/connected-diagram.mmd', diagram);
+    await Promise.all([
+      copyFile('test/fixtures/connected-diagram.mmd', diagram),
+      copyFile('test/fixtures/connected-diagram.mmd', diagram2),
+    ]);
   });
 
   it('should fail if MermaidChart document has not yet been linked', async () => {
@@ -283,16 +350,18 @@ describe('push', () => {
     ).rejects.toThrowError('Diagram at test/fixtures/unsynced.mmd has no id');
   });
 
-  it('should push document and remove the `id:` field front frontmatter', async () => {
+  it('should push documents and remove the `id:` field front frontmatter', async () => {
     const { program } = mockedProgram();
 
-    vi.mocked(MermaidChart.prototype.getDocument).mockResolvedValueOnce(mockedEmptyDiagram);
+    vi.mocked(MermaidChart.prototype.getDocument).mockResolvedValue(mockedEmptyDiagram);
 
     await expect(readFile(diagram, { encoding: 'utf8' })).resolves.not.toContain(/^id:/);
 
-    await program.parseAsync(['--config', CONFIG_AUTHED, 'push', diagram], { from: 'user' });
+    await program.parseAsync(['--config', CONFIG_AUTHED, 'push', diagram, diagram2], {
+      from: 'user',
+    });
 
-    expect(vi.mocked(MermaidChart.prototype.setDocument)).toHaveBeenCalledOnce();
+    expect(vi.mocked(MermaidChart.prototype.setDocument)).toHaveBeenCalledTimes(2);
     expect(vi.mocked(MermaidChart.prototype.setDocument)).toHaveBeenCalledWith(
       expect.objectContaining({
         code: expect.not.stringContaining('id:'),

packages/cli/src/commander.ts

@@ -7,10 +7,11 @@ import {
 import { readFile, writeFile } from 'fs/promises';
 import { MermaidChart } from '@mermaidchart/sdk';
 import { createRequire } from 'node:module';
+import confirm from '@inquirer/confirm';
 import input from '@inquirer/input';
 import select, { Separator } from '@inquirer/select';
 import { type Config, defaultConfigPath, readConfig, writeConfig } from './config.js';
-import { link, pull, push } from './methods.js';
+import { link, type LinkOptions, pull, push } from './methods.js';
 
 /**
  * Global configuration option for the root Commander Command.
@@ -158,78 +159,107 @@ function logout() {
 
 function linkCmd() {
   return createCommand('link')
-    .description('Link the given Mermaid diagram to Mermaid Chart')
-    .addArgument(new Argument('<path>', 'The path of the file to link.'))
-    .action(async (path, _options, command) => {
+    .description('Link the given Mermaid diagrams to Mermaid Chart')
+    .addArgument(new Argument('<path...>', 'The paths of the files to link.'))
+    .action(async (paths, _options, command) => {
       const optsWithGlobals = command.optsWithGlobals<CommonOptions>();
       const client = await createClient(optsWithGlobals);
+
+      // Ask the user which project they want to upload each diagram to
+      const getProjectId: LinkOptions['getProjectId'] = async (cache, documentTitle) => {
+        if (cache.previousSelectedProjectId !== undefined) {
+          if (cache.usePreviousSelectedProjectId === undefined) {
+            cache.usePreviousSelectedProjectId = confirm({
+              message: `Would you like to upload all diagrams to this project?`,
+              default: true,
+            });
+          }
+          if (await cache.usePreviousSelectedProjectId) {
+            return cache.previousSelectedProjectId;
+          }
+        }
+
+        cache.projects = cache.projects ?? client.getProjects();
+        const projectId = await select({
+          message: `Select a project to upload ${documentTitle} to`,
+          choices: [
+            ...(await cache.projects).map((project) => {
+              return {
+                name: project.title,
+                value: project.id,
+              };
+            }),
+            new Separator(
+              `Or go to ${new URL('/app/projects', client.baseURL)} to create a new project`,
+            ),
+          ],
+        });
+
+        cache.previousSelectedProjectId = projectId;
+
+        return projectId;
+      };
+
       const linkCache = {};
 
-      const existingFile = await readFile(path, { encoding: 'utf8' });
-
-      const linkedDiagram = await link(existingFile, client, {
-        cache: linkCache,
-        title: path,
-        async getProjectId(cache) {
-          cache.projects = cache.projects ?? client.getProjects();
-          const projectId = await select({
-            message: `Select a project to upload ${path} to`,
-            choices: [
-              ...(await cache.projects).map((project) => {
-                return {
-                  name: project.title,
-                  value: project.id,
-                };
-              }),
-              new Separator(
-                `Or go to ${new URL('/app/projects', client.baseURL)} to create a new project`,
-              ),
-            ],
-          });
-          return projectId;
-        },
-      });
+      for (const path of paths) {
+        const existingFile = await readFile(path, { encoding: 'utf8' });
+
+        const linkedDiagram = await link(existingFile, client, {
+          cache: linkCache,
+          title: path,
+          getProjectId,
+        });
 
-      await writeFile(path, linkedDiagram, { encoding: 'utf8' });
+        await writeFile(path, linkedDiagram, { encoding: 'utf8' });
+      }
     });
 }
 
 function pullCmd() {
   return createCommand('pull')
-    .description('Pulls a document from from Mermaid Chart')
-    .addArgument(new Argument('<path>', 'The path of the file to pull.'))
-    .option('--check', 'Check whether the local file would be overwrited')
-    .action(async (path, options, command) => {
+    .description('Pulls documents from Mermaid Chart')
+    .addArgument(new Argument('<path...>', 'The paths of the files to pull.'))
+    .option('--check', 'Check whether the local files would be overwrited')
+    .action(async (paths, options, command) => {
       const optsWithGlobals = command.optsWithGlobals<CommonOptions>();
       const client = await createClient(optsWithGlobals);
-      const text = await readFile(path, { encoding: 'utf8' });
-
-      const newFile = await pull(text, client, { title: path });
-
-      if (text === newFile) {
-        console.log(`✅ - ${path} is up to date`);
-      } else {
-        if (options['check']) {
-          console.log(`❌ - ${path} would be updated`);
-          process.exitCode = 1;
-        } else {
-          await writeFile(path, newFile, { encoding: 'utf8' });
-          console.log(`✅ - ${path} was updated`);
-        }
-      }
+      await Promise.all(
+        paths.map(async (path) => {
+          const text = await readFile(path, { encoding: 'utf8' });
+
+          const newFile = await pull(text, client, { title: path });
+
+          if (text === newFile) {
+            console.log(`✅ - ${path} is up to date`);
+          } else {
+            if (options['check']) {
+              console.log(`❌ - ${path} would be updated`);
+              process.exitCode = 1;
+            } else {
+              await writeFile(path, newFile, { encoding: 'utf8' });
+              console.log(`✅ - ${path} was updated`);
+            }
+          }
+        }),
+      );
     });
 }
 
 function pushCmd() {
   return createCommand('push')
-    .description('Push a local diagram to Mermaid Chart')
-    .addArgument(new Argument('<path>', 'The path of the file to push.'))
-    .action(async (path, _options, command) => {
+    .description('Push local diagrams to Mermaid Chart')
+    .addArgument(new Argument('<path...>', 'The paths of the files to push.'))
+    .action(async (paths, _options, command) => {
       const optsWithGlobals = command.optsWithGlobals<CommonOptions>();
       const client = await createClient(optsWithGlobals);
-      const text = await readFile(path, { encoding: 'utf8' });
+      await Promise.all(
+        paths.map(async (path) => {
+          const text = await readFile(path, { encoding: 'utf8' });
 
-      await push(text, client, { title: path });
+          await push(text, client, { title: path });
+        }),
+      );
     });
 }
 

packages/cli/src/methods.ts

@@ -6,12 +6,22 @@ import { extractFrontMatter, injectFrontMatter, removeFrontMatterKeys } from './
 /**
  * Cached data to use when pulling/pushing/linking multiple files at once.
  */
-interface Cache {
+export interface Cache {
   /**
-   * If set, the user has said to use the projectId to create all documents
+   * If `true`, the user has said to use the projectId to create all documents
    * in.
+   *
+   * If `undefined`, ask the user if they want to use their first chosen project
+   * id for every other document.
+   *
+   * If `false`, don't ask the user.
    */
-  selectedProjectId?: string;
+  usePreviousSelectedProjectId?: Promise<boolean>;
+  /**
+   * Previously selected project ID.
+   * Will be reused if {@link usePreviousSelectedProjectId} is `true`.
+   */
+  previousSelectedProjectId?: string;
   /**
    * Cached response from {@link MermaidChart.getProjects}.
    */
@@ -23,10 +33,13 @@ interface CommonOptions {
   title: string;
 }
 
-interface LinkOptions extends CommonOptions {
+/**
+ * Options to pass to {@link link}.
+ */
+export interface LinkOptions extends CommonOptions {
   /** Function that asks the user which project id they want to upload a diagram to */
-  getProjectId: (cache: LinkOptions['cache']) => Promise<string>;
-  // cache to be shared between link calls
+  getProjectId: (cache: LinkOptions['cache'], documentTitle: string) => Promise<string>;
+  // cache to be shared between link calls. This object may be modified between calls.
   cache: Cache;
 }
 
@@ -48,7 +61,7 @@ export async function link(diagram: string, client: MermaidChart, options: LinkO
 
   const { title, getProjectId, cache } = options;
 
-  const projectId = cache.selectedProjectId ?? (await getProjectId(cache));
+  const projectId = await getProjectId(cache, title);
 
   const createdDocument = await client.createDocument(projectId);