@tulip-systems/drive 0.7.0

package/src/providers/local/lib/route-handler.server.ts

@@ -0,0 +1,153 @@
+import { getSession } from "@tulip-systems/core/auth/server";
+import type { TDatabaseSchema, TulipContext } from "@tulip-systems/core/config";
+import { ServerError } from "@tulip-systems/core/router/server";
+import { connection, type NextRequest } from "next/server";
+import z from "zod";
+import type { LocalDrive } from "./service.server";
+import { getLocalFileURLSchema } from "./validators";
+
+type RouteCtx = {
+  params: Promise<{ rest?: string[] }>;
+};
+
+type CreateLocalDriveRouteHandlerProps<TSchema extends TDatabaseSchema> = Pick<
+  TulipContext<TSchema>,
+  "auth"
+> & {
+  drive: LocalDrive<TSchema>;
+};
+
+/**
+ * Creates a catch-all drive route handler for `/api/drive/[[...rest]]`.
+ *
+ * Current support:
+ * - `GET /api/drive/files/:id?variant=:variant&disposition=:disposition`
+ *   resolves a drive node, checks access for private local assets, and redirects
+ *   to a short-lived file URL for the requested node variant.
+ *
+ * @param props - Route handler dependencies.
+ * @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE.
+ */
+export function createLocalDriveRouteHandler<TSchema extends TDatabaseSchema>(
+  context: CreateLocalDriveRouteHandlerProps<TSchema>,
+) {
+  /**
+   * GET /api/drive/[[...rest]]
+   *
+   * Current route support:
+   * - /api/drive/files/:id?variant=:variant&disposition=:disposition
+   */
+  async function GET(request: NextRequest, ctx: RouteCtx) {
+    const { rest = [] } = await ctx.params;
+    const resource = rest[0];
+
+    if (resource === "files") {
+      const id = rest[1];
+      if (!id) {
+        return Response.json(
+          { error: { code: "BAD_REQUEST", message: "Missing file id" } },
+          { status: 400 },
+        );
+      }
+
+      const searchParams = request.nextUrl.searchParams;
+
+      const variant = searchParams.get("variant") ?? undefined;
+      const disposition = searchParams.get("disposition") ?? undefined;
+
+      try {
+        const node = await context.drive.getNodeById(id);
+
+        if (!node) {
+          return Response.json(
+            { error: { code: "NOT_FOUND", message: "Node not found" } },
+            { status: 404 },
+          );
+        }
+
+        if (node.assetId) {
+          const asset = await context.drive.storage.getAssetById(node.assetId);
+
+          if (!asset) {
+            return Response.json(
+              { error: { code: "NOT_FOUND", message: "Asset not found" } },
+              { status: 404 },
+            );
+          }
+
+          if (asset.visibility === "private") {
+            const session = await getSession(context);
+
+            if (!session) {
+              return Response.json(
+                { error: { code: "UNAUTHORIZED", message: "Unauthorized" } },
+                { status: 401 },
+              );
+            }
+          }
+        }
+
+        const options = getLocalFileURLSchema.parse({ variant, disposition });
+        const url = await context.drive.getURL(node, options);
+
+        return Response.redirect(url, 307);
+      } catch (error) {
+        if (error instanceof z.ZodError) {
+          return Response.json(
+            { error: { code: "BAD_REQUEST", message: "Invalid request input" } },
+            { status: 400 },
+          );
+        }
+
+        if (error instanceof ServerError) {
+          if (error.code === "BAD_REQUEST") {
+            return Response.json(
+              { error: { code: "BAD_REQUEST", message: error.message } },
+              { status: 400 },
+            );
+          }
+
+          if (error.code === "NOT_FOUND") {
+            return Response.json(
+              { error: { code: "NOT_FOUND", message: error.message } },
+              { status: 404 },
+            );
+          }
+
+          if (error.code === "UNAUTHORIZED") {
+            return Response.json(
+              { error: { code: "UNAUTHORIZED", message: error.message } },
+              { status: 401 },
+            );
+          }
+        }
+
+        console.error("Drive route error", error);
+
+        return Response.json(
+          { error: { code: "INTERNAL_SERVER_ERROR", message: "Something went wrong" } },
+          { status: 500 },
+        );
+      }
+    }
+
+    return Response.json(
+      { error: { code: "NOT_FOUND", message: "Route not found" } },
+      { status: 404 },
+    );
+  }
+
+  /**
+   * POST, PUT, PATCH, DELETE /api/drive/[[...rest]]
+   */
+  async function POST() {
+    await connection();
+
+    return Response.json(
+      { error: { code: "NOT_FOUND", message: "Route not found" } },
+      { status: 404 },
+    );
+  }
+
+  return { GET, POST, PUT: POST, PATCH: POST, DELETE: POST };
+}

