@tulip-systems/core 0.4.0 → 0.5.0

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

@@ -1,95 +0,0 @@
-"use client";
-
-import { useAction } from "@/lib/hooks/use-action";
-import { MutationOptions } from "@tanstack/react-query";
-import { toast } from "sonner";
-import { useCommand } from "./context.client";
-
-export type CommandActionResult = Promise<unknown>;
-
-export type CommandAction<TInput = void> = (input: TInput) => CommandActionResult;
-export type BulkCommandAction = (params: { ids: string[] }) => CommandActionResult;
-
-/**
- * Hook to use command
- * @returns Command context value
- */
-export function useCommandAction<TInput = void>(
-  action: CommandAction<TInput>,
-  options?: {
-    message?: string;
-    onSuccess?: () => Promise<void> | void;
-    onError?: () => Promise<void> | void;
-  },
-) {
-  const commandContext = useCommand();
-
-  const { mutateAsync } = useAction({
-    mutationFn: action,
-    onMutate: () => {
-      commandContext.setStatus("pending");
-    },
-    onSuccess: async () => {
-      commandContext.setStatus("success");
-      toast.success(options?.message || "Actie voltooid!");
-      await options?.onSuccess?.();
-      await commandContext.onSuccess?.();
-    },
-    onRedirect: async () => {
-      commandContext.setStatus("success");
-      toast.success(options?.message || "Actie voltooid!");
-      await options?.onSuccess?.();
-      await commandContext.onSuccess?.();
-    },
-    onError: async () => {
-      commandContext.setStatus("error");
-      await options?.onError?.();
-      await commandContext.onError?.();
-    },
-    onSettled: () => {
-      commandContext.setStatus("idle");
-      // finnalyCallback?.();
-      // options?.callback?.();
-    },
-  });
-
-  return mutateAsync as (input: TInput) => CommandActionResult;
-}
-
-export function useCommandAction2<TInput = void>(
-  // action: CommandAction<TInput>,
-  options?: MutationOptions,
-) {
-  const commandContext = useCommand();
-
-  const { mutateAsync } = useAction({
-    ...options,
-    onMutate: () => {
-      commandContext.setStatus("pending");
-    },
-    onSuccess: async (...params) => {
-      commandContext.setStatus("success");
-      // toast.success(options?.message || "Actie voltooid!");
-      await options?.onSuccess?.(...params);
-      await commandContext.onSuccess?.();
-    },
-    // onRedirect: async () => {
-    //   commandContext.setStatus("success");
-    //   toast.success(options?.message || "Actie voltooid!");
-    //   await options?.onSuccess?.();
-    //   await commandContext.onSuccess?.();
-    // },
-    onError: async (...params) => {
-      commandContext.setStatus("error");
-      await options?.onError?.(...params);
-      await commandContext.onError?.();
-    },
-    onSettled: () => {
-      commandContext.setStatus("idle");
-      // finnalyCallback?.();
-      // options?.callback?.();
-    },
-  });
-
-  return mutateAsync as (input: TInput) => CommandActionResult;
-}

package/src/modules/config/lib/config.server.ts

@@ -1,39 +0,0 @@
-import "server-cli-only";
-
-import { createAccessControl, Role } from "@/modules/auth/lib/permissions";
-import { TDatabaseSchema } from "@/modules/config/db/types";
-import { S3ClientConfig } from "@aws-sdk/client-s3";
-
-export type TulipConfig<TSchema extends TDatabaseSchema> = {
-  general: {
-    name: string;
-    shortName: string;
-  };
-  // paths: PathConfig;
-  database: {
-    schema: TSchema;
-    pool: {
-      connectionString: string;
-      max?: number;
-    };
-  };
-  auth: {
-    ac: ReturnType<typeof createAccessControl>;
-    roles: {
-      [key in string]?: Role;
-    };
-  };
-  email: {
-    key: string;
-    from: string;
-  };
-  uploads: S3ClientConfig;
-};
-
-/**
- * Build the Tulip config
- */
-
-export const defineConfig = <TSchema extends TDatabaseSchema>(
-  config: TulipConfig<TSchema>,
-): TulipConfig<TSchema> => config;

