@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/employees/_config/roles.tsx

@@ -0,0 +1,86 @@
+import {
+  type CreateStatusComponentProps,
+  createStatusConfig,
+  createStatusVariants,
+  StatusBadge,
+  StatusField,
+} from "@tulip-systems/ui/status";
+import { cva } from "class-variance-authority";
+import { UserCog2Icon, UserStarIcon } from "lucide-react";
+import { Icons } from "@/components/icons";
+import type { Role } from "@/server/auth/permissions";
+
+/**
+ * Employee roles
+ */
+export const employeeRolesConfig = createStatusConfig<Role>([
+  {
+    value: "developer",
+    label: "Ontwikkelaar",
+    icon: UserCog2Icon,
+    className: "",
+  },
+  {
+    value: "admin",
+    label: "Beheerder",
+    icon: UserStarIcon,
+    className: "",
+  },
+  {
+    value: "projectLeader",
+    label: "Projectleider",
+    icon: Icons.user,
+    className: "",
+  },
+  {
+    value: "teamleader",
+    label: "Teamleider",
+    icon: Icons.user,
+    className: "",
+  },
+  {
+    value: "worker",
+    label: "Werknemer",
+    icon: Icons.user,
+    className: "",
+  },
+  {
+    value: "external",
+    label: "Extern",
+    icon: Icons.user,
+    className: "",
+  },
+]);
+
+/**
+ * User status variants
+ */
+export const employeeRolesVariants = cva("", {
+  variants: { status: createStatusVariants(employeeRolesConfig) },
+});
+
+/**
+ * User status column
+ */
+export function EmployeeRoleField(props: CreateStatusComponentProps<Role>) {
+  return (
+    <StatusField
+      config={employeeRolesConfig}
+      variants={employeeRolesVariants}
+      status={props.status}
+    />
+  );
+}
+
+/**
+ * User status badge
+ */
+export function EmployeeRoleBadge(props: CreateStatusComponentProps<Role>) {
+  return (
+    <StatusBadge
+      config={employeeRolesConfig}
+      variants={employeeRolesVariants}
+      status={props.status}
+    />
+  );
+}

package/dist/templates/spark/src/app/admin/employees/_config/sorting.ts

@@ -0,0 +1,30 @@
+import {
+  createSortingParser,
+  defineSorting,
+  resolveSortingSchema,
+  sortOption,
+} from "@tulip-systems/query";
+import { createDatabaseSortingCompiler } from "@tulip-systems/query/drizzle";
+import { createLocalSortingCompiler } from "@tulip-systems/query/tanstack-db";
+
+export const employeeTableSorts = defineSorting({
+  "user.name": sortOption((direction) => ({ field: "userName", direction })),
+  "user.email": sortOption((direction) => ({ field: "userEmail", direction })),
+  "user.role": sortOption((direction) => ({ field: "userRole", direction })),
+  createdAt: sortOption((direction) => ({ field: "createdAt", direction })),
+});
+
+/**
+ * Validators
+ */
+export const employeeTableSortsSchema = resolveSortingSchema(employeeTableSorts);
+
+/**
+ * Parsers
+ */
+export const employeeTableSortsParser = createSortingParser(employeeTableSorts, {
+  fallback: [{ key: "createdAt", direction: "asc" }],
+});
+
+export const employeeTableLocalSortsCompiler = createLocalSortingCompiler(employeeTableSorts);
+export const employeeTableDatabaseSortsCompiler = createDatabaseSortingCompiler(employeeTableSorts);

package/dist/templates/spark/src/app/admin/employees/_config/status.tsx

