@tulip-systems/drive 0.7.0

package/src/providers/local/lib/upload.client.ts

@@ -0,0 +1,177 @@
+import { generateDefaultUUID } from "@tulip-systems/core/config";
+import type { BulkActionSchema } from "@tulip-systems/core/router";
+import type { StorageAsset } from "@tulip-systems/core/storage";
+import type {
+  LocalDriveFileNode,
+  LocalDriveNode,
+  PresignLocalDriveFileInput,
+  UpdateLocalDriveNodeInput,
+} from "./validators";
+
+/**
+ * Upload request
+ */
+export type PrepareLocalDriveUploadInput = Omit<
+  LocalDriveUploadFileRequest,
+  "name" | "size" | "contentType"
+>;
+
+export type LocalDriveUploadFileRequest = PresignLocalDriveFileInput & { file: File };
+export type LocalDriveUploadHooks = {
+  beforePresign?: (input: LocalDriveUploadFileRequest) => Promise<void> | void;
+  afterPresign?: (presignResult: {
+    asset: Omit<StorageAsset, "presignedUrl">;
+    node: LocalDriveFileNode;
+    uploadId: string;
+    presignedUrl: string;
+  }) => Promise<void> | void;
+  beforeConfirm?: (presignResult: {
+    asset: Omit<StorageAsset, "presignedUrl">;
+    node: LocalDriveFileNode;
+    uploadId: string;
+    presignedUrl: string;
+  }) => Promise<void> | void;
+  afterConfirm?: (node: LocalDriveFileNode) => Promise<void> | void;
+};
+
+/**
+ * Upload client
+ */
+export type LocalDriveUploadClient = {
+  prepareUpload: (input: PrepareLocalDriveUploadInput) => LocalDriveUploadFileRequest;
+  upload: (
+    input: LocalDriveUploadFileRequest,
+    hooks?: LocalDriveUploadHooks,
+  ) => Promise<LocalDriveFileNode>;
+  deleteFiles: (ids: string[]) => Promise<void>;
+  updateNode: (id: string, data: UpdateLocalDriveNodeInput) => Promise<LocalDriveNode>;
+};
+
+/**
+ * Create upload client
+ */
+type CreateLocalDriveUploadClientProps = {
+  endpoints: {
+    presignUpload: (input: PresignLocalDriveFileInput) => Promise<{
+      asset: Omit<StorageAsset, "presignedUrl">;
+      node: LocalDriveFileNode;
+      uploadId: string;
+      presignedUrl: string;
+    }>;
+    confirmUpload: (input: { uploadId: string }) => Promise<LocalDriveFileNode>;
+    deleteNodes: (input: BulkActionSchema) => Promise<void>;
+    updateNode: (input: { id: string; data: UpdateLocalDriveNodeInput }) => Promise<LocalDriveNode>;
+  };
+};
+
+export function createLocalDriveUploadClient(
+  props: CreateLocalDriveUploadClientProps,
+): LocalDriveUploadClient {
+  /**
+   * Create input schema for the upload method
+   * @param {PrepareLocalDriveUploadInput} input
+   * @returns {LocalDriveUploadFileRequest}
+   */
+  function prepareUpload(input: PrepareLocalDriveUploadInput): LocalDriveUploadFileRequest {
+    return {
+      ...input,
+      uploadId: input.uploadId ?? generateDefaultUUID(),
+      name: input.file.name,
+      size: input.file.size,
+      contentType: input.file.type,
+    };
+  }
+
+  /**
+   * Upload file to the server
+   * @param {LocalDriveUploadFileRequest} input
+   * @returns {Promise<LocalDriveFileNode>}
+   */
+  async function upload(
+    input: LocalDriveUploadFileRequest,
+    hooks?: LocalDriveUploadHooks,
+  ): Promise<LocalDriveFileNode> {
+    let presignResult: {
+      asset: Omit<StorageAsset, "presignedUrl">;
+      node: LocalDriveFileNode;
+      uploadId: string;
+      presignedUrl: string;
+    } | null = null;
+
+    try {
+      /**
+       * Presign
+       */
+      await hooks?.beforePresign?.(input);
+      const { file, ...presignInput } = input;
+      presignResult = await props.endpoints.presignUpload(presignInput);
+      await hooks?.afterPresign?.(presignResult);
+      /**
+       * Upload the file
+       */
+      const uploadResponse = await fetch(presignResult.presignedUrl, {
+        method: "PUT",
+        headers: { "Content-Type": input.file.type },
+        body: input.file,
+      });
+
+      if (!uploadResponse.ok) {
+        const message = await uploadResponse.text();
+        throw new Error(`Upload failed: ${message}`);
+      }
+
+      /**
+       * Confirm
+       */
+      await hooks?.beforeConfirm?.(presignResult);
+      const node = await props.endpoints.confirmUpload({ uploadId: presignResult.uploadId });
+      await hooks?.afterConfirm?.(node);
+      /**
+       * Return
+       */
+      return node;
+    } catch (err) {
+      console.error("Upload error: ", err);
+
+      /**
+       * Delete if upload failed
+       * */
+      try {
+        if (presignResult?.node.id) {
+          await deleteFiles([presignResult.node.id]);
+        }
+      } catch (cleanupErr) {
+        console.error("Cleanup delete failed:", cleanupErr);
+      }
+
+      throw err;
+    }
+  }
+
+  /**
+   * Delete files
+   * @param {string[]} ids
+   */
+  async function deleteFiles(ids: string[]) {
+    await props.endpoints.deleteNodes({ ids });
+  }
+
+  /**
+   * Update node
+   * @param {string} id
+   * @param {UpdateLocalDriveNodeInput} data
+   */
+  async function updateNode(id: string, data: UpdateLocalDriveNodeInput) {
+    return props.endpoints.updateNode({ id, data });
+  }
+
+  /**
+   * Upload client
+   */
+  return {
+    prepareUpload,
+    upload,
+    deleteFiles,
+    updateNode,
+  };
+}

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

