@zinn-dev/core 0.1.0 → 0.3.0

package/index.ts

@@ -1,4 +1,6 @@
 import type { Column } from "./src/types";
+import type { ProjectCreateInput, ProjectEditInput } from "./src/schemas/project";
+import type { TaskCreateInput, TaskEditInput } from "./src/schemas/task";
 
 import { randomUUIDv7 } from "bun";
 import { generateKeyBetween } from "fractional-indexing";
@@ -8,26 +10,24 @@ import * as dbColumn from "./src/db/column";
 import * as dbTask from "./src/db/task";
 import { standardizeProjectKey } from "./src/lib";
 import { validateTaskInput, taskCreateSchema, taskEditSchema } from "./src/schemas/task";
-import type { TaskCreateInput, TaskEditInput } from "./src/schemas/task";
 
-export { taskCreateSchema, taskEditSchema } from "./src/schemas/task";
+import {
+  validateProjectInput,
+  projectCreateSchema,
+  projectEditSchema,
+} from "./src/schemas/project";
+
+export type { ProjectCreateInput, ProjectEditInput } from "./src/schemas/project";
 export type { TaskCreateInput, TaskEditInput } from "./src/schemas/task";
 
+export { projectCreateSchema, projectEditSchema } from "./src/schemas/project";
+export { taskCreateSchema, taskEditSchema } from "./src/schemas/task";
+
 export const project = {
   getById: dbProject.getById,
   getByKey: dbProject.getByKey,
-  create: (props: { key: string; name: string }) => {
-    const validKeyRegex = /^[A-Za-z][A-Za-z0-9]*$/;
-    if (!validKeyRegex.test(props.key)) {
-      throw new Error("Project key must start with a letter and contain only letters and numbers");
-    }
-
-    const invalidNameCharRegex = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/;
-    // control characters and Unicode line separators are not valid project data.
-    if (props.name.trim().length === 0 || invalidNameCharRegex.test(props.name)) {
-      throw new Error("Project name must contain printable text on a single line");
-    }
-
+  create: (input: ProjectCreateInput) => {
+    const props = validateProjectInput(projectCreateSchema, input);
     const existingProject = dbProject.getByKey(props.key);
 
     if (existingProject != null) {
@@ -49,6 +49,25 @@ export const project = {
       })!;
       lastColumnOrder = columnOrder;
     }
+
+    return project;
+  },
+  /** Rename a project. Same name does not alter the timestamp */
+  edit: (input: ProjectEditInput) => {
+    const props = validateProjectInput(projectEditSchema, input);
+    const projectMatch = dbProject.getByKey(props.projectKey);
+
+    if (projectMatch == null) {
+      throw new Error(
+        `Project with key "${standardizeProjectKey(props.projectKey)}" does not exist!`,
+      );
+    }
+
+    if (props.name === projectMatch.name) {
+      return projectMatch;
+    }
+
+    return dbProject.update({ id: projectMatch.id, name: props.name, updated_at: Date.now() })!;
   },
   getAll: dbProject.getAll,
   delete: (key: string) => {
@@ -59,6 +78,7 @@ export const project = {
     }
 
     dbProject.deleteByKey(key);
+    return project;
   },
   standardizeKey: standardizeProjectKey,
 };
@@ -94,12 +114,13 @@ export const column = {
     }
 
     const lastColOrder = allProjectColumns[allProjectColumns.length - 1]?.column_order ?? null;
-    const res = dbColumn.create({
+
+    return dbColumn.create({
       id: randomUUIDv7(),
       name: column.name,
       column_order: generateKeyBetween(lastColOrder, null),
       project_id: project.id,
-    });
+    })!;
   },
 };
 
