@alt-t4b/pm-domain 0.1.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@alt-t4b/pm-domain",
+  "version": "0.1.0",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": ["src"],
+  "dependencies": {
+    "ulid": "^2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2",
+    "typescript": "^5"
+  }
+}

package/src/bootstrap.ts

@@ -0,0 +1,26 @@
+import type { Database } from "bun:sqlite";
+import { createDatabase } from "./db/connection";
+import { runMigrations } from "./db/schema";
+import { ProjectRepository } from "./repositories/projects";
+import { TaskRepository } from "./repositories/tasks";
+import { ProjectService } from "./services/projects";
+import { TaskService } from "./services/tasks";
+import type { IProjectService, ITaskService } from "./services";
+
+export interface AppContext {
+  db: Database;
+  projectService: IProjectService;
+  taskService: ITaskService;
+}
+
+export function bootstrap(dbPath?: string): AppContext {
+  const db = createDatabase(dbPath);
+  runMigrations(db);
+
+  const projectRepo = new ProjectRepository(db);
+  const taskRepo = new TaskRepository(db);
+  const projectService = new ProjectService(projectRepo);
+  const taskService = new TaskService(taskRepo, projectRepo);
+
+  return { db, projectService, taskService };
+}

package/src/db/connection.ts

@@ -0,0 +1,21 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const DEFAULT_DB_PATH = join(homedir(), ".tab", "project-management", "sqlite.db");
+
+export function getDbPath(): string {
+  return process.env.SQLITE_PATH ?? DEFAULT_DB_PATH;
+}
+
+export function createDatabase(dbPath?: string): Database {
+  const resolvedPath = dbPath ?? getDbPath();
+  mkdirSync(join(resolvedPath, ".."), { recursive: true });
+
+  const db = new Database(resolvedPath);
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA foreign_keys = ON");
+
+  return db;
+}

package/src/db/schema.ts

@@ -0,0 +1,35 @@
+import type { Database } from "bun:sqlite";
+import { PROJECT_STATUSES, TASK_STATUSES } from "../statuses";
+
+const projectStatusCheck = PROJECT_STATUSES.map((s) => `'${s}'`).join(", ");
+const taskStatusCheck = TASK_STATUSES.map((s) => `'${s}'`).join(", ");
+
+export function runMigrations(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id          TEXT PRIMARY KEY,
+      slug        TEXT NOT NULL UNIQUE,
+      name        TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      status      TEXT NOT NULL DEFAULT 'active'
+                  CHECK (status IN (${projectStatusCheck})),
+      created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+  `);
+
+  db.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_projects_slug ON projects(slug)");
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id          TEXT PRIMARY KEY,
+      project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      title       TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      status      TEXT NOT NULL DEFAULT 'todo'
+                  CHECK (status IN (${taskStatusCheck})),
+      created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+  `);
+}

package/src/entities.ts