package/src/modules/config/lib/resolve.server.ts

@@ -1,75 +0,0 @@
-import "server-cli-only";
-
-import { createServerAuth } from "@/modules/auth/handler/server.server";
-import { createDatabaseClient } from "@/modules/config/db/create-client";
-import { TDatabaseSchema } from "@/modules/config/db/types";
-import { S3Client } from "@aws-sdk/client-s3";
-import { cache } from "react";
-import { Resend } from "resend";
-import { TulipConfig } from "./config.server";
-
-/**
- * Get the Tulip provider
- */
-export type GetTulipParams<TSchema extends TDatabaseSchema> = {
-  config: TulipConfig<TSchema>;
-};
-
-export type GetTulipReturn<TSchema extends TDatabaseSchema> = Awaited<
-  ReturnType<typeof getTulip<TSchema>>
->;
-
-/**
- * Get the Tulip provider
- */
-export const getTulip = cache(
-  async <TSchema extends TDatabaseSchema>(params: GetTulipParams<TSchema>) => {
-    const { general, paths, database, email, uploads } = params.config;
-
-    const { schema } = database;
-
-    /**
-     * Create a database client
-     */
-    const db = createDatabaseClient<TSchema>(database);
-
-    /**
-     * Email provider
-     */
-    const resend = new Resend(email.key);
-
-    /**
-     * Auth provider
-     */
-    const auth = createServerAuth({
-      auth: params.config.auth,
-      db,
-      schema,
-      email,
-      resend,
-    });
-
-    /**
-     * S3 client
-     */
-    const blob = new S3Client(uploads);
-
-    /**
-     * Session
-     */
-    // const headers = new Headers(await headersList());
-    // const session = await auth.api.getSession({ headers });
-
-    return {
-      general,
-      paths,
-      // headers,
-      // session,
-      schema,
-      db,
-      auth,
-      resend,
-      blob,
-    };
-  },
-);

package/src/modules/config/lib/router.server.ts

@@ -1,64 +0,0 @@
-// import { initRPC } from "../entry.server";
-
-// export function createBaseRouter() {
-//   const { protectedProcedure } = initRPC();
-
-//   return {
-//     /**
-//      * Get paths
-//      */
-//     getPaths: protectedProcedure.handler(async ({ context }) => {
-//       /**
-//        * Initialise the paths by executing the path functions
-//        */
-//       const resolvedPaths = await Promise.all(
-//         context.paths.map(async (group) => {
-//           /**
-//            * Initialise the path by executing the path function
-//            */
-//           const initialisedPaths = await Promise.all(group.items.map((path) => path()));
-
-//           /**
-//            * Filter out paths that the user doesn't have permission for
-//            */
-//           const validatedPaths = await Promise.all(
-//             initialisedPaths.map(async (path) => {
-//               if (!path.permission) return path;
-
-//               const hasPermission = await context.auth.api.userHasPermission({
-//                 body: {
-//                   permission: path.permission,
-//                   userId: context.session.user?.id,
-//                 },
-//               });
-//               if (!hasPermission.success) return null;
-
-//               return path;
-//             }),
-//           );
-
-//           // /**
-//           //  * Resolve the icon component
-//           //  */
-//           // const resolvedPaths = validatedPaths
-//           //   .filter((path) => !!path)
-//           //   .map((path) => {
-//           //     return {
-//           //       ...path,
-//           //       icon: path.icon ? createElement(path.icon) : undefined,
-//           //     };
-//           //   });
-
-//           const items = validatedPaths.filter((path) => !!path);
-
-//           return { ...group, items };
-//         }),
-//       );
-
-//       /**
-//        * Filter out empty groups
-//        */
-//       return resolvedPaths.filter((group) => group.items.length > 0);
-//     }),
-//   };
-// }

package/src/modules/config/router/client.server.tsx

