@tulip-systems/core 0.4.1 → 0.5.1

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

@@ -0,0 +1,63 @@
+import "server-cli-only";
+
+import { getSession } from "@/modules/auth/entry.server";
+import { TulipContext } from "@/modules/config/entry";
+import { eq } from "drizzle-orm";
+import { connection, NextRequest } from "next/server";
+import { DriveSchema, nodes } from "./schema";
+import { getFileURLSchema } from "./validators";
+
+type CreateDriveProxyRouteProps<TSchema extends DriveSchema> = {
+  context: TulipContext<TSchema>;
+};
+
+/**
+ * Create drive proxy route
+ */
+export function createDriveProxyRoute<TSchema extends DriveSchema>({
+  context,
+}: CreateDriveProxyRouteProps<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 });
+
+      console.info("Proxying file: ", id);
+
+      // 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 options
+      const options = getFileURLSchema.parse({ variant, disposition });
+
+      // Get the file url
+      const url = await context.storage.getSignedURL(node, options);
+
+      // 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/storage/lib/router.server.ts

@@ -0,0 +1,180 @@
+import { bulkActionSchema } from "@/modules/router/entry";
+import { ServerError } from "@/modules/router/entry.server";
+import { initRPC } from "@/modules/router/handler/init.server";
+import { and, eq, sql } from "drizzle-orm";
+import { z } from "zod";
+import { isFolder } from "./helpers";
+import { DriveSchema, nodes } from "./schema";
+import {
+  createFolderNodeSchema,
+  getFileURLSchema,
+  getNodesByParentIdSchema,
+  presignFileSchema,
+  selectNodeSchema,
+  selectNodeWithChildrenSchema,
+  updateNodeSchema,
+} from "./validators";
+
+/**
+ * Create Drive base procedures
+ */
+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(getNodesByParentIdSchema)
+      .output(z.array(selectNodeSchema))
+      .handler(async ({ context, input }) => context.storage.getNodesByParentId(input)),
+    /**
+     * 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 opening a file
+     */
+    getSignedURL: protectedProcedure
+      .input(getFileURLSchema.extend({ id: z.string() }))
+      .output(z.string().nullable())
+      .handler(async ({ context, input: { id, ...options } }) => {
+        const [node] = await context.db.select().from(nodes).where(eq(nodes.id, id));
+        if (!node) return null;
+
+        return await context.storage.getSignedURL(node, options);
+      }),
+
+    /**
+     * Get presigned url for uploading a file
+     */
+    presign: protectedProcedure
+      .input(presignFileSchema)
+      .handler(async ({ context, input }) => context.storage.presignUpload(input)),
+    /**
+     * Confirm the upload
+     */
+    confirm: protectedProcedure
+      .input(z.object({ id: z.string() }))
+      .output(selectNodeSchema)
+      .handler(async ({ context, input }) => context.storage.confirmUpload(input)),
+    /**
+     * Create a folder
+     */
+    createFolder: protectedProcedure
+      .input(createFolderNodeSchema)
+      .output(selectNodeSchema)
+      .handler(async ({ context, input }) => context.storage.createFolder(input)),
+    /**
+     * Update node
+     */
+    updateNode: protectedProcedure
+      .input(z.object({ id: z.string(), data: updateNodeSchema }))
+      .output(selectNodeSchema)
+      .handler(async ({ context, input }) => context.storage.updateNode(input)),
+    /**
+     * 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 (node?.readonly) {
+          throw new ServerError("BAD_REQUEST", {
+            message: "Deze node is alleen leesbaar en kan niet worden gewijzigd",
+          });
+        }
+
+        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));
+      }),
+    /**
+     * Delete nodes
+     */
+    deleteNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.void())
+      .handler(async ({ context, input }) => context.storage.deleteNodes(input)),
+  };
+}

package/src/modules/{uploads → storage}/lib/schema.ts

@@ -21,7 +21,7 @@ export const nodes = pgTable("nodes", (t) => ({
   size: t.integer().default(0),
   contentType: t.varchar({ length: 255 }),
   readonly: boolean().default(false),
-  createdBy: t.text().references(() => users.id, { onDelete: "set null" }),
+  createdBy: t.uuid().references(() => users.id, { onDelete: "set null" }),
   isPending: t.boolean().default(false).notNull(),
   isDeleted: t.boolean().default(false).notNull(),
   parentId: t.uuid().references((): AnyPgColumn => nodes.id, { onDelete: "cascade" }),
@@ -37,6 +37,28 @@ export const nodesRelations = relations(nodes, ({ one, many }) => ({
     relationName: "parent",
   }),
   urls: many(nodePresignedUrls),
+  variants: many(nodeVariants),
+}));
+
+/**
+ * Node variants table
+ */
+export const nodeVariants = pgTable("node_variants", (t) => ({
+  ...baseColumns,
+  nodeId: t
+    .uuid()
+    .notNull()
+    .references(() => nodes.id, { onDelete: "cascade" }),
+  variant: t.text({ enum: imageVariants }).notNull(),
+  width: t.integer().notNull(),
+}));
+
+export const nodeVariantsRelations = relations(nodeVariants, ({ one }) => ({
+  node: one(nodes, {
+    fields: [nodeVariants.nodeId],
+    references: [nodes.id],
+    relationName: "node",
+  }),
 }));
 
 /**
@@ -54,6 +76,7 @@ export const nodePresignedUrls = pgTable(
       .uuid()
       .notNull()
       .references(() => nodes.id, { onDelete: "cascade" }),
+    variantId: t.uuid().references(() => nodeVariants.id, { onDelete: "set null" }),
   }),
   (t) => [unique("node_presigned_url_unique").on(t.nodeId, t.variant, t.disposition)],
 );
@@ -67,16 +90,14 @@ export const nodePresignedUrlsRelations = relations(nodePresignedUrls, ({ one })
 }));
 
 /**
- * @deprecated
- */
-export const assets = pgTable("assets", (t) => ({
-  ...baseColumns,
-  name: t.text().notNull(),
-  pathname: t.text().notNull(),
-  url: t.text().notNull().unique(),
-  size: t.integer().default(0),
-  contentType: t.varchar({ length: 255 }),
-}));
-
-const driveSchema = { nodes, nodesRelations };
+ * Drive schema
+ **/
+const driveSchema = {
+  nodes,
+  nodesRelations,
+  nodeVariants,
+  nodeVariantsRelations,
+  nodePresignedUrls,
+  nodePresignedUrlsRelations,
+};
 export type DriveSchema = typeof driveSchema;