@zinn-dev/core 0.2.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) {
@@ -52,6 +52,23 @@ export const project = {
 
     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) => {
     const project = dbProject.getByKey(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zinn-dev/core",
-  "version": "0.2.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/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;
+}