@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/app/admin/tasks/_config/sorting.ts

@@ -0,0 +1,38 @@
+import {
+  createSortingParser,
+  defineSorting,
+  resolveParsedSortingSchema,
+  resolveSortingSchema,
+  sortOption,
+} from "@tulip-systems/query";
+import { createDatabaseSortingCompiler } from "@tulip-systems/query/drizzle";
+import { createLocalSortingCompiler } from "@tulip-systems/query/tanstack-db";
+
+export const taskTableSorts = defineSorting({
+  code: sortOption((direction) => ({ field: "code", direction })),
+  title: sortOption((direction) => ({ field: "title", direction })),
+  status: sortOption((direction) => ({ field: "status", direction })),
+  deadline: sortOption((direction) => ({ field: "deadline", direction })),
+  updatedAt: sortOption((direction) => ({ field: "updatedAt", direction })),
+  id: sortOption((direction) => ({ field: "id", direction })),
+});
+
+/**
+ * Validators
+ */
+export const taskTableSortsSchema = resolveSortingSchema(taskTableSorts);
+export const taskParsedSortsSchema = resolveParsedSortingSchema(taskTableSorts);
+
+/**
+ * Parsers
+ */
+export const taskTableSortsParser = createSortingParser(taskTableSorts, {
+  fallback: [
+    { key: "status", direction: "asc" },
+    { key: "updatedAt", direction: "desc" },
+    { key: "id", direction: "asc" },
+  ],
+});
+
+export const taskTableLocalSortsCompiler = createLocalSortingCompiler(taskTableSorts);
+export const taskTableDatabaseSortsCompiler = createDatabaseSortingCompiler(taskTableSorts);

package/dist/templates/code/src/app/admin/tasks/_config/status.tsx

@@ -0,0 +1,84 @@
+import {
+  type CreateStatusComponentProps,
+  createStatusConfig,
+  createStatusVariants,
+  StatusBadge,
+  StatusField,
+} from "@tulip-systems/ui/status";
+import { cva } from "class-variance-authority";
+import {
+  CheckCircle2Icon,
+  CircleDashedIcon,
+  CircleDotIcon,
+  CircleIcon,
+  CirclePercentIcon,
+  CircleXIcon,
+} from "lucide-react";
+import type { TaskStatus } from "../_lib/validators";
+
+/**
+ * Project statuses
+ */
+export const taskStatusConfig = createStatusConfig<TaskStatus>([
+  {
+    value: "backlog",
+    label: "Backlog",
+    icon: CircleDashedIcon,
+    className: "stroke-foreground/50 text-foreground/50",
+  },
+  {
+    value: "todo",
+    label: "Todo",
+    icon: CircleIcon,
+    className: "stroke-foreground text-foreground",
+  },
+  {
+    value: "in_progress",
+    label: "In Progress",
+    icon: CircleDotIcon,
+    className: "stroke-yellow-500 text-yellow-500",
+  },
+  {
+    value: "in_review",
+    label: "In Review",
+    icon: CirclePercentIcon,
+    className: "stroke-green-500 text-green-500",
+  },
+  {
+    value: "done",
+    label: "Done",
+    icon: CheckCircle2Icon,
+    className: "stroke-blue-500 text-blue-500",
+  },
+  {
+    value: "canceled",
+    label: "Canceled",
+    icon: CircleXIcon,
+    className: "stroke-foreground/50 text-foreground/50",
+  },
+]);
+
+/**
+ * Project status variants
+ */
+export const taskStatusVariants = cva("", {
+  variants: { status: createStatusVariants(taskStatusConfig) },
+});
+
+/**
+ * Project status column
+ */
+export function TaskStatusField(props: CreateStatusComponentProps<TaskStatus>) {
+  return (
+    <StatusField config={taskStatusConfig} variants={taskStatusVariants} status={props.status} />
+  );
+}
+
+/**
+ * Project status badge
+ */
+export function TaskStatusBadge(props: CreateStatusComponentProps<TaskStatus>) {
+  return (
+    <StatusBadge config={taskStatusConfig} variants={taskStatusVariants} status={props.status} />
+  );
+}

package/dist/templates/code/src/app/admin/tasks/_lib/constants.ts

@@ -0,0 +1 @@
+export const storyPointsConfig = [0, 1, 2, 3, 5, 8, 13];

package/dist/templates/code/src/app/admin/tasks/_lib/helpers.ts