@@ -0,0 +1,65 @@
+import {
+  type CreateStatusComponentProps,
+  createStatusConfig,
+  createStatusVariants,
+  StatusBadge,
+  StatusField,
+} from "@tulip-systems/ui/status";
+import { cva } from "class-variance-authority";
+import { Icons } from "@/components/icons";
+
+/**
+ * User banned
+ */
+export type EmployeeBanned = "banned" | "unbanned";
+
+/**
+ * User statuses
+ */
+export const employeeBannedConfig = createStatusConfig([
+  {
+    value: "banned",
+    label: "Actief",
+    icon: Icons.unLock,
+    className: "stroke-green-500 text-green-500",
+  },
+  {
+    value: "unbanned",
+    label: "Inactief",
+    icon: Icons.lock,
+    className: "stroke-red-500 text-red-500",
+  },
+]);
+
+/**
+ * User status variants
+ */
+export const employeeBannedVariants = cva("", {
+  variants: { status: createStatusVariants(employeeBannedConfig) },
+});
+
+/**
+ * User status column
+ */
+export function EmployeeBannedField(props: CreateStatusComponentProps<EmployeeBanned>) {
+  return (
+    <StatusField
+      config={employeeBannedConfig}
+      variants={employeeBannedVariants}
+      status={props.status}
+    />
+  );
+}
+
+/**
+ * User status badge
+ */
+export function EmployeeBannedBadge(props: CreateStatusComponentProps<EmployeeBanned>) {
+  return (
+    <StatusBadge
+      config={employeeBannedConfig}
+      variants={employeeBannedVariants}
+      status={props.status}
+    />
+  );
+}

package/dist/templates/spark/src/app/admin/employees/_lib/helpers.server.ts

@@ -0,0 +1,46 @@
+import "server-cli-only";
+
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { DRIVE_NAMESPACES } from "@/app/admin/drive/_config/namespaces";
+import type { User } from "@/server/auth/schema";
+import type { DatabaseSchema } from "@/server/db/types";
+import { drive } from "../../drive/_lib/service.server";
+import { employees } from "./schema";
+import type { Employee } from "./validators";
+
+/**
+ * Create employee drive folder
+ */
+export async function ensureEmployeeDriveFolder(
+  context: { db: NodePgDatabase<DatabaseSchema> },
+  employee: Pick<Employee & { user: User }, "id" | "user" | "nodeId">,
+) {
+  /**
+   * Employee already has a folder
+   */
+  if (employee.nodeId) return employee.nodeId;
+
+  /**
+   * Ensure employee folder exists
+   */
+  const folder = await drive.createFolder({
+    namespace: DRIVE_NAMESPACES.employees.namespace,
+    name: employee.user.name,
+    parentId: null,
+    readonly: true,
+  });
+
+  /**
+   * Update employee
+   */
+  await context.db
+    .update(employees)
+    .set({ nodeId: folder.id })
+    .where(eq(employees.id, employee.id));
+
+  /**
+   * Return folder ID
+   */
+  return folder.id;
+}

package/dist/templates/spark/src/app/admin/employees/_lib/router.ts

