@tulip-systems/core 0.4.1 → 0.5.0

package/src/modules/uploads/hooks/use-upload-image.client.tsx

@@ -1,131 +0,0 @@
-import { useAction } from "@/lib/hooks/use-action";
-import { useIndicator } from "@/lib/hooks/use-indicator";
-import { arrayMove } from "@/lib/utils/array-move";
-import { DragEndEvent, UniqueIdentifier } from "@dnd-kit/core";
-import { upload } from "@vercel/blob/client";
-import { useState } from "react";
-import { toast } from "sonner";
-import { Asset } from "../entry";
-import { UploadZoneContextValue } from "./use-upload-zone.client";
-
-type ImageUpload = Pick<Asset, "pathname" | "name" | "url"> & {
-  loading?: boolean;
-};
-
-type UploadOptions<TPayload> = {
-  initial: ImageUpload[];
-  payload: TPayload;
-  handleUploadUrl: string;
-  createPathname?: (file: File) => string;
-  deleteAction: (params: { url: string }) => Promise<void>;
-  moveAction?: (params: { fromIndex: number; toIndex: number }) => Promise<void>;
-  max?: number;
-};
-
-export function useUploadImage<TPayload>({
-  max,
-  payload,
-  initial,
-  handleUploadUrl,
-  createPathname,
-  deleteAction,
-  moveAction,
-}: UploadOptions<TPayload>): UploadZoneContextValue<ImageUpload> {
-  const { status, setStatus, startTransition } = useIndicator();
-
-  const [files, setFiles] = useState<ImageUpload[]>(initial ?? []);
-
-  const disabled = files.length >= (max ?? Infinity);
-
-  /**
-   * Uploads a file
-   */
-  async function onUpload(file: File) {
-    // Check if the upload has reached the max limit
-    if (disabled) return;
-
-    // Create the pathname
-    const pathname = createPathname ? createPathname(file) : file.name;
-
-    // Add the file to the state so that it starts loading
-    const fileUrl = URL.createObjectURL(file);
-    setFiles((prev) => [...prev, { name: file.name, url: fileUrl, pathname, isLoading: true }]);
-
-    startTransition(async () => {
-      try {
-        // Create the payload
-        const basePayload = { size: file.size };
-
-        // Upload the file
-        const blob = await upload(pathname, file, {
-          access: "public",
-          handleUploadUrl,
-          clientPayload: JSON.stringify(payload ? { ...payload, ...basePayload } : basePayload),
-        });
-
-        // Find the file in the state and update it so that it stops loading and has the correct URL
-        setFiles((prev) =>
-          prev.map((file) => (file.pathname === pathname ? { ...blob, name: file.name } : file)),
-        );
-
-        toast.success(`Afbeelding ${file.name} is geüpload`);
-        setStatus("success");
-      } catch (err: unknown) {
-        console.error(err);
-        // Remove the file from the state so that it stops loading
-        setFiles((prev) => prev.filter((file) => file.pathname !== pathname));
-
-        toast.error("Error", { description: err instanceof Error ? err.message : undefined });
-        setStatus("error");
-      }
-    });
-  }
-
-  /**
-   * Delete an image
-   */
-  const deleteMutation = useAction({
-    mutationFn: deleteAction,
-    onSuccess: () => toast.success("Afbeelding is succesvol verwijderd"),
-  });
-
-  function onDelete(url: string) {
-    setFiles((prev) => prev.filter((file) => file.url !== url));
-    deleteMutation.mutate({ url });
-  }
-
-  /**
-   * Move an image
-   */
-  const moveMutation = useAction({
-    mutationFn: async (params: { activeId: UniqueIdentifier; overId: UniqueIdentifier }) => {
-      if (!moveAction) return Promise.resolve();
-
-      const fromIndex = files.findIndex((file) => file.url === params.activeId);
-      const toIndex = files.findIndex((file) => file.url === params.overId);
-
-      setFiles((prev) => arrayMove(prev, { fromIndex, toIndex }));
-      await moveAction({ fromIndex, toIndex });
-    },
-  });
-
-  function onMove({ active, over }: DragEndEvent) {
-    const activeId = active.id;
-    const overId = over?.id;
-
-    if (!activeId || !overId || activeId === overId) return;
-
-    moveMutation.mutate({ activeId, overId });
-  }
-
-  return {
-    files,
-    status,
-    disabled,
-    handleUploadUrl,
-    createPathname,
-    onUpload,
-    onDelete,
-    onMove,
-  };
-}