package/src/providers/local/lib/router.server.ts

@@ -0,0 +1,137 @@
+import { bulkActionSchema } from "@tulip-systems/core/router";
+import { initRPC } from "@tulip-systems/core/router/server";
+import { z } from "zod";
+import type { DriveSchema } from "./schema";
+import type { LocalDrive } from "./service.server";
+import {
+  createLocalDriveFolderInputSchema,
+  getLocalDriveNodesByParentIdInputSchema,
+  getLocalFileURLSchema,
+  listLocalDriveFlatInputSchema,
+  listLocalDriveTreeInputSchema,
+  localDriveNodeSchema,
+  localDriveNodeWithChildrenSchema,
+  presignLocalDriveFileInputSchema,
+  updateLocalDriveNodeInputSchema,
+} from "./validators";
+
+/**
+ * Create Drive base procedures
+ */
+export function createLocalDriveProcedures(drive: LocalDrive<DriveSchema>) {
+  const { protectedProcedure } = initRPC<DriveSchema>();
+
+  return {
+    /**
+     * Get node with children
+     */
+    getNodeWithChildren: protectedProcedure
+      .input(z.object({ id: z.string(), namespace: z.string() }))
+      .output(localDriveNodeWithChildrenSchema.nullable())
+      .handler(async ({ input }) => drive.getNodeWithChildren(input)),
+    /**
+     * Get folders by parent id
+     */
+    getNodesByParentId: protectedProcedure
+      .input(getLocalDriveNodesByParentIdInputSchema)
+      .output(z.array(localDriveNodeSchema))
+      .handler(async ({ input }) => drive.getNodesByParentId(input)),
+    /**
+     * List tree nodes with pagination and search.
+     */
+    listTree: protectedProcedure
+      .input(listLocalDriveTreeInputSchema)
+      .handler(async ({ input }) => drive.listTree(input)),
+    /**
+     * List flat nodes with pagination and search.
+     */
+    listFlat: protectedProcedure
+      .input(listLocalDriveFlatInputSchema)
+      .handler(async ({ input }) => drive.listFlat(input)),
+    /**
+     * Get parents of a folder
+     */
+    getFolderParents: protectedProcedure
+      .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
+      .handler(async ({ input }) => drive.getFolderParents(input)),
+    /**
+     * Get url for opening a file
+     */
+    getURL: protectedProcedure
+      .input(getLocalFileURLSchema.extend({ id: z.string() }))
+      .output(z.string().nullable())
+      .handler(async ({ input: { id, ...options } }) => {
+        const node = await drive.getNodeById(id);
+        if (!node) return null;
+
+        return await drive.getURL(node, options);
+      }),
+
+    /**
+     * Create a direct upload intent for a file
+     */
+    presignUpload: protectedProcedure
+      .input(presignLocalDriveFileInputSchema)
+      .handler(async ({ input }) => drive.presignUpload(input)),
+    /**
+     * Confirm a direct upload intent
+     */
+    confirmUpload: protectedProcedure
+      .input(z.object({ uploadId: z.string() }))
+      .handler(async ({ input }) => drive.confirmUpload(input.uploadId)),
+    /**
+     * Create a folder
+     */
+    createFolder: protectedProcedure
+      .input(createLocalDriveFolderInputSchema)
+      .output(localDriveNodeSchema)
+      .handler(async ({ input }) => drive.createFolder(input)),
+    /**
+     * Update node
+     */
+    updateNode: protectedProcedure
+      .input(z.object({ id: z.string(), data: updateLocalDriveNodeInputSchema }))
+      .output(localDriveNodeSchema)
+      .handler(async ({ input }) => drive.updateNode(input.id, input.data)),
+    /**
+     * Set readonly
+     */
+    setReadonly: protectedProcedure
+      .input(bulkActionSchema.extend({ readonly: z.boolean() }))
+      .output(z.array(localDriveNodeSchema))
+      .handler(async ({ input }) => drive.setReadonly(input.ids, input.readonly)),
+    /**
+     * Move node
+     */
+    moveNode: protectedProcedure
+      .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
+      .output(localDriveNodeSchema)
+      .handler(async ({ input }) =>
+        drive.moveNode({
+          id: input.id,
+          parentId: input.parentId ?? null,
+        }),
+      ),
+    /**
+     * Archive nodes
+     */
+    archiveNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.array(localDriveNodeSchema))
+      .handler(async ({ input }) => drive.archiveNodes(input.ids)),
+    /**
+     * Restore nodes
+     */
+    restoreNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.array(localDriveNodeSchema))
+      .handler(async ({ input }) => drive.restoreNodes(input.ids)),
+    /**
+     * Delete nodes
+     */
+    deleteNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.void())
+      .handler(async ({ input }) => drive.deleteNodes(input.ids)),
+  };
+}

