@critical-path/core 0.1.2 → 0.2.1

package/src/store/firebase.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { FirebaseStore, InMemoryFirestoreMock } from './firebase.js';
+
+describe('FirebaseStore', () => {
+  let store: FirebaseStore;
+
+  beforeEach(() => {
+    store = new FirebaseStore({ db: new InMemoryFirestoreMock() });
+  });
+
+  it('should throw an error if db is missing in config', () => {
+    expect(() => new FirebaseStore({} as any)).toThrow(
+      'FirebaseStore requires a valid Firestore db instance'
+    );
+  });
+
+  it('should create and retrieve projects in FirebaseStore', async () => {
+    const project = await store.createProject({
+      key: 'FIRE',
+      name: 'Firebase Test Project',
+      description: 'Testing Firebase Firestore adapter'
+    });
+
+    expect(project.id).toBeDefined();
+    expect(project.name).toBe('Firebase Test Project');
+
+    const fetched = await store.getProject(project.id);
+    expect(fetched).not.toBeNull();
+    expect(fetched?.key).toBe('FIRE');
+
+    const all = await store.getProjects();
+    expect(all).toHaveLength(1);
+  });
+
+  it('should create, update, and delete tasks in FirebaseStore', async () => {
+    const project = await store.createProject({ key: 'P1', name: 'Proj 1' });
+    const task = await store.createTask({
+      projectId: project.id,
+      title: 'Firebase Task 1',
+      status: 'todo',
+      priority: 'urgent'
+    });
+
+    expect(task.id).toBeDefined();
+    expect(task.priority).toBe('urgent');
+
+    const updated = await store.updateTask(task.id, { status: 'done' });
+    expect(updated?.status).toBe('done');
+
+    const tasks = await store.getTasks(project.id);
+    expect(tasks).toHaveLength(1);
+
+    const deleted = await store.deleteTask(task.id);
+    expect(deleted).toBe(true);
+
+    const remaining = await store.getTasks(project.id);
+    expect(remaining).toHaveLength(0);
+  });
+});

package/src/store/firebase.ts

