@critical-path/core 0.35.0 → 0.36.1

package/src/store/query.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  CriticalPathEngine,
-  InMemoryStore,
-  SQLiteStore,
-  FirebaseStore,
-  InMemoryFirestoreMock,
-  ValidationError,
-  createRolePolicy,
-  MAX_PAGE_SIZE,
-  type StorageAdapter,
-  type Task
-} from '../index.js';
-
-const stores: Array<[string, () => StorageAdapter]> = [
-  ['InMemoryStore', () => new InMemoryStore()],
-  ['SQLiteStore', () => new SQLiteStore({ filename: ':memory:' })],
-  ['FirebaseStore', () => new FirebaseStore({ db: new InMemoryFirestoreMock() })]
-];
-
-describe.each(stores)('task and activity queries (%s)', (_name, makeStore) => {
-  async function setup() {
-    const engine = new CriticalPathEngine({ store: makeStore() });
-    const project = await engine.createProject({ name: 'Query' });
-    const other = await engine.createProject({ name: 'Other' });
-    const sprint = await engine.createIteration({ projectId: project.id, name: 'S1', status: 'active' });
-    const parent = await engine.createTask({ projectId: project.id, title: 'Parent', status: 'in_progress', priority: 'high', assigneeId: 'ana' });
-    const child = await engine.createTask({ projectId: project.id, title: 'Child', parentId: parent.id, status: 'todo', priority: 'low', iterationId: sprint.id });
-    const shared = await engine.createTask({
-      projectId: project.id,
-      title: 'Shared',
-      status: 'done',
-      priority: 'high',
-      assignees: [{ id: 'ana', type: 'user' }, { id: 'ben', type: 'user' }]
-    });
-    const elsewhere = await engine.createTask({ projectId: other.id, title: 'Elsewhere', assigneeId: 'ana' });
-    return { engine, project, other, sprint, parent, child, shared, elsewhere };
-  }
-  const titles = (tasks: Task[]) => tasks.map((t) => t.title).sort();
-
-  it('filters by status, priority, assignee (including assignees), iteration and parent', async () => {
-    const { engine, project, sprint, parent } = await setup();
-    const q = (query: object) => engine.queryTasks({ projectId: project.id, ...query }).then((p) => titles(p.items));
-
-    expect(await q({ status: ['todo', 'done'] })).toEqual(['Child', 'Shared']);
-    expect(await q({ priority: ['high'] })).toEqual(['Parent', 'Shared']);
-    expect(await q({ assigneeId: 'ana' })).toEqual(['Parent', 'Shared']);
-    expect(await q({ assigneeId: 'ben' })).toEqual(['Shared']);
-    expect(await q({ iterationId: sprint.id })).toEqual(['Child']);
-    expect(await q({ parentId: parent.id })).toEqual(['Child']);
-    expect(await q({ parentId: null })).toEqual(['Parent', 'Shared']);
-    expect(titles((await engine.queryTasks({ assigneeId: 'ana' })).items)).toEqual(['Elsewhere', 'Parent', 'Shared']);
-  });
-
-  it('pages through every task exactly once, oldest first', async () => {
-    const { engine, project } = await setup();
-    for (let i = 0; i < 12; i++) await engine.createTask({ projectId: project.id, title: `Bulk ${i}` });
-
-    const seen: Task[] = [];
-    let cursor: string | undefined;
-    do {
-      const page = await engine.queryTasks({ projectId: project.id, limit: 5, cursor });
-      expect(page.items.length).toBeLessThanOrEqual(5);
-      seen.push(...page.items);
-      cursor = page.nextCursor;
-    } while (cursor);
-
-    expect(seen).toHaveLength(15);
-    expect(new Set(seen.map((t) => t.id)).size).toBe(15);
-    const keys = seen.map((t) => `${t.createdAt}|${t.id}`);
-    expect([...keys].sort()).toEqual(keys);
-  });
-
-  it('pages the activity feed newest first', async () => {
-    const { engine, project } = await setup();
-    const all = (await engine.queryActivities({ projectId: project.id, limit: MAX_PAGE_SIZE })).items;
-    expect(all.length).toBeGreaterThan(3);
-    const keys = all.map((a) => `${a.createdAt}|${a.id}`);
-    expect([...keys].sort().reverse()).toEqual(keys);
-
-    const first = await engine.queryActivities({ projectId: project.id, limit: 2 });
-    const second = await engine.queryActivities({ projectId: project.id, limit: 2, cursor: first.nextCursor });
-    expect([...first.items, ...second.items].map((a) => a.id)).toEqual(all.slice(0, 4).map((a) => a.id));
-  });
-
-  it('rejects malformed cursors and clamps page sizes', async () => {
-    const { engine, project } = await setup();
-    await expect(engine.queryTasks({ projectId: project.id, cursor: 'not-a-cursor' })).rejects.toThrow(ValidationError);
-    expect((await engine.queryTasks({ projectId: project.id, limit: 0 })).items).toHaveLength(1);
-    expect((await engine.queryTasks({ projectId: project.id, limit: 10_000 })).items).toHaveLength(3);
-  });
-});
-
-describe('query authorization', () => {
-  it('limits cross-project queries and activity feeds to readable projects', async () => {
-    const engine = new CriticalPathEngine({ authorize: createRolePolicy() });
-    const mine = await engine.createProject({ name: 'Mine', members: [{ userId: 'ana', role: 'viewer' }] });
-    const secret = await engine.createProject({ name: 'Secret' });
-    await engine.createTask({ projectId: mine.id, title: 'Visible' });
-    await engine.createTask({ projectId: secret.id, title: 'Hidden' });
-    const ana = engine.withActor({ userId: 'ana' });
-
-    expect((await ana.queryTasks()).items.map((t) => t.title)).toEqual(['Visible']);
-    expect((await ana.queryTasks({ projectId: secret.id })).items).toEqual([]);
-    expect((await ana.queryTasks({ projectIds: [mine.id, secret.id] })).items.map((t) => t.title)).toEqual(['Visible']);
-    const feed = (await ana.queryActivities()).items;
-    expect(feed.length).toBeGreaterThan(0);
-    expect(feed.every((a) => a.projectId === mine.id)).toBe(true);
-  });
-});

