@zinn-dev/core 0.6.0 → 0.7.0

package/index.ts

@@ -1,4 +1,4 @@
-import type { Column } from "./src/types";
+import type { Column, Task, TaskRelation } from "./src/types";
 import type { ProjectCreateInput, ProjectEditInput } from "./src/schemas/project";
 import type { TaskCreateInput, TaskEditInput } from "./src/schemas/task";
 import type { RelationCreateInput } from "./src/schemas/relation";
@@ -382,6 +382,41 @@ export const task = {
   },
 };
 
+type TaskWithKey = Task & { key: string };
+
+// TODO: would be better to reuse where task keys attached manually
+function attachTaskKey(task: Task): TaskWithKey {
+  const project = dbProject.getById(task.project_id)!;
+  return { ...task, key: `${project.key}-${task.number}` };
+}
+
+type RelationResult = TaskRelation & {
+  source?: TaskWithKey;
+  target?: TaskWithKey;
+};
+
+type RelationGetOptions = {
+  include?: { tasks?: boolean };
+};
+
+function getRelations(taskKey: string, options?: RelationGetOptions): Array<RelationResult> {
+  if (taskKey == null) {
+    throw new Error("A task key is required to list relations");
+  }
+
+  const taskMatch = getTaskByKey(taskKey);
+  const relations = dbRelation.getAllByTaskId(taskMatch.id);
+  if (!options?.include?.tasks) {
+    return relations;
+  }
+
+  return relations.map((entry) => ({
+    ...entry,
+    source: attachTaskKey(dbTask.getById(entry.source_task_id)!),
+    target: attachTaskKey(dbTask.getById(entry.target_task_id)!),
+  }));
+}
+
 export const relation = {
   create: (input: RelationCreateInput) => {
     const props = validateTaskInput(relationCreateSchema, input);
@@ -423,12 +458,5 @@ export const relation = {
       relation_type: props.relation_type,
     });
   },
-  getAll: (taskKey: string) => {
-    if (taskKey == null) {
-      throw new Error("Provide a task key to list relations");
-    }
-    const taskMatch = getTaskByKey(taskKey);
-
-    return dbRelation.getAllByTaskId(taskMatch.id);
-  },
+  getAll: getRelations,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zinn-dev/core",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Shared logic for zinn, a kanban workflow in the terminal.",
   "license": "MIT",
   "bugs": {

package/src/db/relation.test.ts

@@ -101,3 +101,29 @@ test("relations clean up without deleting connected tasks", () => {
       assert.deepEqual(getDb().query("PRAGMA foreign_key_check").all(), []);
   `);
 });
+
+test("duplicate direction and optional task enrichment preserve raw lookup", () => {
+  runRelationCheck(`
+    const app = project.create({ key: "APP" });
+    const other = project.create({ key: "OTHER" });
+    task.create({ project_id: app.id, title: "Copy", description: null });
+    task.create({ project_id: other.id, title: "Original", description: null });
+    const before = task.getByKey("OTHER-1");
+    const created = relation.create({ sourceTaskKey: "APP-1", targetTaskKey: "OTHER-1", relation_type: "duplicate" });
+    assert.equal(created.source_task_id, task.getByKey("APP-1").id);
+    assert.equal(created.target_task_id, before.id);
+    assert.deepEqual(task.getByKey("OTHER-1"), before);
+    assert.throws(() => relation.create({ sourceTaskKey: "APP-1", targetTaskKey: "OTHER-1", relation_type: "duplicate" }), /already exists/);
+    const raw = relation.getAll("APP-1");
+    assert.equal("source" in raw[0], false);
+    assert.deepEqual(relation.getAll("APP-1", { include: { tasks: false } }), raw);
+    task.archive("OTHER-1");
+    const [expanded] = relation.getAll("APP-1", { include: { tasks: true } });
+    assert.equal(expanded.source.key, "APP-1");
+    assert.equal(expanded.target.key, "OTHER-1");
+    assert.equal(expanded.target.title, "Original");
+    assert.ok(expanded.target.archived_at);
+    relation.create({ sourceTaskKey: "OTHER-1", targetTaskKey: "APP-1", relation_type: "duplicate" });
+    assert.equal(relation.getAll("APP-1").length, 2);
+  `);
+});

package/src/db/task.ts

@@ -16,6 +16,10 @@ function getArchiveCondition(filter: TaskArchiveFilter) {
   }
 }
 
+export function getById(taskId: string) {
+  return getDb().query<Task, [string]>(`SELECT * FROM ${DB_TABLE.task} WHERE id = ?`).get(taskId);
+}
+
 // TODO: refined parameters, preferably of type SQLBindings
 export function getAll(archive: TaskArchiveFilter = "active") {
   const db = getDb();

package/src/schemas/relation.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 
 export const relationCreateSchema = z.strictObject({
   // For dependency, the source task depends on the target task.
+  // For duplicate, the source task is a duplicate of the target task.
   sourceTaskKey: z.string(),
   targetTaskKey: z.string(),
   relation_type: z.enum(["related", "dependency", "duplicate"]),