@tulip-systems/core 0.6.1 → 0.8.0

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

@@ -1,85 +1,38 @@
 import type { ImageLoaderProps } from "next/image";
-import type { ImageVariant } from "./constants";
-import type { CreateNodeSchema, GetFileURLSchema, Node } from "./validators";
+import type { GetAssetURLInput } from "../lib/validators";
 
 /**
- * Check if the node is a file
+ * Builds the public API route URL for a storage file proxy request.
+ *
+ * Use this helper when you need a stable file URL in the client/UI
+ * without manually composing the route path.
+ *
+ * @param id - Storage asset id
+ * @returns File proxy URL for the storage route handler
+ * @example
+ * const url = getAssetURL("019d0051-2c0d-741e-9e3c-e5a5bc4d16a2", { disposition: "attachment" });
+ * // /api/storage/files/019d0051-2c0d-741e-9e3c-e5a5bc4d16a2?disposition=attachment
  */
-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, options: Partial<GetFileURLSchema> = {}) {
+export function getAssetURL(id: string, options: Partial<GetAssetURLInput> = {}) {
   const searchParams = new URLSearchParams();
-  searchParams.set("id", id);
-  if (options?.variant) searchParams.set("variant", options.variant);
   if (options?.disposition) searchParams.set("disposition", options.disposition);
 
-  return `/api/storage/files?${searchParams.toString()}`;
+  const queryString = searchParams.toString();
+
+  return `/api/storage/files/${id}${queryString ? `?${queryString}` : ""}`;
 }
 
 /**
  * Image loader
  */
-export function imageLoader({ src, width }: ImageLoaderProps) {
+export function imageLoader({ src }: ImageLoaderProps) {
+  if (typeof window === "undefined") return src;
+
   const url = new URL(src, window.location.origin);
-  url.searchParams.set("variant", `preview-${width}`);
   return url.toString();
 }
 
-/**
- * Generate object key
- */
-export function getDriveBucketKey(id: string, variant: ImageVariant) {
-  return `storage/${id}/${variant}`;
-}
-
-/**
- * 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<CreateNodeSchema, "name" | "contentType">): NodeSubtype {
-  if (!contentType) return "other";
-  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";
-}
-
 /**
  * Render bytes
  */

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

@@ -0,0 +1,60 @@
+import type { InferRouterInputs, InferRouterOutputs } from "@orpc/server";
+import { z } from "zod";
+import type { TDatabaseSchema } from "@/modules/config/db/types";
+import { initRPC } from "@/modules/router/handler/init.server";
+import {
+  confirmUploadInputSchema,
+  presignUploadInputSchema,
+  presignUploadOutputSchema,
+  selectStorageAssetSchema,
+} from "./validators";
+
+export function createStorageProcedures<TSchema extends TDatabaseSchema>() {
+  const { protectedProcedure } = initRPC<TSchema>();
+
+  return {
+    presign: protectedProcedure
+      .input(presignUploadInputSchema)
+      .output(presignUploadOutputSchema)
+      .handler(async ({ context, input }) => context.storage.presignUpload(input)),
+
+    confirm: protectedProcedure
+      .input(confirmUploadInputSchema)
+      .output(selectStorageAssetSchema)
+      .handler(async ({ context, input }) => context.storage.confirmUpload(input)),
+
+    deleteAsset: protectedProcedure
+      .input(z.uuid())
+      .output(selectStorageAssetSchema.nullable())
+      .handler(async ({ context, input }) => context.storage.deleteAsset(input)),
+
+    deleteAssets: protectedProcedure
+      .input(z.string().array())
+      .output(z.array(selectStorageAssetSchema))
+      .handler(async ({ context, input }) => context.storage.deleteAssets(input)),
+
+    restoreAsset: protectedProcedure
+      .input(z.uuid())
+      .output(selectStorageAssetSchema.nullable())
+      .handler(async ({ context, input }) => context.storage.restoreAsset(input)),
+
+    restoreAssets: protectedProcedure
+      .input(z.string().array())
+      .output(z.array(selectStorageAssetSchema))
+      .handler(async ({ context, input }) => context.storage.restoreAssets(input)),
+
+    purgeAsset: protectedProcedure
+      .input(z.uuid())
+      .output(selectStorageAssetSchema.nullable())
+      .handler(async ({ context, input }) => context.storage.purgeAsset(input)),
+
+    purgeAssets: protectedProcedure
+      .input(z.string().array())
+      .output(z.array(selectStorageAssetSchema))
+      .handler(async ({ context, input }) => context.storage.purgeAssets(input)),
+  };
+}
+
+export type StorageRouter = ReturnType<typeof createStorageProcedures>;
+export type StorageRouterOutputs = InferRouterOutputs<StorageRouter>;
+export type StorageRouterInputs = InferRouterInputs<StorageRouter>;

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

@@ -0,0 +1,178 @@
+import { connection, type NextRequest } from "next/server";
+import z from "zod";
+import { getSession } from "@/modules/auth/lib/helpers.server";
+import type { TDatabaseSchema } from "@/modules/config/db/types";
+import type { TulipContext } from "@/modules/config/lib/context";
+import { ServerError } from "@/modules/router/lib/error.server";
+import { getAssetURLSchema } from "../entry";
+
+type RouteCtx = {
+  params: Promise<{ rest?: string[] }>;
+};
+
+type CreateStorageRouteHandlerProps<TSchema extends TDatabaseSchema> = {
+  context: Pick<TulipContext<TSchema>, "auth" | "storage">;
+};
+
+/**
+ * Creates a catch-all storage route handler for `/api/storage/[[...rest]]`.
+ *
+ * Current support:
+ * - `GET /api/storage/files/:id`:
+ *   resolves a storage asset, enforces visibility checks, and redirects
+ *   to a short-lived signed read URL.
+ *
+ * Reserved for future extension:
+ * - `POST /api/storage/assets/presign`
+ * - `POST /api/storage/assets/confirm`
+ * - additional storage endpoints under the same catch-all route.
+ *
+ * @param props - Route handler dependencies (application context)
+ * @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE
+ */
+
+export function createStorageRouteHandler<TSchema extends TDatabaseSchema>({
+  context,
+}: CreateStorageRouteHandlerProps<TSchema>) {
+  /**
+   * GET /api/storage/[[...rest]]
+   *
+   * Current route support:
+   * - /api/storage/files/:id
+   *
+   * The file route resolves an asset by id, enforces visibility rules,
+   * and redirects to a short-lived signed object URL.
+   */
+  async function GET(request: NextRequest, ctx: RouteCtx) {
+    // Get the params
+    const { rest = [] } = await ctx.params;
+    const resource = rest[0];
+
+    /**
+     * Proxy file request
+     * GET /api/storage/files/:id
+     */
+    if (resource === "files") {
+      const id = rest[1];
+
+      // Guard required path segment: /api/storage/files/:id
+      if (!id) {
+        return Response.json(
+          { error: { code: "BAD_REQUEST", message: "Missing id" } },
+          { status: 400 },
+        );
+      }
+
+      console.info("Proxying file: ", id);
+
+      try {
+        // Resolve storage asset record by id
+        const asset = await context.storage.getAssetById(id);
+
+        if (!asset) {
+          return Response.json(
+            { error: { code: "NOT_FOUND", message: "Asset not found" } },
+            { status: 404 },
+          );
+        }
+
+        // Enforce private visibility with session auth
+        if (asset.visibility === "private") {
+          const session = await getSession(context);
+          if (!session) {
+            return Response.json(
+              { error: { code: "UNAUTHORIZED", message: "Unauthorized" } },
+              { status: 401 },
+            );
+          }
+        }
+
+        // Handle searchParams for disposition
+        const searchParams = request.nextUrl.searchParams;
+        const disposition = searchParams.get("disposition") ?? undefined;
+
+        // Parse the options
+        const options = getAssetURLSchema.parse({ disposition });
+
+        // Resolve signed read URL and redirect to object storage
+        const url = await context.storage.getObjectURL(asset.id, options);
+
+        // Return the file
+        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) {
+          const code = error.code;
+
+          if (code === "BAD_REQUEST") {
+            return Response.json(
+              { error: { code: "BAD_REQUEST", message: error.message } },
+              { status: 400 },
+            );
+          }
+
+          if (code === "NOT_FOUND") {
+            return Response.json(
+              { error: { code: "NOT_FOUND", message: error.message } },
+              { status: 404 },
+            );
+          }
+
+          if (code === "UNAUTHORIZED") {
+            return Response.json(
+              { error: { code: "UNAUTHORIZED", message: error.message } },
+              { status: 401 },
+            );
+          }
+        }
+
+        if (error instanceof Error && error.message === "Storage asset not found") {
+          return Response.json(
+            { error: { code: "NOT_FOUND", message: "Asset not found" } },
+            { status: 404 },
+          );
+        }
+
+        console.error("Storage 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/storage/[[...rest]]
+   *
+   * Reserved for future extension, for example:
+   * - POST /api/storage/assets/presign
+   * - POST /api/storage/assets/confirm
+   */
+  async function POST() {
+    // Make endpoint dynamic
+    await connection();
+
+    // future:
+    // POST /api/storage/assets/presign
+    // POST /api/storage/assets/confirm
+    return Response.json(
+      { error: { code: "NOT_FOUND", message: "Route not found" } },
+      { status: 404 },
+    );
+  }
+
+  return { GET, POST, PUT: POST, PATCH: POST, DELETE: POST };
+}

package/src/modules/storage/lib/schema.ts

@@ -1,105 +1,34 @@
-import { relations } from "drizzle-orm";
-import { type AnyPgColumn, boolean, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
-import { users } from "@/modules/auth/db/schema";
-import { baseColumns } from "@/modules/config/db/helpers";
-import { imageDispositions, imageVariants } from "./constants";
-import { nodeSubtypes } from "./helpers";
+import { index, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/modules/database/lib/helpers";
+import { storageProviders } from "../providers/lib/constants";
 
-export const nodeTypeEnum = pgEnum("node_types", ["file", "folder"]);
-export const nodeModeEnum = pgEnum("node_mode", ["private", "public"]);
+export const storageAssetStatusEnum = pgEnum("storage_asset_status", ["pending", "ready", "error"]);
+export const storageAssetVisibilityEnum = pgEnum("storage_asset_visibility", ["private", "public"]);
 
 /**
- * Node table
+ * Storage objects table
  */
-export const nodes = pgTable("nodes", (t) => ({
-  ...baseColumns,
-  name: t.text().notNull(),
-  namespace: t.text().notNull().default("global"),
-  type: nodeTypeEnum(),
-  mode: nodeModeEnum().default("private"),
-  subtype: t.text({ enum: nodeSubtypes }).notNull().default("other"),
-  size: t.integer().default(0),
-  contentType: t.varchar({ length: 255 }),
-  readonly: boolean().default(false),
-  hidden: boolean().default(false),
-  createdBy: t.uuid().references(() => users.id, { onDelete: "set null" }),
-  isPending: t.boolean().default(false).notNull(),
-  isDeleted: t.boolean().default(false).notNull(),
-  orphanedAt: t.timestamp(),
-  parentId: t.uuid().references((): AnyPgColumn => nodes.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" }),
-  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",
+export const storageAssets = pgTable(
+  "storage_assets",
   (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" }),
+    provider: t.text({ enum: storageProviders }).notNull(),
+    bucket: t.text().notNull(),
+    key: t.text().notNull(),
+    status: storageAssetStatusEnum().notNull(),
+    visibility: storageAssetVisibilityEnum().notNull().default("private"),
+    size: t.integer().default(0),
+    contentType: t.varchar({ length: 255 }),
+    uploadId: t.uuid().notNull().defaultRandom(),
+    name: t.text(),
+    metadata: t.jsonb(),
+    etag: t.text(),
+    uploadedAt: t.timestamp().defaultNow().notNull(),
+    deletedAt: t.timestamp(),
   }),
-  (t) => [unique("node_presigned_url_unique").on(t.nodeId, t.variant, t.disposition)],
+  (t) => [
+    unique("storage_assets_provider_bucket_key_unique").on(t.provider, t.bucket, t.key),
+    index("storage_assets_status_idx").on(t.status),
+    index("storage_assets_bucket_key_idx").on(t.bucket, t.key),
+  ],
 );
-
-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;