@impactor/nodejs 3.0.1

package/src/fs.spec.js

@@ -0,0 +1,251 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import { resolve } from "./fs-sync";
+import {
+  copy,
+  getEntries,
+  getModifiedTime,
+  getSize,
+  isDir,
+  mkdir,
+  move,
+  read,
+  remove,
+  write
+} from "./fs";
+import { existsSync } from "node:fs";
+import { objectType } from "@impactor/javascript";
+import { utimes } from "node:fs/promises";
+let dir = resolve(import.meta.dirname, "./test!!/fs"), file = dir + "/file.txt";
+beforeEach(() => remove(dir).then(() => write(file, "ok")));
+afterEach(() => remove(dir));
+test("mkdir", () => {
+  expect(existsSync(`${dir}/mkdir`)).toBeFalsy();
+  return mkdir(`${dir}/mkdir`).then(
+    (_value) => expect(existsSync(dir)).toBeTruthy()
+  );
+});
+test("write", () => {
+  expect(existsSync(`${dir}/write.txt`)).toBeFalsy();
+  return mkdir(dir).then(() => write(`${dir}/write.txt`, "ok")).then(() => {
+    expect(existsSync(`${dir}/write.txt`)).toBeTruthy();
+  });
+});
+test("write in non-existing dir", () => {
+  let file2 = dir + "/non-existing/file.txt";
+  expect(existsSync(file2)).toBeFalsy();
+  return write(file2, "ok").then(() => {
+    expect(existsSync(file2)).toBeTruthy();
+  });
+});
+test("getSize", () => Promise.all([
+  write(`${dir}/get-size/file1.txt`, "ok"),
+  write(`${dir}/get-size/file2.txt`, "ok")
+]).then(
+  () => Promise.all([
+    // file
+    getSize(`${dir}/get-size/file1.txt`),
+    // array of files and directories (sum of all sizes)
+    getSize([`${dir}/get-size/file1.txt`, `${dir}/get-size/file2.txt`])
+    // directory (sum of its contents sizes)
+    // getSize(`${dir}/get-size`),
+  ])
+).then((value) => expect(value).toEqual([2, 4])));
+test("isDir", () => Promise.all([isDir(file), isDir(dir)]).then(
+  (value) => expect(value).toEqual([false, true])
+));
+test("getModifiedTime -> file", () => Promise.all([getModifiedTime(file), getModifiedTime(dir)]).then((value) => {
+  expect(Math.floor(value[0])).toBeGreaterThanOrEqual(1624906832178);
+  expect(Math.floor(value[1])).toBeGreaterThanOrEqual(1624906832178);
+}));
+test("move", () => {
+  let file2 = dir + "/file2.txt";
+  expect(existsSync(file)).toBeTruthy();
+  expect(existsSync(file2)).toBeFalsy();
+  return move(file, file2).then(() => {
+    expect(existsSync(file)).toBeFalsy();
+    expect(existsSync(file2)).toBeTruthy();
+  });
+});
+test("read", () => {
+  let fileJson = dir + "/file.json", fileArray = dir + "/array.json", fileJsonComments = dir + "/comments.json";
+  let contentJsonComments = `
+    // this file is created to test reading .json files that contains comments
+      // to test stripComments()
+ 
+   {
+     /* it should remove all comments */
+     /* even this 
+          multi-line comment 
+       */
+     // also this comment
+ 
+     "x": 1,
+     "hello": "ok"
+   }
+   `;
+  return Promise.all([
+    read(file),
+    write(fileJson, { x: 1, y: 2 }).then(() => read(fileJson)),
+    write(fileArray, [1, 2, 3]).then(() => read(fileArray)),
+    write(fileJsonComments, contentJsonComments).then(
+      () => read(fileJsonComments)
+    )
+  ]).then((value) => {
+    let [txt, json, array, jsonWithComments] = value;
+    expect(txt.length).toEqual(2);
+    expect(txt).toContain("ok");
+    expect(objectType(txt)).toEqual("string");
+    expect(objectType(json)).toEqual("object");
+    expect(objectType(jsonWithComments)).toEqual("object");
+    expect(objectType(array)).toEqual("array");
+    expect(json).toEqual({ x: 1, y: 2 });
+    expect(jsonWithComments).toEqual({ x: 1, hello: "ok" });
+    expect(array).toEqual([1, 2, 3]);
+  });
+});
+test("read from a non-existing file", () => expect(
+  read(`${dir}/non-existing.txt`, { maxAge: 24 * 60 * 60 })
+).rejects.toThrow("no such file or directory"));
+test("read: maxAge", (done) => {
+  let file2 = dir + "/file.txt";
+  write(file2, "ok").then(() => read(file2, { maxAge: 24 * 60 * 60 })).then((content) => {
+    expect(content).toEqual("ok");
+    done();
+  }).catch((error) => done(error));
+});
+test("read from an expired cache", () => {
+  let file2 = dir + "/file.txt";
+  let date = /* @__PURE__ */ new Date(), today = date.getDate();
+  date.setDate(today - 1);
+  let yesterday = date.getTime() / 1e3;
+  return expect(
+    write(file2, "ok").then(() => utimes(file2, yesterday, yesterday)).then(() => read(file2, { maxAge: 1 }))
+  ).rejects.toThrow("expired file");
+});
+test("remove a dir", () => {
+  expect(existsSync(file)).toBeTruthy();
+  expect(existsSync(dir)).toBeTruthy();
+  return remove([dir]).then(() => {
+    expect(existsSync(file)).toBeFalsy();
+    expect(existsSync(dir)).toBeFalsy();
+  });
+});
+test("remove a non-exists path", () => {
+  let file2 = `${dir}/non-existing/file.txt`;
+  return remove(file2).then(() => expect(existsSync(file2)).toBeFalsy());
+});
+test("copy a directory and its sub-directories", () => {
+  return Promise.all([
+    write(`${dir}/copy-dir/file.txt`, ""),
+    write(`${dir}/copy-dir/sub-dir/file2.txt`, "")
+  ]).then(() => copy(`${dir}/copy-dir`, `${dir}/copy-dir2`)).then(() => {
+    expect(existsSync(`${dir}/copy-dir2/file.txt`)).toBeTruthy();
+    expect(existsSync(`${dir}/copy-dir2/sub-dir/file2.txt`)).toBeTruthy();
+  });
+});
+describe("getEntries", () => {
+  let entries = ["file.txt", "file.js"];
+  beforeEach(() => {
+    return remove(dir).then(
+      () => Promise.all(
+        entries.map((element) => {
+          return write(`${dir}/${element}`, "").then(
+            () => write(`${dir}/subdir/${element}`, "")
+          );
+        })
+      )
+    );
+  });
+  test("list all entries recursively", () => {
+    return getEntries(dir).then((result) => {
+      expect(result.sort()).toEqual(
+        // all files in dir with full path
+        [
+          ...entries.map((element) => resolve(`${dir}/${element}`)).concat(
+            entries.map((element) => resolve(`${dir}/subdir/${element}`))
+          ),
+          resolve(`${dir}/subdir`)
+        ].sort()
+      );
+    });
+  });
+  test("filter by function", () => {
+    return getEntries(dir, (element) => element.includes(".js")).then(
+      (result) => {
+        expect(result).toEqual([
+          resolve(`${dir}/file.js`),
+          resolve(`${dir}/subdir/file.js`)
+        ]);
+      }
+    );
+  });
+  test("filter by regex", () => {
+    return getEntries(dir, /subdir/).then((result) => {
+      expect(result.sort()).toEqual(
+        [
+          ...entries.map((element) => resolve(`${dir}/subdir/${element}`)),
+          resolve(`${dir}/subdir`)
+        ].sort()
+      );
+    });
+  });
+  test("filter by type: files", () => {
+    return getEntries(dir, "files").then((result) => {
+      expect(result.sort()).toEqual(
+        entries.map((element) => resolve(`${dir}/${element}`)).concat(entries.map((element) => resolve(`${dir}/subdir/${element}`))).sort()
+      );
+    });
+  });
+  test("filter by type: dirs", () => getEntries(dir, "dirs").then((result) => {
+    expect(result).toEqual([resolve(`${dir}/subdir`)]);
+  }));
+  test("depth=0", async () => {
+    for (let element of entries) {
+      await write(`${dir}/subdir/extra/${element}`, "");
+    }
+    return getEntries(dir, void 0, 0).then((result) => {
+      expect(result.sort()).toEqual(
+        [
+          ...entries.map((element) => resolve(`${dir}/${element}`)),
+          resolve(`${dir}/subdir`)
+        ].sort()
+      );
+    });
+  });
+  test("depth=1", async () => {
+    for (let element of entries) {
+      await write(`${dir}/subdir/extra/${element}`, "");
+    }
+    return getEntries(dir, void 0, 1).then((result) => {
+      expect(result.sort()).toEqual(
+        [
+          ...entries.map((element) => resolve(`${dir}/${element}`)),
+          resolve(`${dir}/subdir`),
+          resolve(`${dir}/subdir/extra`)
+        ].concat(entries.map((element) => resolve(`${dir}/subdir/${element}`))).sort()
+      );
+    });
+  });
+  test("depth=2", async () => {
+    for (let element of entries) {
+      await write(`${dir}/subdir/extra/${element}`, "");
+    }
+    return getEntries(dir, void 0, 2).then((result) => {
+      expect(result.sort()).toEqual(
+        [
+          ...entries.map((element) => resolve(`${dir}/${element}`)),
+          resolve(`${dir}/subdir`),
+          resolve(`${dir}/subdir/extra`)
+        ].concat(entries.map((element) => resolve(`${dir}/subdir/${element}`))).concat(
+          entries.map((element) => resolve(`${dir}/subdir/extra/${element}`))
+        ).sort()
+      );
+    });
+  });
+  test("non existing dir", () => {
+    expect.hasAssertions();
+    return expect(getEntries(dir + "/non-existing")).rejects.toThrow(
+      "no such file or directory"
+    );
+  });
+});