@@ -0,0 +1,352 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { inlineEditStringSchema } from "@tulip-systems/inline";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+  parseOffsetPagination,
+} from "@tulip-systems/query";
+import { and, count, eq, getTableColumns, inArray, notInArray } from "drizzle-orm";
+import { after } from "next/server";
+import { z } from "zod";
+import type { Role } from "@/server/auth/permissions";
+import { users } from "@/server/auth/schema";
+import { nodes } from "@/server/drive-local/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import { createAddress } from "../../addresses/_lib/helpers.server";
+import { createAddressSchema } from "../../addresses/_lib/validators";
+import type { EmployeeTableData } from "../_components/tables";
+import {
+  employeeDatabaseFiltersCompiler,
+  employeeFiltersParser,
+  employeeFiltersSchema,
+} from "../_config/filters";
+import {
+  employeeTableDatabaseSortsCompiler,
+  employeeTableSortsParser,
+  employeeTableSortsSchema,
+} from "../_config/sorting";
+import { ensureEmployeeDriveFolder } from "./helpers.server";
+import { employees, employeesAddresses } from "./schema";
+import { createEmployeeSchema, updateEmployeeSchema } from "./validators";
+
+const employeeBulkProcedure = protectedProcedure
+  .input(bulkActionSchema)
+  .use(async ({ next, context }, input) => {
+    const data = await context.db
+      .select({ userId: employees.userId })
+      .from(employees)
+      .where(inArray(employees.id, input.ids));
+
+    return next({ context: { ...context, employees: data } });
+  });
+
+export const employeesRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ employee: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: employeeFiltersSchema,
+        sorts: employeeTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const developers = await context.db.select().from(users).where(eq(users.role, "developer"));
+      const developersIds = developers.map(({ id }) => id);
+      const { limit, offset } = parseOffsetPagination(input.pagination);
+
+      const parsedSorts = employeeTableSortsParser.parse(input.sorts);
+      const orderBy = employeeTableDatabaseSortsCompiler({
+        userName: users.name,
+        userEmail: users.email,
+        userRole: users.role,
+        createdAt: employees.createdAt,
+      }).parse(parsedSorts);
+
+      const parsedFilters = employeeFiltersParser.parse(input.filters);
+      const filtersWhere = employeeDatabaseFiltersCompiler({
+        id: employees.id,
+        isDeleted: employees.isDeleted,
+        jobTitle: employees.jobTitle,
+        contract: employees.contract,
+        insz: employees.insz,
+        iban: employees.iban,
+        birthPlace: employees.birthPlace,
+        userName: users.name,
+        userEmail: users.email,
+      }).parse(parsedFilters);
+
+      const where = and(filtersWhere, notInArray(employees.userId, developersIds));
+
+      const [data, [totalResult]] = await Promise.all([
+        context.db
+          .select({ ...getTableColumns(employees), user: users })
+          .from(employees)
+          .innerJoin(users, eq(employees.userId, users.id))
+          .where(where)
+          .orderBy(...orderBy)
+          .limit(limit)
+          .offset(offset),
+        context.db
+          .select({ total: count() })
+          .from(employees)
+          .innerJoin(users, eq(employees.userId, users.id))
+          .where(where),
+      ]);
+
+      const total = totalResult?.total ?? 0;
+
+      return offsetPaginationResponse<EmployeeTableData>({
+        data: data as EmployeeTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ employee: ["view"] }))
+    .input(z.object({ filters: employeeFiltersSchema }))
+    .handler(async ({ context, input }) => {
+      const developers = await context.db.select().from(users).where(eq(users.role, "developer"));
+      const developersIds = developers.map(({ id }) => id);
+      const parsedFilters = employeeFiltersParser.omit({ search: true }).parse(input.filters);
+      const filtersWhere = employeeDatabaseFiltersCompiler(employees).parse(parsedFilters);
+
+      return context.db.query.employees.findMany({
+        where: and(filtersWhere, notInArray(employees.userId, developersIds)),
+        with: { user: true },
+      });
+    }),
+  getAvatars: protectedProcedure
+    .use(permissionMiddleware({ employee: ["view.avatar"] }))
+    .input(employeeFiltersSchema)
+    .handler(async ({ context, input }) => {
+      const developers = await context.db.select().from(users).where(eq(users.role, "developer"));
+      const developersIds = developers.map(({ id }) => id);
+      const parsedFilters = employeeFiltersParser.omit({ search: true }).parse(input);
+      const filtersWhere = employeeDatabaseFiltersCompiler(employees).parse(parsedFilters);
+
+      return context.db.query.employees.findMany({
+        where: and(filtersWhere, notInArray(employees.userId, developersIds)),
+        with: { user: { columns: { id: true, name: true, image: true } } },
+        columns: { id: true },
+      });
+    }),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ employee: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.employees.findFirst({
+        where: eq(employees.id, input.id),
+        with: { user: true, employeesAddresses: { with: { address: true } } },
+      });
+
+      return data ?? null;
+    }),
+  getCurrent: protectedProcedure.handler(async ({ context }) => {
+    const data = await context.db.query.employees.findFirst({
+      where: eq(employees.userId, context.user.id),
+      with: { user: { with: { sessions: true, passkeys: true } } },
+    });
+
+    // Create employee if user is developer
+    if (!data && context.user.role === "developer") {
+      after(async () => {
+        await context.db.insert(employees).values({ userId: context.user.id });
+      });
+    }
+
+    return data ?? null;
+  }),
+  getDrive: protectedProcedure
+    .use(permissionMiddleware({ employee: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const employee = await context.db.query.employees.findFirst({
+        where: eq(employees.id, input.id),
+        with: { user: true },
+      });
+      if (!employee) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Medewerker kon niet worden gevonden",
+        });
+      }
+
+      const nodeId = await ensureEmployeeDriveFolder(context, employee);
+
+      const [folder] = await context.db.select().from(nodes).where(eq(nodes.id, nodeId));
+
+      if (!folder) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Folder kon niet worden gevonden",
+        });
+      }
+
+      return folder;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ employee: ["create"] }))
+    .input(createEmployeeSchema)
+    .handler(async ({ context, input }) => {
+      const { firstName, lastName } = input.user;
+
+      const response = await context.auth.api.createUser({
+        headers: context.headers,
+        body: {
+          ...input.user,
+          role: input.user.role as Role,
+          name: `${firstName} ${lastName}`,
+          data: { firstName, lastName },
+        },
+      });
+
+      const [result] = await context.db
+        .insert(employees)
+        .values({ ...input, userId: response.user.id })
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Medewerker kon niet worden aangemaakt",
+        });
+      }
+
+      after(async () => {
+        const employee = await context.db.query.employees.findFirst({
+          where: eq(employees.id, result.id),
+          with: { user: true },
+        });
+
+        if (!employee) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Medewerker kon niet worden gevonden",
+          });
+        }
+
+        await ensureEmployeeDriveFolder(context, employee);
+      });
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ employee: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateEmployeeSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [employee] = await context.db
+        .select({ userId: employees.userId })
+        .from(employees)
+        .where(eq(employees.id, input.id));
+
+      if (!employee) {
+        throw new ORPCError("NOT_FOUND", { message: "Medewerker niet gevonden" });
+      }
+
+      await context.db.update(employees).set(input.data).where(eq(employees.id, input.id));
+
+      if (input.data.user) {
+        await context.db.update(users).set(input.data.user).where(eq(users.id, employee.userId));
+      }
+    }),
+  setRole: protectedProcedure
+    .use(permissionMiddleware({ employee: ["update"] }))
+    .input(inlineEditStringSchema)
+    .handler(async ({ context, input }) => {
+      const [employee] = await context.db
+        .select({ userId: employees.userId })
+        .from(employees)
+        .where(eq(employees.id, input.id));
+
+      if (!employee) {
+        throw new ORPCError("NOT_FOUND", { message: "Medewerker niet gevonden" });
+      }
+
+      await context.auth.api.setRole({
+        headers: context.headers,
+        body: {
+          userId: employee.userId,
+          role: input.value as Role,
+        },
+      });
+    }),
+  createAddress: protectedProcedure
+    .use(permissionMiddleware({ client: ["update"] }))
+    .input(createAddressSchema.extend({ employeeId: z.string() }))
+    .output(z.void())
+    .handler(async (opts) => {
+      await createAddress(opts, async ({ tx, data }) => {
+        await tx
+          .insert(employeesAddresses)
+          .values({ employeeId: opts.input.employeeId, addressId: data.id });
+      });
+    }),
+  archive: employeeBulkProcedure
+    .use(permissionMiddleware({ employee: ["archive"] }))
+    .handler(async ({ context, input }) => {
+      // Can't archive current user
+      if (context.employees.some(({ userId }) => userId === context.user.id)) {
+        throw new ORPCError("FORBIDDEN", { message: "Je kan jezelf niet archiveren" });
+      }
+
+      await context.db
+        .update(employees)
+        .set({ isDeleted: true })
+        .where(inArray(employees.id, input.ids))
+        .returning();
+    }),
+  restore: employeeBulkProcedure
+    .use(permissionMiddleware({ employee: ["archive"] }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(employees)
+        .set({ isDeleted: false })
+        .where(inArray(employees.id, input.ids))
+        .returning();
+    }),
+  ban: employeeBulkProcedure
+    .use(permissionMiddleware({ employee: ["ban"] }))
+    .handler(async ({ context }) => {
+      // Can't ban current user
+      if (context.employees.some(({ userId }) => userId === context.user.id)) {
+        throw new ORPCError("FORBIDDEN", { message: "Je kan jezelf niet bannen" });
+      }
+
+      const userIds = context.employees.map(({ userId }) => userId);
+
+      await Promise.all(
+        userIds.map((userId) =>
+          context.auth.api.banUser({ headers: context.headers, body: { userId } }),
+        ),
+      );
+    }),
+  unban: employeeBulkProcedure
+    .use(permissionMiddleware({ employee: ["ban"] }))
+    .handler(async ({ context }) => {
+      const userIds = context.employees.map(({ userId }) => userId);
+
+      await Promise.all(
+        userIds.map((userId) =>
+          context.auth.api.unbanUser({ headers: context.headers, body: { userId } }),
+        ),
+      );
+    }),
+  delete: employeeBulkProcedure
+    .use(permissionMiddleware({ employee: ["delete"] }))
+    .handler(async ({ context }) => {
+      // Can't delete current user
+      if (context.employees.some(({ userId }) => userId === context.user.id)) {
+        throw new ORPCError("FORBIDDEN", { message: "Je kan jezelf niet verwijderen" });
+      }
+
+      const userIds = context.employees.map(({ userId }) => userId);
+
+      await Promise.all(
+        userIds.map((userId) =>
+          context.auth.api.removeUser({ headers: context.headers, body: { userId } }),
+        ),
+      );
+    }),
+};

