feat(coord): DB migration — project-scoped missions, multi-tenant RBAC (#149)

Co-authored-by: Jason Woltje <jason@diversecanvas.com>
Co-committed-by: Jason Woltje <jason@diversecanvas.com>

packages/brain/src/brain.ts

@@ -1,12 +1,14 @@
 import type { Db } from '@mosaic/db';
 import { createProjectsRepo, type ProjectsRepo } from './projects.js';
 import { createMissionsRepo, type MissionsRepo } from './missions.js';
+import { createMissionTasksRepo, type MissionTasksRepo } from './mission-tasks.js';
 import { createTasksRepo, type TasksRepo } from './tasks.js';
 import { createConversationsRepo, type ConversationsRepo } from './conversations.js';
 
 export interface Brain {
   projects: ProjectsRepo;
   missions: MissionsRepo;
+  missionTasks: MissionTasksRepo;
   tasks: TasksRepo;
   conversations: ConversationsRepo;
 }
@@ -15,6 +17,7 @@ export function createBrain(db: Db): Brain {
   return {
     projects: createProjectsRepo(db),
     missions: createMissionsRepo(db),
+    missionTasks: createMissionTasksRepo(db),
     tasks: createTasksRepo(db),
     conversations: createConversationsRepo(db),
   };

packages/brain/src/index.ts

@@ -11,6 +11,12 @@ export {
   type Mission,
   type NewMission,
 } from './missions.js';
+export {
+  createMissionTasksRepo,
+  type MissionTasksRepo,
+  type MissionTask,
+  type NewMissionTask,
+} from './mission-tasks.js';
 export { createTasksRepo, type TasksRepo, type Task, type NewTask } from './tasks.js';
 export {
   createConversationsRepo,

packages/brain/src/mission-tasks.ts

@@ -0,0 +1,61 @@
+import { eq, and, type Db, missionTasks } from '@mosaic/db';
+
+export type MissionTask = typeof missionTasks.$inferSelect;
+export type NewMissionTask = typeof missionTasks.$inferInsert;
+
+export function createMissionTasksRepo(db: Db) {
+  return {
+    async findByMission(missionId: string): Promise<MissionTask[]> {
+      return db.select().from(missionTasks).where(eq(missionTasks.missionId, missionId));
+    },
+
+    async findByMissionAndUser(missionId: string, userId: string): Promise<MissionTask[]> {
+      return db
+        .select()
+        .from(missionTasks)
+        .where(and(eq(missionTasks.missionId, missionId), eq(missionTasks.userId, userId)));
+    },
+
+    async findById(id: string): Promise<MissionTask | undefined> {
+      const rows = await db.select().from(missionTasks).where(eq(missionTasks.id, id));
+      return rows[0];
+    },
+
+    async findByIdAndUser(id: string, userId: string): Promise<MissionTask | undefined> {
+      const rows = await db
+        .select()
+        .from(missionTasks)
+        .where(and(eq(missionTasks.id, id), eq(missionTasks.userId, userId)));
+      return rows[0];
+    },
+
+    async create(data: NewMissionTask): Promise<MissionTask> {
+      const rows = await db.insert(missionTasks).values(data).returning();
+      return rows[0]!;
+    },
+
+    async update(id: string, data: Partial<NewMissionTask>): Promise<MissionTask | undefined> {
+      const rows = await db
+        .update(missionTasks)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(missionTasks.id, id))
+        .returning();
+      return rows[0];
+    },
+
+    async remove(id: string): Promise<boolean> {
+      const rows = await db.delete(missionTasks).where(eq(missionTasks.id, id)).returning();
+      return rows.length > 0;
+    },
+
+    async removeByMission(missionId: string): Promise<number> {
+      const rows = await db
+        .delete(missionTasks)
+        .where(eq(missionTasks.missionId, missionId))
+        .returning();
+      return rows.length;
+    },
+  };
+}
+
+export type MissionTasksRepo = ReturnType<typeof createMissionTasksRepo>;

packages/brain/src/missions.ts

@@ -1,4 +1,4 @@
-import { eq, type Db, missions } from '@mosaic/db';
+import { eq, and, type Db, missions } from '@mosaic/db';
 
 export type Mission = typeof missions.$inferSelect;
 export type NewMission = typeof missions.$inferInsert;
@@ -9,15 +9,34 @@ export function createMissionsRepo(db: Db) {
       return db.select().from(missions);
     },
 
+    async findAllByUser(userId: string): Promise<Mission[]> {
+      return db.select().from(missions).where(eq(missions.userId, userId));
+    },
+
     async findById(id: string): Promise<Mission | undefined> {
       const rows = await db.select().from(missions).where(eq(missions.id, id));
       return rows[0];
     },
 
+    async findByIdAndUser(id: string, userId: string): Promise<Mission | undefined> {
+      const rows = await db
+        .select()
+        .from(missions)
+        .where(and(eq(missions.id, id), eq(missions.userId, userId)));
+      return rows[0];
+    },
+
     async findByProject(projectId: string): Promise<Mission[]> {
       return db.select().from(missions).where(eq(missions.projectId, projectId));
     },
 
+    async findByProjectAndUser(projectId: string, userId: string): Promise<Mission[]> {
+      return db
+        .select()
+        .from(missions)
+        .where(and(eq(missions.projectId, projectId), eq(missions.userId, userId)));
+    },
+
     async create(data: NewMission): Promise<Mission> {
       const rows = await db.insert(missions).values(data).returning();
       return rows[0]!;