@critical-path/core 0.2.0 → 0.3.0

package/src/store/firebase.ts

@@ -2,13 +2,16 @@ import type { StorageAdapter } from './index.js';
 import type {
   Project,
   Task,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
   Webhook,
   TaskDependency
 } from '../types/index.js';
+import { generateProjectKey } from '../utils/key.js';
 
 export interface FirestoreDBInterface {
   collection(name: string): {
@@ -92,16 +95,21 @@ export class InMemoryFirestoreMock implements FirestoreDBInterface {
 
 export interface FirebaseStoreConfig {
   /**
-   * Firestore instance or mockable DB interface.
+   * Firestore instance or mockable DB interface. Required.
    */
-  db?: FirestoreDBInterface;
+  db: FirestoreDBInterface;
 }
 
 export class FirebaseStore implements StorageAdapter {
   private db: FirestoreDBInterface;
 
-  constructor(config: FirebaseStoreConfig = {}) {
-    this.db = config.db || new InMemoryFirestoreMock();
+  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 ---
@@ -119,7 +127,8 @@ export class FirebaseStore implements StorageAdapter {
   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 };
+    const key = project.key || generateProjectKey(project.name);
+    const newProj: Project = { ...project, key, id: docRef.id, createdAt: now, updatedAt: now };
     await docRef.set(newProj);
     return newProj;
   }
@@ -144,6 +153,78 @@ export class FirebaseStore implements StorageAdapter {
     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;
@@ -189,29 +270,42 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
-  // --- Sprints ---
-  async getSprints(projectId: string): Promise<Sprint[]> {
-    const snap = await this.db.collection('sprints').where('projectId', '==', projectId).get();
+  // --- 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 createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const docRef = this.db.collection('sprints').doc();
+  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 newSprint: Sprint = { ...sprint, id: docRef.id, createdAt: now };
-    await docRef.set(newSprint);
-    return newSprint;
+    const newIteration: Iteration = { ...iteration, id: docRef.id, createdAt: now };
+    await docRef.set(newIteration);
+    return newIteration;
   }
 
-  async updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null> {
-    const snap = await this.db.collection('sprints').doc(id).get();
+  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: Sprint = { ...snap.data(), id, ...updates };
-    await this.db.collection('sprints').doc(id).set(updated, { merge: true });
+    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();

package/src/store/index.ts

@@ -4,13 +4,16 @@ export * from './firebase.js';
 import type {
   Project,
   Task,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
   Webhook,
   TaskDependency
 } from '../types/index.js';
+import { generateProjectKey } from '../utils/key.js';
 
 export interface StorageAdapter {
   // Projects
@@ -27,10 +30,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[]>;
@@ -54,7 +73,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>();
@@ -72,8 +93,10 @@ export class InMemoryStore implements StorageAdapter {
   async createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project> {
     const id = `proj_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
+    const key = project.key || generateProjectKey(project.name);
     const newProject: Project = {
       ...project,
+      key,
       id,
       createdAt: now,
       updatedAt: now
@@ -139,29 +162,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 createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const id = `sprint_${Math.random().toString(36).substring(2, 9)}`;
-    const newSprint: Sprint = {
-      ...sprint,
+  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 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);
   }
@@ -174,6 +265,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;
@@ -189,6 +281,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);
   }
@@ -200,6 +293,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
@@ -213,6 +307,7 @@ export class InMemoryStore implements StorageAdapter {
     return newDep;
   }
 
+  // Webhooks
   async getWebhooks(): Promise<Webhook[]> {
     return Array.from(this.webhooks.values());
   }