package/dist/templates/spark/src/app/admin/employees/_lib/schema.ts

@@ -0,0 +1,79 @@
+import { relations } from "drizzle-orm";
+import { pgTable, unique } from "drizzle-orm/pg-core";
+import { users } from "@/server/auth/schema";
+import { baseColumns } from "@/server/db/helpers";
+import { addresses, nodes, registrations } from "@/server/db/schema";
+
+export const employeesGenders = ["male", "female", "other"] as const;
+
+/**
+ * Employee table
+ */
+export const employees = pgTable("employees", (t) => ({
+  ...baseColumns,
+  startDate: t.timestamp(),
+  endDate: t.timestamp(),
+  gender: t.text({ enum: employeesGenders }),
+  insz: t.varchar(),
+  language: t.varchar(),
+  birthDate: t.timestamp(),
+  birthPlace: t.varchar(),
+  iban: t.varchar(),
+  jobTitle: t.varchar(),
+  contract: t.varchar(),
+  isDeleted: t.boolean().default(false).notNull(),
+  userId: t
+    .uuid()
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  nodeId: t.uuid().references(() => nodes.id, { onDelete: "set default" }),
+}));
+
+/**
+ * Relations
+ */
+export const employeesRelations = relations(employees, ({ one, many }) => ({
+  user: one(users, {
+    fields: [employees.userId],
+    references: [users.id],
+  }),
+  node: one(nodes, {
+    fields: [employees.nodeId],
+    references: [nodes.id],
+  }),
+  employeesAddresses: many(employeesAddresses),
+  registrations: many(registrations),
+}));
+
+/**
+ * Customer address
+ */
+export const employeesAddresses = pgTable(
+  "employees_addresses",
+  (t) => ({
+    ...baseColumns,
+    employeeId: t
+      .uuid()
+      .references(() => employees.id, { onDelete: "cascade" })
+      .notNull(),
+    addressId: t
+      .uuid()
+      .references(() => addresses.id, { onDelete: "cascade" })
+      .notNull(),
+  }),
+  (t) => [unique("employee_address_unique").on(t.employeeId, t.addressId)],
+);
+
+/**
+ * Relations
+ */
+export const employeesAddressesRelations = relations(employeesAddresses, ({ one }) => ({
+  employee: one(employees, {
+    fields: [employeesAddresses.employeeId],
+    references: [employees.id],
+  }),
+  address: one(addresses, {
+    fields: [employeesAddresses.addressId],
+    references: [addresses.id],
+  }),
+}));

