dongnelibrary 0.2.8 → 0.2.10

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "dongnelibrary",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "책을 빌릴 수 있는지 확인한다.",
   "main": "src/dongnelibrary.js",
   "bin": {
@@ -17,7 +17,8 @@
     "hscity": "mocha test/hscity.spec.js",
     "osan": "mocha test/osan.spec.js",
     "snlib": "mocha test/snlib.spec.js",
-    "suwon": "mocha test/suwon.spec.js"
+    "suwon": "mocha test/suwon.spec.js",
+    "yongin": "mocha test/yongin.spec.js"
   },
   "repository": {
     "type": "git",
@@ -32,7 +33,8 @@
     "성남시도서관",
     "오산시도서관",
     "화성시립도서관",
-    "수원시도서관"
+    "수원시도서관",
+    "용인시도서관"
   ],
   "author": "<autoscripts@gmail.com>",
   "license": "MIT",
@@ -56,6 +58,6 @@
     "jquery": "^3.7.1",
     "jsdom": "^21.1.1",
     "lodash": "^4.17.20",
-    "request": "^2.73.0"
+    "undici": "^6.23.0"
   }
 }

package/src/cli.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 const Configstore = require("configstore");
-const _ = require("lodash");
 const colors = require("colors");
 const figlet = require("figlet");
-const fp = require("lodash/fp");
 const inquirer = require("inquirer");
 const program = require("commander");
 const dl = require("./dongnelibrary");
@@ -11,11 +9,13 @@ const util = require("./util");
 const pkg = require("../package.json");
 
 const conf = new Configstore(pkg.name, {});