@@ -1,57 +0,0 @@
-import "server-cli-only";
-
-import { AnyRouter, createRouterClient } from "@orpc/server";
-import { dehydrate, HydrationBoundary } from "@tanstack/react-query";
-import { cache } from "react";
-import { createQueryClient } from "./query-client";
-
-/**
- *  Create a stable getter for the query client that will return the same client during the same request.
- */
-export const getQueryClient = cache(createQueryClient);
-
-/**
- * Hydrate the client with the data from the server
- */
-export function HydrateClient(props: { children: React.ReactNode }) {
-  const queryClient = getQueryClient();
-
-  return <HydrationBoundary state={dehydrate(queryClient)}>{props.children}</HydrationBoundary>;
-}
-
-/**
- * Initialize the server client
- */
-export function createRPCServerClient<TRouter extends AnyRouter>(appRouter: TRouter) {
-  return createRouterClient(appRouter, { context: {} as any });
-}
-
-// /**
-//  * Prefetch a single query
-//  */
-// export function prefetchQuery<T extends QueryOptionsBase<unknown, unknown>>(queryOptions: T) {
-//   const queryClient = getQueryClient();
-//   void queryClient.prefetchQuery(queryOptions);
-// }
-
-// export function prefetchInfiniteQuery<
-//   T extends FetchInfiniteQueryOptions<unknown, unknown, unknown>,
-// >(queryOptions: T) {
-//   const queryClient = getQueryClient();
-//   void queryClient.prefetchInfiniteQuery(queryOptions);
-// }
-
-// /**
-//  * Prefetch multiple queries
-//  */
-// export function batchPrefetch<T extends ReturnType<TRPCQueryOptions<any>>>(queryOptionsArray: T[]) {
-//   const queryClient = getQueryClient();
-
-//   for (const queryOptions of queryOptionsArray) {
-//     if (queryOptions.queryKey[1]?.type === "infinite") {
-//       void queryClient.prefetchInfiniteQuery(queryOptions as any);
-//     } else {
-//       void queryClient.prefetchQuery(queryOptions);
-//     }
-//   }
-// }

package/src/modules/config/router/client.tsx

@@ -1,31 +0,0 @@
-"use client";
-
-import { createORPCClient } from "@orpc/client";
-import { RPCLink } from "@orpc/client/fetch";
-import { AnyRouter, RouterClient } from "@orpc/server";
-import { createTanstackQueryUtils } from "@orpc/tanstack-query";
-
-/**
- * Create a new RPC link
- */
-const link = new RPCLink({
-  url: () => {
-    if (typeof window === "undefined") {
-      throw new Error("RPCLink is not allowed on the server side.");
-    }
-
-    return `${window.location.origin}/api/rpc`;
-  },
-});
-
-/**
- * Create a new RPC client
- */
-const client: RouterClient<AnyRouter> = createORPCClient(link);
-
-/**
- * Create a new RPC client
- */
-export function createRPCClient<TRouter extends AnyRouter>() {
-  return createTanstackQueryUtils(client as RouterClient<TRouter>);
-}

package/src/modules/config/router/context.server.ts

@@ -1,29 +0,0 @@
-import "server-cli-only";
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { type TDatabaseSchema } from "@/modules/config/db/types";
-import { getTulip, GetTulipParams } from "@/modules/config/lib/resolve.server";
-import { headers as headersList } from "next/headers";
-import { cache } from "react";
-
-/**
- * Create the router context
- */
-export const createRPCContext = cache(
-  async <TSchema extends TDatabaseSchema>(params: GetTulipParams<TSchema>) => {
-    const tulip = await getTulip(params);
-    const headers = await headersList();
-    const session = await tulip.auth.api.getSession({ headers });
-
-    return { ...tulip, session, headers };
-  },
-);
-
-export type RPCContext<TSchema extends TDatabaseSchema = any> = Awaited<
-  ReturnType<typeof createRPCContext<TSchema>>
->;
-
-export type ProtectedRPCContext<TSchema extends TDatabaseSchema = any> = RPCContext<TSchema> & {
-  session: NonNullable<RPCContext<TSchema>["session"]>;
-};

package/src/modules/config/router/init.server.ts