@@ -0,0 +1,154 @@
+import { resolveFiltersSchema, tableQuerySchema } from "@tulip-systems/core/data-tables";
+import {
+  getAssetURLSchema,
+  type StorageAsset,
+  storageAssetVisibilitySchema,
+} from "@tulip-systems/core/storage";
+import { z } from "zod";
+import { type DriveNodeChild, driveNodeSchema } from "@/lib/dto";
+import {
+  createDriveFolderInputSchema,
+  presignDriveFileInputSchema,
+  updateDriveNodeInputSchema,
+  uploadDriveFileInputSchema,
+} from "@/lib/validators";
+import { localDriveFilters } from "../config/filters";
+import { imageVariants } from "./constants";
+import type { nodes } from "./schema";
+
+/**
+ * Nodes
+ */
+export type LocalNode = typeof nodes.$inferSelect;
+
+export const localDriveNodeSchema = driveNodeSchema.extend({
+  provider: z.literal("local"),
+  assetId: z.string().nullable(),
+});
+
+export type LocalDriveNode = z.infer<typeof localDriveNodeSchema>;
+export type LocalDriveFileNode = LocalDriveNode & { type: "file" };
+export type LocalDriveFolderNode = LocalDriveNode & { type: "folder" };
+export type LocalDriveNodeChild = DriveNodeChild<LocalDriveNode>;
+export type LocalDriveNodeWithAsset = LocalDriveNode & { asset: StorageAsset | null };
+
+/**
+ * Node with children
+ */
+export const localDriveNodeWithChildrenSchema = localDriveNodeSchema.extend({
+  children: z.array(localDriveNodeSchema),
+});
+
+export type LocalDriveNodeWithChildren = z.infer<typeof localDriveNodeWithChildrenSchema>;
+
+/**
+ * Create folder
+ */
+export const createLocalDriveFolderInputSchema = createDriveFolderInputSchema.extend({
+  hidden: z.boolean().optional(),
+  readonly: z.boolean().optional(),
+});
+export type CreateLocalDriveFolderInput = z.input<typeof createLocalDriveFolderInputSchema>;
+export type CreateLocalDriveFolderSchema = z.infer<typeof createLocalDriveFolderInputSchema>;
+
+/**
+ * Update node
+ */
+export const updateLocalDriveNodeInputSchema = updateDriveNodeInputSchema.extend({
+  parentId: z.string().nullable().optional(),
+  hidden: z.boolean().optional(),
+  readonly: z.boolean().optional(),
+  archivedAt: z.date().nullable().optional(),
+});
+export type UpdateLocalDriveNodeInput = z.input<typeof updateLocalDriveNodeInputSchema>;
+
+/**
+ * Upload file
+ */
+export const uploadLocalDriveFileInputSchema = uploadDriveFileInputSchema.extend({
+  hidden: z.boolean().optional(),
+  readonly: z.boolean().optional(),
+});
+export type UploadLocalDriveFileSchema = z.infer<typeof uploadLocalDriveFileInputSchema>;
+
+/**
+ * Presign file
+ */
+export const presignLocalDriveFileInputSchema = presignDriveFileInputSchema.extend({
+  hidden: z.boolean().optional(),
+  readonly: z.boolean().optional(),
+  uploadId: z.uuid().optional(),
+  visibility: storageAssetVisibilitySchema.optional().default("private"),
+});
+export type PresignLocalDriveFileInput = z.input<typeof presignLocalDriveFileInputSchema>;
+
+/**
+ * Get file url schema
+ */
+export const getLocalFileURLSchemaDefaults = { variant: "main", disposition: "inline" } as const;
+
+export const getLocalFileURLSchema = getAssetURLSchema.extend({
+  variant: z.enum(imageVariants).optional().default(getLocalFileURLSchemaDefaults.variant),
+});
+
+export type GetLocalFileURLSchema = z.infer<typeof getLocalFileURLSchema>;
+
+/**
+ * Tree filters
+ */
+export const localDriveTreeFiltersSchema = resolveFiltersSchema(localDriveFilters)
+  .partial()
+  .extend({
+    namespace: z.string(),
+    parentId: z.string().nullable(),
+  })
+  .transform((input) => ({
+    ...input,
+    hidden: input?.hidden ?? false,
+    isArchived: input?.isArchived ?? false,
+  }));
+export type LocalDriveTableFilters = z.input<typeof localDriveTreeFiltersSchema>;
+
+/**
+ * Flat filters
+ */
+export const localDriveFlatFiltersSchema = resolveFiltersSchema(localDriveFilters)
+  .partial()
+  .extend({
+    namespace: z.string().optional(),
+  })
+  .transform((input) => ({
+    ...input,
+    hidden: input?.hidden ?? false,
+    isArchived: input?.isArchived ?? false,
+  }));
+
+/**
+ * List tree input schema
+ */
+export const listLocalDriveTreeInputSchema = tableQuerySchema.extend({
+  filters: localDriveTreeFiltersSchema,
+});
+
+export type ListLocalDriveTreeInput = z.input<typeof listLocalDriveTreeInputSchema>;
+export type ListLocalDriveTreeSchema = z.infer<typeof listLocalDriveTreeInputSchema>;
+
+/**
+ * List flat input schema
+ */
+export const listLocalDriveFlatInputSchema = tableQuerySchema.extend({
+  filters: localDriveFlatFiltersSchema,
+});
+
+export type ListLocalDriveFlatSchema = z.infer<typeof listLocalDriveFlatInputSchema>;
+
+/**
+ * Get by parent id input
+ */
+export const getLocalDriveNodesByParentIdInputSchema = tableQuerySchema
+  .pick({ order: true, sort: true, search: true })
+  .extend({ filters: localDriveTreeFiltersSchema });
+
+export type GetLocalDriveNodesByParentIdInput = z.input<
+  typeof getLocalDriveNodesByParentIdInputSchema
+>;

package/src/styles.css

@@ -0,0 +1 @@
+@source ".";