@zinn-dev/core 0.0.4 → 0.0.5

package/index.ts

@@ -1,31 +1,70 @@
+import type { Task } from "./src/types";
+
+import { randomUUIDv7 } from "bun";
+import { generateKeyBetween } from "fractional-indexing";
+
 // TODO: do not initialize before the first "valid" command
 import "./src/config";
-import { db, addProject, getProjectByKey, deleteProjectByKey } from "./src/db";
+import * as dbProject from "./src/db/project";
+import * as dbTask from "./src/db/task";
+import { standardizeProjectKey } from "./src/lib";
+
+export const project = {
+  getByKey: dbProject.getByKey,
+  create: ({ key, name }: { key: string; name: string }) => {
+    const standardizedKey = standardizeProjectKey(key);
+    const project = dbProject.getByKey(standardizedKey);
+
+    if (project != null) {
+      throw new Error(`Project with key "${standardizedKey}" already exists!`);
+    }
+
+    dbProject.create(standardizedKey, name);
+  },
+  delete: (key: string) => {
+    const standardizedKey = standardizeProjectKey(key);
+    const project = dbProject.getByKey(standardizedKey);
+
+    if (project == null) {
+      throw new Error(`Project with key "${standardizedKey}" does not exist!`);
+    }
 
-function standardizeKey(key: string) {
-  // TODO: maybe force latin characters only to prevent unexpected stuff from charaters like Ğ, İ, etc.
-  return key.toUpperCase();
-}
+    dbProject.deleteByKey(standardizedKey);
+  },
+  standardizeKey: standardizeProjectKey,
+};
 