@@ -0,0 +1,21 @@
+import type { ProjectStatus, TaskStatus } from "./statuses";
+
+export interface Project {
+  id: string;
+  slug: string;
+  name: string;
+  description: string;
+  status: ProjectStatus;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Task {
+  id: string;
+  project_id: string;
+  title: string;
+  description: string;
+  status: TaskStatus;
+  created_at: string;
+  updated_at: string;
+}

package/src/errors.ts

@@ -0,0 +1,9 @@
+export class ServiceError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number
+  ) {
+    super(message);
+    this.name = "ServiceError";
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from "./statuses";
+export * from "./entities";
+export * from "./inputs";
+export * from "./errors";
+export * from "./services";
+export * from "./bootstrap";
+export { createDatabase, getDbPath } from "./db/connection";
+export { runMigrations } from "./db/schema";
+export { ProjectRepository } from "./repositories/projects";
+export { TaskRepository } from "./repositories/tasks";
+export { ProjectService } from "./services/projects";
+export { TaskService } from "./services/tasks";

package/src/inputs.ts

@@ -0,0 +1,13 @@
+import type { Project, Task } from "./entities";
+
+export type CreateProjectInput = Pick<Project, "name" | "slug"> &
+  Partial<Pick<Project, "description" | "status">>;
+
+export type UpdateProjectInput = Partial<
+  Pick<Project, "name" | "description" | "status">
+>;
+
+export type CreateTaskInput = Pick<Task, "title"> &
+  Partial<Pick<Task, "description" | "status">>;
+
+export type UpdateTaskInput = Partial<Pick<Task, "title" | "description" | "status">>;

package/src/repositories/projects.ts

@@ -0,0 +1,75 @@
+import type { Database } from "bun:sqlite";
+import { ulid } from "ulid";
+import type { Project } from "../entities";
+import type { CreateProjectInput, UpdateProjectInput } from "../inputs";
+
+export class ProjectRepository {
+  constructor(private db: Database) {}
+
+  findAll(): Project[] {
+    return this.db
+      .query("SELECT * FROM projects ORDER BY created_at DESC")
+      .all() as Project[];
+  }
+
+  findById(id: string): Project | null {
+    return (
+      this.db.query("SELECT * FROM projects WHERE id = ?").get(id) as Project | null
+    );
+  }
+
+  findBySlug(slug: string): Project | null {
+    return (
+      this.db.query("SELECT * FROM projects WHERE slug = ?").get(slug) as Project | null
+    );
+  }
+
+  create(input: CreateProjectInput): Project {
+    const id = ulid();
+    const now = new Date().toISOString();
+
+    this.db
+      .query(
+        `INSERT INTO projects (id, slug, name, description, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        input.slug,
+        input.name,
+        input.description ?? "",
+        input.status ?? "active",
+        now,
+        now
+      );
+
+    return this.findById(id)!;
+  }
+
+  update(slug: string, input: UpdateProjectInput): Project | null {
+    const existing = this.findBySlug(slug);
+    if (!existing) return null;
+
+    const name = input.name ?? existing.name;
+    const description = input.description ?? existing.description;
+    const status = input.status ?? existing.status;
+    const now = new Date().toISOString();
+
+    this.db
+      .query(
+        `UPDATE projects
+         SET name = ?, description = ?, status = ?, updated_at = ?
+         WHERE slug = ?`
+      )
+      .run(name, description, status, now, slug);
+
+    return this.findBySlug(slug)!;
+  }
+
+  delete(slug: string): boolean {
+    const result = this.db
+      .query("DELETE FROM projects WHERE slug = ?")
+      .run(slug);
+    return result.changes > 0;
+  }
+}

package/src/repositories/tasks.ts

@@ -0,0 +1,62 @@
+import type { Database } from "bun:sqlite";
+import { ulid } from "ulid";
+import type { Task } from "../entities";
+import type { CreateTaskInput } from "../inputs";
+import type { UpdateTaskInput } from "../inputs";
+
+export class TaskRepository {
+  constructor(private db: Database) {}
+
+  findByProject(projectId: string): Task[] {
+    return this.db
+      .query("SELECT * FROM tasks WHERE project_id = ? ORDER BY created_at ASC")
+      .all(projectId) as Task[];
+  }
+
+  create(projectId: string, input: CreateTaskInput): Task {
+    const id = ulid();
+    const now = new Date().toISOString();
+
+    this.db
+      .query(
+        `INSERT INTO tasks (id, project_id, title, description, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        projectId,
+        input.title,
+        input.description ?? "",
+        input.status ?? "todo",
+        now,
+        now
+      );
+
+    return this.db.query("SELECT * FROM tasks WHERE id = ?").get(id) as Task;
+  }
+
+  update(id: string, input: UpdateTaskInput): Task | null {
+    const existing = this.db
+      .query("SELECT * FROM tasks WHERE id = ?")
+      .get(id) as Task | null;
+    if (!existing) return null;
+
+    const title = input.title ?? existing.title;
+    const description = input.description ?? existing.description;
+    const status = input.status ?? existing.status;
+    const now = new Date().toISOString();
+
+    this.db
+      .query(
+        `UPDATE tasks SET title = ?, description = ?, status = ?, updated_at = ? WHERE id = ?`
+      )
+      .run(title, description, status, now, id);
+
+    return this.db.query("SELECT * FROM tasks WHERE id = ?").get(id) as Task;
+  }
+
+  delete(id: string): boolean {
+    const result = this.db.query("DELETE FROM tasks WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+}

package/src/services/projects.ts

@@ -0,0 +1,68 @@
+import type { Project } from "../entities";
+import type { CreateProjectInput, UpdateProjectInput } from "../inputs";
+import type { IProjectService } from "../services";
+import { ServiceError } from "../errors";
+import type { ProjectRepository } from "../repositories/projects";
+import { PROJECT_STATUSES } from "../statuses";
+
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export class ProjectService implements IProjectService {
+  constructor(private repo: ProjectRepository) {}
+
+  findAll(): Project[] {
+    return this.repo.findAll();
+  }
+
+  findBySlug(slug: string): Project | null {
+    return this.repo.findBySlug(slug);
+  }
+
+  create(input: CreateProjectInput): Project {
+    if (!input.name?.trim()) {
+      throw new ServiceError("name is required", 400);
+    }
+    if (input.name.length > 255) {
+      throw new ServiceError("name must be 255 characters or fewer", 400);
+    }
+    if (!input.slug?.trim()) {
+      throw new ServiceError("slug is required", 400);
+    }
+    if (input.slug.length > 100) {
+      throw new ServiceError("slug must be 100 characters or fewer", 400);
+    }
+    if (!SLUG_RE.test(input.slug)) {
+      throw new ServiceError("slug must be lowercase alphanumeric with hyphens only", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(PROJECT_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${PROJECT_STATUSES.join(", ")}`, 400);
+    }
+    if (this.repo.findBySlug(input.slug)) {
+      throw new ServiceError("slug already exists", 409);
+    }
+    return this.repo.create(input);
+  }
+
+  update(slug: string, input: UpdateProjectInput): Project | null {
+    if (input.name !== undefined && !input.name.trim()) {
+      throw new ServiceError("name cannot be empty", 400);
+    }
+    if (input.name !== undefined && input.name.length > 255) {
+      throw new ServiceError("name must be 255 characters or fewer", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(PROJECT_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${PROJECT_STATUSES.join(", ")}`, 400);
+    }
+    return this.repo.update(slug, input);
+  }
+
+  delete(slug: string): boolean {
+    return this.repo.delete(slug);
+  }
+}

package/src/services/tasks.ts

@@ -0,0 +1,62 @@
+import type { Task } from "../entities";
+import type { CreateTaskInput, UpdateTaskInput } from "../inputs";
+import type { ITaskService } from "../services";
+import { ServiceError } from "../errors";
+import type { TaskRepository } from "../repositories/tasks";
+import type { ProjectRepository } from "../repositories/projects";
+import { TASK_STATUSES } from "../statuses";
+
+export class TaskService implements ITaskService {
+  constructor(
+    private taskRepo: TaskRepository,
+    private projectRepo: ProjectRepository
+  ) {}
+
+  findByProjectSlug(projectSlug: string): Task[] {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
+    return this.taskRepo.findByProject(project.id);
+  }
+
+  create(projectSlug: string, input: CreateTaskInput): Task {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
+    if (!input.title?.trim()) {
+      throw new ServiceError("title is required", 400);
+    }
+    if (input.title.length > 500) {
+      throw new ServiceError("title must be 500 characters or fewer", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(TASK_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${TASK_STATUSES.join(", ")}`, 400);
+    }
+    return this.taskRepo.create(project.id, input);
+  }
+
+  update(id: string, input: UpdateTaskInput): Task | null {
+    if (input.title !== undefined && !input.title.trim()) {
+      throw new ServiceError("title cannot be empty", 400);
+    }
+    if (input.title !== undefined && input.title.length > 500) {
+      throw new ServiceError("title must be 500 characters or fewer", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(TASK_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${TASK_STATUSES.join(", ")}`, 400);
+    }
+    return this.taskRepo.update(id, input);
+  }
+
+  delete(id: string): boolean {
+    return this.taskRepo.delete(id);
+  }
+}

package/src/services.ts

@@ -0,0 +1,22 @@
+import type { Project, Task } from "./entities";
+import type {
+  CreateProjectInput,
+  UpdateProjectInput,
+  CreateTaskInput,
+  UpdateTaskInput,
+} from "./inputs";
+
+export interface IProjectService {
+  findAll(): Project[];
+  findBySlug(slug: string): Project | null;
+  create(input: CreateProjectInput): Project;
+  update(slug: string, input: UpdateProjectInput): Project | null;
+  delete(slug: string): boolean;
+}
+
+export interface ITaskService {
+  findByProjectSlug(projectSlug: string): Task[];
+  create(projectSlug: string, input: CreateTaskInput): Task;
+  update(id: string, input: UpdateTaskInput): Task | null;
+  delete(id: string): boolean;
+}

package/src/statuses.ts

@@ -0,0 +1,5 @@
+export const PROJECT_STATUSES = ["active", "paused", "completed", "archived"] as const;
+export type ProjectStatus = (typeof PROJECT_STATUSES)[number];
+
+export const TASK_STATUSES = ["todo", "in_progress", "done"] as const;
+export type TaskStatus = (typeof TASK_STATUSES)[number];