writenpmstat.js: create WriteNpmStat

Author: veghdev

.eslintrc.js

@@ -0,0 +1,17 @@
+module.exports = {
+  env: {
+    browser: true,
+    commonjs: true,
+    es2021: true
+  },
+  extends: [
+    'standard',
+    'prettier'
+  ],
+  parserOptions: {
+    ecmaVersion: 'latest'
+  },
+  rules: {
+      'no-unused-vars': 1
+  }
+}

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+
+package-lock.json

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "printWidth": 80,
+  "tabWidth": 4
+}

package.json

@@ -0,0 +1,44 @@
+{
+  "name": "write-npmstat",
+  "version": "0.1.0",
+  "description": "write-npmstat makes it easy to collect, filter and save npm statistics to csv files.",
+  "main": "writenpmstat.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "check-prettier": "prettier -c ./*js",
+    "prettier": "prettier -w ./*js",
+    "check-eslint": "eslint ./*js",
+    "eslint": "eslint --fix ./*js",
+    "format": "npm-run-all prettier eslint",
+    "check": "npm-run-all check-prettier check-eslint"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/veghdev/write-npmstat.git"
+  },
+  "keywords": [
+    "js",
+    "csv",
+    "npmstats"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/veghdev/write-npmstat/issues"
+  },
+  "homepage": "https://github.com/veghdev/write-npmstat#readme",
+  "dependencies": {
+    "npm-stat-api": "^1.0.0",
+    "enum": "^3.0.0"
+  },
+  "devDependencies": {
+    "npm-run-all": "^4.1.0",
+    "prettier": "^2.6.0",
+    "eslint": "^8.14.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.2.0",
+    "eslint-plugin-promise": "^6.0.0"
+  }
+}

statdate.js

@@ -0,0 +1,93 @@
+class StatDate {
+    #start;
+    #end;
+
+    constructor(start, end) {
+        this.#start = StatDate.formatStart(start);
+        this.#end = StatDate.formatEnd(end);
+        if (this.#start >= this.#end) {
+            throw new Error("start must be before end");
+        }
+    }
+
+    get start() {
+        return this.#start;
+    }
+
+    set start(start) {
+        start = StatDate.formatStart(start);
+        if (this.end && start) {
+            if (start <= this.end) {
+                throw new Error("start must be before end");
+            }
+        }
+        this.#start = start;
+    }
+
+    get end() {
+        return this.#end;
+    }
+
+    set end(end) {
+        end = StatDate.formatEnd(end);
+        if (this.start && end) {
+            if (this.start <= end) {
+                throw new Error("start must be before end");
+            }
+        }
+        this.#end = end;
+    }
+
+    static formatDate(date) {
+        const dateObj = new Date(date);
+        const year = dateObj.getFullYear();
+        const day = ("0" + dateObj.getDate()).slice(-2);
+        const month = ("0" + (dateObj.getMonth() + 1)).slice(-2);
+        return year + "-" + month + "-" + day;
+    }
+
+    static formatStart(start) {
+        const timeDeltaMax = 181;
+        if (!start) {
+            start = new Date();
+            start.setDate(start.getDate() - timeDeltaMax);
+        }
+        if (start instanceof Date) {
+            start = StatDate.formatDate(start);
+        }
+        const parsed = start.split("-");
+        if (parsed.length === 1) {
+            start += "-01-01";
+        } else if (parsed.length === 2) {
+            start += "-01";
+        } else if (parsed.length !== 3) {
+            throw new Error("start format is incorrect");
+        }
+        return start;
+    }
+
+    static formatEnd(end) {
+        if (!end) {
+            end = new Date();
+        }
+        if (end instanceof Date) {
+            end = StatDate.formatDate(end);
+        }
+        const parsed = end.split("-");
+        if (parsed.length === 1) {
+            end += "-12-31";
+        } else if (parsed.length === 2) {
+            const lastDay = new Date(
+                parseInt(parsed[0]),
+                parseInt(parsed[1]) + 1,
+                0
+            );
+            end += "-" + ("0" + lastDay.getDate()).slice(-2);
+        } else if (parsed.length !== 3) {
+            throw new Error("end format is incorrect");
+        }
+        return end;
+    }
+}
+
+module.exports = StatDate;

writenpmstat.js

@@ -0,0 +1,126 @@
+const npm = require("npm-stat-api");
+const Enum = require("enum");
+
+const StatDate = require("./statdate.js");
+
+const StatPeriod = new Enum(
+    ["year", "month", "day", null],
+    { ignoreCase: true },
+    { freeze: true }
+);
+
+class WriteNpmStat {
+    #packageName;
+
+    #datePeriod;
+
+    constructor(packageName) {
+        if (!packageName) {
+            throw new Error("packageName is a required argument");
+        }
+
+        this.#packageName = packageName;
+
+        this.#datePeriod = StatPeriod.year;
+    }
+
+    get packageName() {
+        return this.#packageName;
+    }
+
+    get datePeriod() {
+        return this.#datePeriod;
+    }
+
+    set datePeriod(datePeriod) {
+        this.#datePeriod = StatPeriod.get(datePeriod);
+    }
+
+    getNpmStat(startDay, endDay) {
+        const statDate = new StatDate(startDay, endDay);
+        const days = WriteNpmStat.getDays(statDate.start, statDate.end);
+        return new Promise((resolve) => {
+            const stats = [];
+            days.forEach((day) => {
+                stats.push(this.#getStat(day, 100));
+            });
+            Promise.all(stats).then((stats) => {
+                resolve(Object.fromEntries(stats));
+            });
+        });
+    }
+
+    static getDays(startDay, endDay) {
+        const arr = [];
+        const dt = new Date(startDay);
+        for (dt; dt <= new Date(endDay); dt.setDate(dt.getDate() + 1)) {
+            arr.push(StatDate.formatDate(new Date(dt)));
+        }
+        return arr;
+    }
+
+    #getStat(day, retryLimit, retryCount) {
+        retryLimit = retryLimit || Number.MAX_VALUE;
+        retryCount = Math.max(retryCount || 0, 0);
+        return new Promise((resolve) => {
+            npm.stat(this.packageName, day, day, (err, res) => {
+                if (err) {
+                    if (retryCount < retryLimit) {
+                        return this.#getStat(day, retryLimit, retryCount + 1);
+                    }
+                    throw new Error("retryLimit reached");
+                }
+                return resolve([res.start, res.downloads]);
+            });
+        });
+    }
+
+    writeNpmStat(startDay, endDay, postfix = "npmstat") {
+        return new Promise((resolve) => {
+            const stats = this.getNpmStat(startDay, endDay);
+            stats.then((stats) => {
+                this.#groupStats(stats, startDay, endDay, postfix);
+                return resolve();
+            });
+        });
+    }
+
+    #groupStats(stats, startDay, endDay, postfix) {
+        const statDate = new StatDate(startDay, endDay);
+        const days = WriteNpmStat.getDays(statDate.start, statDate.end);
+        const processedStats = {};
+        if (this.datePeriod) {
+            let substring;
+            if (this.datePeriod === StatPeriod.year) {
+                substring = 4;
+            } else if (this.datePeriod === StatPeriod.month) {
+                substring = 7;
+            } else if (this.datePeriod === StatPeriod.month) {
+                substring = 10;
+            }
+            const initialized = {};
+            days.forEach((day) => {
+                const prefix = day.substring(0, substring);
+                if (!initialized[prefix]) {
+                    initialized[prefix] = true;
+                    processedStats[prefix + "_" + postfix + ".csv"] = [
+                        [day, stats[day]],
+                    ];
+                } else {
+                    processedStats[prefix + "_" + postfix + ".csv"].push([
+                        day,
+                        stats[day],
+                    ]);
+                }
+            });
+        } else {
+            processedStats[postfix + ".csv"] = [];
+            days.forEach((day) => {
+                processedStats[postfix + ".csv"].push([day, stats[day]]);
+            });
+        }
+        console.log(processedStats);
+    }
+}
+
+module.exports = WriteNpmStat;