@tulip-systems/core 0.2.0

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

@@ -0,0 +1,66 @@
+import { GetFileUrlInput } from "./proxy.server";
+import { FileNode, Node } from "./validators";
+
+/**
+ * Check if the node is a file
+ */
+export function isFile(node: Pick<Node, "type">): node is Node {
+  return node.type === "file";
+}
+
+/**
+ * Check if the node is a folder
+ */
+export function isFolder(node: Pick<Node, "type">): node is Node {
+  return node.type === "folder";
+}
+
+/**
+ * Get file url
+ */
+export function getFileUrl(
+  id: string,
+  { variant, disposition }: Pick<GetFileUrlInput, "variant" | "disposition"> = {},
+) {
+  const searchParams = new URLSearchParams();
+  searchParams.set("id", id);
+  if (variant) searchParams.set("variant", variant);
+  if (disposition) searchParams.set("disposition", disposition);
+
+  return `/api/drive/files?${searchParams.toString()}`;
+}
+
+/**
+ * Node subtype
+ */
+export const nodeSubtypes = [
+  "image",
+  "document",
+  "spreadsheet",
+  "video",
+  "audio",
+  "archive",
+  "other",
+] as const;
+
+export type NodeSubtype = (typeof nodeSubtypes)[number];
+
+export function inferNodeSubtype({
+  name,
+  contentType,
+}: Pick<FileNode, "name" | "contentType">): NodeSubtype {
+  if (contentType?.startsWith("image/")) return "image";
+  if (contentType === "application/pdf") return "document";
+  if (contentType?.includes("spreadsheet")) return "spreadsheet";
+  if (contentType?.startsWith("video/")) return "video";
+  if (contentType?.startsWith("audio/")) return "audio";
+  if (contentType?.includes("zip") || contentType?.includes("archive")) return "archive";
+
+  const ext = name.split(".").pop()?.toLowerCase();
+  if (["jpg", "jpeg", "png", "gif", "bmp", "webp"].includes(ext ?? "")) return "image";
+  if (["pdf", "doc", "docx", "txt"].includes(ext ?? "")) return "document";
+  if (["xls", "xlsx", "ods"].includes(ext ?? "")) return "spreadsheet";
+  if (["zip", "rar", "7z"].includes(ext ?? "")) return "archive";
+
+  return "other";
+}

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