package/src/store/query.ts

@@ -1,113 +0,0 @@
-import type { Activity, Task } from '../types/index.js';
-import { ValidationError } from '../domain/errors.js';
-
-export const DEFAULT_PAGE_SIZE = 100;
-export const MAX_PAGE_SIZE = 500;
-
-/** Filters for `queryTasks`. All given filters must match. */
-export interface TaskQuery {
-  projectId?: string;
-  /** Restrict to these projects (used for authorization when no `projectId` is given). */
-  projectIds?: string[];
-  /** Any of these statuses. */
-  status?: string[];
-  /** Matches `assigneeId` or any entry in `assignees`. */
-  assigneeId?: string;
-  /** Any of these priorities. */
-  priority?: string[];
-  iterationId?: string;
-  deliverableId?: string;
-  containerId?: string;
-  /** A task id for its subtasks, or `null` for top-level tasks only. */
-  parentId?: string | null;
-  limit?: number;
-  /** Opaque cursor from a previous page's `nextCursor`. */
-  cursor?: string;
-}
-
-export interface ActivityQuery {
-  projectId?: string;
-  projectIds?: string[];
-  taskId?: string;
-  limit?: number;
-  cursor?: string;
-}
-
-/** One page of results. `nextCursor` is set when more results exist. */
-export interface Page<T> {
-  items: T[];
-  nextCursor?: string;
-}
-
-/** Clamps a requested page size to `[1, MAX_PAGE_SIZE]`, defaulting to `DEFAULT_PAGE_SIZE`. */
-export function pageSize(limit: number | undefined): number {
-  if (limit === undefined || !Number.isFinite(limit)) return DEFAULT_PAGE_SIZE;
-  return Math.min(Math.max(1, Math.floor(limit)), MAX_PAGE_SIZE);
-}
-
-/** Cursors encode the last item's sort key and id (keyset pagination). */
-export function encodeCursor(sortKey: string, id: string): string {
-  return btoa(JSON.stringify([sortKey, id])).replace(/=+$/, '');
-}
-
-export function decodeCursor(cursor: string | undefined): [string, string] | undefined {
-  if (!cursor) return undefined;
-  try {
-    const value = JSON.parse(atob(cursor));
-    if (Array.isArray(value) && value.length === 2 && value.every((v) => typeof v === 'string')) {
-      return value as [string, string];
-    }
-  } catch {
-    // fall through
-  }
-  throw new ValidationError('Invalid pagination cursor.');
-}
-
-export function matchesTaskQuery(task: Task, query: TaskQuery): boolean {
-  if (query.projectId && task.projectId !== query.projectId) return false;
-  if (query.projectIds && !query.projectIds.includes(task.projectId)) return false;
-  if (query.status?.length && !query.status.includes(task.status)) return false;
-  if (query.priority?.length && !query.priority.includes(task.priority)) return false;
-  if (query.iterationId && task.iterationId !== query.iterationId) return false;
-  if (query.deliverableId && task.deliverableId !== query.deliverableId) return false;
-  if (query.containerId && task.containerId !== query.containerId) return false;
-  if (query.parentId === null && task.parentId) return false;
-  if (query.parentId && task.parentId !== query.parentId) return false;
-  if (query.assigneeId && task.assigneeId !== query.assigneeId && !task.assignees?.some((a) => a.id === query.assigneeId)) {
-    return false;
-  }
-  return true;
-}
-
-export function matchesActivityQuery(activity: Activity, query: ActivityQuery): boolean {
-  if (query.projectId && activity.projectId !== query.projectId) return false;
-  if (query.projectIds && (!activity.projectId || !query.projectIds.includes(activity.projectId))) return false;
-  if (query.taskId && activity.taskId !== query.taskId) return false;
-  return true;
-}
-
-/**
- * Sorts by `(sortKey, id)` and returns the page after `cursor`. Tasks page oldest first
- * (`asc`), activity feeds newest first (`desc`).
- */
-export function paginate<T extends { id: string }>(
-  items: T[],
-  sortKey: (item: T) => string,
-  direction: 'asc' | 'desc',
-  limit: number | undefined,
-  cursor: string | undefined
-): Page<T> {
-  const sign = direction === 'asc' ? 1 : -1;
-  const compare = (a: [string, string], b: [string, string]) =>
-    sign * (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0);
-  const after = decodeCursor(cursor);
-  const sorted = [...items].sort((a, b) => compare([sortKey(a), a.id], [sortKey(b), b.id]));
-  const remaining = after ? sorted.filter((item) => compare([sortKey(item), item.id], after) > 0) : sorted;
-  const size = pageSize(limit);
-  const page = remaining.slice(0, size);
-  const last = page[page.length - 1];
-  return {
-    items: page,
-    nextCursor: remaining.length > size && last ? encodeCursor(sortKey(last), last.id) : undefined
-  };
-}