@@ -1,77 +0,0 @@
-import "server-cli-only";
-
-import { Permission } from "@/modules/auth/lib/permissions";
-import { os } from "@orpc/server";
-import { TDatabaseSchema } from "../entry";
-import { ProtectedRPCContext, RPCContext } from "./context.server";
-import { ServerError } from "./error.server";
-
-/**
- * Initialize TRPC
- */
-export function initRPC<TSchema extends TDatabaseSchema>() {
-  /**
-   * Create the router
-   */
-  const o = os.$context<RPCContext<TSchema>>();
-
-  /**
-   * Middleware function to check if the user is authenticated
-   */
-  const authMiddleware = o.middleware(async (opts) => {
-    if (!opts.context.session) {
-      throw new ServerError("UNAUTHORIZED", {
-        message: "Jou hebt geen toegang om deze actie uit te voeren",
-      });
-    }
-
-    return opts.next({
-      context: { ...opts.context, session: opts.context.session } as ProtectedRPCContext<TSchema>,
-    });
-  });
-
-  /**
-   * Middleware function to check if the user has the required permission
-   */
-  function permissionMiddleware(permission: Permission) {
-    /**
-     * Middleware function to check if the user has the required permission
-     */
-    return os.$context<ProtectedRPCContext<TSchema>>().middleware(async (opts) => {
-      const { success, error } = await opts.context.auth.api.userHasPermission({
-        body: {
-          userId: opts.context.session.user.id,
-          permission,
-        },
-      });
-
-      if (error || !success) {
-        throw new ServerError("UNAUTHORIZED", {
-          message: "Jou hebt geen toegang om deze actie uit te voeren",
-        });
-      }
-
-      return opts.next({ context: { ...opts.context } as ProtectedRPCContext<TSchema> });
-    });
-  }
-
-  /**
-   * Public procedures
-   */
-  const publicProcedure = o;
-
-  /**
-   * Protected procedures
-   */
-  const protectedProcedure = o.use(authMiddleware);
-
-  /**
-   * Export
-   */
-  return {
-    publicProcedure,
-    protectedProcedure,
-    authMiddleware,
-    permissionMiddleware,
-  };
-}

package/src/modules/inline-edit/components/richtext.client.tsx

@@ -1,36 +0,0 @@
-"use client";
-
-import { EditorContextProvider } from "@/components/editor/context.client";
-import { Editor } from "@/components/editor/index.client";
-import { Input } from "@/components/ui/input";
-import { ComponentProps, useEffect } from "react";
-import { useDebounce } from "use-debounce";
-import { useInlineEdit, type useInlineEditOptions } from "../hooks/use-inline.client";
-
-export function InlineRichtext({
-  initialValue,
-  action,
-  ...props
-}: Omit<ComponentProps<typeof Input>, "type"> & useInlineEditOptions<string>) {
-  const { value, setValue, handleUpdate } = useInlineEdit<string>({
-    initialValue,
-    action,
-  });
-
-  const [debouncedValue] = useDebounce(value, 500);
-
-  useEffect(() => {
-    if (!value) return;
-    handleUpdate(value);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [debouncedValue]);
-
-  return (
-    <EditorContextProvider
-      value={value ? JSON.parse(value) : undefined}
-      onChange={(value) => setValue(JSON.stringify(value))}
-    >
-      <Editor {...props} />
-    </EditorContextProvider>
-  );
-}

package/src/modules/uploads/components/button.client.tsx

@@ -1,29 +0,0 @@
-"use client";
-
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { cn } from "@/lib/utils/cn";
-import { UploadIcon } from "lucide-react";
-import { ComponentProps } from "react";
-import { useUploadZone } from "../hooks/use-upload-zone.client";
-
-export function UploadButton({ className, ...props }: ComponentProps<typeof Button>) {
-  const { onUpload } = useUploadZone();
-
-  return (
-    <Button {...props} className={cn("relative gap-2", className)}>
-      <UploadIcon className="h-3 w-3" />
-      <span>Upload</span>
-
-      <Input
-        type="file"
-        className="absolute inset-0 z-10 h-full w-full cursor-pointer opacity-0"
-        multiple
-        onChange={(e) => {
-          if (!e.target.files) return;
-          Array.from(e.target.files).forEach(onUpload);
-        }}
-      />
-    </Button>
-  );
-}