package/src/modules/uploads/hooks/use-upload-zone.client.ts

@@ -1,44 +0,0 @@
-import "client-only";
-
-import { IndicatorStatus } from "@/lib/hooks/use-indicator";
-import { DragEndEvent } from "@dnd-kit/core";
-import React from "react";
-
-/**
- * UploadFile
- */
-export type UploadFile = {
-  name: string;
-  url: string;
-  isLoading?: boolean;
-};
-
-/**
- * UploadZoneContextValue
- */
-export type UploadZoneContextValue<TFile extends UploadFile> = {
-  files: TFile[];
-  disabled?: boolean;
-  status: IndicatorStatus;
-  handleUploadUrl: string;
-  createPathname?: (file: File) => string;
-  onUpload: (file: File) => void;
-  onDelete: (url: string) => void;
-  onMove?: (event: DragEndEvent) => void;
-};
-
-/**
- * UploadZoneContext
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const UploadZoneContext = React.createContext({} as UploadZoneContextValue<any>);
-
-/**
- * useUploadZone
- */
-export function useUploadZone<TFile extends UploadFile>() {
-  const context = React.useContext(UploadZoneContext);
-  if (!context) throw new Error("Missing UploadZoneContext");
-
-  return context as UploadZoneContextValue<TFile>;
-}

package/src/modules/uploads/lib/constants.ts

@@ -1,10 +0,0 @@
-// Device sizes
-export const deviceSizes = [640, 750, 828, 1080, 1200, 1920, 2048, 3840] as const;
-
-// Image variants
-export const imageVariants = ["main", ...deviceSizes.map((size) => `preview-${size}` as const)] as const;
-export type ImageVariant = typeof imageVariants[number];
-
-// Image dispositions
-export const imageDispositions = ["inline", "attachment"] as const;
-export type ImageDisposition = typeof imageDispositions[number];

package/src/modules/uploads/lib/procedures.server.ts