package/src/store/sqlite.test.ts

@@ -1,218 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { SQLiteStore } from './sqlite.js';
-
-describe('SQLiteStore', () => {
-  let store: SQLiteStore;
-
-  beforeEach(() => {
-    store = new SQLiteStore({ filename: ':memory:' });
-  });
-
-  it('should create and retrieve projects', async () => {
-    const project = await store.createProject({
-      key: 'SQLITE',
-      name: 'SQLite Test Project',
-      description: 'Testing SQLite adapter'
-    });
-
-    expect(project.id).toMatch(/^proj_/);
-    expect(project.name).toBe('SQLite Test Project');
-
-    const fetched = await store.getProject(project.id);
-    expect(fetched).not.toBeNull();
-    expect(fetched?.key).toBe('SQLITE');
-
-    const all = await store.getProjects();
-    expect(all).toHaveLength(1);
-  });
-
-  it('should create, update, filter, and delete tasks', async () => {
-    const project = await store.createProject({ key: 'P1', name: 'Proj 1' });
-    const task = await store.createTask({
-      projectId: project.id,
-      title: 'SQLite Task 1',
-      status: 'todo',
-      priority: 'high',
-      tags: ['sqlite', 'db']
-    });
-
-    expect(task.id).toMatch(/^task_/);
-    expect(task.priority).toBe('high');
-    expect(task.tags).toContain('sqlite');
-
-    const updated = await store.updateTask(task.id, {
-      status: 'in_progress',
-      isBlocked: true,
-      blockedReason: 'Waiting for SQLite lock'
-    });
-    expect(updated?.status).toBe('in_progress');
-    expect(updated?.isBlocked).toBe(true);
-    expect(updated?.blockedReason).toBe('Waiting for SQLite lock');
-
-    const fetchedTask = await store.getTask(task.id);
-    expect(fetchedTask?.isBlocked).toBe(true);
-    expect(fetchedTask?.blockedReason).toBe('Waiting for SQLite lock');
-
-    const unblocked = await store.updateTask(task.id, {
-      isBlocked: false,
-      blockedReason: null
-    });
-    expect(unblocked?.isBlocked).toBe(false);
-
-    const projectTasks = await store.getTasks(project.id);
-    expect(projectTasks).toHaveLength(1);
-
-    const deleted = await store.deleteTask(task.id);
-    expect(deleted).toBe(true);
-
-    const remaining = await store.getTasks(project.id);
-    expect(remaining).toHaveLength(0);
-  });
-
-  it('should handle comments, activities, and time tracking', async () => {
-    const comment = await store.addComment({
-      taskId: 'task_1',
-      authorId: 'user_1',
-      authorType: 'user',
-      content: 'Great work!'
-    });
-    expect(comment.id).toMatch(/^cmt_/);
-    expect(comment.authorType).toBe('user');
-
-    // Threaded reply
-    const reply = await store.addComment({
-      taskId: 'task_1',
-      authorId: 'agent_1',
-      authorType: 'agent',
-      parentId: comment.id,
-      content: 'I agree!'
-    });
-    expect(reply.parentId).toBe(comment.id);
-    expect(reply.authorType).toBe('agent');
-
-    const comments = await store.getComments('task_1');
-    expect(comments).toHaveLength(2);
-
-    const updatedComment = await store.updateComment(comment.id, {
-      content: 'Updated content',
-      mentions: ['planner', 'coordinator']
-    });
-    expect(updatedComment?.content).toBe('Updated content');
-    expect(updatedComment?.mentions).toEqual(['planner', 'coordinator']);
-
-    const fetchedComment = await store.getComment(comment.id);
-    expect(fetchedComment?.content).toBe('Updated content');
-    expect(fetchedComment?.mentions).toEqual(['planner', 'coordinator']);
-
-    const timeEntry = await store.logTime({
-      taskId: 'task_1',
-      userId: 'user_1',
-      hours: 2.5,
-      description: 'Code review'
-    });
-    expect(timeEntry.hours).toBe(2.5);
-
-    const entries = await store.getTimeEntries('task_1');
-    expect(entries).toHaveLength(1);
-
-    // Emoji reactions
-    const reactComment = await store.addReaction(comment.id, { emoji: '🔥', userId: 'user_2' });
-    expect(reactComment?.reactions).toHaveLength(1);
-    expect(reactComment?.reactions?.[0].emoji).toBe('🔥');
-
-    const fetchedWithReactions = await store.getComment(comment.id);
-    expect(fetchedWithReactions?.reactions).toHaveLength(1);
-
-    const unreactComment = await store.removeReaction(comment.id, { emoji: '🔥', userId: 'user_2' });
-    expect(unreactComment?.reactions).toHaveLength(0);
-
-    const deletedComment = await store.deleteComment(reply.id);
-    expect(deletedComment).toBe(true);
-    expect(await store.getComments('task_1')).toHaveLength(1);
-  });
-
-  it('should create, filter, retrieve, and delete attachments', async () => {
-    const attachment = await store.createAttachment({
-      filename: 'design-mockup.fig',
-      url: 'https://storage.example.com/design-mockup.fig',
-      storageKey: 'attachments/task_1/design-mockup.fig',
-      mimeType: 'application/octet-stream',
-      sizeBytes: 2048,
-      taskId: 'task_1',
-      projectId: 'proj_1',
-      uploaderId: 'user_1',
-      uploaderType: 'user'
-    });
-
-    expect(attachment.id).toMatch(/^att_/);
-    expect(attachment.filename).toBe('design-mockup.fig');
-
-    const fetched = await store.getAttachment(attachment.id);
-    expect(fetched?.url).toBe('https://storage.example.com/design-mockup.fig');
-
-    const taskAttachments = await store.getAttachments({ taskId: 'task_1' });
-    expect(taskAttachments).toHaveLength(1);
-
-    const projectAttachments = await store.getAttachments({ projectId: 'proj_1' });
-    expect(projectAttachments).toHaveLength(1);
-
-    const nonExistent = await store.getAttachments({ taskId: 'other_task' });
-    expect(nonExistent).toHaveLength(0);
-
-    const deleted = await store.deleteAttachment(attachment.id);
-    expect(deleted).toBe(true);
-
-    const remaining = await store.getAttachments({ taskId: 'task_1' });
-    expect(remaining).toHaveLength(0);
-  });
-
-  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', category: 'not_started' }],
-      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);
-  });
-});
-
-describe('SQLiteStore outside the vitest runtime', () => {
-  const distEntry = fileURLToPath(new URL('../../dist/index.js', import.meta.url));
-
-  // vitest injects `require` into ESM modules, which once hid an `eval("require(...)")` failure
-  // that broke `new SQLiteStore({ filename })` in plain Node. Run the built package in a real Node process.
-  it.skipIf(!existsSync(distEntry))('constructs from a filename in a plain Node ESM process', () => {
-    const script = `
-      const { SQLiteStore } = await import(${JSON.stringify(pathToFileURL(distEntry).href)});
-      const store = new SQLiteStore({ filename: ':memory:' });
-      const project = await store.createProject({ key: 'SMOKE', name: 'Smoke' });
-      process.stdout.write(project.key);
-    `;
-    const output = execFileSync(process.execPath, ['--input-type=module', '--no-warnings', '-e', script], {
-      encoding: 'utf8'
-    });
-    expect(output).toBe('SMOKE');
-  });
-});