@@ -205,7 +226,7 @@ export const task = {
       title: props.title,
       description: props.description,
       updated_at: Date.now(),
-    });
+    })!;
   },
   /**
    * Moves a task to another column in its project.
@@ -245,7 +266,7 @@ export const task = {
       column_id: columnMatch.id,
       task_order: order,
       updated_at: Date.now(),
-    });
+    })!;
   },
   order: (props: TaskOrderProps) => {
     const { taskKey, direction } = props;
@@ -317,11 +338,13 @@ export const task = {
         futureNextTask?.task_order ?? null,
       ),
       updated_at: Date.now(),
-    });
+    })!;
   },
   delete: (taskKey: string) => {
     const taskMatch = getTaskByKey(taskKey);
-    return dbTask.deleteById(taskMatch.id);
+    dbTask.deleteById(taskMatch.id);
+
+    return taskMatch;
   },
   archive: (taskKey: string) => {
     const taskMatch = getTaskByKey(taskKey);
@@ -331,7 +354,8 @@ export const task = {
     }
 
     const now = Date.now();
-    return dbTask.update({ id: taskMatch.id, updated_at: now, archived_at: now });
+
+    return dbTask.update({ id: taskMatch.id, updated_at: now, archived_at: now })!;
   },
   unarchive: (taskKey: string) => {
     const taskMatch = getTaskByKey(taskKey);
@@ -348,6 +372,6 @@ export const task = {
       task_order: order,
       updated_at: Date.now(),
       archived_at: null,
-    });
+    })!;
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zinn-dev/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Shared logic for zinn, a kanban workflow in the terminal.",
   "repository": {
     "type": "git",

package/src/db/project.ts

@@ -71,3 +71,13 @@ export function deleteByKey(key: string) {
     .query(`DELETE FROM ${DB_TABLE.project} WHERE key = $key;`)
     .run({ $key: standardizedKey });
 }
+
+export function update(props: Pick<Project, "id" | "name" | "updated_at">) {
+  const db = getDb();
+
+  return db
+    .query<Project, Bind<typeof props>>(`UPDATE ${DB_TABLE.project}
+      SET name = $name, updated_at = $updated_at
+      WHERE id = $id RETURNING *`)
+    .get({ $id: props.id, $name: props.name, $updated_at: props.updated_at });
+}

package/src/db/task.ts

@@ -92,7 +92,7 @@ export function create(task: Omit<Task, "archived_at">) {
     ${DB_TABLE.task}  (id, project_id, column_id, number, title, description, task_order, created_at, updated_at)
     VALUES            ($id, $project_id, $column_id, $number, $title, $description, $task_order, $created_at, $updated_at);`);
 
-  return q.run({
+  q.run({
     $id: task.id,
     $project_id: task.project_id,
     $column_id: task.column_id,
@@ -103,6 +103,8 @@ export function create(task: Omit<Task, "archived_at">) {
     $created_at: task.created_at,
     $updated_at: task.updated_at,
   });
+
+  return { ...task, archived_at: null };
 }
 
 const TASK_UPDATE_COLUMNS = [

package/src/schemas/project.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test";
+import { projectCreateSchema, projectEditSchema, validateProjectInput } from "./project";
+
+test("project creation and editing share name validation and preserve supplied text", () => {
+  for (const name of ["", " ", "Two\nlines", "Bad\u0000name"]) {
+    expect(projectCreateSchema.safeParse({ key: "TEST", name }).success).toBe(false);
+    expect(projectEditSchema.safeParse({ projectKey: "TEST", name }).success).toBe(false);
+  }
+  expect(projectEditSchema.parse({ projectKey: "test", name: " Name " })).toEqual({
+    projectKey: "test", name: " Name ",
+  });
+});
+
+test("project edits require a name and reject unsupported fields", () => {
+  for (const input of [
+    { projectKey: "TEST" },
+    { projectKey: "TEST", name: undefined },
+    { projectKey: "TEST", name: null },
+    { projectKey: "TEST", name: 42 },
+    { projectKey: "TEST", name: "Name", key: "NEW" },
+  ]) {
+    expect(() => validateProjectInput(projectEditSchema, input)).toThrow();
+  }
+});

package/src/schemas/project.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+const nameMessage = "Project name must contain printable text on a single line";
+const invalidNameCharRegex = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/;
+
+export const projectNameSchema = z
+  .string({ error: nameMessage })
+  .refine((value) => value.trim().length > 0 && !invalidNameCharRegex.test(value), nameMessage);
+
+export const projectCreateSchema = z.strictObject({
+  key: z
+    .string()
+    .regex(
+      /^[A-Za-z][A-Za-z0-9]*$/,
+      "Project key must start with a letter and contain only letters and numbers",
+    ),
+  name: projectNameSchema,
+});
+
+export const projectEditSchema = z.strictObject({
+  projectKey: z.string(),
+  name: projectNameSchema,
+});
+
+export type ProjectCreateInput = z.infer<typeof projectCreateSchema>;
+export type ProjectEditInput = z.infer<typeof projectEditSchema>;
+
+export function validateProjectInput<S extends z.ZodType>(schema: S, input: unknown): z.output<S> {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    throw new Error(result.error.issues.map((issue) => issue.message).join("\n"));
+  }
+
+  return result.data;
+}