@tulip-systems/core 0.4.0 → 0.5.0

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

@@ -1,131 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,340 +0,0 @@
-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");
-      }),
-  };
-}

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

@@ -1,82 +0,0 @@
-import { users } from "@/modules/auth/db/schema";
-import { baseColumns } from "@/modules/config/db/helpers";
-import { relations } from "drizzle-orm";
-import { AnyPgColumn, boolean, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
-import { imageDispositions, imageVariants } from "./constants";
-import { nodeSubtypes } from "./helpers";
-
-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().default(0),
-  contentType: t.varchar({ length: 255 }),
-  // url: t.text(),
-  // urlExpiresAt: t.timestamp(),
-  readonly: boolean().default(false),
-  createdBy: t.text().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" }),
-}));
-
-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),
-}));
-
-/**
- * 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" }),
-  }),
-  (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",
-  }),
-}));
-
-/**
- * @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 };
-export type DriveSchema = typeof driveSchema;

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

@@ -1,47 +0,0 @@
-import { resolveFiltersSchema } from "@/modules/data-tables/lib/filters/resolvers";
-import { createInsertSchema, createSelectSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nodesTableFilters } from "./filters";
-import { assets, nodes } from "./schema";
-
-/**
- * Asset type
- */
-export type Asset = typeof assets.$inferSelect;
-
-/**
- * Asset insert schema
- */
-export const createAssetSchema = createInsertSchema(assets);
-
-export type CreateAssetInput = z.input<typeof createAssetSchema>;
-export type CreateAssetSchema = z.infer<typeof createAssetSchema>;
-
-/**
- * Nodes
- */
-export type Node = typeof nodes.$inferSelect;
-export type FileNode = typeof nodes.$inferSelect & { type: "file" };
-export type FolderNode = typeof nodes.$inferSelect & { type: "folder" };
-
-export const createNodeSchema = createInsertSchema(nodes);
-
-export type CreateNodeInput = z.input<typeof createNodeSchema>;
-export type CreateNodeSchema = z.infer<typeof createNodeSchema>;
-
-export const selectNodeSchema = createSelectSchema(nodes);
-export const selectNodeWithChildrenSchema = selectNodeSchema.extend({
-  children: z.array(selectNodeSchema),
-});
-
-export type SelectNodeSchema = z.infer<typeof selectNodeSchema>;
-export type SelectNodeWithChildrenSchema = z.infer<typeof selectNodeWithChildrenSchema>;
-
-/**
- * Project where input
- */
-export const nodesTableFiltersSchema = resolveFiltersSchema(nodesTableFilters)
-  .partial()
-  .transform((input) => ({ ...input, isDeleted: input?.isDeleted ?? false }));
-
-export type NodesTableFilters = z.input<typeof nodesTableFiltersSchema>;