@tulip-systems/core 0.3.0 → 0.4.1

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

@@ -1,22 +1,12 @@
 "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";
 
 export const authClient = createAuthClient({
-  plugins: [emailOTPClient(), adminClient(), inferAdditionalFields<ServerAuth>()],
+  plugins: [emailOTPClient(), passkeyClient(), adminClient(), inferAdditionalFields<AuthClient>()],
 });
 
 export type ClientAuth = typeof authClient;

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

@@ -0,0 +1,108 @@
+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: drizzleAdapter(props.db, {
+      provider: "pg",
+        // schema: props.schema,
+      usePlural: true,
+    }),
+    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

@@ -0,0 +1,28 @@
+import { getSessionCookie } from "better-auth/cookies";
+import { NextRequest, NextResponse } from "next/server";
+import { URLPattern } from "urlpattern-polyfill";
+import { authCookiePrefix } from "./init";
+
+/**
+ * Create auth proxy
+ */
+export function createAuthProxy(props: { publicRoutes: string[] }) {
+  return (req: NextRequest) => {
+    // 1. Check if the current route is protected or public
+    const pathname = req.nextUrl.pathname;
+
+    const isPublicRoute = props.publicRoutes.some((route) =>
+      new URLPattern({ pathname: route }).test({ pathname }),
+    );
+
+    // 2. Check if a session cookie is present
+    const sessionCookie = getSessionCookie(req, { cookiePrefix: authCookiePrefix });
+
+    // 3. Redirect to /auth/login if the user is not authenticated
+    if (!isPublicRoute && !sessionCookie) {
+      return NextResponse.redirect(new URL("/auth/login", req.nextUrl));
+    }
+
+    return NextResponse.next();
+  };
+}

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

@@ -13,16 +13,13 @@ 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;
 
         const { data, error } = await authClient.admin.hasPermission({ permission, userId });

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

@@ -1,11 +1,10 @@
 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 { redirect } from "next/navigation";
 import { users } from "../entry";
 import { CreateUserSchema, UpdateUserSchema } from "./validators";
 
@@ -14,18 +13,15 @@ import { CreateUserSchema, UpdateUserSchema } from "./validators";
  */
 export async function getSession<TSchema extends TDatabaseSchema>({
   auth,
-}: Pick<GetTulipReturn<TSchema>, "auth">) {
-  const session = await auth.api.getSession({ headers: await headers() });
-  if (!session) redirect("/auth/login");
-
-  return session;
+}: Pick<TulipContext<TSchema>, "auth">) {
+  return auth.api.getSession({ headers: await headers() });
 }
 
 /**
  * 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;
@@ -45,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/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 { useCommandAction2 } from "../hooks/use-command-action.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 } = useCommandAction2({
+    ...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 { useCommandAction2 } from "../hooks/use-command-action.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 } = useCommandAction2(mutation);
 
   const isDisabled = disabled || status === "pending";
 
-  const handleClick = () => execute();
+  const handleClick = () => mutate(variables);
 
   useHotkeys(hotkey ?? "", () => handleClick(), { enabled: !isDisabled && hotkey !== undefined });
 

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

@@ -17,9 +17,10 @@ import {
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { cn } from "@/lib/utils/cn";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
 import React from "react";
 import { useCommand } from "../hooks/context.client";
-import { CommandAction, useCommandAction } from "../hooks/use-command-action.client";
+import { useCommandAction2 } from "../hooks/use-command-action.client";
 import { CommandTrigger } from "./command-trigger.client";
 
 /**
@@ -163,26 +164,48 @@ export function CommandDropdownTrigger({
 /**
  * CommandDropdownItem
  */
