@vanshbhardwaj/worklog 1.0.0

package/src/tests/repositories/work-unit.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import { runMigrations } from '../../database/migrations.js';
+import { WorkUnitRepository } from '../../repositories/work-unit.js';
+import { DatabaseError } from '../../errors/index.js';
+
+describe('WorkUnitRepository', () => {
+  const tempTestDir = path.join(process.cwd(), 'src', 'tests', 'temp-repo-test');
+  let db: Database.Database;
+  let repo: WorkUnitRepository;
+
+  beforeAll(() => {
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempTestDir, { recursive: true });
+
+    db = new Database(path.join(tempTestDir, 'test.db'));
+    runMigrations(db);
+    repo = new WorkUnitRepository(db);
+  });
+
+  afterAll(() => {
+    if (db) {
+      db.close();
+    }
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+  });
+
+  beforeEach(() => {
+    db.exec('DELETE FROM work_units');
+    db.exec('DELETE FROM work_unit_tags');
+    db.exec('DELETE FROM work_unit_relations');
+    db.exec('DELETE FROM work_units_fts');
+  });
+
+  it('should return null when finding a non-existent ID', () => {
+    expect(repo.findById(999)).toBeNull();
+  });
+
+  it('should return empty list on recent, status, type search when DB is empty', () => {
+    expect(repo.findRecent()).toEqual([]);
+    expect(repo.findByStatus('Completed')).toEqual([]);
+    expect(repo.findByType('Bug')).toEqual([]);
+    expect(repo.search('anything')).toEqual([]);
+  });
+
+  it('should create and find a work unit', () => {
+    const created = repo.create({
+      title: 'First feature',
+      type: 'Feature',
+      status: 'Planned',
+      priority: 'High',
+      module: 'core',
+      description: 'First feature desc',
+      nextStep: 'write tests',
+      decision: null,
+      blocker: null,
+      notes: 'some notes',
+      tags: ['backend', 'test'],
+      relatedWorkUnits: [],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    expect(created.id).toBeTypeOf('number');
+    expect(created.title).toBe('First feature');
+    expect(created.tags).toEqual(['backend', 'test']);
+
+    const found = repo.findById(created.id);
+    expect(found).not.toBeNull();
+    expect(found!.title).toBe('First feature');
+    expect(found!.tags).toEqual(['backend', 'test']);
+  });
+
+  it('should throw DatabaseError if creating relation to non-existent ID', () => {
+    expect(() =>
+      repo.create({
+        title: 'Invalid relation unit',
+        type: 'Feature',
+        status: 'Planned',
+        priority: null,
+        module: null,
+        description: null,
+        nextStep: null,
+        decision: null,
+        blocker: null,
+        notes: null,
+        tags: [],
+        relatedWorkUnits: [9999],
+        createdAt: '2026-07-26T20:00:00Z',
+        updatedAt: '2026-07-26T20:00:00Z',
+      }),
+    ).toThrow(DatabaseError);
+  });
+
+  it('should support creating relations between work units', () => {
+    const unit1 = repo.create({
+      title: 'Unit 1',
+      type: 'Feature',
+      status: 'Planned',
+      priority: null,
+      module: null,
+      description: null,
+      nextStep: null,
+      decision: null,
+      blocker: null,
+      notes: null,
+      tags: [],
+      relatedWorkUnits: [],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    const unit2 = repo.create({
+      title: 'Unit 2',
+      type: 'Bug',
+      status: 'In Progress',
+      priority: null,
+      module: null,
+      description: null,
+      nextStep: null,
+      decision: null,
+      blocker: null,
+      notes: null,
+      tags: [],
+      relatedWorkUnits: [unit1.id],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    const found2 = repo.findById(unit2.id);
+    expect(found2!.relatedWorkUnits).toEqual([unit1.id]);
+  });
+
+  it('should update a work unit and its sub-tables', () => {
+    const original = repo.create({
+      title: 'Original Title',
+      type: 'Feature',
+      status: 'Planned',
+      priority: 'Low',
+      module: 'core',
+      description: 'Original description',
+      nextStep: 'original next',
+      decision: null,
+      blocker: null,
+      notes: 'some notes',
+      tags: ['alpha'],
+      relatedWorkUnits: [],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    const updated = repo.update(original.id, {
+      title: 'Updated Title',
+      priority: 'High',
+      tags: ['beta', 'gamma'],
+      updatedAt: '2026-07-26T21:00:00Z',
+    });
+
+    expect(updated.title).toBe('Updated Title');
+    expect(updated.priority).toBe('High');
+    expect(updated.tags).toEqual(['beta', 'gamma']);
+    expect(updated.updatedAt).toBe('2026-07-26T21:00:00Z');
+  });
+
+  it('should search work units using FTS5 MATCH', () => {
+    repo.create({
+      title: 'Build the compiler frontend',
+      type: 'Feature',
+      status: 'In Progress',
+      priority: null,
+      module: null,
+      description: 'Using parsing techniques',
+      nextStep: null,
+      decision: null,
+      blocker: null,
+      notes: null,
+      tags: [],
+      relatedWorkUnits: [],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    repo.create({
+      title: 'Clean the database connection logs',
+      type: 'Improvement',
+      status: 'Completed',
+      priority: null,
+      module: null,
+      description: 'Removed stdout statements',
+      nextStep: null,
+      decision: 'Keep logs silent by default',
+      blocker: null,
+      notes: null,
+      tags: [],
+      relatedWorkUnits: [],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    const search1 = repo.search('compiler');
+    expect(search1.length).toBe(1);
+    expect(search1[0].title).toBe('Build the compiler frontend');
+
+    const search2 = repo.search('logs');
+    expect(search2.length).toBe(1);
+    expect(search2[0].title).toBe('Clean the database connection logs');
+  });
+
+  it('should delete a work unit and cascade deletes to sub-tables', () => {
+    const created = repo.create({
+      title: 'Delete Me',
+      type: 'Bug',
+      status: 'Planned',
+      priority: null,
+      module: null,
+      description: null,
+      nextStep: null,
+      decision: null,
+      blocker: null,
+      notes: null,
+      tags: ['temp'],
+      relatedWorkUnits: [],
+      createdAt: '2026-07-26T20:00:00Z',
+      updatedAt: '2026-07-26T20:00:00Z',
+    });
+
+    const deleted = repo.delete(created.id);
+    expect(deleted).toBe(true);
+
+    expect(repo.findById(created.id)).toBeNull();
+
+    const tagsCount = db
+      .prepare('SELECT count(*) as count FROM work_unit_tags WHERE work_unit_id = ?')
+      .get(created.id) as any;
+    expect(tagsCount.count).toBe(0);
+  });
+});

package/src/tests/services/work-unit.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi } from 'vitest';
+import { WorkUnitService } from '../../services/work-unit.js';
+import { WorkUnitRepository } from '../../repositories/work-unit.js';
+import { ValidationError } from '../../errors/index.js';
+
+describe('WorkUnitService', () => {
+  it('should throw ValidationError if input title is empty', () => {
+    const mockRepo = {} as unknown as WorkUnitRepository;
+    const service = new WorkUnitService(mockRepo);
+
+    expect(() =>
+      service.createWorkUnit({
+        title: '',
+        type: 'Feature',
+      }),
+    ).toThrow(ValidationError);
+  });
+
+  it('should throw ValidationError if input type is invalid', () => {
+    const mockRepo = {} as unknown as WorkUnitRepository;
+    const service = new WorkUnitService(mockRepo);
+
+    expect(() =>
+      service.createWorkUnit({
+        title: 'Valid Title',
+        type: 'INVALID_TYPE',
+      }),
+    ).toThrow(ValidationError);
+  });
+
+  it('should validate creation inputs, set dates, and delegate to repo', () => {
+    const mockRepo = {
+      create: vi.fn().mockImplementation((data) => ({
+        id: 1,
+        ...data,
+      })),
+    } as unknown as WorkUnitRepository;
+
+    const service = new WorkUnitService(mockRepo);
+
+    const result = service.createWorkUnit({
+      title: '  New Feature  ', // tests string trimming
+      type: 'Feature',
+      status: 'Planned',
+      priority: 'High',
+      module: 'ui',
+      tags: ['css', 'layout'],
+    });
+
+    expect(mockRepo.create).toHaveBeenCalledOnce();
+    expect(result.id).toBe(1);
+    expect(result.createdAt).toBeDefined();
+    expect(result.updatedAt).toBeDefined();
+    expect(result.title).toBe('New Feature'); // verified trimmed
+  });
+
+  it('should validate update inputs and delegate to repo', () => {
+    const mockRepo = {
+      update: vi.fn().mockImplementation((id, data) => ({
+        id,
+        ...data,
+      })),
+    } as unknown as WorkUnitRepository;
+
+    const service = new WorkUnitService(mockRepo);
+
+    const result = service.updateWorkUnit(1, {
+      title: 'Updated Feature',
+      status: 'In Progress',
+    });
+
+    expect(mockRepo.update).toHaveBeenCalledOnce();
+    expect(result.id).toBe(1);
+    expect(result.title).toBe('Updated Feature');
+    expect(result.status).toBe('In Progress');
+    expect(result.updatedAt).toBeDefined();
+  });
+
+  it('should throw ValidationError on update with invalid ID', () => {
+    const mockRepo = {} as unknown as WorkUnitRepository;
+    const service = new WorkUnitService(mockRepo);
+
+    expect(() => service.updateWorkUnit(0, { title: 'Test' })).toThrow(ValidationError);
+    expect(() => service.updateWorkUnit(-5, { title: 'Test' })).toThrow(ValidationError);
+    expect(() => service.updateWorkUnit(3.14, { title: 'Test' })).toThrow(ValidationError);
+  });
+});

package/src/validators/work-unit.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+const WorkUnitTypeSchema = z.enum([
+  'Feature',
+  'Bug',
+  'Spike',
+  'Refactor',
+  'Improvement',
+  'Research',
+  'Decision',
+  'Blocker',
+  'Review',
+  'Idea',
+]);
+
+const WorkUnitStatusSchema = z.enum([
+  'Planned',
+  'In Progress',
+  'Blocked',
+  'Completed',
+  'Cancelled',
+]);
+
+const WorkUnitPrioritySchema = z.enum(['Low', 'Medium', 'High']);
+
+export const CreateWorkUnitSchema = z.object({
+  title: z
+    .string()
+    .trim()
+    .min(1, 'Title cannot be empty')
+    .max(200, 'Title cannot exceed 200 characters'),
+  type: WorkUnitTypeSchema,
+  status: WorkUnitStatusSchema.default('Planned'),
+  priority: WorkUnitPrioritySchema.nullable().optional().default(null),
+  module: z
+    .string()
+    .trim()
+    .max(100, 'Module cannot exceed 100 characters')
+    .nullable()
+    .optional()
+    .default(null),
+  description: z.string().trim().nullable().optional().default(null),
+  nextStep: z.string().trim().nullable().optional().default(null),
+  decision: z.string().trim().nullable().optional().default(null),
+  blocker: z.string().trim().nullable().optional().default(null),
+  tags: z
+    .array(
+      z
+        .string()
+        .trim()
+        .min(1, 'Tag cannot be empty')
+        .max(50, 'Tag cannot exceed 50 characters'),
+    )
+    .optional()
+    .default([]),
+  relatedWorkUnits: z.array(z.number().int().positive()).optional().default([]),
+  notes: z.string().trim().nullable().optional().default(null),
+});
+
+export const UpdateWorkUnitSchema = CreateWorkUnitSchema.partial();
+
+export type CreateWorkUnitInput = z.infer<typeof CreateWorkUnitSchema>;
+export type UpdateWorkUnitInput = z.infer<typeof UpdateWorkUnitSchema>;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,50 @@
+import { defineConfig } from 'tsup';
+import * as fs from 'fs';
+import * as path from 'path';
+
+function copyMigrations() {
+  const srcDir = path.resolve('src/database/migrations');
+  const destDir = path.resolve('dist/database/migrations');
+  if (fs.existsSync(srcDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+    const files = fs.readdirSync(srcDir).filter((f) => f.endsWith('.sql'));
+    for (const file of files) {
+      fs.copyFileSync(path.join(srcDir, file), path.join(destDir, file));
+    }
+  }
+}
+
+export default defineConfig([
+  {
+    entry: ['src/cli/index.ts'],
+    format: ['esm'],
+    target: 'node20',
+    sourcemap: true,
+    clean: true,
+    dts: true,
+    shims: true,
+    external: ['better-sqlite3'],
+    onSuccess: async () => {
+      copyMigrations();
+    },
+  },
+  {
+    entry: ['src/cli/index.ts'],
+    format: ['cjs'],
+    target: 'node20',
+    sourcemap: true,
+    external: ['better-sqlite3'],
+    noExternal: [
+      'commander',
+      'cli-table3',
+      'ora',
+      'picocolors',
+      'pino',
+      'prompts',
+      'zod',
+    ],
+    onSuccess: async () => {
+      copyMigrations();
+    },
+  },
+]);

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});