package/dist/templates/spark/src/app/admin/employees/_lib/validators.ts

@@ -0,0 +1,45 @@
+import { createUserSchema } from "@tulip-systems/auth";
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import type { z } from "zod";
+import { selectUserSchema, updateUserSchema } from "@/server/auth/schema";
+
+export type { EmployeeFiltersSchema } from "../_config/filters";
+export { employeeFiltersSchema } from "../_config/filters";
+
+import { employees, type employeesGenders } from "./schema";
+
+/**
+ * Employee type
+ */
+export type Employee = typeof employees.$inferSelect;
+
+export type EmployeeGender = (typeof employeesGenders)[number];
+
+/**
+ * Employee select schema
+ */
+export const selectEmployeeSchema = createSelectSchema(employees).extend({
+  user: selectUserSchema,
+});
+
+export type SelectEmployeeSchema = z.infer<typeof selectEmployeeSchema>;
+
+/**
+ * Employee schema
+ */
+export const createEmployeeSchema = createInsertSchema(employees)
+  .omit({ userId: true })
+  .extend({ user: createUserSchema });
+
+export const updateEmployeeSchema = createUpdateSchema(employees)
+  .omit({ userId: true })
+  .extend({ user: updateUserSchema.partial() });
+
+/**
+ * Employee schema
+ */
+export type CreateEmployeeInput = z.input<typeof createEmployeeSchema>;
+export type CreateEmployeeSchema = z.infer<typeof createEmployeeSchema>;
+
+export type UpdateEmployeeInput = z.input<typeof updateEmployeeSchema>;
+export type UpdateEmployeeSchema = z.infer<typeof updateEmployeeSchema>;