@tulip-systems/core 0.4.1 → 0.5.0

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

@@ -1,93 +0,0 @@
-import "server-cli-only";
-
-import { TDatabaseSchema } from "@/modules/config/db/types";
-import { TulipContext } from "@/modules/config/entry";
-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: TulipContext<TSchema>;
-  }) => Promise<void>;
-  onUploadCompletedCallback?: (values: {
-    payload: TPayload;
-    asset: Asset;
-    ctx: TulipContext<TSchema>;
-  }) => Promise<void>;
-};
-
-/**
- * @deprecated
- */
-export function handleUploadRoute<TSchema extends TDatabaseSchema, TPayload>(
-  ctx: TulipContext<TSchema>,
-  { allowedContentTypes, schema, ...options }: HandleAssetUploadOptions<TSchema, TPayload>,
-) {
-  async function POST(request: NextRequest) {
-    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/validators.ts

@@ -1,50 +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, nodeModeEnum, 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 nodeModeSchema = z.enum(nodeModeEnum.enumValues);
-export type NodeMode = z.infer<typeof nodeModeSchema>;
-
-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>;