@@ -1,332 +0,0 @@
-import { BUCKET_NAME } from "@/lib/config/constants";
-import { initRPC } from "@/modules/router/handler/init.server";
-import { ServerError } from "@/modules/router/lib/error.server";
-import { bulkActionSchema } from "@/modules/router/lib/validators";
-import { DeleteObjectsCommand, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { and, eq, inArray, isNull, sql } from "drizzle-orm";
-import { revalidatePath } from "next/cache";
-import { after } from "next/server";
-import { z } from "zod";
-import { deviceSizes } from "./constants";
-import { inferNodeSubtype, isFile, isFolder } from "./helpers";
-import { getFileUrl, getFileUrlInput } from "./proxy.server";
-import { DriveSchema, nodes } from "./schema";
-import {
-  createNodeSchema,
-  Node,
-  nodesTableFiltersSchema,
-  selectNodeSchema,
-  selectNodeWithChildrenSchema,
-} from "./validators";
-
-export function createDriveBaseProcedures() {
-  const { protectedProcedure } = initRPC<DriveSchema>();
-
-  return {
-    /**
-     * Get node and its children
-     */
-    getNodeById: protectedProcedure
-      .input(z.object({ id: z.string(), namespace: z.string() }))
-      .output(selectNodeWithChildrenSchema.optional())
-      .handler(async ({ context, input }) =>
-        context.db.query.nodes.findFirst({
-          where: and(eq(nodes.id, input.id), eq(nodes.namespace, input.namespace)),
-          with: { children: true },
-        }),
-      ),
-    /**
-     * Get folders by parent id
-     */
-    getNodesByParentId: protectedProcedure
-      .input(
-        z.object({
-          parentId: z.string().nullable(),
-          namespace: z.string(),
-          filters: nodesTableFiltersSchema,
-        }),
-      )
-      .output(z.array(selectNodeSchema))
-      .handler(async ({ context, input }) =>
-        context.db.query.nodes.findMany({
-          where: and(
-            input.parentId ? eq(nodes.parentId, input.parentId) : isNull(nodes.parentId),
-            input.filters.nodeIds ? inArray(nodes.id, input.filters.nodeIds) : undefined,
-            input.filters.types ? inArray(nodes.type, input.filters.types) : undefined,
-            eq(nodes.namespace, input.namespace),
-            eq(nodes.isDeleted, input.filters.isDeleted),
-          ),
-        }),
-      ),
-    /**
-     * Get parents of a folder
-     */
-    getFolderParents: protectedProcedure
-      .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
-      .handler(async ({ context, input }) => {
-        if (!input.id) return [];
-
-        const startNodeQuery = context.db
-          .select({
-            id: nodes.id,
-            name: nodes.name,
-            parentId: nodes.parentId,
-            depth: sql<number>`0`.as("depth"),
-          })
-          .from(nodes)
-          .where(and(eq(nodes.id, input.id), eq(nodes.namespace, input.namespace)));
-
-        const alias = "parent_nodes";
-        const parentNodesQueryAlias = startNodeQuery.as(alias);
-        const recursiveQueryName = sql.raw(`"${alias}"`);
-
-        const recursiveQuery = startNodeQuery.unionAll(
-          context.db
-            .select({
-              id: nodes.id,
-              name: nodes.name,
-              parentId: nodes.parentId,
-              depth: sql<number>`${parentNodesQueryAlias.depth} + 1`,
-            })
-            .from(nodes)
-            .innerJoin(recursiveQueryName, eq(nodes.id, parentNodesQueryAlias.parentId)),
-        );
-
-        const result = (await context.db.execute(
-          sql`WITH RECURSIVE ${recursiveQueryName} AS ${recursiveQuery}
-          SELECT * FROM ${recursiveQueryName}`,
-        )) as Awaited<ReturnType<(typeof recursiveQuery)["execute"]>>;
-
-        return result.toSorted((a, b) => Number(b.depth) - Number(a.depth));
-      }),
-    /**
-     * Get presigned url for uploading a file
-     */
-    presign: protectedProcedure
-      .input(
-        z.object({
-          id: z.string(),
-          name: z.string().min(1),
-          namespace: z.string(),
-          parentId: z.uuid().nullable(),
-          size: z.number().optional().default(0),
-          contentType: z.string().optional().default(""),
-        }),
-      )
-      .handler(async ({ context, input }) => {
-        // Generate the put command
-        const putCommand = new PutObjectCommand({
-          Bucket: BUCKET_NAME,
-          Key: `${input.id}/main`,
-          ContentType: input.contentType,
-        });
-
-        // Generate the presigned url
-        const presignedUrl = await getSignedUrl(context.blob, putCommand, { expiresIn: 3600 });
-
-        const [node] = await context.db
-          .insert(nodes)
-          .values({
-            ...input,
-            subtype: inferNodeSubtype(input),
-            isPending: true,
-            type: "file",
-          })
-          .returning();
-
-        // Return the result
-        return { node, presignedUrl };
-      }),
-    /**
-     * Confirm the upload
-     */
-    confirm: protectedProcedure
-      .input(z.object({ id: z.string() }))
-      .output(selectNodeSchema)
-      .handler(async ({ context, input }) => {
-        const [result] = await context.db
-          .update(nodes)
-          .set({ isPending: false })
-          .where(eq(nodes.id, input.id))
-          .returning();
-
-        if (!result) {
-          throw new ServerError("NOT_FOUND", { message: "File not found" });
-        }
-
-        /**
-         * Generate the preview version of the file
-         */
-        after(async () => {
-          if (!result.contentType || !result.contentType?.startsWith("image/")) return;
-
-          const getCommand = new GetObjectCommand({
-            Bucket: BUCKET_NAME,
-            Key: `${input.id}/main`,
-          });
-
-          const response = await context.blob.send(getCommand);
-          const contentType = response.ContentType;
-          if (!response.Body) {
-            throw new ServerError("INTERNAL_SERVER_ERROR", {
-              message: "Oep! Er is iets fout gegaan",
-            });
-          }
-
-          const byteArray = await response.Body.transformToByteArray();
-          const buffer = Buffer.from(byteArray);
-
-          if (contentType?.startsWith("image/")) {
-            const sharp = await import("sharp");
-
-            await Promise.allSettled(
-              deviceSizes.flatMap(async (width) => {
-                const preview = await sharp.default(buffer).resize({ width }).webp().toBuffer();
-
-                const putCommand = new PutObjectCommand({
-                  Bucket: BUCKET_NAME,
-                  Key: `${input.id}/preview-${width}`,
-                  ContentType: "image/webp",
-                  Body: preview,
-                });
-
-                await context.blob.send(putCommand);
-              }),
-            );
-          }
-        });
-
-        return result;
-      }),
-    /**
-     * Get presigned url for opening a file
-     */
-    getFileUrl: protectedProcedure
-      .input(getFileUrlInput)
-      .output(z.string())
-      .handler(async ({ context, input }) => await getFileUrl(context, input)),
-    /**
-     * Create a folder
-     */
-    createFolder: protectedProcedure
-      .input(createNodeSchema)
-      .output(selectNodeSchema)
-      .handler(async ({ context, input }) => {
-        const parent =
-          input.parentId &&
-          (await context.db.query.nodes.findFirst({
-            where: eq(nodes.id, input.parentId),
-          }));
-
-        /**
-         * Validate
-         */
-        if (input.parentId && !parent) {
-          throw new ServerError("BAD_REQUEST", { message: "Parent not found" });
-        }
-
-        if (parent && !isFolder(parent)) {
-          throw new ServerError("BAD_REQUEST", { message: "Parent is not a folder" });
-        }
-
-        if (parent && parent.namespace !== input.namespace) {
-          throw new ServerError("BAD_REQUEST", {
-            message: "Parent is not in the same namespace",
-          });
-        }
-
-        /**
-         * Create the folder
-         */
-        const [result] = await context.db
-          .insert(nodes)
-          .values({ ...input, type: "folder" } as Node)
-          .returning();
-
-        if (!result) {
-          throw new ServerError("INTERNAL_SERVER_ERROR", {
-            message: "Folder kon niet worden aangemaakt",
-          });
-        }
-
-        return result;
-      }),
-    /**
-     * Delete nodes
-     */
-    deleteNodes: protectedProcedure
-      .input(bulkActionSchema)
-      .output(z.void())
-      .handler(async ({ context, input }) => {
-        const items = await context.db
-          .select({ id: nodes.id, type: nodes.type })
-          .from(nodes)
-          .where(inArray(nodes.id, input.ids));
-
-        // Split the nodes into folders and files
-        const folders = items.filter(isFolder).map((folder) => folder.id);
-        const files = items.filter(isFile).map((file) => file.id);
-
-        // Delete command for S3
-        const deleteCommand = new DeleteObjectsCommand({
-          Bucket: BUCKET_NAME,
-          Delete: {
-            Objects: files.map((id) => ({ Key: id })),
-          },
-        });
-
-        /**
-         * Delete files
-         */
-        await Promise.allSettled([
-          context.db.delete(nodes).where(inArray(nodes.id, folders)),
-          context.db.delete(nodes).where(inArray(nodes.id, files)),
-          context.blob.send(deleteCommand),
-        ]);
-      }),
-    /**
-     * Change node parent
-     */
-    changeParent: protectedProcedure
-      .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
-      .handler(async ({ context, input }) => {
-        const [parent, node] = await Promise.all([
-          input.parentId &&
-            (await context.db.query.nodes.findFirst({
-              where: eq(nodes.id, input.parentId),
-            })),
-          context.db.query.nodes.findFirst({
-            where: eq(nodes.id, input.id),
-          }),
-        ]);
-
-        /**
-         * Validate
-         */
-        if (input.parentId && !parent)
-          throw new ServerError("BAD_REQUEST", { message: "Parent not found" });
-        if (!node) throw new ServerError("BAD_REQUEST", { message: "Node not found" });
-
-        if (parent && !isFolder(parent)) {
-          throw new ServerError("BAD_REQUEST", { message: "Parent is not a folder" });
-        }
-
-        if (parent && parent.namespace !== node.namespace) {
-          throw new ServerError("BAD_REQUEST", {
-            message: "Parent is not in the same namespace",
-          });
-        }
-
-        /**
-         * Update the parent
-         */
-        await context.db
-          .update(nodes)
-          .set({ parentId: input.parentId })
-          .where(eq(nodes.id, input.id));
-
-        revalidatePath("/drive", "page");
-      }),
-  };
-}

package/src/modules/uploads/lib/proxy.server.ts

@@ -1,139 +0,0 @@
-import "server-cli-only";
-
-import { BUCKET_NAME } from "@/lib/config/constants";
-import { getSession } from "@/modules/auth/entry.server";
-import { TulipContext } from "@/modules/config/entry";
-import { GetObjectCommand } from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { addSeconds } from "date-fns";
-import { and, eq } from "drizzle-orm";
-import { after, connection, NextRequest } from "next/server";
-import { z } from "zod";
-import { imageDispositions, imageVariants } from "./constants";
-import { DriveSchema, nodePresignedUrls, nodes } from "./schema";
-import { Node } from "./validators";
-
-/**
- * Get file url schema
- */
-export const getFileUrlInput = z.object({
-  variant: z.enum(imageVariants).optional().default("main"),
-  disposition: z.enum(imageDispositions).optional().default("inline"),
-});
-
-export type GetFileUrlInput = z.input<typeof getFileUrlInput>;
-export type GetFileUrlSchema = z.infer<typeof getFileUrlInput>;
-
-/**
- * Get file url
- */
-export async function getFileUrl<TSchema extends DriveSchema>(
-  ctx: TulipContext<TSchema>,
-  { input, node }: { input: GetFileUrlSchema; node: Node },
-  // input: GetFileUrlSchema,
-) {
-  // const [node] = await ctx.db.select().from(nodes).where(eq(nodes.id, input.id));
-  // if (!node) {
-  //   throw new ServerError("NOT_FOUND", { message: "Bestand kon niet worden gevonden" });
-  // }
-
-  const [presignedUrl] = await ctx.db
-    .select({ url: nodePresignedUrls.url, expiresAt: nodePresignedUrls.expiresAt })
-    .from(nodePresignedUrls)
-    .where(
-      and(
-        eq(nodePresignedUrls.nodeId, node.id),
-        eq(nodePresignedUrls.variant, input.variant),
-        eq(nodePresignedUrls.disposition, input.disposition),
-      ),
-    );
-
-  if (presignedUrl && presignedUrl.expiresAt > new Date()) return presignedUrl.url;
-
-  const expiresIn = 3600 * 24;
-
-  // Generate the get command
-  const getCommand = new GetObjectCommand({
-    Bucket: BUCKET_NAME,
-    Key: `${node.id}/${input.variant}`,
-    ResponseContentDisposition: `${input.disposition}; filename="${node.name}"`,
-    ResponseContentType: node.contentType ?? undefined,
-  });
-
-  // Generate the presigned url that expires in 24 hours
-  const url = await getSignedUrl(ctx.blob, getCommand, { expiresIn });
-
-  // Add the presigned url to the database
-  after(async () => {
-    await ctx.db
-      .insert(nodePresignedUrls)
-      .values({
-        nodeId: node.id,
-        url,
-        variant: input.variant,
-        disposition: input.disposition,
-        expiresAt: addSeconds(new Date(), expiresIn),
-      })
-      .onConflictDoUpdate({
-        target: [
-          nodePresignedUrls.nodeId,
-          nodePresignedUrls.variant,
-          nodePresignedUrls.disposition,
-        ],
-        set: { url, expiresAt: addSeconds(new Date(), expiresIn) },
-      });
-  });
-
-  return url;
-}
-
-/**
- * Create drive proxy route
- */
-export function createDriveProxyRoute<TSchema extends DriveSchema>({
-  context,
-}: {
-  context: TulipContext<TSchema>;
-}) {
-  /**
-   * GET: Drive node proxy
-   */
-  async function GET(request: NextRequest) {
-    // Make endpoint dynamic
-    await connection();
-
-    try {
-      // Get the params
-      const searchParams = request.nextUrl.searchParams;
-      const id = searchParams.get("id");
-      if (!id) return Response.json("Missing id", { status: 400 });
-
-      // Get the node
-      const [node] = await context.db.select().from(nodes).where(eq(nodes.id, id));
-      if (!node) return Response.json("Bestand kon niet worden gevonden", { status: 404 });
-
-      // If the node is private check if the user is authenticated
-      if (node.mode === "private") {
-        const session = await getSession(context);
-        if (!session) return Response.json("Unauthorized", { status: 401 });
-      }
-
-      const variant = searchParams.get("variant") ?? undefined;
-      const disposition = searchParams.get("disposition") ?? undefined;
-
-      // Parse the input
-      const input = getFileUrlInput.parse({ variant, disposition });
-
-      // Get the file url
-      const url = await getFileUrl(context, { input, node });
-
-      // Return the file
-      return Response.redirect(url, 307);
-    } catch (error) {
-      console.error("error", error);
-      return Response.json("Error", { status: 500 });
-    }
-  }
-
-  return { GET };
-}