@@ -0,0 +1,381 @@
+import type { StorageAdapter } from './index.js';
+import type {
+  Project,
+  Task,
+  Iteration,
+  Team,
+  TaskContainer,
+  Comment,
+  TimeEntry,
+  Activity,
+  Webhook,
+  TaskDependency
+} from '../types/index.js';
+
+export interface FirestoreDBInterface {
+  collection(name: string): {
+    doc(id?: string): {
+      id: string;
+      get(): Promise<{ exists: boolean; id: string; data(): any }>;
+      set(data: any, options?: { merge?: boolean }): Promise<void>;
+      delete(): Promise<void>;
+    };
+    get(): Promise<{ docs: Array<{ id: string; data(): any }> }>;
+    where(field: string, op: string, value: any): {
+      get(): Promise<{ docs: Array<{ id: string; data(): any }> }>;
+    };
+  };
+}
+
+export class InMemoryFirestoreMock implements FirestoreDBInterface {
+  private collections = new Map<string, Map<string, any>>();
+
+  private getCollectionMap(name: string) {
+    if (!this.collections.has(name)) {
+      this.collections.set(name, new Map());
+    }
+    return this.collections.get(name)!;
+  }
+
+  collection(name: string) {
+    const colMap = this.getCollectionMap(name);
+
+    return {
+      doc(id?: string) {
+        const docId = id || `doc_${Math.random().toString(36).substring(2, 9)}`;
+        return {
+          id: docId,
+          async get() {
+            const data = colMap.get(docId);
+            return {
+              exists: !!data,
+              id: docId,
+              data: () => data
+            };
+          },
+          async set(data: any, options?: { merge?: boolean }) {
+            if (options?.merge && colMap.has(docId)) {
+              colMap.set(docId, { ...colMap.get(docId), ...data });
+            } else {
+              colMap.set(docId, data);
+            }
+          },
+          async delete() {
+            colMap.delete(docId);
+          }
+        };
+      },
+      async get() {
+        const docs = Array.from(colMap.entries()).map(([id, data]) => ({
+          id,
+          data: () => data
+        }));
+        return { docs };
+      },
+      where(field: string, op: string, value: any) {
+        return {
+          async get() {
+            const docs = Array.from(colMap.entries())
+              .filter(([_, data]) => {
+                if (op === '==') return data[field] === value;
+                return true;
+              })
+              .map(([id, data]) => ({
+                id,
+                data: () => data
+              }));
+            return { docs };
+          }
+        };
+      }
+    };
+  }
+}
+
+export interface FirebaseStoreConfig {
+  /**
+   * Firestore instance or mockable DB interface. Required.
+   */
+  db: FirestoreDBInterface;
+}
+
+export class FirebaseStore implements StorageAdapter {
+  private db: FirestoreDBInterface;
+
+  constructor(config: FirebaseStoreConfig) {
+    if (!config?.db) {
+      throw new Error(
+        'FirebaseStore requires a valid Firestore db instance (e.g. FirebaseStoreConfig.db). Automatic fallback to InMemoryFirestoreMock has been removed.'
+      );
+    }
+    this.db = config.db;
+  }
+
+  // --- Projects ---
+  async getProjects(): Promise<Project[]> {
+    const snap = await this.db.collection('projects').get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getProject(id: string): Promise<Project | null> {
+    const snap = await this.db.collection('projects').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project> {
+    const docRef = this.db.collection('projects').doc();
+    const now = new Date().toISOString();
+    const newProj: Project = { ...project, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newProj);
+    return newProj;
+  }
+
+  async updateProject(id: string, updates: Partial<Project>): Promise<Project | null> {
+    const existing = await this.getProject(id);
+    if (!existing) return null;
+
+    const updated: Project = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    await this.db.collection('projects').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteProject(id: string): Promise<boolean> {
+    const existing = await this.getProject(id);
+    if (!existing) return false;
+    await this.db.collection('projects').doc(id).delete();
+    return true;
+  }
+
+  // --- Teams ---
+  async getTeams(): Promise<Team[]> {
+    const snap = await this.db.collection('teams').get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getTeam(id: string): Promise<Team | null> {
+    const snap = await this.db.collection('teams').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const docRef = this.db.collection('teams').doc();
+    const now = new Date().toISOString();
+    const newTeam: Team = { ...team, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newTeam);
+    return newTeam;
+  }
+
+  async updateTeam(id: string, updates: Partial<Team>): Promise<Team | null> {
+    const existing = await this.getTeam(id);
+    if (!existing) return null;
+
+    const updated: Team = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    await this.db.collection('teams').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    const existing = await this.getTeam(id);
+    if (!existing) return false;
+    await this.db.collection('teams').doc(id).delete();
+    return true;
+  }
+
+  // --- Containers ---
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    const snap = await this.db.collection('containers').where('projectId', '==', projectId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    const snap = await this.db.collection('containers').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const docRef = this.db.collection('containers').doc();
+    const now = new Date().toISOString();
+    const newContainer: TaskContainer = { ...container, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newContainer);
+    return newContainer;
+  }
+
+  async updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null> {
+    const existing = await this.getContainer(id);
+    if (!existing) return null;
+
+    const updated: TaskContainer = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    await this.db.collection('containers').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    const existing = await this.getContainer(id);
+    if (!existing) return false;
+    await this.db.collection('containers').doc(id).delete();
+    return true;
+  }
+
+  // --- Tasks ---
+  async getTasks(projectId?: string): Promise<Task[]> {
+    let snap;
+    if (projectId) {
+      snap = await this.db.collection('tasks').where('projectId', '==', projectId).get();
+    } else {
+      snap = await this.db.collection('tasks').get();
+    }
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getTask(id: string): Promise<Task | null> {
+    const snap = await this.db.collection('tasks').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createTask(task: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>): Promise<Task> {
+    const docRef = this.db.collection('tasks').doc();
+    const now = new Date().toISOString();
+    const newTask: Task = { ...task, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newTask);
+    return newTask;
+  }
+
+  async updateTask(id: string, updates: Partial<Task>): Promise<Task | null> {
+    const existing = await this.getTask(id);
+    if (!existing) return null;
+
+    const updated: Task = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    await this.db.collection('tasks').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteTask(id: string): Promise<boolean> {
+    const existing = await this.getTask(id);
+    if (!existing) return false;
+    await this.db.collection('tasks').doc(id).delete();
+    return true;
+  }
+
+  // --- Iterations ---
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    const snap = await this.db.collection('iterations').where('projectId', '==', projectId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getIteration(id: string): Promise<Iteration | null> {
+    const snap = await this.db.collection('iterations').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const docRef = this.db.collection('iterations').doc();
+    const now = new Date().toISOString();
+    const newIteration: Iteration = { ...iteration, id: docRef.id, createdAt: now };
+    await docRef.set(newIteration);
+    return newIteration;
+  }
+
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const snap = await this.db.collection('iterations').doc(id).get();
+    if (!snap.exists) return null;
+
+    const updated: Iteration = { ...snap.data(), id, ...updates };
+    await this.db.collection('iterations').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteIteration(id: string): Promise<boolean> {
+    const existing = await this.getIteration(id);
+    if (!existing) return false;
+    await this.db.collection('iterations').doc(id).delete();
+    return true;
+  }
+
+  // --- Comments & Activity ---
+  async getComments(taskId: string): Promise<Comment[]> {
+    const snap = await this.db.collection('comments').where('taskId', '==', taskId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment> {
+    const docRef = this.db.collection('comments').doc();
+    const now = new Date().toISOString();
+    const newComment: Comment = { ...comment, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newComment);
+    return newComment;
+  }
+
+  async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
+    let snap;
+    if (filter?.taskId) {
+      snap = await this.db.collection('activities').where('taskId', '==', filter.taskId).get();
+    } else if (filter?.projectId) {
+      snap = await this.db.collection('activities').where('projectId', '==', filter.projectId).get();
+    } else {
+      snap = await this.db.collection('activities').get();
+    }
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async logActivity(activity: Omit<Activity, 'id' | 'createdAt'>): Promise<Activity> {
+    const docRef = this.db.collection('activities').doc();
+    const now = new Date().toISOString();
+    const newAct: Activity = { ...activity, id: docRef.id, createdAt: now };
+    await docRef.set(newAct);
+    return newAct;
+  }
+
+  // --- Time Tracking ---
+  async getTimeEntries(taskId: string): Promise<TimeEntry[]> {
+    const snap = await this.db.collection('time_entries').where('taskId', '==', taskId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async logTime(entry: Omit<TimeEntry, 'id' | 'loggedAt'>): Promise<TimeEntry> {
+    const docRef = this.db.collection('time_entries').doc();
+    const now = new Date().toISOString();
+    const newEntry: TimeEntry = { ...entry, id: docRef.id, loggedAt: now };
+    await docRef.set(newEntry);
+    return newEntry;
+  }
+
+  // --- Dependencies ---
+  async getDependencies(taskId: string): Promise<TaskDependency[]> {
+    const snap = await this.db.collection('dependencies').where('taskId', '==', taskId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async addDependency(dep: Omit<TaskDependency, 'id'>): Promise<TaskDependency> {
+    const docRef = this.db.collection('dependencies').doc();
+    const newDep: TaskDependency = { ...dep, id: docRef.id };
+    await docRef.set(newDep);
+    return newDep;
+  }
+
+  // --- Webhooks ---
+  async getWebhooks(): Promise<Webhook[]> {
+    const snap = await this.db.collection('webhooks').get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook> {
+    const docRef = this.db.collection('webhooks').doc();
+    const now = new Date().toISOString();
+    const newWh: Webhook = { ...webhook, id: docRef.id, createdAt: now };
+    await docRef.set(newWh);
+    return newWh;
+  }
+}

package/src/store/index.ts

@@ -1,8 +1,12 @@
+export * from './sqlite.js';
+export * from './firebase.js';
+
 import type {
   Project,
   Task,
-  User,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
@@ -25,10 +29,26 @@ export interface StorageAdapter {
   updateTask(id: string, updates: Partial<Task>): Promise<Task | null>;
   deleteTask(id: string): Promise<boolean>;
 
-  // Sprints
-  getSprints(projectId: string): Promise<Sprint[]>;
-  createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint>;
-  updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null>;
+  // Teams
+  getTeams(): Promise<Team[]>;
+  getTeam(id: string): Promise<Team | null>;
+  createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team>;
+  updateTeam(id: string, updates: Partial<Team>): Promise<Team | null>;
+  deleteTeam(id: string): Promise<boolean>;
+
+  // Task Containers
+  getContainers(projectId: string): Promise<TaskContainer[]>;
+  getContainer(id: string): Promise<TaskContainer | null>;
+  createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer>;
+  updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null>;
+  deleteContainer(id: string): Promise<boolean>;
+
+  // Iterations
+  getIterations(projectId: string): Promise<Iteration[]>;
+  getIteration(id: string): Promise<Iteration | null>;
+  createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration>;
+  updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null>;
+  deleteIteration(id: string): Promise<boolean>;
 
   // Comments & Activity
   getComments(taskId: string): Promise<Comment[]>;
@@ -52,7 +72,9 @@ export interface StorageAdapter {
 export class InMemoryStore implements StorageAdapter {
   private projects = new Map<string, Project>();
   private tasks = new Map<string, Task>();
-  private sprints = new Map<string, Sprint>();
+  private teams = new Map<string, Team>();
+  private containers = new Map<string, TaskContainer>();
+  private iterations = new Map<string, Iteration>();
   private comments = new Map<string, Comment>();
   private activities: Activity[] = [];
   private timeEntries = new Map<string, TimeEntry>();
@@ -137,29 +159,97 @@ export class InMemoryStore implements StorageAdapter {
     return this.tasks.delete(id);
   }
 
-  async getSprints(projectId: string): Promise<Sprint[]> {
-    return Array.from(this.sprints.values()).filter((s) => s.projectId === projectId);
+  // Teams
+  async getTeams(): Promise<Team[]> {
+    return Array.from(this.teams.values());
+  }
+
+  async getTeam(id: string): Promise<Team | null> {
+    return this.teams.get(id) || null;
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const id = `team_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newTeam: Team = { ...team, id, createdAt: now, updatedAt: now };
+    this.teams.set(id, newTeam);
+    return newTeam;
+  }
+
+  async updateTeam(id: string, updates: Partial<Team>): Promise<Team | null> {
+    const existing = this.teams.get(id);
+    if (!existing) return null;
+    const updated: Team = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    this.teams.set(id, updated);
+    return updated;
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    return this.teams.delete(id);
+  }
+
+  // Containers
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    return Array.from(this.containers.values()).filter((c) => c.projectId === projectId);
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    return this.containers.get(id) || null;
   }
 
-  async createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const id = `sprint_${Math.random().toString(36).substring(2, 9)}`;
-    const newSprint: Sprint = {
-      ...sprint,
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const id = `cnt_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newContainer: TaskContainer = { ...container, id, createdAt: now, updatedAt: now };
+    this.containers.set(id, newContainer);
+    return newContainer;
+  }
+
+  async updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null> {
+    const existing = this.containers.get(id);
+    if (!existing) return null;
+    const updated: TaskContainer = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    this.containers.set(id, updated);
+    return updated;
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    return this.containers.delete(id);
+  }
+
+  // Iterations
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    return Array.from(this.iterations.values()).filter((s) => s.projectId === projectId);
+  }
+
+  async getIteration(id: string): Promise<Iteration | null> {
+    return this.iterations.get(id) || null;
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const id = `iter_${Math.random().toString(36).substring(2, 9)}`;
+    const newIteration: Iteration = {
+      ...iteration,
       id,
       createdAt: new Date().toISOString()
     };
-    this.sprints.set(id, newSprint);
-    return newSprint;
+    this.iterations.set(id, newIteration);
+    return newIteration;
   }
 
-  async updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null> {
-    const existing = this.sprints.get(id);
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const existing = this.iterations.get(id);
     if (!existing) return null;
-    const updated: Sprint = { ...existing, ...updates };
-    this.sprints.set(id, updated);
+    const updated: Iteration = { ...existing, ...updates };
+    this.iterations.set(id, updated);
     return updated;
   }
 
+  async deleteIteration(id: string): Promise<boolean> {
+    return this.iterations.delete(id);
+  }
+
+  // Comments
   async getComments(taskId: string): Promise<Comment[]> {
     return Array.from(this.comments.values()).filter((c) => c.taskId === taskId);
   }
@@ -172,6 +262,7 @@ export class InMemoryStore implements StorageAdapter {
     return newComment;
   }
 
+  // Activities
   async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
     return this.activities.filter((a) => {
       if (filter?.projectId && a.projectId !== filter.projectId) return false;
@@ -187,6 +278,7 @@ export class InMemoryStore implements StorageAdapter {
     return newAct;
   }
 
+  // Time Entries
   async getTimeEntries(taskId: string): Promise<TimeEntry[]> {
     return Array.from(this.timeEntries.values()).filter((e) => e.taskId === taskId);
   }
@@ -198,6 +290,7 @@ export class InMemoryStore implements StorageAdapter {
     return newEntry;
   }
 
+  // Dependencies
   async getDependencies(taskId: string): Promise<TaskDependency[]> {
     return Array.from(this.dependencies.values()).filter(
       (d) => d.taskId === taskId || d.dependsOnTaskId === taskId
@@ -211,6 +304,7 @@ export class InMemoryStore implements StorageAdapter {
     return newDep;
   }
 
+  // Webhooks
   async getWebhooks(): Promise<Webhook[]> {
     return Array.from(this.webhooks.values());
   }