package/src/https.d.ts

@@ -0,0 +1,3 @@
+import { type RequestOptions } from 'node:https';
+import { URL } from 'node:url';
+export default function request(url: string | URL, data?: any, options?: RequestOptions): Promise<any>;

package/src/https.js

@@ -0,0 +1,52 @@
+import https from "node:https";
+import { parse } from "content-type";
+import { objectType } from "@impactor/javascript";
+function request(url, data, options) {
+  return new Promise((resolve, reject) => {
+    let isObject = ["array", "object"].includes(objectType(data));
+    let requestOptions = Object.assign(
+      { method: data ? "POST" : "GET" },
+      options || {}
+    );
+    if (isObject) {
+      requestOptions.headers = {
+        "content-type": "application/json",
+        ...requestOptions.headers
+      };
+    }
+    let responseChunks = [];
+    let request_ = https.request(url, requestOptions, (res) => {
+      res.setEncoding("utf8");
+      res.on("data", function(chunk) {
+        responseChunks.push(chunk.toString());
+      });
+      res.on("end", () => {
+        try {
+          let response = responseChunks.join("");
+          let type = parse(res).type;
+          if (type === "application/json") {
+            response = JSON.parse(response);
+          }
+          if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+            reject(
+              ["array", "object"].includes(objectType(response)) ? { code: res.statusCode, ...response } : { code: res.statusCode, message: response }
+            );
+          } else {
+            resolve(response);
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    request_.on("error", (error) => reject(error));
+    if (requestOptions.method.toUpperCase() === "POST") {
+      let dataString = isObject ? JSON.stringify(data) : data;
+      request_.write(dataString);
+    }
+    request_.end();
+  });
+}
+export {
+  request as default
+};

package/src/https.spec.js

@@ -0,0 +1,19 @@
+import { expect, test } from "@jest/globals";
+import request from "./https";
+test("request", (done) => {
+  request(`https://jsonplaceholder.typicode.com/posts/1`).then((result) => {
+    expect(result.userId).toEqual(1);
+    done();
+  }).catch((error) => done(error));
+});
+test("request: POST", (done) => {
+  request(`https://jsonplaceholder.typicode.com/posts`, {
+    title: "test post request"
+  }).then((result) => {
+    expect(result.title).toEqual("test post request");
+    done();
+  }).catch((error) => done(error));
+});
+test("request: catching errors", () => expect(
+  request(`https://jsonplaceholder.typicode.com/wrong-endpoint`)
+).rejects.toEqual({ code: 404 }));

package/src/process.d.ts

@@ -0,0 +1,13 @@
+import { type ExecOptions, type ExecSyncOptions, type SpawnOptionsWithoutStdio } from 'node:child_process';
+import { type Obj } from '@impactor/javascript';
+export interface Argv {
+    cmd: Array<string>;
+    options: Obj;
+    external: string;
+}
+export declare function parseArgv(arguments_?: string | Array<string>): Argv;
+export declare function toArgv(argumentsObject: Argv): string;
+export declare function execSync(cmd: string, options?: ExecSyncOptions): Buffer | string;
+export declare function exec(cmd: string, options?: ExecOptions): Promise<string>;
+export declare function spawn(cmd: string, options?: SpawnOptionsWithoutStdio): Promise<void>;
+export declare function runTask(tasks: Obj, arguments_?: string | Array<string>): Promise<void>;

package/src/process.js

@@ -0,0 +1,203 @@
+import { argv } from "node:process";
+import {
+  exec as _exec,
+  execSync as _execSync,
+  spawn as _spawn
+} from "node:child_process";
+import {
+  chunk,
+  dotNotationToObject,
+  flatten,
+  objectType,
+  toNumber
+} from "@impactor/javascript";
+function parseArgv(arguments_) {
+  if (!arguments_) {
+    arguments_ = argv.slice(2);
+  } else if (typeof arguments_ === "string") {
+    arguments_ = arguments_.split(" ");
+  }
+  let argumentsObject = { cmd: [], options: {}, external: "" };
+  let setOption = (key, value) => {
+    if (typeof value === "string") {
+      if (value === "true") {
+        value = true;
+      } else if (value === "false") {
+        value = false;
+      } else {
+        value = toNumber(value);
+      }
+    }
+    if (argumentsObject.options[key]) {
+      if (!Array.isArray(argumentsObject.options[key])) {
+        argumentsObject.options[key] = [argumentsObject.options[key]];
+      }
+      value = argumentsObject.options[key].concat(value);
+    }
+    if (key.includes(".")) {
+      let keys = key.split(".");
+      key = keys.shift();
+      argumentsObject.options[key] = dotNotationToObject(keys, value);
+    } else {
+      argumentsObject.options[key] = value;
+    }
+  };
+  if (arguments_.includes("--")) {
+    let chunks = chunk(arguments_, arguments_.indexOf("--") || 0);
+    argumentsObject.external = chunks[1]?.slice(1)?.join(" ");
+    arguments_ = chunks[0];
+  }
+  for (let index = 0; index < arguments_.length; index++) {
+    let argument = arguments_[index].trim();
+    if (argument === "") {
+      continue;
+    }
+    if (/^--no-.+/.test(argument)) {
+      let match = argument.match(/^--no-(.+)/), key = match[1];
+      setOption(key, false);
+    } else if (/^--.+=/.test(argument)) {
+      let match = argument.match(/^--([^=]+)=(.*)$/s), key = match[1], value = match[2];
+      setOption(key, value);
+    } else if (/^--.+/.test(argument)) {
+      let match = argument.match(/^--(.+)/), key = match[1], next = arguments_[index + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        setOption(key, next);
+        index++;
+      } else {
+        setOption(key, true);
+      }
+    } else if (/^-[^-]+/.test(argument)) {
+      let letters = argument.slice(1, -1).split("");
+      let broken = false;
+      for (let index_ = 0; index_ < letters.length; index_++) {
+        let next2 = argument.slice(index_ + 2);
+        if (next2 === "-") {
+          setOption(letters[index_], "-");
+          continue;
+        }
+        if (/[A-Za-z]/.test(letters[index_]) && /=/.test(next2)) {
+          setOption(letters[index_], next2.split("=")[1]);
+          broken = true;
+          break;
+        } else if (/[A-Za-z]/.test(letters[index_]) && /-?\d+(?:\.\d*)?(?:e-?\d+)?$/.test(next2)) {
+          setOption(letters[index_], next2);
+          broken = true;
+          break;
+        } else if (letters[index_ + 1] && /\W/.test(letters[index_ + 1])) {
+          setOption(letters[index_], argument.slice(index_ + 2));
+          broken = true;
+          break;
+        } else {
+          setOption(letters[index_], true);
+        }
+      }
+      let key = argument.at(-1), next = arguments_[index + 1];
+      if (!broken && key !== "-") {
+        if (next && !/^(?:-|--)[^-]/.test(next)) {
+          setOption(key, next);
+          index++;
+        } else {
+          setOption(key, true);
+        }
+      }
+    } else {
+      argumentsObject.cmd.push(argument);
+    }
+  }
+  return argumentsObject;
+}
+function toArgv(argumentsObject) {
+  let argv2 = "";
+  for (let element of argumentsObject.cmd) {
+    argv2 += element + " ";
+  }
+  let setOption = function(key, value) {
+    let argv3 = "";
+    if (Array.isArray(value)) {
+      for (let element of value) {
+        argv3 += `--${key}=${element} `;
+      }
+    } else {
+      argv3 += `--${key}=${value} `;
+    }
+    return argv3;
+  };
+  for (let key in argumentsObject.options) {
+    if (argumentsObject.options.hasOwnProperty(key)) {
+      let value = argumentsObject.options[key];
+      if (objectType(value) === "object") {
+        for (let [k, v] of Object.entries(flatten({ [key]: value }))) {
+          argv2 += setOption(k, v);
+        }
+      } else {
+        argv2 += setOption(key, value);
+      }
+    }
+  }
+  if (argumentsObject.external) {
+    let external = argumentsObject.external.trim();
+    if (external !== "") {
+      argv2 += `-- ${argumentsObject.external}`;
+    }
+  }
+  return argv2;
+}
+function execSync(cmd, options) {
+  let opts = { stdio: "inherit", ...options };
+  return _execSync(cmd, opts);
+}
+function exec(cmd, options) {
+  return new Promise((res, rej) => {
+    _exec(cmd, options, (error, stdout, stderr) => {
+      if (error) {
+        error.message = error?.message || stderr || stdout;
+        rej(error);
+      } else {
+        res(stdout);
+      }
+    });
+  });
+}
+function spawn(cmd, options) {
+  return new Promise((res, rej) => {
+    let childProcess = _spawn(cmd, options);
+    childProcess.stdout.on("data", (data) => console.log(data.toString()));
+    childProcess.stderr.on("data", (err) => console.error(err.toString()));
+    childProcess.on("exit", (exitCode) => {
+      if (exitCode) rej();
+      else res();
+    });
+  });
+}
+async function runTask(tasks, arguments_) {
+  let parsedArguments = parseArgv(arguments_), task = parsedArguments.cmd.shift();
+  if (!task) {
+    throw new Error("task not provided!");
+  } else if (!(task in tasks)) {
+    throw new Error(`unknown task ${task}`);
+  }
+  try {
+    let optionsString = "";
+    for (let key in parsedArguments.options) {
+      optionsString += `--${key}=${parsedArguments.options[key]} `;
+    }
+    console.log(
+      `>> running the task: ${task} ${parsedArguments.cmd.join(
+        " "
+      )} ${optionsString}`
+    );
+    await tasks[task](...parsedArguments.cmd, parsedArguments.options);
+    console.log(">> Done");
+  } catch (error) {
+    error.task = task;
+    throw error;
+  }
+}
+export {
+  exec,
+  execSync,
+  parseArgv,
+  runTask,
+  spawn,
+  toArgv
+};

package/src/process.spec.js

@@ -0,0 +1,49 @@
+import { expect, test } from "@jest/globals";
+import { parseArgv, toArgv } from "./process";
+let input = "cmd1 cmd2 - --a 1 --b=2 --c true --d false --e --no-f -g -h hh -ijk ok -l- --num=1 --arr=1 --arr=2 --obj.a.b=1 -mn-o -p - -q123 --whitespaces=a\nb	c --no-exit -- ext1 ext2";
+let parsed = {
+  cmd: ["cmd1", "cmd2", "-"],
+  options: {
+    a: 1,
+    b: 2,
+    c: true,
+    d: false,
+    e: true,
+    f: false,
+    g: true,
+    h: "hh",
+    i: true,
+    j: true,
+    k: "ok",
+    l: "-",
+    num: 1,
+    arr: [1, 2],
+    obj: { a: { b: 1 } },
+    m: true,
+    n: "-o",
+    p: "-",
+    q: 123,
+    whitespaces: "a\nb	c",
+    exit: false
+  },
+  external: "ext1 ext2"
+};
+test("parseArgv()", () => {
+  expect(parseArgv(input)).toEqual(parsed);
+});
+test("parseArgv(): contains extra spaces", () => {
+  expect(parseArgv("cmd --a=1  --b=2")).toEqual({
+    cmd: ["cmd"],
+    options: { a: 1, b: 2 },
+    external: ""
+  });
+});
+test("toArgv()", () => {
+  let parsedArguments = {
+    cmd: ["cmd1", "cmd2"],
+    options: { a: "x", b: 1, c: true, d: false, e: { f: 1 }, g: [1, 2] },
+    external: "--external params"
+  };
+  let arguments_ = `cmd1 cmd2 --a=x --b=1 --c=true --d=false --e.f=1 --g=1 --g=2 -- --external params`;
+  expect(toArgv(parsedArguments)).toEqual(arguments_);
+});