-const getDefaultLibrary = () => conf.get("library");
-const setDefaultLibrary = (name) => conf.set("library", name);
-const getDefaultTitle = () =>
-  conf.get("title") === undefined ? "javascript" : conf.get("title");
-const setDefaultTitle = (title) => conf.set("title", title);
+
+const config = {
+  getLibrary: () => conf.get("library"),
+  setLibrary: (name) => conf.set("library", name),
+  getTitle: () => conf.get("title") ?? "javascript",
+  setTitle: (title) => conf.set("title", title),
+};
 
 const introMessage = (msg) => {
   console.log(
@@ -35,151 +35,121 @@ program
   .option("-t, --title [title]", "a part of book title")
   .parse(process.argv);
 
-function cutTail(str, tail) {
-  let result = "";
+const cutTail = (str, tail) => {
   const index = str.indexOf(tail);
-  if (index === -1) {
-    result = str;
-  } else {
-    result = str.substring(0, index);
+  return index === -1 ? str : str.substring(0, index);
+};
+
+const MARKS = {
+  ok: "✓ ",
+  notOk: "✖ ",
+};
+
+const printBooks = ({ booklist }) => {
+  for (const { libraryName, exist, title, bookUrl } of booklist) {
+    const mark = exist ? ` ${MARKS.ok} ` : ` ${colors.red(MARKS.notOk)} `;
+    console.log(`${cutTail(libraryName, "도서관")}${mark}${title}`);
+    if (bookUrl) {
+      console.log(`  → ${colors.cyan(bookUrl)}`);
+    }
   }
-  return result;
-}
-
-const okMark = "✓ ";
-const notokMark = "✖ ";
-
-function printBooks(book) {
-  _.each(book.booklist, (book) => {
-    console.log(
-      cutTail(book.libraryName, "도서관") +
-        (book.exist ? " " + okMark + " " : " " + colors.red(notokMark) + " ") +
-        book.title +
-        " ",
-    );
-  });
-}
+};
 
-function printAllLibraryName() {
+const printAllLibraryNames = () => {
   const libs = dl.getLibraryNames();
-  libs.forEach((name) => {
-    console.log(name);
-  });
-  const msg = `모두 ${libs.length} 개의 도서관`;
-  console.log(colors.green(msg));
-}
+  libs.forEach((name) => console.log(name));
+  console.log(colors.green(`모두 ${libs.length} 개의 도서관`));
+};
 
 const getFullLibraryName = (str) =>
-  _.find(dl.getLibraryNames(), (name) => name.indexOf(str) >= 0);
-
-function search(option, bookCallback, allBookCallback) {
-  dl.search(
-    {
-      title: option.title,
-      libraryName: getLibraries(option.libraryName),
-    },
-    (err, book) => {
-      if (err) {
-        err.msg = err.msg || "Unknown Error";
-        if (bookCallback) {
-          bookCallback(err);
-        }
-      } else {
-        if (bookCallback) {
-          bookCallback(null, book);
-        }
-      }
-    },
-    (err, books) => {
-      if (err) {
-        err.msg = err.msg || "Unknown Error";
-        if (allBookCallback) {
-          allBookCallback(err);
-        }
-      } else {
-        if (allBookCallback) {
-          allBookCallback(null, books);
-        }
-      }
-    },
-  );
-}
+  dl.getLibraryNames().find((name) => name.includes(str));
 
 const getBookCount = (results) =>
-  _.reduce(
-    results,
-    (memo, book) =>
-      memo +
-      (book && book.booklist && book.booklist.length
-        ? book.booklist.length
-        : 0),
-    0,
-  );
+  results.reduce((sum, book) => sum + (book?.booklist?.length ?? 0), 0);
 
-const getLibraryFullNameList = _.flow([
-  util.getArrayFromCommaSeparatedString,
-  fp.filter((shortLibraryName) => getFullLibraryName(shortLibraryName)),
-]);
+const getLibraryFullNameList = (libraryName) =>
+  util
+    .getArrayFromCommaSeparatedString(libraryName)
+    .filter((name) => getFullLibraryName(name));
 
 const getLibraries = (libraryName) =>
   libraryName ? getLibraryFullNameList(libraryName) : dl.getLibraryNames();
 
-const processOneLibrary = (err, book) => {
-  if (err) {
-    console.log(err.msg);
-  } else {
-    printBooks(book);
-  }
+const searchLibraries = ({ title, libraryName }) =>
+  new Promise((resolve) => {
+    const results = [];
+    dl.search(
+      { title, libraryName: getLibraries(libraryName) },
+      (err, book) => {
+        if (err) {
+          console.log(err.msg ?? "Unknown Error");
+        } else {
+          printBooks(book);
+          results.push(book);
+        }
+      },
+      (err, allBooks) => {
+        if (err) {
+          console.log("Error, Can't access detail information");
+          resolve([]);
+        } else {
+          resolve(allBooks);
+        }
+      },
+    );
+  });
+
+const printSearchSummary = (results) => {
+  const bookCount = getBookCount(results);
+  console.log(
+    colors.green(`${results.length} 개의 도서관에서  ${bookCount} 권 검색됨`),
+  );
 };
 
-const processLibraries = (err, results) => {
-  if (err) {
-    console.log("Error, Can't access detail information");
-  } else {
-    console.log(
-      colors.green(
-        `${results.length} 개의 도서관에서  ${getBookCount(results)} 권 검색됨`,
-      ),
-    );
-  }
+const promptForSearchOptions = async () => {
+  introMessage("Dongne Library");
+  const { library, title } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "library",
+      message: "도서관 이름은?",
+      choices: dl.getLibraryNames(),
+      default: config.getLibrary(),
+    },
+    {
+      type: "input",
+      name: "title",
+      message: "책 이름은?",
+      default: config.getTitle(),
+    },
+  ]);
+
+  config.setLibrary(library);
+  config.setTitle(title);
+
+  return { libraryName: library, title };
 };
 
-function activate(option) {
-  if (option.libraryList) {
-    printAllLibraryName(option);
+const activate = async () => {
+  const { libraryList, interactive, libraryName, title } = program;
+
+  if (libraryList) {
+    printAllLibraryNames();
     return;
   }
 
-  if (option.interactive) {
-    introMessage("Dongne Library");
-    inquirer
-      .prompt([
-        {
-          type: "list",
-          name: "library",
-          message: "도서관 이름은?",
-          choices: dl.getLibraryNames(),
-          default: getDefaultLibrary(),
-        },
-        {
-          type: "input",
-          name: "title",
-          message: "책 이름은?",
-          default: getDefaultTitle(),
-        },
-      ])
-      .then((answers) => {
-        option.libraryName = answers["library"];
-        option.title = answers["title"];
-        setDefaultLibrary(option.libraryName);
-        setDefaultTitle(option.title);
-        if (option.libraryName && option.title) {
-          search(option, processOneLibrary, processLibraries);
-        }
-      });
-  } else if (option.libraryName && option.title) {
-    search(option, processOneLibrary, processLibraries);
+  let searchOptions;
+
+  if (interactive) {
+    searchOptions = await promptForSearchOptions();
+  } else if (libraryName && title) {
+    searchOptions = { libraryName, title };
+  } else {
+    return;
   }
-}
 
-activate(program);
+  const results = await searchLibraries(searchOptions);
+  printSearchSummary(results);
+};
+
+activate();

package/src/dongnelibrary.js

@@ -1,139 +1,97 @@
-const _ = require("lodash");
-const fp = require("lodash/fp");
 const gg = require("./library/gg");
 const gunpo = require("./library/gunpo");
 const hscity = require("./library/hscity");
 const osan = require("./library/osan");
 const snlib = require("./library/snlib");
 const suwon = require("./library/suwon");
-const async = require("async");
+const yongin = require("./library/yongin");
 const util = require("./util.js");
 
-const libraryList = [];
+const LIBRARY_MODULES = [gg, gunpo, hscity, osan, snlib, suwon, yongin];
+
+const libraryList = LIBRARY_MODULES.flatMap((module) =>
+  module.getLibraryNames().map((name) => ({
+    name,
+    search: module.search,
+  })),
+);
 
 const getLibraryNames = () => util.getLibraryNames(libraryList);
 
-function makeLibraryList() {
-  const library = [gg, gunpo, hscity, osan, snlib, suwon];
+const UNKNOWN_LIBRARY = {
+  name: "Unknown",
+  search: (opt, getBook) => getBook?.({ msg: "Unknown library name" }),
+};
 
-  _.each(library, (library) => {
-    _.each(library.getLibraryNames(), (name) => {
-      libraryList.push({
-        name,
-        search: library.search,
-      });
-    });
-  });
-}
+const getLibraryFunction = (libraryName) =>
+  libraryList.find((lib) => lib.name === libraryName) ?? UNKNOWN_LIBRARY;
 
-const getLibraryFunction = (libraryName) => {
-  const found = _.find(libraryList, (lib) => lib.name === libraryName);
-  return found
-    ? found
-    : {
-        search: (opt, getBook) => {
-          if (getBook) {
-            getBook({ msg: "Unknown library name" });
-          }
-        },
-        name: "Unknown",
-      };
-};
+const completeLibraryName = (str) =>
+  getLibraryNames().find((name) => name.includes(str)) ?? "";
 
-function completeLibraryName(str) {
-  const found = _.find(getLibraryNames(), (name) => name.indexOf(str) >= 0);
-  return found ? found : "";
-}
+const isValidLibraryName = (libraryName) =>
+  libraryList.some((lib) => lib.name === libraryName);
 
-function isValidLibraryName(libraryName) {
-  const found = _.find(libraryList, (lib) => lib.name === libraryName);
-  return found ? true : false;
-}
+const getLibArray = (libraryName) => {
+  const names = Array.isArray(libraryName) ? libraryName : [libraryName];
+  return names
+    .map((name) => completeLibraryName(name))
+    .filter((fullName) => isValidLibraryName(fullName))
+    .map((fullName) => getLibraryFunction(fullName));
+};
 
-function getLibArray(libraryName) {
-  return _.flow([
-    fp.map((name) => {
-      const fullName = completeLibraryName(name);
-      return isValidLibraryName(fullName) ? getLibraryFunction(fullName) : null;
-    }),
-    _.compact,
-  ])(Array.isArray(libraryName) ? libraryName : [libraryName]);
-}
+const getSortedBooks = (books) =>
+  books
+    .map(({ libraryName, title, exist, bookUrl }) => ({ libraryName, title, exist, bookUrl }))
+    .sort((a, b) => (a.exist === b.exist ? 0 : a.exist ? -1 : 1));
 
-const getSortedBooks = _.flow([
-  fp.map((book) => ({
-    libraryName: book.libraryName,
-    title: book.title,
-    exist: book.exist,
-  })),
-  fp.sortBy((book) => !book.exist),
-]);
+const searchLibrary = (lib, title) =>
+  new Promise((resolve) => {
+    lib.search({ title, libraryName: lib.name }, (err, data) => {
+      if (err) {
+        resolve({ error: err });
+        return;
+      }
+      if (!data?.booklist) {
+        resolve({ error: { msg: "invalid Data response" } });
+        return;
+      }
+      resolve({
+        result: {
+          title,
+          libraryName: lib.name,
+          totalBookCount: data.totalBookCount,
+          startPage: data.startPage,
+          booklist: getSortedBooks(data.booklist),
+        },
+      });
+    });
+  });
 
-function search(opt, getBook, getAllBooks) {
+const search = (opt, getBook, getAllBooks) => {
   if (!opt || (!getBook && !getAllBooks)) {
     console.log("invalid search options");
     return;
   }
 
-  const title = opt.title;
-  const tasks = [];
-
-  _.each(getLibArray(opt.libraryName), (lib) => {
-    tasks.push((callback) => {
-      lib.search(
-        {
-          title: title,
-          libraryName: lib.name,
-        },
-        (err, data) => {
-          if (err) {
-            if (getBook) {
-              getBook(err);
-            }
-            callback(err);
-            return;
-          }
-          if (!data || !data.booklist) {
-            if (getBook) {
-              getBook({ msg: "invalid Data response" });
-            }
-            callback({ msg: "invalid Data response" });
-            return;
-          }
-
-          const bookObj = {
-            title: title,
-            libraryName: lib.name,
-            totalBookCount: data.totalBookCount,
-            startPage: data.startPage,
-            booklist: getSortedBooks(data.booklist),
-          };
+  const { title, libraryName } = opt;
+  const libraries = getLibArray(libraryName);
 
-          if (getBook) {
-            getBook(null, bookObj);
-          }
-          callback(null, bookObj);
-        },
-      );
-    });
-  });
-
-  async.parallel(tasks, (err, results) => {
-    if (getAllBooks) {
-      if (err) {
-        getAllBooks(err);
-      } else {
-        getAllBooks(null, results);
-      }
+  const promises = libraries.map(async (lib) => {
+    const { error, result } = await searchLibrary(lib, title);
+    if (error) {
+      getBook?.(error);
+      return null;
     }
+    getBook?.(null, result);
+    return result;
   });
-}
 
-function activate() {
-  makeLibraryList();
-}
-
-activate();
+  Promise.all(promises).then((results) => {
+    const validResults = results.filter(Boolean);
+    getAllBooks?.(null, validResults);
+  });
+};
 
 module.exports = {
   search,

package/src/http.js

@@ -0,0 +1,109 @@
+const { request } = require("undici");
+
+const DEFAULT_TIMEOUT = 20000;
+const DEFAULT_USER_AGENT =
+  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+
+async function get(url, options = {}) {
+  const { qs, headers = {}, timeout = DEFAULT_TIMEOUT } = options;
+
+  let fullUrl = url;
+  if (qs && Object.keys(qs).length > 0) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(qs)) {
+      params.append(key, String(value));
+    }
+    fullUrl = `${url}?${params}`;
+  }
+
+  const res = await request(fullUrl, {
+    method: "GET",
+    headersTimeout: timeout,
+    bodyTimeout: timeout,
+    headers: { "User-Agent": DEFAULT_USER_AGENT, ...headers },
+  });
+
+  return { statusCode: res.statusCode, body: await res.body.text() };
+}
+
+async function post(url, options = {}) {
+  const { form, headers = {}, timeout = DEFAULT_TIMEOUT } = options;
+
+  const formData = new URLSearchParams();
+  if (form) {
+    for (const [key, value] of Object.entries(form)) {
+      formData.append(key, String(value));
+    }
+  }
+
+  const res = await request(url, {
+    method: "POST",
+    headersTimeout: timeout,
+    bodyTimeout: timeout,
+    headers: {
+      "User-Agent": DEFAULT_USER_AGENT,
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...headers,
+    },
+    body: formData.toString(),
+  });
+
+  return { statusCode: res.statusCode, body: await res.body.text() };
+}
+
+function createSession() {
+  let cookies = [];
+
+  return {
+    async get(url, options = {}) {
+      const { headers = {}, timeout = DEFAULT_TIMEOUT } = options;
+
+      const res = await request(url, {
+        method: "GET",
+        headersTimeout: timeout,
+        bodyTimeout: timeout,
+        headers: {
+          "User-Agent": DEFAULT_USER_AGENT,
+          Cookie: cookies.join("; "),
+          ...headers,
+        },
+      });
+
+      const setCookie = res.headers["set-cookie"];
+      if (setCookie) {
+        const newCookies = Array.isArray(setCookie) ? setCookie : [setCookie];
+        cookies = [...cookies, ...newCookies.map((c) => c.split(";")[0])];
+      }
+
+      return { statusCode: res.statusCode, body: await res.body.text() };
+    },
+
+    async post(url, options = {}) {
+      const { form, headers = {}, timeout = DEFAULT_TIMEOUT } = options;
+
+      const formData = new URLSearchParams();
+      if (form) {
+        for (const [key, value] of Object.entries(form)) {
+          formData.append(key, String(value));
+        }
+      }
+
+      const res = await request(url, {
+        method: "POST",
+        headersTimeout: timeout,
+        bodyTimeout: timeout,
+        headers: {
+          "User-Agent": DEFAULT_USER_AGENT,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Cookie: cookies.join("; "),
+          ...headers,
+        },
+        body: formData.toString(),
+      });
+
+      return { statusCode: res.statusCode, body: await res.body.text() };
+    },
+  };
+}
+
+module.exports = { get, post, createSession };