@tulip-systems/core 0.4.0 → 0.5.0

package/src/modules/auth/db/schema.ts

@@ -1,8 +1,12 @@
-import { sql, SQL } from "drizzle-orm";
+import { baseColumns } from "@/modules/config/entry";
+import { relations, sql, SQL } from "drizzle-orm";
 import { pgTable } from "drizzle-orm/pg-core";
 
+/**
+ * Users
+ */
 export const users = pgTable("users", (t) => ({
-  id: t.text().primaryKey(),
+  ...baseColumns,
   name: t
     .varchar()
     .notNull()
@@ -12,37 +16,49 @@ export const users = pgTable("users", (t) => ({
   email: t.text().notNull().unique(),
   emailVerified: t.boolean().notNull(),
   image: t.text(),
-  createdAt: t.timestamp().notNull(),
-  updatedAt: t.timestamp().notNull(),
   role: t.text(),
   banned: t.boolean(),
   banReason: t.text(),
   banExpires: t.timestamp(),
 }));
 
+export const usersRelations = relations(users, ({ many }) => ({
+  sessions: many(sessions),
+  accounts: many(accounts),
+  verifications: many(verifications),
+  passkeys: many(passkeys),
+}));
+
+/**
+ * Sessions
+ */
 export const sessions = pgTable("sessions", (t) => ({
-  id: t.text().primaryKey(),
+  ...baseColumns,
   expiresAt: t.timestamp().notNull(),
   token: t.text().notNull().unique(),
-  createdAt: t.timestamp().notNull(),
-  updatedAt: t.timestamp().notNull(),
   ipAddress: t.text(),
   userAgent: t.text(),
+  impersonatedBy: t.text(),
   userId: t
-    .text()
+    .uuid()
     .notNull()
     .references(() => users.id, { onDelete: "cascade" }),
-  impersonatedBy: t.text(),
 }));
 
+export const sessionsRelations = relations(sessions, ({ one }) => ({
+  user: one(users, {
+    fields: [sessions.userId],
+    references: [users.id],
+  }),
+}));
+
+/**
+ * Accounts
+ */
 export const accounts = pgTable("accounts", (t) => ({
-  id: t.text().primaryKey(),
+  ...baseColumns,
   accountId: t.text().notNull(),
   providerId: t.text().notNull(),
-  userId: t
-    .text()
-    .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
   accessToken: t.text(),
   refreshToken: t.text(),
   idToken: t.text(),
@@ -50,17 +66,60 @@ export const accounts = pgTable("accounts", (t) => ({
   refreshTokenExpiresAt: t.timestamp(),
   scope: t.text(),
   password: t.text(),
-  createdAt: t.timestamp().notNull(),
-  updatedAt: t.timestamp().notNull(),
+  userId: t
+    .uuid()
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+}));
+
+export const accountsRelations = relations(accounts, ({ one }) => ({
+  user: one(users, {
+    fields: [accounts.userId],
+    references: [users.id],
+  }),
 }));
 
+/**
+ * Verifications
+ */
 export const verifications = pgTable("verifications", (t) => ({
-  id: t.text().primaryKey(),
+  ...baseColumns,
   identifier: t.text().notNull(),
   value: t.text().notNull(),
   expiresAt: t.timestamp().notNull(),
-  createdAt: t.timestamp(),
-  updatedAt: t.timestamp(),
+}));
+
+export const verificationsRelations = relations(verifications, ({ one }) => ({
+  user: one(users, {
+    fields: [verifications.identifier],
+    references: [users.id],
+  }),
+}));
+
+/**
+ * Passkeys
+ */
+export const passkeys = pgTable("passkeys", (t) => ({
+  ...baseColumns,
+  name: t.text(),
+  publicKey: t.text().notNull(),
+  credentialID: t.text().notNull(),
+  counter: t.integer().notNull(),
+  deviceType: t.text().notNull(),
+  backedUp: t.boolean().notNull(),
+  transports: t.text(),
+  aaguid: t.text(),
+  userId: t
+    .uuid()
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+}));
+
+export const passkeysRelations = relations(passkeys, ({ one }) => ({
+  user: one(users, {
+    fields: [passkeys.userId],
+    references: [users.id],
+  }),
 }));
 
 /**

package/src/modules/auth/entry.client.ts

@@ -1,4 +1,5 @@
 export * from "./components/allowed.client";
+export * from "./components/create-first-user-page.client";
 export * from "./components/forget-password-page.client";
 export * from "./components/login-page.client";
 export * from "./components/reset-password-page.client";

package/src/modules/auth/entry.server.ts

@@ -1,4 +1,18 @@
+/**
+ * Components
+ */
 export * from "./components/auth-layout.server";
+export * from "./components/guard-first-user.server";
+export * from "./components/guard.server";
+
+/**
+ * Handlers
+ */
+export * from "./handler/init";
 export * from "./handler/proxy.server";
 export * from "./handler/route.server";
+
+/**
+ * Lib
+ **/
 export * from "./lib/helpers.server";

package/src/modules/auth/handler/client.client.ts

@@ -1,22 +1,14 @@
 "use client";
 
-import { type ClientOptions } from "better-auth";
+import { passkeyClient } from "@better-auth/passkey/client";
 import { adminClient, emailOTPClient, inferAdditionalFields } from "better-auth/client/plugins";
 import { createAuthClient } from "better-auth/react";
-import { type ServerAuth } from "./server.server";
-
-type AuthClientOptions = Omit<ClientOptions, "plugins"> & {
-  plugins: [
-    ReturnType<typeof emailOTPClient>,
-    ReturnType<typeof adminClient>,
-    ReturnType<typeof inferAdditionalFields<ServerAuth>>,
-  ];
-};
-
-type AuthClient = ReturnType<typeof createAuthClient<AuthClientOptions>>;
+import { AuthClient } from "./init";
+import { url } from "@/lib/utils/url";
 
 export const authClient = createAuthClient({
-  plugins: [emailOTPClient(), adminClient(), inferAdditionalFields<ServerAuth>()],
+  baseURL: url(),
+  plugins: [emailOTPClient(), passkeyClient(), adminClient(), inferAdditionalFields<AuthClient>()],
 });
 
 export type ClientAuth = typeof authClient;

package/src/modules/auth/handler/init.ts

@@ -0,0 +1,111 @@
+import ForgetPasswordEmail from "@/components/emails/forget-password-email";
+import { url } from "@/lib/utils/url";
+import { TDatabaseSchema } from "@/modules/config/entry";
+import { DatabaseClient, EmailClient } from "@/modules/config/entry.server";
+import { TulipConfig } from "@/modules/config/lib/config";
+import { passkey } from "@better-auth/passkey";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { betterAuth } from "better-auth/minimal";
+import { nextCookies } from "better-auth/next-js";
+import { admin, createAuthMiddleware, emailOTP } from "better-auth/plugins";
+import { eq } from "drizzle-orm";
+import { users } from "../entry";
+import { createAccessControl, Role } from "../lib/permissions";
+
+export const authCookiePrefix = "tulip";
+
+type InitAuthProps<TSchema extends TDatabaseSchema> = {
+  db: DatabaseClient<TSchema>;
+  email: EmailClient;
+  config: TulipConfig;
+  ac: ReturnType<typeof createAccessControl>;
+  roles: {
+    [key in string]?: Role;
+  };
+};
+
+export function initAuth<TSchema extends TDatabaseSchema>(props: InitAuthProps<TSchema>) {
+  return betterAuth({
+    advanced: {
+      cookiePrefix: authCookiePrefix,
+      database: {
+        generateId: () => false,
+      },
+    },
+    database: drizzleAdapter(props.db, {
+      provider: "pg",
+      usePlural: true,
+      // schema: props.schema,
+    }),
+    emailAndPassword: {
+      enabled: true,
+    },
+    user: {
+      changeEmail: {
+        enabled: true,
+      },
+      additionalFields: {
+        firstName: {
+          type: "string",
+          required: true,
+          input: true,
+        },
+        lastName: {
+          type: "string",
+          required: true,
+          input: true,
+        },
+      },
+    },
+    hooks: {
+      after: createAuthMiddleware(async (ctx) => {
+        if (!ctx.path.startsWith("/sign-up")) return;
+
+        const session = ctx.context.newSession;
+        if (!session) return;
+
+        const existingUsers = await props.db.select().from(users);
+
+        if (existingUsers.length === 1) {
+          await props.db
+            .update(users)
+            .set({ role: "developer" })
+            .where(eq(users.id, session.user.id));
+        }
+      }),
+    },
+    plugins: [
+      nextCookies(),
+      passkey(),
+      admin({
+        roles: props.roles,
+        ac: props.ac,
+        adminRoles: ["admin", "developer"],
+      }),
+      emailOTP({
+        sendVerificationOTP: async ({ email, otp, type }) => {
+          /**
+           * Send a forget password mail
+           */
+          if (type === "forget-password") {
+            const searchParams = new URLSearchParams();
+            searchParams.set("email", email);
+            searchParams.set("otp", otp);
+
+            const resetPasswordHref = url(`/auth/reset-password?${searchParams.toString()}`);
+
+            const result = await props.email.emails.send({
+              from: props.config.email.defaultFrom,
+              to: email,
+              subject: "Wachtwoord herstellen",
+              react: ForgetPasswordEmail({ resetPasswordHref }),
+            });
+            if (result.error) throw new Error(result.error.message);
+          }
+        },
+      }),
+    ],
+  });
+}
+
+export type AuthClient = ReturnType<typeof initAuth>;

package/src/modules/auth/handler/proxy.server.ts

@@ -1,7 +1,7 @@
 import { getSessionCookie } from "better-auth/cookies";
 import { NextRequest, NextResponse } from "next/server";
 import { URLPattern } from "urlpattern-polyfill";
-import { authCookiePrefix } from "./server.server";
+import { authCookiePrefix } from "./init";
 
 /**
  * Create auth proxy

package/src/modules/auth/handler/route.server.ts

@@ -1,20 +1,17 @@
-import { TDatabaseSchema } from "@/modules/config/db/types";
-import { getTulip, GetTulipParams } from "@/modules/config/lib/resolve.server";
 import { toNextJsHandler } from "better-auth/next-js";
 import { NextRequest } from "next/server";
 import "server-cli-only";
+import { AuthClient } from "./init";
 
 /**
  * Handle the auth routes
  */
-export function handleAuthRoute<TSchema extends TDatabaseSchema>(params: GetTulipParams<TSchema>) {
+export function handleAuthRoute(props: { auth: AuthClient }) {
   /**
    * GET route handler
    */
   async function GET(request: NextRequest) {
-    const { auth } = await getTulip(params);
-    const routes = toNextJsHandler(auth.handler);
-
+    const routes = toNextJsHandler(props.auth.handler);
     return routes.GET(request);
   }
 
@@ -22,9 +19,7 @@ export function handleAuthRoute<TSchema extends TDatabaseSchema>(params: GetTuli
    * POST route handler
    */
   async function POST(request: NextRequest) {
-    const { auth } = await getTulip(params);
-    const routes = toNextJsHandler(auth.handler);
-
+    const routes = toNextJsHandler(props.auth.handler);
     return routes.POST(request);
   }
 

package/src/modules/auth/hooks/use-permission.ts

@@ -1,7 +1,6 @@
 "use client";
 
 import { useSuspenseQueries } from "@tanstack/react-query";
-import { LiteralString } from "better-auth";
 import { authClient } from "../handler/client.client";
 import { type Permission } from "../lib/permissions";
 import { useSession } from "./use-session";
@@ -13,17 +12,15 @@ export function usePermission(permission?: Permission) {
   const sessionQuery = useSession();
 
   const keys = Object.entries(permission ?? {}).flatMap(([resource, permissions]) =>
-    permissions.map((permission) => [resource, permission] as const),
+    permissions.map((permission) => ({ [resource]: [permission] }) as Permission),
   );
 
   return useSuspenseQueries({
-    queries: keys.map((key) => ({
-      queryKey: ["permission", ...key],
+    queries: keys.map((permission) => ({
+      queryKey: ["permission", permission],
       queryFn: async () => {
-        const resource = key[0]?.toString() as string;
-        const permission: Permission = { [resource]: [key[1]] as LiteralString[] };
-
         const userId = sessionQuery.data?.user.id;
+        if (!userId) return { permission, success: false };
 
         const { data, error } = await authClient.admin.hasPermission({ permission, userId });
         if (error) {
@@ -36,13 +33,14 @@ export function usePermission(permission?: Permission) {
           success: data.success,
         };
       },
+      staleTime: 5 * 60 * 1000, // 5 minutes
     })),
     combine: (results) => {
       const errors = results.filter(({ error }) => error);
       if (errors.length) return { data: null, errors };
 
       const values = results.map(({ data }) => data);
-      const success = results.every(({ data }) => data.success);
+      const success = results.every(({ data }) => data?.success);
 
       return { data: { success, values }, errors: null };
     },

package/src/modules/auth/hooks/use-session.ts

@@ -1,18 +1,24 @@
 "use client";
 
-import { useSuspenseQuery } from "@tanstack/react-query";
+import { queryOptions, useSuspenseQuery } from "@tanstack/react-query";
 import { authClient } from "../entry.client";
 
-export function useSession() {
-  const session = useSuspenseQuery({
-    queryKey: ["session"],
-    queryFn: async () => {
-      const session = await authClient.getSession();
-      if (session.error) throw session.error;
+export const sessionQueryOptions = queryOptions({
+  queryKey: ["session"],
+  queryFn: async () => {
+    const session = await authClient.getSession();
+
+    if (session.error) {
+      console.error(session.error);
+      return null;
+    }
 
-      return session.data;
-    },
-  });
+    return session.data;
+  },
+  staleTime: 1000 * 60 * 60,
+});
 
+export function useSession() {
+  const session = useSuspenseQuery(sessionQueryOptions);
   return session;
 }

package/src/modules/auth/lib/helpers.server.ts

@@ -1,8 +1,8 @@
 import "server-cli-only";
 
 import { type TDatabaseSchema } from "@/modules/config/db/types";
-import { GetTulipReturn } from "@/modules/config/lib/resolve.server";
-import { ServerError } from "@/modules/config/router/error.server";
+import { TulipContext } from "@/modules/config/entry";
+import { ServerError } from "@/modules/router/lib/error.server";
 import { eq } from "drizzle-orm";
 import { headers } from "next/headers";
 import { users } from "../entry";
@@ -13,7 +13,7 @@ import { CreateUserSchema, UpdateUserSchema } from "./validators";
  */
 export async function getSession<TSchema extends TDatabaseSchema>({
   auth,
-}: Pick<GetTulipReturn<TSchema>, "auth">) {
+}: Pick<TulipContext<TSchema>, "auth">) {
   return auth.api.getSession({ headers: await headers() });
 }
 
@@ -21,7 +21,7 @@ export async function getSession<TSchema extends TDatabaseSchema>({
  * Create a user
  */
 export function createUser<TSchema extends TDatabaseSchema>(
-  { auth, headers }: GetTulipReturn<TSchema> & { headers: Headers },
+  { auth, headers }: TulipContext<TSchema> & { headers: Headers },
   { body }: { body: CreateUserSchema },
 ) {
   const { firstName, lastName } = body;
@@ -41,7 +41,7 @@ export function createUser<TSchema extends TDatabaseSchema>(
  */
 
 export async function updateUser<TSchema extends TDatabaseSchema>(
-  { db }: GetTulipReturn<TSchema>,
+  { db }: TulipContext<TSchema>,
   { userId, body }: { userId: string; body: Partial<UpdateUserSchema> },
 ) {
   const [result] = await db.update(users).set(body).where(eq(users.id, userId)).returning();

package/src/modules/auth/lib/validators.ts

@@ -64,7 +64,7 @@ export const createUserSchema = userSchema.pick({ email: true, image: true }).ex
     .min(2, { message: "Achternaam moet langer zijn dan 2 karakters" })
     .max(50, { message: "Achternaam mag niet langer zijn dan 50 karakters" }),
   password: z.string().min(6, { message: "Wachtwoord moet minimaal 6 karakters hebben" }),
-  role: z.string().default("user"),
+  role: z.string(),
 });
 
 export type CreateUserSchema = z.infer<typeof createUserSchema>;

package/src/modules/commands/components/alert-dialog-command.client.tsx

@@ -21,10 +21,11 @@ import {
   AlertDialogContentProps,
   AlertDialogProps,
 } from "@radix-ui/react-alert-dialog";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
 import React from "react";
 import { Keys, useHotkeys } from "react-hotkeys-hook";
 import { useCommand } from "../hooks/context.client";
-import { CommandAction, useCommandAction } from "../hooks/use-command-action.client";
+import { useCommandMutation } from "../hooks/use-command-mutation.client";
 import { CommandTrigger } from "./command-trigger.client";
 
 /**
@@ -184,101 +185,49 @@ export function CommandAlertDialogCancel({ children, ...props }: AlertDialogCanc
 /**
  * CommandAlertDialogAction
  */
-type CommandAlertDialogActionProps = {
+type CommandAlertDialogActionProps<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+> = {
+  variables: TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
   children: React.ReactNode;
   className?: string;
-  action: CommandAction;
-  message?: string;
   disabled?: boolean;
 };
 
-export function CommandAlertDialogAction({
-  action,
-  message,
+export function CommandAlertDialogAction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+>({
+  variables,
+  mutation,
   children,
   disabled,
   ...props
-}: CommandAlertDialogActionProps) {
+}: CommandAlertDialogActionProps<TData, TError, TVariables, TOnMutateResult>) {
   const { setOpen } = React.useContext(CommandAlertDialogContext);
   const { status } = useCommand();
-  const execute = useCommandAction(action, { message, onSuccess: () => setOpen(false) });
+
+  const { mutateAsync } = useCommandMutation({
+    ...mutation,
+    onSuccess: async (...params) => {
+      setOpen(false);
+
+      return await mutation?.onSuccess?.(...params);
+    },
+  });
 
   const isDisabled = disabled || status === "pending";
 
   return (
-    <AlertDialogAction {...props} disabled={isDisabled} onClick={() => execute()}>
+    <AlertDialogAction {...props} disabled={isDisabled} onClick={() => mutateAsync(variables)}>
       {status === "pending" && <Icons.spinner className="mr-2 h-4 w-4 animate-spin" />}
       {children}
     </AlertDialogAction>
   );
 }
-
-// /**
-//  * CommandAlertDialogAction
-//  */
-// type CommandAlertDialogAction2Props<
-//   TRouter extends AnyTRPCRouter,
-//   TInput,
-//   TDef extends { input: TInput; output: any; transformer: boolean; errorShape: any },
-// > = {
-//   children: React.ReactNode;
-//   className?: string;
-
-//   input: TInput;
-//   mutation: (trpc: ReturnType<typeof useTRPC<TRouter>>) => DecorateMutationProcedure<TDef>;
-
-//   message?: string;
-//   disabled?: boolean;
-// };
-
-// export function CommandAlertDialogAction2<
-// TInput,
-// TDef extends { input: TInput; output: any; transformer: boolean; errorShape: any },
-// TRouter extends AnyTRPCRouter,
-// >({
-//   input,
-//   mutation,
-//   message,
-//   children,
-//   disabled,
-//   ...props
-// }: CommandAlertDialogAction2Props<TRouter, TInput, TDef>) {
-//   const trpc = useTRPC<TRouter>();
-
-//   const { setOpen } = React.useContext(CommandAlertDialogContext);
-//   const commandContext = useCommand();
-
-//   const options = mutation?.(trpc);
-
-//   const { mutate } = useMutation(
-//     options.mutationOptions({
-//       onMutate: () => {
-//         commandContext.setStatus("pending");
-//       },
-//       onSuccess: async () => {
-//         commandContext.setStatus("success");
-//         toast.success(message || "Actie voltooid!");
-//         setOpen(false);
-//         await commandContext.onSuccess?.();
-//       },
-//       onError: async () => {
-//         commandContext.setStatus("error");
-//         await commandContext.onError?.();
-//       },
-//       onSettled: () => {
-//         commandContext.setStatus("idle");
-//       },
-//     }),
-//   );
-
-//   const isDisabled = disabled || status === "pending";
-
-//   return (
-//     <AlertDialogAction {...props} disabled={isDisabled} onClick={() => mutate(input)}>
-//       {commandContext.status === "pending" && (
-//         <Icons.spinner className="mr-2 h-4 w-4 animate-spin" />
-//       )}
-//       {children}
-//     </AlertDialogAction>
-//   );
-// }

package/src/modules/commands/components/click-command.client.tsx

@@ -3,37 +3,48 @@
 import { Button } from "@/components/ui/button";
 import { ContextMenuItem } from "@/components/ui/context-menu";
 import { DropdownMenuItem } from "@/components/ui/dropdown-menu";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
 import React from "react";
+import { Keys, useHotkeys } from "react-hotkeys-hook";
 import { useCommand } from "../hooks/context.client";
-import { CommandAction, useCommandAction } from "../hooks/use-command-action.client";
+import { useCommandMutation } from "../hooks/use-command-mutation.client";
 import { CommandTrigger } from "./command-trigger.client";
-import { Keys, useHotkeys } from "react-hotkeys-hook";
 
-export type CommandClickProps = {
+export type CommandClickProps<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+> = {
   children: React.ReactNode;
   className?: string;
   disabled?: boolean;
-  action: CommandAction;
-  message?: string;
+  variables: TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
   label?: string;
   hotkey?: Keys;
 };
 
-export function CommandClick({
+export function CommandClick<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+>({
   children,
-  action,
-  message,
+  variables,
+  mutation,
   label,
   hotkey,
   disabled,
   ...props
-}: CommandClickProps) {
+}: CommandClickProps<TData, TError, TVariables, TOnMutateResult>) {
   const { menu, status } = useCommand();
-  const execute = useCommandAction(action, { message });
+  const { mutate } = useCommandMutation(mutation);
 
   const isDisabled = disabled || status === "pending";
 
-  const handleClick = () => execute();
+  const handleClick = () => mutate(variables);
 
   useHotkeys(hotkey ?? "", () => handleClick(), { enabled: !isDisabled && hotkey !== undefined });