Add config file system to change options

Author: getty104

README.md

@@ -167,6 +167,7 @@ Qiita CLI、Qiita Preview から記事の削除はできません。
 
 - .gitignore
 - GitHub Actions のワークフローファイル
+- ユーザー設定ファイル（qiita.config.json）
 
 が生成されます。
 
@@ -206,19 +207,37 @@ npx qiita pull
 
 ### version
 
-qiita-cli のバージョンを確認できます。
+Qiita CLI のバージョンを確認できます。
 
 ```console
 npx qiita version
 ```
 
+## ユーザー設定ファイルについて
+
+`npx qiita init`コマンドで生成される`qiita.config.json`について説明します。
+このファイルを用いて、Qiita CLI の設定を行うことができます。
+設定できるオプションは以下の通りです。
+
+- includePrivate: 限定共有記事を含めるかどうかを選べます。デフォルトは`false`です。
+
 ## オプション
 
+### --credential \<credential_dir>
+
+Qiita CLI の認証情報（`credentials.json`）を配置する・しているディレクトリを指定できます。
+デフォルトでは`$XDG_CONFIG_HOME/qiita-cli`もしくは`$HOME/.config/qiita-cli`になっています。
+
+```console
+npx qiita login ---credential ./my_conf/
+npx qiita preview --credential ./my_conf/
+```
+
 ### --config \<config_dir>
 
-qiita-cli の設定情報（`credentials.json`）を配置する・しているディレクトリを指定できます。
+Qiita CLI の設定情報（`qiita.config.json`）を配置する・しているディレクトリを指定できます。
 
-デフォルトでは`$XDG_CONFIG_HOME/qiita-cli`もしくは`$HOME/.config/qiita-cli`になっています。
+デフォルトでは、カレントディレクトリになります。
 
 例）
 

src/commands/help.ts

@@ -13,15 +13,18 @@ COMMAND:
   help                    ヘルプを表示
 
 OPTIONS:
-  --config <config_dir>
-    qiita-cliの設定情報を配置するディレクトリを指定
+  --credential <credential_dir>
+    qiita-cliの認証情報を配置するディレクトリを指定
 
   --root <root_dir>
     記事ファイルをダウンロードするディレクトリを指定
 
   --verbose
     詳細表示オプションを有効
 
+  --config
+    設定ファイルを配置するディレクトリを指定
+
 詳細についてはReadme(https://github.com/increments/qiita-cli)をご覧ください
 `;
 

src/commands/init.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { config } from "../lib/config";
 
 export const init = async () => {
   const rootDir = process.cwd();
@@ -48,6 +49,18 @@ jobs:
 node_modules
 `;
   writeFile(gitignoreFilePath, gitignoreFileContent);
+
+  const userConfigFilePath = config.getUserConfigFilePath();
+  const userConfigDir = config.getUserConfigDir();
+  if (!fs.existsSync(userConfigFilePath)) {
+    fs.mkdirSync(userConfigDir, { recursive: true });
+  }
+  const userConfigFileContent = JSON.stringify(
+    await config.getUserConfig(),
+    null,
+    2
+  );
+  writeFile(userConfigFilePath, userConfigFileContent);
 };
 
 const writeFile = (path: string, content: string) => {

src/lib/config.test.ts

@@ -55,6 +55,14 @@ jest.mock("node:fs/promises", () => {
     mkdir: jest.fn(() => {}),
   };
 });