package/src/providers/local/lib/schema.ts

@@ -0,0 +1,104 @@
+import { baseColumns } from "@tulip-systems/core/config";
+import { imageDispositions, storageAssets } from "@tulip-systems/core/storage";
+import { relations } from "drizzle-orm";
+import { type AnyPgColumn, boolean, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+import { imageVariants, nodeSubtypes } from "./constants";
+
+export const nodeTypeEnum = pgEnum("node_types", ["file", "folder"]);
+
+/**
+ * Node table
+ */
+export const nodes = pgTable("nodes", (t) => ({
+  ...baseColumns,
+  name: t.text().notNull(),
+  namespace: t.text().notNull().default("global"),
+  type: nodeTypeEnum(),
+  subtype: t.text({ enum: nodeSubtypes }).notNull().default("other"),
+  size: t.integer(),
+  contentType: t.varchar({ length: 255 }),
+  readonly: boolean().default(false),
+  hidden: boolean().default(false),
+  archivedAt: t.timestamp(),
+  parentId: t.uuid().references((): AnyPgColumn => nodes.id, { onDelete: "cascade" }),
+  assetId: t.uuid().references(() => storageAssets.id, { onDelete: "cascade" }),
+}));
+
+export const nodesRelations = relations(nodes, ({ one, many }) => ({
+  parent: one(nodes, {
+    fields: [nodes.parentId],
+    references: [nodes.id],
+    relationName: "parent",
+  }),
+  children: many(nodes, {
+    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" }),
+  assetId: t
+    .uuid()
+    .notNull()
+    .references(() => storageAssets.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",
+  }),
+}));
+
+/**
+ * Node presigned urls table
+ */
+export const nodePresignedUrls = pgTable(
+  "node_presigned_urls",
+  (t) => ({
+    ...baseColumns,
+    url: t.text().notNull().unique(),
+    variant: t.text({ enum: imageVariants }).notNull(),
+    disposition: t.text({ enum: imageDispositions }).notNull(),
+    expiresAt: t.timestamp().notNull(),
+    nodeId: t
+      .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)],
+);
+
+export const nodePresignedUrlsRelations = relations(nodePresignedUrls, ({ one }) => ({
+  node: one(nodes, {
+    fields: [nodePresignedUrls.nodeId],
+    references: [nodes.id],
+    relationName: "node",
+  }),
+}));
+
+/**
+ * Drive schema
+ **/
+const driveSchema = {
+  nodes,
+  nodesRelations,
+  nodeVariants,
+  nodeVariantsRelations,
+  nodePresignedUrls,
+  nodePresignedUrlsRelations,
+};
+export type DriveSchema = typeof driveSchema;

package/src/providers/local/lib/search-params.ts

@@ -0,0 +1,4 @@
+import { resolveFiltersSearchParams } from "@tulip-systems/core/data-tables";
+import { localDriveFilters } from "../config/filters";
+
+export const localDriveTreeFilterSearchParams = resolveFiltersSearchParams(localDriveFilters);