-// TODO: switch to object param
-export function createProject(key: string, name: string) {
-  const standardizedKey = standardizeKey(key);
-  const project = getProjectByKey(standardizedKey);
+export const task = {
+  create: (task: Pick<Task, "project_id" | "name" | "description">) => {
+    // TODO: if anything after this fails, especially the task creation, the counter is still incremented but not assigned to any task
+    const project = dbProject.incrementTaskCounterById(task.project_id);
 
-  if (project != null) {
-    throw new Error(`Project with key "${standardizedKey}" already exists!`);
-  }
+    if (project == null) {
+      throw new Error(`Project's next task number could not be retrieved  (ID:${task.project_id})`);
+    }
 
-  addProject(standardizedKey, name);
-}
+    // TODO: do proper refined query
+    // FIXME: returns all tasks from *all* projects
+    const allTasks = dbTask.getAll();
 
-export function deleteProject(key: string) {
-  const standardizedKey = standardizeKey(key);
-  const project = getProjectByKey(standardizedKey);
+    let previousTaskOrder = null;
+    if (allTasks.length > 0) {
+      const lastTask = allTasks[allTasks.length - 1]!;
+      previousTaskOrder = lastTask.task_order;
+    }
 
-  if (project == null) {
-    throw new Error(`Project with key "${standardizedKey}" does not exist!`);
-  }
+    const order = generateKeyBetween(previousTaskOrder, null);
 
-  deleteProjectByKey(standardizedKey);
-}
+    const now = Date.now();
+    return dbTask.create({
+      id: randomUUIDv7(),
+      project_id: task.project_id,
+      number: project.task_count,
+      name: task.name,
+      description: task.description,
+      task_order: order,
+      created_at: now,
+      updated_at: now,
+    });
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zinn-dev/core",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"description": "Shared logic for zinn, a kanban workflow in the terminal.",
 	"repository": {
 		"type": "git",
@@ -22,5 +22,8 @@
 	],
 	"publishConfig": {
 		"access": "public"
+	},
+	"dependencies": {
+		"fractional-indexing": "4.0.0"
 	}
 }

package/src/constant.ts

@@ -12,6 +12,7 @@ export const DATA_DIR = join(MAIN_DIR, "data");
 export const DB_PATH = join(DATA_DIR, DB_FILE_NAME);
 export const DB_TABLE = {
   project: "project",
+  task: "task",
 };
 
 // TODO: implement zod schema for setting.json

package/src/db/project.ts

@@ -0,0 +1,46 @@
+import type { Bind, Project } from "../types";
+
+import { randomUUIDv7 } from "bun";
+
+import { DB_TABLE } from "../constant";
+import { getDb } from "../db";
+import { standardizeProjectKey } from "../lib";
+
+export function getByKey(key: string) {
+  const db = getDb();
+  const standardizedKey = standardizeProjectKey(key);
+
+  return db
+    .query<Project, Bind<{ key: string }>>(`SELECT * FROM ${DB_TABLE.project} WHERE key = $key`)
+    .get({ $key: standardizedKey });
+}
+
+// TODO: switch to object param
+export function create(key: string, name: string) {
+  const db = getDb();
+
+  const query = db.query(`INSERT INTO
+    ${DB_TABLE.project} (id, key, name, created_at, updated_at)
+    VALUES              ($id, $key, $name, $created, $updated);`);
+  const time = Date.now();
+
+  return query.run({ $id: randomUUIDv7(), $key: key, $name: name, $created: time, $updated: time });
+}
+
+export function incrementTaskCounterById(projectId: string) {
+  const db = getDb();
+
+  const nextTaskNumber = db
+    .query<Pick<Project, "task_count">, Bind<Pick<Project, "id">>>(`UPDATE ${DB_TABLE.project}
+          SET task_count = task_count + 1
+          WHERE id = $id RETURNING task_count`)
+    .get({ $id: projectId });
+  return nextTaskNumber;
+}
+
+// TODO: maybe allow both by `key` and `id`, and use whichever is provided
+export function deleteByKey(key: string) {
+  const db = getDb();
+
+  return db.query(`DELETE FROM ${DB_TABLE.project} WHERE key = $key;`).run({ $key: key });
+}

package/src/db/task.ts

@@ -0,0 +1,29 @@
+import type { Bind, Task } from "../types";
+
+import { getDb } from "../db";
+import { DB_TABLE } from "../constant";
+
+// TODO: refined parameters, preferably of type SQLBindings
+export function getAll() {
+  const db = getDb();
+  return db.query<Task, any>(`SELECT * FROM ${DB_TABLE.task}`).all();
+}
+
+export function create(task: Omit<Task, "archived_at">) {
+  const db = getDb();
+
+  const q = db.query<Task, Bind<Omit<Task, "archived_at">>>(`INSERT INTO
+    ${DB_TABLE.task}  (id, project_id, number, name, description, task_order, created_at, updated_at)
+    VALUES            ($id, $project_id, $number, $name, $description, $task_order, $created_at, $updated_at);`);
+
+  return q.run({
+    $id: task.id,
+    $project_id: task.project_id,
+    $number: task.number,
+    $name: task.name,
+    $description: task.description,
+    $task_order: task.task_order,
+    $created_at: task.created_at,
+    $updated_at: task.updated_at,
+  });
+}

package/src/db.ts

@@ -1,34 +1,48 @@
 import { Database } from "bun:sqlite";
 import { DB_PATH, DB_TABLE } from "./constant";
-import { randomUUIDv7 } from "bun";
 
-export const db = new Database(DB_PATH, { create: true });
-db.run("PRAGMA journal_mode = WAL;");
-// TODO: https://bun.com/docs/runtime/sqlite#wal-sidecar-file-cleanup macOS does not auto cleanup
+let db: Database | null = null;
 
-const projectTableSetup = db.query(`CREATE TABLE IF NOT EXISTS ${DB_TABLE.project} (
+function initDb() {
+  // TODO: turn on strict mode, and refactor `$` prefixes: https://bun.com/docs/runtime/sqlite#strict-true-lets-you-bind-values-without-prefixes
+  const db = new Database(DB_PATH, { create: true });
+
+  db.run("PRAGMA journal_mode = WAL;");
+  db.run("PRAGMA foreign_keys = true;");
+  // TODO: https://bun.com/docs/runtime/sqlite#wal-sidecar-file-cleanup macOS does not auto cleanup
+
+  // --- PROJECT TABLE
+  db.query(`CREATE TABLE IF NOT EXISTS ${DB_TABLE.project} (
   id          TEXT PRIMARY KEY,
   key         TEXT NOT NULL UNIQUE,
   name        TEXT NOT NULL,
+  task_count  INTEGER NOT NULL DEFAULT 0,
+  created_at  INTEGER NOT NULL,
+  updated_at  INTEGER NOT NULL,
+  archived_at INTEGER);`).run();
+
+  // --- TASK TABLE
+  db.query(`CREATE TABLE IF NOT EXISTS ${DB_TABLE.task} (
+  id          TEXT PRIMARY KEY,
+  project_id  TEXT NOT NULL REFERENCES project(id) ON DELETE CASCADE,
+  number      INTEGER NOT NULL,
+  name        TEXT NOT NULL,
+  description TEXT,
+  task_order  TEXT,
   created_at  INTEGER NOT NULL,
   updated_at  INTEGER NOT NULL,
-  archived_at INTEGER);`);
-projectTableSetup.run();
+  archived_at INTEGER);`).run();
 
-export function getProjectByKey(key: string) {
-  return db.query(`SELECT * FROM ${DB_TABLE.project} WHERE key = $key`).get({ $key: key });
+  return db;
 }
 
-// TODO: switch to object param
-export function addProject(key: string, name: string) {
-  const query = db.query(`INSERT INTO
-    ${DB_TABLE.project} (id, key, name, created_at, updated_at)
-    VALUES              ($id, $key, $name, $created, $updated);`);
-  const time = Date.now();
+db = initDb();
 
-  return query.run({ $id: randomUUIDv7(), $key: key, $name: name, $created: time, $updated: time });
-}
+export function getDb() {
+  if (db == null) {
+    console.error("There was a problem initializing the database");
+    process.exit(1);
+  }
 
-export function deleteProjectByKey(key: string) {
-  return db.query(`DELETE FROM ${DB_TABLE.project} WHERE key = $key;`).run({ $key: key });
+  return db;
 }

package/src/lib.ts

@@ -0,0 +1,4 @@
+export function standardizeProjectKey(key: string) {
+  // TODO: maybe force latin characters only to prevent unexpected stuff from charaters like Ğ, İ, etc.
+  return key.toUpperCase();
+}

package/src/types.ts

@@ -0,0 +1,28 @@
+// https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html
+type BoundProperty<P extends string> = `$${P}`;
+// https://www.typescriptlang.org/docs/handbook/2/mapped-types.html
+export type Bind<T, K extends string & keyof T = string & keyof T> = {
+  [Property in BoundProperty<K>]: T[keyof T];
+};
+
+export type Project = {
+  id: string;
+  key: string;
+  name: string;
+  task_count: number;
+  created_at: number;
+  updated_at: number;
+  archived_at: number | null;
+};
+
+export type Task = {
+  id: string;
+  project_id: string;
+  number: number;
+  name: string;
+  description: string | null;
+  task_order: string;
+  created_at: number;
+  updated_at: number;
+  archived_at: number | null;
+};