+jest.mock("node:fs", () => {
+  return {
+    existsSync: jest.fn((filePath: string): boolean => {
+      const text = getFile(filePath);
+      return !!text;
+    }),
+  };
+});
 
 describe("config", () => {
   describe("#getCredentialDir", () => {
@@ -111,6 +119,101 @@ describe("config", () => {
     });
   });
 
+  describe("#getUserConfigDir", () => {
+    describe("paths", () => {
+      beforeEach(() => {
+        config.load({});
+      });
+
+      it("returns default path", () => {
+        expect(config.getUserConfigDir()).toEqual(
+          "/home/test-user/qiita-articles"
+        );
+      });
+
+      describe("with options", () => {
+        beforeEach(() => {
+          config.load({
+            userConfigDir: "my-root",
+          });
+        });
+
+        it("returns customized path", () => {
+          expect(config.getUserConfigDir()).toEqual(
+            "/home/test-user/qiita-articles/my-root"
+          );
+        });
+      });
+    });
+  });
+
+  describe("#getUserConfigFilePath", () => {
+    describe("paths", () => {
+      beforeEach(() => {
+        config.load({});
+      });
+
+      it("returns default path", () => {
+        expect(config.getUserConfigFilePath()).toEqual(
+          "/home/test-user/qiita-articles/qiita.config.json"
+        );
+      });
+
+      describe("with options", () => {
+        beforeEach(() => {
+          config.load({
+            userConfigDir: "my-root",
+          });
+        });
+
+        it("returns customized path", () => {
+          expect(config.getUserConfigFilePath()).toEqual(
+            "/home/test-user/qiita-articles/my-root/qiita.config.json"
+          );
+        });
+      });
+    });
+  });
+
+  describe("#getUserConfig", () => {
+    const userConfigFilePath =
+      "/home/test-user/qiita-articles/qiita.config.json";
+
+    beforeEach(() => {
+      config.load({});
+    });
+
+    describe("when user config file already exists", () => {
+      beforeEach(() => {
+        const userConfigData = {
+          includePrivate: true,
+        };
+        resetFiles();
+        setFile(userConfigFilePath, JSON.stringify(userConfigData, null, 2));
+      });
+
+      it("returns user config", async () => {
+        const userConfig = await config.getUserConfig();
+        expect(userConfig).toStrictEqual({
+          includePrivate: true,
+        });
+      });
+    });
+
+    describe("when user config file does not exist", () => {
+      beforeEach(() => {
+        resetFiles();
+      });
+
+      it("returns default user config", async () => {
+        const userConfig = await config.getUserConfig();
+        expect(userConfig).toStrictEqual({
+          includePrivate: false,
+        });
+      });
+    });
+  });
+
   describe("#getCredential", () => {
     const credentialFilePath =
       "/home/test-user/.config/qiita-cli/credentials.json";

src/lib/config.ts

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import fsSync from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -8,18 +9,29 @@ interface Options {
   credentialDir?: string;
   profile?: string;
   itemsRootDir?: string;
+  userConfigDir?: string;
 }
 
+type UserConfig = {
+  includePrivate: boolean;
+};
+
 class Config {
   private credentialDir?: string;
   private itemsRootDir?: string;
+  private userConfigFilePath?: string;
+  private userConfigDir?: string;
   private credential?: Credential;
 
   constructor() {}
 
   load(options: Options) {
     this.credentialDir = this.resolveConfigDir(options.credentialDir);
     this.itemsRootDir = this.resolveItemsRootDir(options.itemsRootDir);
+    this.userConfigDir = this.resolveUserConfigDirPath(options.userConfigDir);
+    this.userConfigFilePath = this.resolveUserConfigFilePath(
+      options.userConfigDir
+    );
     this.credential = new Credential({
       credentialDir: this.credentialDir,
       profile: options.profile,
@@ -30,6 +42,7 @@ class Config {
       JSON.stringify({
         credentialDir: this.credentialDir,
         itemsRootDir: this.itemsRootDir,
+        userConfigFilePath: this.userConfigFilePath,
       })
     );
   }
@@ -49,6 +62,20 @@ class Config {
     return this.itemsRootDir;
   }
 
+  getUserConfigDir() {
+    if (!this.userConfigDir) {
+      throw new Error("userConfigDir is undefined");
+    }
+    return this.userConfigDir;
+  }
+
+  getUserConfigFilePath() {
+    if (!this.userConfigFilePath) {
+      throw new Error("userConfigFilePath is undefined");
+    }
+    return this.userConfigFilePath;
+  }
+
   getCredential() {
     if (!this.credential) {
       throw new Error("credential is undefined");
@@ -63,6 +90,24 @@ class Config {
     return this.credential.setCredential(credential);
   }
 
+  async getUserConfig() {
+    const defaultConfig = {
+      includePrivate: false,
+    } as UserConfig;
+
+    if (fsSync.existsSync(this.userConfigFilePath as string)) {
+      const userConfigFileData = await fs.readFile(
+        this.userConfigFilePath as string
+      );
+      const userConfig = JSON.parse(
+        userConfigFileData.toString()
+      ) as UserConfig;
+      return { ...defaultConfig, ...userConfig };
+    }
+
+    return defaultConfig;
+  }
+
   private resolveConfigDir(credentialDirPath?: string) {
     const packageName = "qiita-cli";
 
@@ -89,6 +134,22 @@ class Config {
     return this.resolveFullPath(dirPath);
   }
 
+  private resolveUserConfigDirPath(dirPath?: string) {
+    if (process.env.QIITA_CLI_USER_CONFIG_DIR) {
+      return process.env.QIITA_CLI_USER_CONFIG_DIR;
+    }
+    if (!dirPath) {
+      return process.cwd();
+    }
+
+    return this.resolveFullPath(dirPath);
+  }
+
+  private resolveUserConfigFilePath(dirPath?: string) {
+    const filename = "qiita.config.json";
+    return path.join(this.resolveUserConfigDirPath(dirPath), filename);
+  }
+
   private resolveFullPath(filePath: string) {
     if (path.isAbsolute(filePath)) {
       return filePath;

src/lib/sync-articles-from-qiita.ts

@@ -1,5 +1,6 @@
 import type { QiitaApi } from "../qiita-api";
 import type { FileSystemRepo } from "./file-system-repo";
+import { config } from "./config";
 
 export const syncArticlesFromQiita = async ({
   fileSystemRepo,
@@ -9,8 +10,13 @@ export const syncArticlesFromQiita = async ({
   qiitaApi: QiitaApi;
 }) => {
   const per = 100;
+  const userConfig = await config.getUserConfig();
   for (let page = 1; page <= 100; page += 1) {
-    const items = await qiitaApi.authenticatedUserItems(page, per);
+    const items = await qiitaApi.authenticatedUserItems(
+      page,
+      per,
+      userConfig.includePrivate
+    );
     if (items.length <= 0) {
       break;
     }

src/main.ts

@@ -13,6 +13,7 @@ const args = arg(
   {
     "--credential": String,
     "--profile": String,
+    "--config": String,
     "--root": String,
     "--verbose": Boolean,
   },
@@ -32,6 +33,7 @@ config.load({
   credentialDir: args["--credential"],
   profile: args["--profile"],
   itemsRootDir: args["--root"],
+  userConfigDir: args["--config"],
 });
 
 exec(commandName, commandArgs);

src/qiita-api/index.ts

@@ -130,7 +130,11 @@ export class QiitaApi {
     return await this.get<{ id: string }>("/api/v2/authenticated_user");
   }
 
-  async authenticatedUserItems(page?: number, per?: number) {
+  async authenticatedUserItems(
+    page?: number,
+    per?: number,
+    includePrivate: boolean = false
+  ) {
     const params = new URLSearchParams();
     if (page !== undefined) {
       params.set("page", page.toString());
@@ -141,7 +145,13 @@ export class QiitaApi {
 
     const path = `/api/v2/authenticated_user/items?${params}`;
 
-    return await this.get<Item[]>(path);
+    const items = await this.get<Item[]>(path);
+
+    if (!includePrivate) {
+      return items.filter((item) => !item.private);
+    }
+
+    return items;
   }
 
   async preview(rawBody: string) {