@critical-path/core 0.3.0 → 0.5.0

package/src/engine/index.ts

@@ -6,11 +6,18 @@ import type {
   Team,
   TaskContainer,
   Iteration,
-  WebhookEvent
+  WebhookEvent,
+  Workflow
 } from '../types/index.js';
 import { StorageAdapter, InMemoryStore } from '../store/index.js';
 import { PluginRegistry } from '../plugins/index.js';
 import { deriveTaskLifecycleState, type TaskLifecycleState } from '../utils/status.js';
+import {
+  validateTransition,
+  getAllowedNextStatuses,
+  WorkflowValidationError,
+  DEFAULT_SOFTWARE_WORKFLOW
+} from '../utils/workflow.js';
 
 export class CriticalPathEngine {
   public readonly store: StorageAdapter;
@@ -35,6 +42,11 @@ export class CriticalPathEngine {
   }
 
   private async seedInitialData(data: NonNullable<CriticalPathConfig['initialData']>): Promise<void> {
+    if (data.workflows) {
+      for (const wf of data.workflows) {
+        await this.store.createWorkflow(wf);
+      }
+    }
     if (data.projects) {
       for (const p of data.projects) {
         await this.store.createProject(p);
@@ -62,6 +74,81 @@ export class CriticalPathEngine {
     }
   }
 
+  // --- Workflows ---
+  async getWorkflows(): Promise<Workflow[]> {
+    return this.store.getWorkflows();
+  }
+
+  async getWorkflow(id: string): Promise<Workflow | null> {
+    return this.store.getWorkflow(id);
+  }
+
+  async createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow> {
+    const created = await this.store.createWorkflow(workflow);
+    await this.store.logActivity({
+      actorId: 'system',
+      action: 'workflow.created',
+      details: { name: created.name }
+    });
+    this.dispatchWebhook('workflow.created', { workflow: created });
+    return created;
+  }
+
+  async updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null> {
+    const existing = await this.store.getWorkflow(id);
+    if (!existing) return null;
+
+    const updated = await this.store.updateWorkflow(id, updates);
+    if (updated) {
+      await this.store.logActivity({
+        actorId: 'system',
+        action: 'workflow.updated',
+        details: { name: updated.name }
+      });
+      this.dispatchWebhook('workflow.updated', { workflow: updated, previous: existing });
+    }
+    return updated;
+  }
+
+  async deleteWorkflow(id: string): Promise<boolean> {
+    const existing = await this.store.getWorkflow(id);
+    if (!existing) return false;
+
+    const deleted = await this.store.deleteWorkflow(id);
+    if (deleted) {
+      await this.store.logActivity({
+        actorId: 'system',
+        action: 'workflow.deleted',
+        details: { name: existing.name }
+      });
+      this.dispatchWebhook('workflow.deleted', { workflowId: id, name: existing.name });
+    }
+    return deleted;
+  }
+
+  async resolveProjectWorkflow(projectId: string): Promise<Workflow | null> {
+    const project = await this.store.getProject(projectId);
+    if (project?.workflow) return project.workflow;
+    if (project?.workflowId) {
+      const wf = await this.store.getWorkflow(project.workflowId);
+      if (wf) return wf;
+    }
+
+    const workflows = await this.store.getWorkflows();
+    const defaultWf = workflows.find((w) => w.isDefault);
+    if (defaultWf) return defaultWf;
+    if (workflows.length > 0) return workflows[0];
+
+    return DEFAULT_SOFTWARE_WORKFLOW;
+  }
+
+  async getAllowedTaskTransitions(taskId: string): Promise<string[]> {
+    const task = await this.store.getTask(taskId);
+    if (!task) return [];
+    const workflow = await this.resolveProjectWorkflow(task.projectId);
+    return getAllowedNextStatuses(workflow || undefined, task.status);
+  }
+
   // --- Projects ---
   async getProjects(): Promise<Project[]> {
     return this.store.getProjects();
@@ -94,13 +181,18 @@ export class CriticalPathEngine {
 
   async createTask(taskInput: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>): Promise<Task> {
     const processedInput = await this.plugins.runBeforeTaskCreate(taskInput);
+    const projectId = processedInput.projectId || taskInput.projectId;
+    const workflow = await this.resolveProjectWorkflow(projectId);
+
+    const defaultStatus = workflow?.defaultStatusKey || 'todo';
 
     const created = await this.store.createTask({
-      projectId: processedInput.projectId || taskInput.projectId,
+      projectId,
       title: processedInput.title || taskInput.title,
       description: processedInput.description ?? taskInput.description,
-      status: processedInput.status || taskInput.status || 'todo',
+      status: processedInput.status || taskInput.status || defaultStatus,
       priority: processedInput.priority || taskInput.priority || 'medium',
+      taskType: processedInput.taskType || taskInput.taskType || 'task',
       assigneeId: processedInput.assigneeId ?? taskInput.assigneeId,
       reporterId: processedInput.reporterId ?? taskInput.reporterId,
       reviewerId: processedInput.reviewerId ?? taskInput.reviewerId,
@@ -142,6 +234,14 @@ export class CriticalPathEngine {
     const existing = await this.store.getTask(id);
     if (!existing) return null;
 
+    if (updates.status && updates.status !== existing.status) {
+      const workflow = await this.resolveProjectWorkflow(existing.projectId);
+      const isValid = validateTransition(workflow || undefined, existing.status, updates.status);
+      if (!isValid) {
+        throw new WorkflowValidationError(existing.status, updates.status, workflow?.id);
+      }
+    }
+
     const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, updates);
     const updated = await this.store.updateTask(id, processedUpdates);
     if (!updated) return null;
@@ -220,7 +320,9 @@ export class CriticalPathEngine {
     const task = await this.getTask(taskId);
     if (!task) return null;
     const project = await this.getProject(task.projectId);
-    return deriveTaskLifecycleState(task, project?.statusDefinitions);
+    const workflow = await this.resolveProjectWorkflow(task.projectId);
+    const statusDefs = project?.statusDefinitions || workflow?.statuses;
+    return deriveTaskLifecycleState(task, statusDefs);
   }
 
   // --- Teams ---

package/src/index.test.ts

@@ -172,4 +172,58 @@ describe('CriticalPathEngine Core Tests', () => {
     const graphB = await engine.getTaskDependencyGraph(taskB.id);
     expect(graphB.upstreamTasks.map((t) => t.id)).toContain(taskA.id);
   });
+
+  it('manages workflows and enforces status transitions', async () => {
+    const engine = new CriticalPathEngine();
+
+    // Create a strict workflow
+    const workflow = await engine.createWorkflow({
+      name: 'Strict Software Workflow',
+      defaultStatusKey: 'backlog',
+      statuses: [
+        { key: 'backlog', label: 'Backlog', completionState: 'not_done', executionState: 'inactive' },
+        { key: 'in_progress', label: 'In Progress', completionState: 'not_done', executionState: 'active' },
+        { key: 'done', label: 'Done', completionState: 'done', executionState: 'inactive' }
+      ],
+      transitions: [
+        { id: 't1', fromStatusKey: 'backlog', toStatusKey: 'in_progress', name: 'Start Work' },
+        { id: 't2', fromStatusKey: 'in_progress', toStatusKey: 'done', name: 'Complete Work' }
+      ]
+    });
+
+    expect(workflow.id).toBeDefined();
+
+    // Create project tied to workflow
+    const proj = await engine.createProject({
+      key: 'WF',
+      name: 'Workflow Project',
+      workflowId: workflow.id
+    });
+
+    // Create task
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Workflow Task',
+      status: 'backlog',
+      priority: 'high'
+    });
+
+    expect(task.status).toBe('backlog');
+    expect(task.taskType).toBe('task');
+
+    // Check allowed transitions
+    const allowed = await engine.getAllowedTaskTransitions(task.id);
+    expect(allowed).toEqual(['in_progress']);
+
+    // Valid transition: backlog -> in_progress
+    const updated = await engine.updateTask(task.id, { status: 'in_progress' });
+    expect(updated?.status).toBe('in_progress');
+
+    // Invalid transition: in_progress -> backlog (not allowed in strict workflow)
+    await expect(engine.updateTask(task.id, { status: 'backlog' })).rejects.toThrow();
+
+    // Valid transition: in_progress -> done
+    const doneTask = await engine.updateTask(task.id, { status: 'done' });
+    expect(doneTask?.status).toBe('done');
+  });
 });

package/src/store/firebase.test.ts

@@ -56,4 +56,25 @@ describe('FirebaseStore', () => {
     const remaining = await store.getTasks(project.id);
     expect(remaining).toHaveLength(0);
   });
+
+  it('should create, update, and delete workflows in FirebaseStore', async () => {
+    const workflow = await store.createWorkflow({
+      name: 'Firebase Workflow',
+      isDefault: false,
+      defaultStatusKey: 'backlog',
+      statuses: [{ key: 'backlog', label: 'Backlog', completionState: 'not_done', executionState: 'inactive' }],
+      transitions: []
+    });
+
+    expect(workflow.id).toBeDefined();
+
+    const fetched = await store.getWorkflow(workflow.id);
+    expect(fetched?.name).toBe('Firebase Workflow');
+
+    const updated = await store.updateWorkflow(workflow.id, { isDefault: true });
+    expect(updated?.isDefault).toBe(true);
+
+    const deleted = await store.deleteWorkflow(workflow.id);
+    expect(deleted).toBe(true);
+  });
 });

package/src/store/firebase.ts

@@ -9,7 +9,8 @@ import type {
   TimeEntry,
   Activity,
   Webhook,
-  TaskDependency
+  TaskDependency,
+  Workflow
 } from '../types/index.js';
 import { generateProjectKey } from '../utils/key.js';
 
@@ -153,6 +154,46 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
+  // --- Workflows ---
+  async getWorkflows(): Promise<Workflow[]> {
+    const snap = await this.db.collection('workflows').get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getWorkflow(id: string): Promise<Workflow | null> {
+    const snap = await this.db.collection('workflows').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow> {
+    const docRef = this.db.collection('workflows').doc();
+    const now = new Date().toISOString();
+    const newWf: Workflow = { ...workflow, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newWf);
+    return newWf;
+  }
+
+  async updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null> {
+    const existing = await this.getWorkflow(id);
+    if (!existing) return null;
+
+    const updated: Workflow = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    await this.db.collection('workflows').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteWorkflow(id: string): Promise<boolean> {
+    const existing = await this.getWorkflow(id);
+    if (!existing) return false;
+    await this.db.collection('workflows').doc(id).delete();
+    return true;
+  }
+
   // --- Teams ---
   async getTeams(): Promise<Team[]> {
     const snap = await this.db.collection('teams').get();

package/src/store/index.ts

@@ -11,7 +11,8 @@ import type {
   TimeEntry,
   Activity,
   Webhook,
-  TaskDependency
+  TaskDependency,
+  Workflow
 } from '../types/index.js';
 import { generateProjectKey } from '../utils/key.js';
 
@@ -23,6 +24,13 @@ export interface StorageAdapter {
   updateProject(id: string, updates: Partial<Project>): Promise<Project | null>;
   deleteProject(id: string): Promise<boolean>;
 
+  // Workflows
+  getWorkflows(): Promise<Workflow[]>;
+  getWorkflow(id: string): Promise<Workflow | null>;
+  createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow>;
+  updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null>;
+  deleteWorkflow(id: string): Promise<boolean>;
+
   // Tasks
   getTasks(projectId?: string): Promise<Task[]>;
   getTask(id: string): Promise<Task | null>;
@@ -72,6 +80,7 @@ export interface StorageAdapter {
 
 export class InMemoryStore implements StorageAdapter {
   private projects = new Map<string, Project>();
+  private workflows = new Map<string, Workflow>();
   private tasks = new Map<string, Task>();
   private teams = new Map<string, Team>();
   private containers = new Map<string, TaskContainer>();
@@ -121,6 +130,44 @@ export class InMemoryStore implements StorageAdapter {
     return this.projects.delete(id);
   }
 
+  // Workflows
+  async getWorkflows(): Promise<Workflow[]> {
+    return Array.from(this.workflows.values());
+  }
+
+  async getWorkflow(id: string): Promise<Workflow | null> {
+    return this.workflows.get(id) || null;
+  }
+
+  async createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow> {
+    const id = `wf_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newWorkflow: Workflow = {
+      ...workflow,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.workflows.set(id, newWorkflow);
+    return newWorkflow;
+  }
+
+  async updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null> {
+    const existing = this.workflows.get(id);
+    if (!existing) return null;
+    const updated: Workflow = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    this.workflows.set(id, updated);
+    return updated;
+  }
+
+  async deleteWorkflow(id: string): Promise<boolean> {
+    return this.workflows.delete(id);
+  }
+
   async getTasks(projectId?: string): Promise<Task[]> {
     const all = Array.from(this.tasks.values());
     if (projectId) {

package/src/store/sqlite.test.ts

@@ -75,4 +75,32 @@ describe('SQLiteStore', () => {
     const entries = await store.getTimeEntries('task_1');
     expect(entries).toHaveLength(1);
   });
+
+  it('should create, retrieve, update, and delete workflows', async () => {
+    const workflow = await store.createWorkflow({
+      name: 'SQLite Workflow',
+      isDefault: true,
+      defaultStatusKey: 'todo',
+      statuses: [{ key: 'todo', label: 'To Do', completionState: 'not_done', executionState: 'inactive' }],
+      transitions: []
+    });
+
+    expect(workflow.id).toMatch(/^wf_/);
+    expect(workflow.name).toBe('SQLite Workflow');
+
+    const fetched = await store.getWorkflow(workflow.id);
+    expect(fetched?.isDefault).toBe(true);
+
+    const updated = await store.updateWorkflow(workflow.id, { name: 'Updated SQLite Workflow' });
+    expect(updated?.name).toBe('Updated SQLite Workflow');
+
+    const all = await store.getWorkflows();
+    expect(all).toHaveLength(1);
+
+    const deleted = await store.deleteWorkflow(workflow.id);
+    expect(deleted).toBe(true);
+
+    const remaining = await store.getWorkflows();
+    expect(remaining).toHaveLength(0);
+  });
 });

package/src/store/sqlite.ts

@@ -10,7 +10,8 @@ import type {
   TimeEntry,
   Activity,
   Webhook,
-  TaskDependency
+  TaskDependency,
+  Workflow
 } from '../types/index.js';
 import { generateProjectKey } from '../utils/key.js';
 
@@ -48,6 +49,8 @@ export class SQLiteStore implements StorageAdapter {
         ownerId TEXT,
         members TEXT,
         teamIds TEXT,
+        workflowId TEXT,
+        taskTypes TEXT,
         statusDefinitions TEXT,
         priorityDefinitions TEXT,
         customFieldDefinitions TEXT,
@@ -55,6 +58,19 @@ export class SQLiteStore implements StorageAdapter {
         updatedAt TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS workflows (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        statuses TEXT NOT NULL,
+        transitions TEXT NOT NULL,
+        taskTypes TEXT,
+        defaultStatusKey TEXT,
+        isDefault INTEGER,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS teams (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
@@ -84,6 +100,7 @@ export class SQLiteStore implements StorageAdapter {
         description TEXT,
         status TEXT NOT NULL,
         priority TEXT NOT NULL,
+        taskType TEXT,
         assigneeId TEXT,
         reporterId TEXT,
         reviewerId TEXT,
@@ -188,8 +205,8 @@ export class SQLiteStore implements StorageAdapter {
     const newProj: Project = { ...project, key, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, workflowId, taskTypes, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newProj.id,
@@ -199,6 +216,8 @@ export class SQLiteStore implements StorageAdapter {
       newProj.ownerId || null,
       JSON.stringify(newProj.members || []),
       JSON.stringify(newProj.teamIds || []),
+      newProj.workflowId || null,
+      newProj.taskTypes ? JSON.stringify(newProj.taskTypes) : null,
       JSON.stringify(newProj.statusDefinitions || []),
       JSON.stringify(newProj.priorityDefinitions || []),
       JSON.stringify(newProj.customFieldDefinitions || []),
@@ -220,7 +239,7 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       UPDATE projects
-      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, teamIds = ?, statusDefinitions = ?, priorityDefinitions = ?, customFieldDefinitions = ?, updatedAt = ?
+      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, teamIds = ?, workflowId = ?, taskTypes = ?, statusDefinitions = ?, priorityDefinitions = ?, customFieldDefinitions = ?, updatedAt = ?
       WHERE id = ?
     `);
     stmt.run(
@@ -230,6 +249,8 @@ export class SQLiteStore implements StorageAdapter {
       updated.ownerId || null,
       JSON.stringify(updated.members || []),
       JSON.stringify(updated.teamIds || []),
+      updated.workflowId || null,
+      updated.taskTypes ? JSON.stringify(updated.taskTypes) : null,
       JSON.stringify(updated.statusDefinitions || []),
       JSON.stringify(updated.priorityDefinitions || []),
       JSON.stringify(updated.customFieldDefinitions || []),
@@ -239,6 +260,77 @@ export class SQLiteStore implements StorageAdapter {
     return updated;
   }
 
+  // --- Workflows ---
+  async getWorkflows(): Promise<Workflow[]> {
+    const stmt = this.db.prepare('SELECT * FROM workflows');
+    const rows = stmt.all() as any[];
+    return rows.map((r) => this.mapWorkflow(r));
+  }
+
+  async getWorkflow(id: string): Promise<Workflow | null> {
+    const stmt = this.db.prepare('SELECT * FROM workflows WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row ? this.mapWorkflow(row) : null;
+  }
+
+  async createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow> {
+    const id = `wf_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newWf: Workflow = { ...workflow, id, createdAt: now, updatedAt: now };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, description, statuses, transitions, taskTypes, defaultStatusKey, isDefault, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newWf.id,
+      newWf.name,
+      newWf.description || null,
+      JSON.stringify(newWf.statuses || []),
+      JSON.stringify(newWf.transitions || []),
+      newWf.taskTypes ? JSON.stringify(newWf.taskTypes) : null,
+      newWf.defaultStatusKey || null,
+      newWf.isDefault ? 1 : 0,
+      newWf.createdAt,
+      newWf.updatedAt
+    );
+    return newWf;
+  }
+
+  async updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null> {
+    const existing = await this.getWorkflow(id);
+    if (!existing) return null;
+
+    const updated: Workflow = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+
+    const stmt = this.db.prepare(`
+      UPDATE workflows SET name = ?, description = ?, statuses = ?, transitions = ?, taskTypes = ?, defaultStatusKey = ?, isDefault = ?, updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.name,
+      updated.description || null,
+      JSON.stringify(updated.statuses || []),
+      JSON.stringify(updated.transitions || []),
+      updated.taskTypes ? JSON.stringify(updated.taskTypes) : null,
+      updated.defaultStatusKey || null,
+      updated.isDefault ? 1 : 0,
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteWorkflow(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM workflows WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   async deleteProject(id: string): Promise<boolean> {
     const stmt = this.db.prepare('DELETE FROM projects WHERE id = ?');
     const result = stmt.run(id);
@@ -394,12 +486,12 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       INSERT INTO tasks (
-        id, projectId, title, description, status, priority, assigneeId, reporterId,
+        id, projectId, title, description, status, priority, taskType, assigneeId, reporterId,
         reviewerId, iterationId, teamId, containerId, plannedStartDate, actualStartDate, actualEndDate,
         dueDate, estimatedHours, loggedHours, actualHours, billableHours,
         estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes, progress,
         tags, customFields, parentId, createdAt, updatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTask.id,
@@ -408,6 +500,7 @@ export class SQLiteStore implements StorageAdapter {
       newTask.description || null,
       newTask.status,
       newTask.priority,
+      newTask.taskType || null,
       newTask.assigneeId || null,
       newTask.reporterId || null,
       newTask.reviewerId || null,
@@ -447,7 +540,7 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       UPDATE tasks SET
-        projectId = ?, title = ?, description = ?, status = ?, priority = ?,
+        projectId = ?, title = ?, description = ?, status = ?, priority = ?, taskType = ?,
         assigneeId = ?, reporterId = ?, reviewerId = ?, iterationId = ?, teamId = ?, containerId = ?,
         plannedStartDate = ?, actualStartDate = ?, actualEndDate = ?, dueDate = ?,
         estimatedHours = ?, loggedHours = ?, actualHours = ?, billableHours = ?,
@@ -461,6 +554,7 @@ export class SQLiteStore implements StorageAdapter {
       updated.description || null,
       updated.status,
       updated.priority,
+      updated.taskType || null,
       updated.assigneeId || null,
       updated.reporterId || null,
       updated.reviewerId || null,
@@ -706,6 +800,8 @@ export class SQLiteStore implements StorageAdapter {
   private mapProject(row: any): Project {
     return {
       ...row,
+      workflowId: row.workflowId || undefined,
+      taskTypes: row.taskTypes ? JSON.parse(row.taskTypes) : undefined,
       members: row.members ? JSON.parse(row.members) : [],
       teamIds: row.teamIds ? JSON.parse(row.teamIds) : [],
       statusDefinitions: row.statusDefinitions ? JSON.parse(row.statusDefinitions) : [],
@@ -714,6 +810,16 @@ export class SQLiteStore implements StorageAdapter {
     };
   }
 
+  private mapWorkflow(row: any): Workflow {
+    return {
+      ...row,
+      statuses: row.statuses ? JSON.parse(row.statuses) : [],
+      transitions: row.transitions ? JSON.parse(row.transitions) : [],
+      taskTypes: row.taskTypes ? JSON.parse(row.taskTypes) : undefined,
+      isDefault: row.isDefault !== null && row.isDefault !== undefined ? Boolean(row.isDefault) : undefined
+    };
+  }
+
   private mapTeam(row: any): Team {
     return {
       ...row,
@@ -724,6 +830,7 @@ export class SQLiteStore implements StorageAdapter {
   private mapTask(row: any): Task {
     return {
       ...row,
+      taskType: row.taskType || undefined,
       tags: row.tags ? JSON.parse(row.tags) : [],
       customFields: row.customFields ? JSON.parse(row.customFields) : {}
     };