@tulip-systems/core 0.4.0 → 0.4.1

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

@@ -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

@@ -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,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/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>
   );
 }

package/src/modules/commands/hooks/use-command-action.client.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useAction } from "@/lib/hooks/use-action";
-import { MutationOptions } from "@tanstack/react-query";
+import type { DefaultError, MutationFunction, MutationOptions } from "@tanstack/react-query";
 import { toast } from "sonner";
 import { useCommand } from "./context.client";
 
@@ -56,40 +56,48 @@ export function useCommandAction<TInput = void>(
   return mutateAsync as (input: TInput) => CommandActionResult;
 }
 
-export function useCommandAction2<TInput = void>(
-  // action: CommandAction<TInput>,
-  options?: MutationOptions,
-) {
+export function useCommandAction2<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+>(options?: MutationOptions<TData, TError, TVariables, TOnMutateResult>) {
   const commandContext = useCommand();
 
-  const { mutateAsync } = useAction({
+  const mutation = useAction({
     ...options,
-    onMutate: () => {
+    mutationFn: options?.mutationFn as MutationFunction<TData, TVariables>,
+    onMutate: async (...params) => {
+      const result = options?.onMutate?.(...params);
+
       commandContext.setStatus("pending");
+
+      return (await result) as TOnMutateResult;
     },
     onSuccess: async (...params) => {
+      const result = options?.onSuccess?.(...params);
+
       commandContext.setStatus("success");
-      // toast.success(options?.message || "Actie voltooid!");
-      await options?.onSuccess?.(...params);
       await commandContext.onSuccess?.();
+
+      return await result;
     },
-    // onRedirect: async () => {
-    //   commandContext.setStatus("success");
-    //   toast.success(options?.message || "Actie voltooid!");
-    //   await options?.onSuccess?.();
-    //   await commandContext.onSuccess?.();
-    // },
     onError: async (...params) => {
+      const result = options?.onError?.(...params);
+
       commandContext.setStatus("error");
-      await options?.onError?.(...params);
       await commandContext.onError?.();
+
+      return await result;
     },
-    onSettled: () => {
+    onSettled: async (...params) => {
+      const result = options?.onSettled?.(...params);
+
       commandContext.setStatus("idle");
-      // finnalyCallback?.();
-      // options?.callback?.();
+
+      return await result;
     },
   });
 
-  return mutateAsync as (input: TInput) => CommandActionResult;
+  return mutation;
 }

package/src/modules/commands/lib/definitions.ts

@@ -1,4 +1,4 @@
-import { Permission } from "@/modules/auth/lib/permissions";
+import type { Permission } from "@/modules/auth/lib/permissions";
 
 /**
  * Command mode
@@ -8,7 +8,6 @@ export type CommandMode = Pick<CommandDef<never, never>, "mode">["mode"];
 /**
  * Command definition
  */
-
 export type CommandDef<TData = object, TMeta = object> = {
   name: string;
   permission?: Permission;