@tulip-systems/core 0.7.0 → 0.8.0

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

@@ -1,182 +0,0 @@
-import { and, eq, sql } from "drizzle-orm";
-import type { QueryResult } from "pg";
-import { z } from "zod";
-import { bulkActionSchema } from "@/modules/router/entry";
-import { ServerError } from "@/modules/router/entry.server";
-import { initRPC } from "@/modules/router/handler/init.server";
-import { isFolder } from "./helpers";
-import { type DriveSchema, nodes } from "./schema";
-import {
-  createFolderNodeSchema,
-  getFileURLSchema,
-  getNodesByParentIdSchema,
-  type Node,
-  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 QueryResult<Pick<Node, "id" | "name" | "parentId"> & { depth: number }>;
-
-        return result?.rows?.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)
-      .output(z.object({ id: z.string(), presignedUrl: z.string() }))
-      .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)),
-  };
-}