-type CommandDropdownItemProps = {
-  action: CommandAction;
-  message?: string;
+type CommandDropdownItemProps<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+> = {
+  variables: TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
   children: React.ReactNode;
   className?: string;
 };
 
-export function CommandDropdownItem({
-  action,
-  message,
+export function CommandDropdownItem<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+>({
+  variables,
+  mutation,
   children,
   ...props
-}: CommandDropdownItemProps) {
+}: CommandDropdownItemProps<TData, TError, TVariables, TOnMutateResult>) {
   const { setOpen } = React.useContext(CommandDropdownContext);
   const { menu, status } = useCommand();
-  const execute = useCommandAction(action, { message, onSuccess: () => setOpen(false) });
+
+  const { mutateAsync } = useCommandAction2({
+    ...mutation,
+    onSuccess: async (...params) => {
+      setOpen(false);
+
+      return await mutation?.onSuccess?.(...params);
+    },
+  });
 
   if (menu === "inline" || menu === "table" || menu === "dropdown") {
     return (
-      <DropdownMenuItem {...props} disabled={status === "pending"} onClick={() => execute()}>
+      <DropdownMenuItem
+        {...props}
+        disabled={status === "pending"}
+        onClick={() => mutateAsync(variables)}
+      >
         {children}
       </DropdownMenuItem>
     );
@@ -190,7 +213,11 @@ export function CommandDropdownItem({
 
   if (menu === "context") {
     return (
-      <ContextMenuItem {...props} disabled={status === "pending"} onClick={() => execute()}>
+      <ContextMenuItem
+        {...props}
+        disabled={status === "pending"}
+        onClick={() => mutateAsync(variables)}
+      >
         {children}
       </ContextMenuItem>
     );

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

@@ -14,12 +14,13 @@ import {
 } from "@/components/ui/dialog.client";
 import { DropdownMenuItem } from "@/components/ui/dropdown-menu";
 import { cn } from "@/lib/utils/cn";
-import { DialogContentProps, DialogProps } from "@radix-ui/react-dialog";
-import React, { ComponentProps } from "react";
-import { FieldValues, Form, useFormContext } from "react-hook-form";
-import { Keys, useHotkeys } from "react-hotkeys-hook";
+import type { DialogContentProps, DialogProps } from "@radix-ui/react-dialog";
+import { type DefaultError, type MutationOptions } from "@tanstack/react-query";
+import React, { type ComponentProps } from "react";
+import { type FieldValues, Form, useFormContext } from "react-hook-form";
+import { type Keys, useHotkeys } from "react-hotkeys-hook";
+import { useCommandAction2 } from "../entry.client";
 import { useCommand } from "../hooks/context.client";
-import { CommandAction, useCommandAction } from "../hooks/use-command-action.client";
 import { CommandTrigger } from "./command-trigger.client";
 
 /**
@@ -154,26 +155,46 @@ export const CommandFormDialogContentProvider = Form;
 /**
  * CommandFormDialogContent
  */
-export type CommandFormDialogContentProps<TSchema extends FieldValues> = DialogContentProps & {
-  action: CommandAction<TSchema>;
-  message?: string;
+export type CommandFormDialogContentProps<
+  TValues extends FieldValues,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+> = DialogContentProps & {
+  variables: (values: TValues) => TVariables;
+  mutation?: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
   children: React.ReactNode;
 };
+// export type CommandFormDialogContentProps<TSchema extends FieldValues> = DialogContentProps & {
+//   action: CommandAction<TSchema>;
+//   mutation?: MutationOptions<TSchema>;
+//   message?: string;
+//   children: React.ReactNode;
+// };
 
-export function CommandFormDialogContent<TSchema extends FieldValues>({
-  action,
-  message,
+export function CommandFormDialogContent<
+  TValues extends FieldValues,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+>({
+  variables,
+  mutation,
   children,
   ...props
-}: CommandFormDialogContentProps<TSchema>) {
+}: CommandFormDialogContentProps<TValues, TData, TError, TVariables, TOnMutateResult>) {
   const { setOpen } = React.useContext(CommandFormDialogContext);
-  const form = useFormContext<TSchema>();
+  const form = useFormContext<TValues>();
 
-  const execute = useCommandAction(action, {
-    message,
-    onSuccess: () => {
+  const { mutateAsync } = useCommandAction2({
+    ...mutation,
+    onSuccess: async (...params) => {
       form.reset();
       setOpen(false);
+
+      return await mutation?.onSuccess?.(...params);
     },
   });
 
@@ -183,7 +204,14 @@ export function CommandFormDialogContent<TSchema extends FieldValues>({
 
   return (
     <DialogContent {...props}>
-      <form onSubmit={form.handleSubmit((data) => execute(data))}>{children}</form>
+      <form
+        onSubmit={form.handleSubmit((data) => {
+          const params = variables(data);
+          mutateAsync(params);
+        })}
+      >
+        {children}
+      </form>
     </DialogContent>
   );
 }