@@ -0,0 +1,131 @@
+import "server-cli-only";
+
+import { BUCKET_NAME } from "@/lib/config/constants";
+import { getSession } from "@/modules/auth/entry.server";
+import { ServerError } from "@/modules/config/entry.server";
+import { getTulip, GetTulipParams, GetTulipReturn } from "@/modules/config/lib/resolve.server";
+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, NextRequest } from "next/server";
+import { z } from "zod";
+import { imageDispositions, imageVariants } from "./constants";
+import { DriveSchema, nodePresignedUrls, nodes } from "./schema";
+
+/**
+ * Get file url schema
+ */
+export const getFileUrlInput = z.object({
+  id: z.string(),
+  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: GetTulipReturn<TSchema>,
+  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>({
+  config,
+}: GetTulipParams<TSchema>) {
+  /**
+   * GET: Drive node proxy
+   */
+  async function GET(request: NextRequest) {
+    try {
+      // Get tulip
+      const tulip = await getTulip({ config });
+
+      // Check if the user is authenticated
+      const session = await getSession(tulip);
+      if (!session) return Response.json("Unauthorized", { status: 401 });
+
+      // Get the params
+      const searchParams = request.nextUrl.searchParams;
+      const id = searchParams.get("id");
+      if (!id) return Response.json("Missing id", { status: 400 });
+
+      const variant = searchParams.get("variant") ?? undefined;
+      const disposition = searchParams.get("disposition") ?? undefined;
+
+      // Parse the input
+      const input = getFileUrlInput.parse({ id, variant, disposition });
+
+      // Get the file url
+      const url = await getFileUrl(tulip, input);
+
+      // Return the file
+      return Response.redirect(url, 307);
+    } catch (error) {
+      console.error("error", error);
+      return Response.json("Error", { status: 500 });
+    }
+  }
+
+  return { GET };
+}

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

@@ -0,0 +1,95 @@
+import "server-cli-only";
+
+import { TDatabaseSchema } from "@/modules/config/db/types";
+import { TulipConfig } from "@/modules/config/entry.server";
+import { getTulip, GetTulipReturn } from "@/modules/config/lib/resolve.server";
+import { del } from "@vercel/blob";
+import { handleUpload, HandleUploadBody } from "@vercel/blob/client";
+import { eq } from "drizzle-orm";
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { assets } from "./schema";
+import { Asset } from "./validators";
+
+type HandleAssetUploadOptions<TSchema extends TDatabaseSchema, TPayload> = {
+  schema: z.ZodSchema<TPayload>;
+  allowedContentTypes?: string[];
+  onBeforeGenerateTokenCallback?: (values: {
+    payload: TPayload;
+    ctx: GetTulipReturn<TSchema>;
+  }) => Promise<void>;
+  onUploadCompletedCallback?: (values: {
+    payload: TPayload;
+    asset: Asset;
+    ctx: GetTulipReturn<TSchema>;
+  }) => Promise<void>;
+};
+
+/**
+ * @deprecated
+ */
+export function handleUploadRoute<TSchema extends TDatabaseSchema, TPayload>(
+  config: TulipConfig<TSchema>,
+  { allowedContentTypes, schema, ...options }: HandleAssetUploadOptions<TSchema, TPayload>,
+) {
+  async function POST(request: NextRequest) {
+    const ctx = await getTulip({ config });
+    const body = (await request.json()) as HandleUploadBody;
+
+    try {
+      const jsonResponse = await handleUpload({
+        body,
+        request,
+        onBeforeGenerateToken: async (pathname: string, clientPayload: string | null) => {
+          const payload = clientPayload ? JSON.parse(clientPayload) : {};
+          const validPayload = schema.safeParse(payload);
+
+          if (!validPayload.success) {
+            console.error("Invalid payload", validPayload.error);
+            throw new Error("Invalid payload");
+          }
+
+          await options.onBeforeGenerateTokenCallback?.({ payload: validPayload.data, ctx });
+
+          return {
+            allowedContentTypes,
+            tokenPayload: JSON.stringify(validPayload.data),
+          };
+        },
+        onUploadCompleted: async ({ blob, tokenPayload }) => {
+          const parsedPayload = tokenPayload ? JSON.parse(tokenPayload) : {};
+
+          try {
+            const { pathname, url, contentType } = blob;
+            const payload = schema.parse(parsedPayload);
+
+            const name = pathname.split("/").pop() as string;
+
+            const [asset] = await ctx.db
+              .insert(assets)
+              .values({ name, pathname, url, contentType })
+              .returning();
+
+            if (!asset) throw new Error("Could not create asset");
+
+            await options.onUploadCompletedCallback?.({ payload, asset, ctx });
+          } catch (error) {
+            console.error("error", error);
+            // Delete the blob and the asset on error
+            await Promise.all([
+              del(blob.url),
+              ctx.db.delete(assets).where(eq(assets.url, blob.url)),
+            ]);
+            throw new Error("Could not update post");
+          }
+        },
+      });
+
+      return NextResponse.json(jsonResponse);
+    } catch (error) {
+      return NextResponse.json({ error: (error as Error).message }, { status: 400 });
+    }
+  }
+
+  return { POST };
+}

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

@@ -0,0 +1,340 @@
+import { BUCKET_NAME } from "@/lib/config/constants";
+import { initRPC } from "@/modules/config/entry.server";
+import { RPCContext } from "@/modules/config/router/context.server";
+import { ServerError } from "@/modules/config/router/error.server";
+import { bulkActionSchema } from "@/modules/config/router/validators";
+import { DeleteObjectsCommand, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { type AnyContractRouter } from "@orpc/contract";
+import { Router } from "@orpc/server";
+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 createDriveRouter<TExtendedInput extends Router<AnyContractRouter, RPCContext>>(
+  extendedInput: TExtendedInput = {} as TExtendedInput,
+) {
+  const { protectedProcedure } = initRPC<DriveSchema>();
+  // const rpc = os.$context<ProtectedRPCContext<DriveSchema>>()
+
+  // const  = rpc.router;
+  // const protectedProcedure = rpc.use(authMiddleware<DriveSchema>());
+
+  return {
+    ...extendedInput,
+    /**
+     * 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),
+            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");
+      }),
+  };
+}