subtrack 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { input, select } from "@inquirer/prompts";
+import Table from "cli-table3";
+import { consola } from "consola";
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+//#region src/basefs.ts
+let _db = null;
+function getDbDir() {
+	return process.env.SUBSC_CLI_DB_DIR ?? path.join(homedir(), ".config", "subtrack");
+}
+function getDb() {
+	if (_db) return _db;
+	const dbdir = getDbDir();
+	mkdirSync(dbdir, { recursive: true });
+	_db = new Database(path.join(dbdir, "subtrack.db"));
+	_db.pragma("journal_mode = WAL");
+	_db.pragma("foreign_keys = ON");
+	_db.exec(`
+    CREATE TABLE IF NOT EXISTS subscriptions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      price INTEGER NOT NULL,
+      currency TEXT NOT NULL,
+      cycle TEXT NOT NULL
+    );
+  `);
+	_db.exec(`
+    CREATE TABLE IF NOT EXISTS tags (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE
+    );
+  `);
+	_db.exec(`
+    CREATE TABLE IF NOT EXISTS subscription_tags (
+      subscription_id INTEGER NOT NULL,
+      tag_id INTEGER NOT NULL,
+      PRIMARY KEY (subscription_id, tag_id),
+      FOREIGN KEY (subscription_id) REFERENCES subscriptions(id) ON DELETE CASCADE,
+      FOREIGN KEY (tag_id) REFERENCES tags(id)
+    );
+  `);
+	return _db;
+}
+function mapTags(subs) {
+	if (subs.length === 0) return subs;
+	const getTags = getDb().prepare(`
+    SELECT tags.name FROM tags
+    JOIN subscription_tags ON subscription_tags.tag_id = tags.id
+    WHERE subscription_tags.subscription_id = ?
+  `);
+	for (const sub of subs) sub.tags = getTags.all(sub.id).map((r) => r.name);
+	return subs;
+}
+const getSubscriptions = () => {
+	try {
+		return mapTags(getDb().prepare("SELECT id, name, price, currency, cycle FROM subscriptions ORDER BY id").all());
+	} catch (error) {
+		consola.error("Failed to fetch subscriptions:", error);
+		throw error;
+	}
+};
+const writeSubscription = (data) => {
+	try {
+		const db = getDb();
+		const uniqueTags = Array.from(new Set(data.tags));
+		db.transaction(() => {
+			const result = db.prepare(`
+        INSERT INTO subscriptions (name, price, currency, cycle)
+        VALUES (?, ?, ?, ?)
+      `).run(data.name, data.price, data.currency, data.cycle);
+			const subscriptionId = Number(result.lastInsertRowid);
+			const insertTag = db.prepare(`
+        INSERT OR IGNORE INTO tags (name)
+        VALUES (?)
+      `);
+			const getTagId = db.prepare(`
+        SELECT id FROM tags WHERE name = ?
+      `);
+			const insertRel = db.prepare(`
+        INSERT INTO subscription_tags (subscription_id, tag_id)
+        VALUES (?, ?)
+      `);
+			for (const t of uniqueTags) {
+				insertTag.run(t);
+				const tagRow = getTagId.get(t);
+				if (tagRow) insertRel.run(subscriptionId, tagRow.id);
+			}
+		})();
+	} catch (error) {
+		consola.error("Failed to add subscription:", error);
+		throw error;
+	}
+};
+const deleteSubscription = (id) => {
+	try {
+		if (getDb().prepare("DELETE FROM subscriptions WHERE id = ?").run(id).changes === 0) consola.warn(`No subscription found with id ${id}`);
+	} catch (error) {
+		consola.error("Failed to delete subscription:", error);
+		throw error;
+	}
+};
+const tagsSubscription = (tag) => {
+	try {
+		const db = getDb();
+		const tags = Array.from(new Set(Array.isArray(tag) ? tag : [tag]));
+		if (tags.length === 0) return [];
+		const placeholders = tags.map(() => "?").join(",");
+		const ids = db.prepare(`
+        SELECT subscription_tags.subscription_id
+        FROM subscription_tags
+        JOIN tags ON tags.id = subscription_tags.tag_id
+        WHERE tags.name IN (${placeholders})
+        GROUP BY subscription_tags.subscription_id
+        HAVING COUNT(DISTINCT tags.name) = ?
+      `).all(...tags, tags.length).map((r) => r.subscription_id);
+		if (ids.length === 0) return [];
+		return mapTags(db.prepare(`
+      SELECT id, name, price, currency, cycle FROM subscriptions
+      WHERE id IN (${ids.map(() => "?").join(",")})
+    `).all(...ids));
+	} catch (error) {
+		consola.error("Failed to filter by tags:", error);
+		throw error;
+	}
+};
+//#endregion
+//#region src/table.ts
+const spreadSubscription = (get) => {
+	const list = get ?? getSubscriptions();
+	if (list.length === 0) {
+		consola.info("No subscriptions found");
+		return;
+	}
+	const table = new Table({ head: [
+		"name",
+		"cycle",
+		"tags",
+		"price"
+	] });
+	for (const sub of list) table.push([
+		String(sub.name),
+		String(sub.cycle),
+		sub.tags.length > 0 ? sub.tags.join(", ") : "-",
+		sub.currency === "USD" ? String(`$${sub.price}`) : String(`¥${sub.price}`)
+	]);
+	const usdtotal = list.filter((n) => n.currency === "USD").reduce((sum, n) => sum + n.price, 0);
+	const jpytotal = list.filter((n) => n.currency === "JPY").reduce((sum, n) => sum + n.price, 0);
+	table.push([
+		"",
+		"",
+		"JPY TOTAL",
+		`¥${jpytotal}`
+	], [
+		"",
+		"",
+		"USD TOTAL",
+		`$${usdtotal}`
+	]);
+	consola.log(table.toString());
+};
+//#endregion
+//#region src/index.ts
+const runCLI = () => {
+	const program = new Command();
+	program.name("subtrack");
+	program.command("list").action(() => {
+		spreadSubscription();
+	});
+	program.command("add").action(async () => {
+		const name = await input({ message: "subscription name" });
+		const price = await input({
+			message: "monthly payment amount",
+			validate: (value) => {
+				if (value.trim() === "") return "Please enter a valid number";
+				if (isNaN(Number(value)) || Number(value) < 0) return "Please enter a valid non-negative number";
+				return true;
+			}
+		});
+		const currency = await select({
+			message: "currency",
+			choices: [{
+				name: "JPY",
+				value: "JPY"
+			}, {
+				name: "USD",
+				value: "USD"
+			}]
+		});
+		const cycle = await select({
+			message: "cycle",
+			choices: [{
+				name: "monthly",
+				value: "monthly"
+			}, {
+				name: "yearly",
+				value: "yearly"
+			}]
+		});
+		const tag = (await input({ message: "tags" })).split(",").map((tag) => tag.trim()).filter(Boolean);
+		writeSubscription({
+			name,
+			price: Number(price),
+			currency,
+			cycle,
+			tags: tag
+		});
+	});
+	program.command("delete").argument("<number>").action((number) => {
+		deleteSubscription(Number(number));
+	});
+	program.command("tags").argument("<taglist...>").action((taglist) => {
+		spreadSubscription(tagsSubscription(taglist));
+	});
+	program.parse();
+};
+runCLI();
+//#endregion
+export {};

package/package.json

@@ -1,17 +1,24 @@
 {
   "name": "subtrack",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "license": "MIT",
+  "packageManager": "pnpm@11.5.1",
   "bin": {
-    "subsc-cli": "./dist/index.mjs"
+    "subtrack": "./dist/index.mjs"
   },
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/nazozokc/subsc-cli.git"
+    "url": "https://github.com/nazozokc/subtrack.git"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "start": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.5.2",
@@ -26,11 +33,5 @@
     "tsx": "^4.19.0",
     "typescript": "^5",
     "vitest": "^3.0.0"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "start": "tsx src/index.ts",
-    "test": "vitest run",
-    "test:watch": "vitest"
   }
-}
+}