@@ -0,0 +1,27 @@
+import { sql } from "drizzle-orm";
+
+/**
+ * Generate task code
+ */
+export function generateTaskCode(key: string, lastNumber: number | null | undefined) {
+  const nextNumber = (lastNumber ?? 0) + 1;
+  return `${key}-${nextNumber}`;
+}
+
+/**
+ * Extract the numeric task code suffix in SQL for ordering.
+ */
+export function extractTaskCodeSQL(
+  code: ReturnType<typeof sql.raw> | { getSQL(): unknown } | unknown,
+) {
+  return sql<number>`cast(regexp_replace(${code}, '^.*-(\\d+)$', '\\1') as integer)`;
+}
+
+/**
+ * Extract previous task code
+ * @deprecated This function is deprecated use `extractTaskCodeSQL` for SQL queries instead.
+ */
+export function extractTaskCode(code: string | null | undefined) {
+  const number = code?.split("-").at(-1);
+  return number ? parseInt(number, 10) : null;
+}

package/dist/templates/code/src/app/admin/tasks/_lib/router.ts

@@ -0,0 +1,467 @@
+import "server-cli-only";
+import { ORPCError } from "@orpc/server";
+import { arrayMove } from "@tulip-systems/core";
+import { convertMarkdownToEditorContent } from "@tulip-systems/editor";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+  parseOffsetPagination,
+} from "@tulip-systems/query";
+import { and, asc, count, desc, eq, gte, inArray, sql } from "drizzle-orm";
+import z from "zod";
+import { domains } from "@/app/admin/domains/_lib/schema";
+import { initiatives } from "@/app/admin/initiatives/_lib/schema";
+import { getTableData } from "@/app/lib/utils/table-data.server";
+import { employees, projects, timeEntries, users } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import type { TaskTableData } from "../_components/tables";
+import {
+  taskDatabaseFiltersCompiler,
+  taskFiltersParser,
+  taskParsedFiltersSchema,
+} from "../_config/filters";
+import {
+  taskParsedSortsSchema,
+  taskTableDatabaseSortsCompiler,
+  taskTableSortsParser,
+  taskTableSortsSchema,
+} from "../_config/sorting";
+import { extractTaskCodeSQL, generateTaskCode } from "./helpers";
+import { tasks } from "./schema";
+import {
+  createTaskSchema,
+  importExcelTasksSchema,
+  type Task,
+  taskFiltersSchema,
+  taskStatusSchema,
+  updateTaskSchema,
+} from "./validators";
+
+export const tasksRouter = {
+  list: protectedProcedure
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: taskFiltersSchema,
+        sorts: taskTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = taskTableSortsParser.parse(input.sorts);
+      const orderBy = taskTableDatabaseSortsCompiler(tasks).parse(parsedSorts);
+
+      const parsedFilters = taskFiltersParser.parse(input.filters);
+      const where = taskDatabaseFiltersCompiler(tasks).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, tasks, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: { project: true, parent: true, domain: true, initiative: true },
+      });
+
+      return offsetPaginationResponse({
+        data: data as TaskTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  getCollection: protectedProcedure
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        parsedFilters: taskParsedFiltersSchema.nullish(),
+        parsedSorts: taskParsedSortsSchema.nullish(),
+        sorts: taskTableSortsSchema.nullish(),
+      }),
+    )
+    .handler(async ({ context, input: { parsedFilters, parsedSorts, ...input } }) => {
+      const { limit, offset } = parseOffsetPagination(input.pagination);
+      const sorting = parsedSorts ?? taskTableSortsParser.parse(input.sorts ?? []);
+      const orderBy = taskTableDatabaseSortsCompiler(tasks).parse(sorting);
+      const where = taskDatabaseFiltersCompiler(tasks).parse(parsedFilters);
+
+      const [data, pagination] = await Promise.all([
+        context.db
+          .select()
+          .from(tasks)
+          .where(where)
+          .orderBy(...orderBy)
+          .limit(limit)
+          .offset(offset),
+        context.db.select({ total: count() }).from(tasks).where(where),
+      ]);
+
+      const total = pagination[0]?.total ?? 0;
+
+      return offsetPaginationResponse({
+        data,
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  filterProjects: protectedProcedure
+    .input(z.object({ filters: taskFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) =>
+      context.db
+        .select({
+          value: projects.id,
+          label: projects.title,
+          total: count(projects.id),
+        })
+        .from(projects)
+        .leftJoin(
+          tasks,
+          and(
+            eq(projects.id, tasks.projectId),
+            and(
+              filters.assigneeId ? inArray(tasks.assigneeId, filters.assigneeId) : undefined,
+              filters.parentId ? eq(tasks.parentId, filters.parentId) : undefined,
+              filters.domainId ? inArray(tasks.domainId, filters.domainId) : undefined,
+              filters.status ? inArray(tasks.status, filters.status) : undefined,
+            ),
+          ),
+        )
+        .groupBy(projects.id)
+        .having(gte(sql<number>`count(${projects.id})`, 1))
+        .orderBy(projects.title),
+    ),
+  filterAssignees: protectedProcedure
+    .input(z.object({ filters: taskFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) =>
+      context.db
+        .select({
+          value: employees.id,
+          label: sql<string>`min(${users.name})`,
+          total: count(employees.id),
+        })
+        .from(employees)
+        .leftJoin(
+          tasks,
+          and(
+            eq(employees.id, tasks.assigneeId),
+            and(
+              filters.projectId ? inArray(tasks.projectId, filters.projectId) : undefined,
+              filters.parentId ? eq(tasks.parentId, filters.parentId) : undefined,
+              filters.initiativeId ? inArray(tasks.initiativeId, filters.initiativeId) : undefined,
+              filters.domainId ? inArray(tasks.domainId, filters.domainId) : undefined,
+              filters.status ? inArray(tasks.status, filters.status) : undefined,
+            ),
+          ),
+        )
+        .leftJoin(users, eq(employees.userId, users.id))
+        .groupBy(employees.id, users.name)
+        .having(gte(sql<number>`count(${employees.id})`, 1))
+        .orderBy(users.name),
+    ),
+  filterInitiatives: protectedProcedure
+    .input(z.object({ filters: taskFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) =>
+      context.db
+        .select({
+          value: initiatives.id,
+          label: initiatives.title,
+          total: count(tasks.id),
+        })
+        .from(initiatives)
+        .leftJoin(
+          tasks,
+          and(
+            eq(initiatives.id, tasks.initiativeId),
+            and(
+              filters.assigneeId ? inArray(tasks.assigneeId, filters.assigneeId) : undefined,
+              filters.projectId ? inArray(tasks.projectId, filters.projectId) : undefined,
+              filters.parentId ? eq(tasks.parentId, filters.parentId) : undefined,
+              filters.domainId ? inArray(tasks.domainId, filters.domainId) : undefined,
+              filters.status ? inArray(tasks.status, filters.status) : undefined,
+            ),
+          ),
+        )
+        .groupBy(initiatives.id)
+        .having(gte(sql<number>`count(${tasks.id})`, 1))
+        .orderBy(initiatives.title),
+    ),
+  filterDomains: protectedProcedure
+    .input(z.object({ filters: taskFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) =>
+      context.db
+        .select({
+          value: domains.id,
+          label: domains.title,
+          total: count(tasks.id),
+        })
+        .from(domains)
+        .leftJoin(
+          tasks,
+          and(
+            eq(domains.id, tasks.domainId),
+            and(
+              filters.assigneeId ? inArray(tasks.assigneeId, filters.assigneeId) : undefined,
+              filters.projectId ? inArray(tasks.projectId, filters.projectId) : undefined,
+              filters.parentId ? eq(tasks.parentId, filters.parentId) : undefined,
+              filters.initiativeId ? inArray(tasks.initiativeId, filters.initiativeId) : undefined,
+              filters.status ? inArray(tasks.status, filters.status) : undefined,
+            ),
+          ),
+        )
+        .groupBy(domains.id)
+        .having(gte(sql<number>`count(${tasks.id})`, 1))
+        .orderBy(domains.title),
+    ),
+  getAll: protectedProcedure
+    .input(z.object({ filters: taskFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const data = await context.db.query.tasks.findMany({
+        where: and(
+          filters.assigneeId ? inArray(tasks.assigneeId, filters.assigneeId) : undefined,
+          filters.projectId ? inArray(tasks.projectId, filters.projectId) : undefined,
+          filters.parentId ? eq(tasks.parentId, filters.parentId) : undefined,
+          filters.initiativeId ? inArray(tasks.initiativeId, filters.initiativeId) : undefined,
+          filters.domainId ? inArray(tasks.domainId, filters.domainId) : undefined,
+          filters.status ? inArray(tasks.status, filters.status) : undefined,
+        ),
+      });
+
+      return data;
+    }),
+  getById: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.tasks.findFirst({
+        where: eq(tasks.id, input.id),
+        with: { project: true },
+      });
+
+      return data ?? null;
+    }),
+  getStats: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [stats] = await context.db
+        .select({
+          storyPoints: tasks.storyPoints,
+          totalSeconds: sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`,
+        })
+        .from(tasks)
+        .leftJoin(timeEntries, eq(timeEntries.taskId, tasks.id))
+        .where(eq(tasks.id, input.id))
+        .groupBy(tasks.id, tasks.storyPoints);
+
+      const totalSeconds = Number(stats?.totalSeconds ?? 0);
+      const storyPoints = stats?.storyPoints ?? null;
+
+      return {
+        totalSeconds,
+        storyPoints,
+        hoursPerStoryPoint:
+          storyPoints && storyPoints > 0
+            ? Number((totalSeconds / 3600 / storyPoints).toFixed(1))
+            : null,
+      };
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ task: ["create"] }))
+    .input(createTaskSchema)
+    .handler(async ({ context, input }) => {
+      const [project] = await context.db
+        .select()
+        .from(projects)
+        .where(eq(projects.id, input.projectId));
+
+      if (!project) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gevonden",
+        });
+      }
+
+      if (input.parentId) {
+        const [parent] = await context.db.select().from(tasks).where(eq(tasks.id, input.parentId));
+
+        if (!parent) {
+          throw new ORPCError("NOT_FOUND", {
+            message: "Parent kon niet worden gevonden",
+          });
+        }
+
+        if (parent.projectId !== input.projectId) {
+          throw new ORPCError("NOT_FOUND", {
+            message: "De parent en child moet in hetzelfde project zitten",
+          });
+        }
+      }
+
+      const [lastTask] = await context.db
+        .select({ index: tasks.index })
+        .from(tasks)
+        .limit(1)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(desc(tasks.index));
+
+      const [lastCode] = await context.db
+        .select({ lastNumber: extractTaskCodeSQL(tasks.code) })
+        .from(tasks)
+        .limit(1)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(desc(extractTaskCodeSQL(tasks.code)));
+
+      const index = (lastTask?.index ?? 0) + 1;
+
+      const lastNumber = lastCode?.lastNumber ?? null;
+      const code = generateTaskCode(project.key, lastNumber);
+
+      const [result] = await context.db
+        .insert(tasks)
+        .values({ ...input, code, index })
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Task kon niet worden aangemaakt",
+        });
+      }
+    }),
+  importExcel: protectedProcedure
+    .use(permissionMiddleware({ task: ["create"] }))
+    .input(importExcelTasksSchema)
+    .handler(async ({ context, input }) => {
+      const [project] = await context.db
+        .select()
+        .from(projects)
+        .where(eq(projects.id, input.projectId));
+
+      if (!project) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gevonden",
+        });
+      }
+
+      const assigneeEmails = input.items
+        .map((item) => item.assignee)
+        .filter((email): email is string => Boolean(email));
+
+      const assignees = await context.db
+        .select({ id: employees.id, email: users.email })
+        .from(employees)
+        .leftJoin(users, eq(users.id, employees.userId))
+        .where(inArray(users.email, assigneeEmails));
+
+      const [lastTask] = await context.db
+        .select({ index: tasks.index })
+        .from(tasks)
+        .limit(1)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(desc(tasks.index));
+
+      const [lastCode] = await context.db
+        .select({ lastNumber: extractTaskCodeSQL(tasks.code) })
+        .from(tasks)
+        .limit(1)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(desc(extractTaskCodeSQL(tasks.code)));
+
+      const lastIndex = (lastTask?.index ?? 0) + 1;
+      const lastNumber = lastCode?.lastNumber ?? 0;
+
+      const values = input.items.map(
+        (item, index) =>
+          ({
+            projectId: input.projectId,
+            initiativeId: input.initiativeId,
+            domainId: input.domainId,
+            title: item.title,
+            storyPoints: item.storyPoints,
+            status: item.status,
+            assigneeId: item.assignee
+              ? (assignees.find((assignee) => assignee.email === item.assignee)?.id ?? null)
+              : null,
+            description: convertMarkdownToEditorContent(item.description ?? ""),
+            code: generateTaskCode(project.key, lastNumber + index),
+            index: lastIndex + index,
+          }) satisfies Partial<Task>,
+      );
+
+      const results = await context.db.insert(tasks).values(values).returning();
+
+      if (!results) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Tasks konden niet worden geïmporteerd",
+        });
+      }
+
+      return results;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ task: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateTaskSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(tasks)
+        .set(input.data)
+        .where(eq(tasks.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Task kon niet worden aangemaakt",
+        });
+      }
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ task: ["update"] }))
+    .input(bulkActionSchema.extend({ status: taskStatusSchema }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(tasks)
+        .set({ status: input.status })
+        .where(inArray(tasks.id, input.ids))
+        .returning();
+    }),
+  setAssignee: protectedProcedure
+    .use(permissionMiddleware({ task: ["update"] }))
+    .input(bulkActionSchema.extend({ assigneeId: z.string() }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(tasks)
+        .set({ assigneeId: input.assigneeId })
+        .where(inArray(tasks.id, input.ids));
+    }),
+  move: protectedProcedure
+    .use(permissionMiddleware({ task: ["update"] }))
+    .input(z.object({ fromIndex: z.number(), toIndex: z.number(), filters: taskFiltersSchema }))
+    .handler(async ({ context, input }) => {
+      /**
+       * Get all items
+       */
+      const items = await context.db
+        .select({ id: tasks.id, index: tasks.index })
+        .from(tasks)
+        .where(
+          and(
+            input.filters.projectId ? inArray(tasks.projectId, input.filters.projectId) : undefined,
+            input.filters.parentId ? eq(tasks.parentId, input.filters.parentId) : undefined,
+          ),
+        )
+        .orderBy(asc(tasks.index));
+      const newItems = arrayMove(items, { fromIndex: input.fromIndex, toIndex: input.toIndex });
+
+      /**
+       * Update the index of the items by splicing the item to the new index.
+       */
+      await context.db.transaction(async (tx) =>
+        Promise.allSettled(
+          newItems.map((item, index) =>
+            tx.update(tasks).set({ index }).where(eq(tasks.id, item.id)),
+          ),
+        ),
+      );
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ task: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db.delete(tasks).where(inArray(tasks.id, input.ids));
+    }),
+};

package/dist/templates/code/src/app/admin/tasks/_lib/schema.ts

@@ -0,0 +1,78 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { type AnyPgColumn, index, pgEnum, pgTable, uniqueIndex } from "drizzle-orm/pg-core";
+import { initiatives } from "@/app/admin/initiatives/_lib/schema";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { baseColumns } from "@/server/db/helpers";
+import { domains, employees } from "@/server/db/schema";
+
+export const taskStatusEnum = pgEnum("task_status_enum", [
+  "in_progress",
+  "todo",
+  "backlog",
+  "in_review",
+  "done",
+  "canceled",
+]);
+
+/**
+ * Task table
+ */
+export const tasks = pgTable(
+  "tasks",
+  (t) => ({
+    ...baseColumns,
+    code: t.varchar().notNull(),
+    title: t.varchar().notNull(),
+    description: t.jsonb().$type<EditorJSONContent>(),
+    status: taskStatusEnum().default("backlog").notNull(),
+    priority: t.smallint().default(3).notNull(),
+    storyPoints: t.integer(),
+    deadline: t.timestamp(),
+    completedAt: t.timestamp(),
+    index: t.doublePrecision().notNull(),
+    projectId: t
+      .uuid()
+      .notNull()
+      .references(() => projects.id, { onDelete: "cascade" }),
+    initiativeId: t
+      .uuid()
+      .notNull()
+      .references(() => initiatives.id, { onDelete: "restrict" }),
+    domainId: t.uuid().references(() => domains.id, { onDelete: "restrict" }),
+    parentId: t.uuid().references((): AnyPgColumn => tasks.id, { onDelete: "set null" }),
+    assigneeId: t.uuid().references(() => employees.id, { onDelete: "set null" }),
+    creatorId: t.uuid().references(() => employees.id, { onDelete: "set null" }),
+  }),
+  (table) => [
+    index("tasks_order_idx").on(table.projectId, table.status, table.parentId, table.index),
+    uniqueIndex("tasks_code_uniq").on(table.code),
+  ],
+);
+
+/**
+ * Relations
+ */
+export const tasksRelations = relations(tasks, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [tasks.projectId],
+    references: [projects.id],
+  }),
+  initiative: one(initiatives, {
+    fields: [tasks.initiativeId],
+    references: [initiatives.id],
+  }),
+  domain: one(domains, {
+    fields: [tasks.domainId],
+    references: [domains.id],
+  }),
+  assignee: one(employees, {
+    fields: [tasks.assigneeId],
+    references: [employees.id],
+  }),
+  parent: one(tasks, {
+    fields: [tasks.parentId],
+    references: [tasks.id],
+  }),
+  children: many(tasks),
+}));