@tulip-systems/drive 0.7.0

package/src/providers/google/config/columns-data.tsx

@@ -0,0 +1,81 @@
+"use client";
+
+import { findStatus } from "@tulip-systems/core/components";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@tulip-systems/core/components/client";
+import { type TableColumnDef, TableColumnHeader } from "@tulip-systems/core/data-tables";
+import { createTableSelectCell, TableTextCell } from "@tulip-systems/core/data-tables/client";
+import { FolderIcon } from "lucide-react";
+import Link from "next/link";
+import { createSerializer, useQueryStates } from "nuqs";
+import { nodeSubtypeConfig, nodeSubtypeVariants } from "@/config/types";
+import { driveTreeSearchParams } from "@/lib/search-params";
+import type { GoogleDriveNode } from "../lib/validators";
+
+export const googleDriveColumns: TableColumnDef<GoogleDriveNode>[] = [
+  createTableSelectCell(),
+  {
+    id: "icon",
+    accessorKey: "icon",
+    header: () => null,
+    cell: ({ row }) => {
+      if (row.original.type === "file") {
+        const subtype = findStatus(nodeSubtypeConfig, row.original.subtype);
+        if (!subtype) return null;
+
+        return (
+          <TableTextCell className="w-4">
+            <Tooltip>
+              <TooltipTrigger>
+                <subtype.icon
+                  className={nodeSubtypeVariants({
+                    status: row.original.subtype,
+                    className: "size-4",
+                  })}
+                />
+              </TooltipTrigger>
+
+              <TooltipContent>{subtype.label}</TooltipContent>
+            </Tooltip>
+          </TableTextCell>
+        );
+      }
+
+      if (row.original.type === "folder") {
+        return (
+          <TableTextCell className="w-4">
+            <FolderIcon className="w-4 min-w-4" />
+          </TableTextCell>
+        );
+      }
+
+      return null;
+    },
+    enableSorting: false,
+  },
+  {
+    id: "name",
+    accessorKey: "name",
+    header: ({ column }) => <TableColumnHeader column={column} title="Naam" />,
+    cell: ({ row }) => {
+      const [query] = useQueryStates(driveTreeSearchParams);
+      const serialize = createSerializer(driveTreeSearchParams);
+
+      return (
+        <TableTextCell className="w-full min-w-64">
+          <Link
+            href={
+              row.original.type === "file"
+                ? ((row.original.links.view as string) ?? "#")
+                : serialize({ ...query, parentId: row.original.id })
+            }
+            className="truncate hover:underline"
+            target={row.original.type === "file" ? "_blank" : "_self"}
+          >
+            {row.getValue("name")}
+          </Link>
+        </TableTextCell>
+      );
+    },
+    enableSorting: false,
+  },
+];

package/src/providers/google/config/filters.ts

@@ -0,0 +1,3 @@
+import { driveTreeFilters } from "@/config/filters";
+
+export const googleDriveTreeFilters = driveTreeFilters;

package/src/providers/google/entry.client.ts

@@ -0,0 +1,10 @@
+/**
+ * Components
+ */
+export * from "./components/command-file-update";
+export * from "./components/command-folder-create";
+export * from "./components/command-folder-update";
+export * from "./components/content.client";
+export * from "./components/navigation.client";
+export * from "./components/provider.client";
+export * from "./components/view.client";

package/src/providers/google/entry.server.ts

@@ -0,0 +1,5 @@
+/**
+ * Lib
+ */
+export * from "./lib/router.server";
+export * from "./lib/service.server";

package/src/providers/google/entry.ts

@@ -0,0 +1,12 @@
+/**
+ * Config
+ */
+
+export * from "./config/columns-data";
+export * from "./config/filters";
+/**
+ * Lib
+ */
+export * from "./lib/dto";
+export * from "./lib/search-params";
+export * from "./lib/validators";

package/src/providers/google/lib/constants.ts

@@ -0,0 +1,10 @@
+export const GOOGLE_DRIVE_FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+
+/**
+ * Minimal Google file fields needed to build a complete `GoogleDriveNode`.
+ *
+ * Keeping this list explicit prevents over-fetching large provider payloads and
+ * ensures every service method receives metadata with the same expected shape.
+ */
+export const GOOGLE_DRIVE_NODE_FIELDS =
+  "id,name,mimeType,size,parents,driveId,createdTime,modifiedTime,trashed,trashedTime,webViewLink,webContentLink,thumbnailLink,contentRestrictions,capabilities";

package/src/providers/google/lib/dto.ts

@@ -0,0 +1,104 @@
+import type { drive_v3 } from "googleapis";
+import { inferLocalDriveNodeSubtype } from "../../local/entry";
+import { GOOGLE_DRIVE_FOLDER_MIME_TYPE } from "./constants";
+import type { GoogleDriveNode } from "./validators";
+
+/**
+ * Input used by the DTO factory.
+ *
+ * `namespace` can be supplied by callers when Google metadata does not include
+ * enough drive context. Most service calls rely on `driveId` or the first parent
+ * from the Google response instead.
+ */
+export type GoogleDriveNodeDTOInput = {
+  file: drive_v3.Schema$File;
+  namespace?: string;
+};
+
+/**
+ * Factory for mapping Google Drive API file metadata to the provider-neutral node shape.
+ * This is the single source of truth for how Google Drive metadata maps to our shared
+ * `DriveNode` contract, ensuring consistent mapping across all service methods.
+ * The factory also handles missing or partial metadata from Google by applying sensible
+ * defaults and fallbacks, so the shared DTO always satisfies the base contract expected
+ * by the UI and other consumers.
+ */
+export const GoogleDriveNodeDTO = {
+  /**
+   * Maps raw Google Drive file metadata to the provider-neutral Drive node shape.
+   *
+   * Google models files and folders with the same `drive_v3.Schema$File` object.
+   * Folders are detected by their special MIME type, while every other MIME type
+   * is treated as a file and mapped to a provider-neutral subtype.
+   */
+  create({ file, namespace }: GoogleDriveNodeDTOInput): GoogleDriveNode {
+    if (!file.id) {
+      throw new Error("Google Drive file has no id");
+    }
+
+    // Google Drive folders are files with a special MIME type.
+    const isFolder = file.mimeType === GOOGLE_DRIVE_FOLDER_MIME_TYPE;
+
+    // Google can omit timestamps in partial responses. Fall back to stable dates
+    // so the shared DTO always satisfies the base Drive node contract.
+    const createdAt = file.createdTime ? new Date(file.createdTime) : new Date();
+    const updatedAt = file.modifiedTime ? new Date(file.modifiedTime) : createdAt;
+
+    // Google calls soft deletion `trashed`; the shared Drive contract exposes it
+    // as `archivedAt` for consistency with local/object-storage providers.
+    const trashedAt = file.trashedTime ? new Date(file.trashedTime) : null;
+    const archivedAt = file.trashed
+      ? (trashedAt ?? new Date(file.modifiedTime ?? Date.now()))
+      : null;
+    const contentType = isFolder ? null : (file.mimeType ?? null);
+    const name = file.name ?? "Untitled";
+    const googleParents = file.parents ?? [];
+    const [googleParentId] = googleParents;
+
+    // The shared `namespace` is the drive/root boundary used by the UI. Prefer
+    // explicit caller context, then Google's shared drive id, then the first
+    // parent as a last-resort root context for My Drive-like responses.
+    const nodeNamespace = namespace ?? file.driveId ?? googleParentId;
+
+    if (!nodeNamespace) {
+      throw new Error("Google Drive file has no namespace");
+    }
+
+    const readonly =
+      file.contentRestrictions?.some((restriction) => restriction.readOnly) ??
+      file.capabilities?.canEdit === false;
+
+    return {
+      id: file.id,
+      provider: "google",
+      createdAt,
+      updatedAt,
+      name,
+      namespace: nodeNamespace,
+      type: isFolder ? "folder" : "file",
+      subtype: isFolder ? "other" : inferLocalDriveNodeSubtype({ name, contentType }),
+      size: file.size ? Number(file.size) : null,
+      contentType,
+      readonly,
+      hidden: false,
+      archivedAt,
+      parentId: googleParentId && googleParentId !== nodeNamespace ? googleParentId : null,
+      links: {
+        view: file.webViewLink ?? file.webContentLink ?? null,
+        download: file.webContentLink ?? null,
+        preview: file.webViewLink ?? null,
+        thumbnail: file.thumbnailLink ?? null,
+      },
+      availability: "ready",
+      googleDriveId: file.driveId ?? null,
+      mimeType: file.mimeType ?? null,
+      webViewLink: file.webViewLink ?? null,
+      webContentLink: file.webContentLink ?? null,
+      thumbnailLink: file.thumbnailLink ?? null,
+      trashed: file.trashed ?? false,
+      trashedAt,
+      googleParents,
+      canEdit: file.capabilities?.canEdit ?? null,
+    } satisfies GoogleDriveNode;
+  },
+};

package/src/providers/google/lib/helpers.ts

@@ -0,0 +1,37 @@
+import { Readable } from "node:stream";
+import type { ObjectBodyInput } from "@tulip-systems/core/storage";
+
+/**
+ * Escapes dynamic values before interpolating them into Google Drive `q` strings.
+ *
+ * Drive query values are wrapped in single quotes. Backslashes and single quotes
+ * can otherwise break the query literal or change the meaning of the expression.
+ */
+export function escapeGoogleDriveQueryValue(value: string) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+/**
+ * Returns true when a Google API error represents a missing file/folder.
+ *
+ * The Google client throws rich error objects rather than typed exceptions, so
+ * the service checks the normalized `code` property and treats only 404 as a
+ * nullable not-found result. Permission, quota, and transport failures should
+ * keep bubbling up.
+ */
+export function isGoogleNotFound(error: unknown) {
+  return typeof error === "object" && error != null && "code" in error && error.code === 404;
+}
+
+/**
+ * Normalizes supported object body inputs into a readable stream for googleapis.
+ *
+ * The Drive client accepts a stream-like `media.body`. Local upload flows can
+ * provide strings, buffers, array-like chunks, or already-created streams, so we
+ * pass through streams and wrap everything else with `Readable.from`.
+ */
+export function toGoogleDriveReadable(body: ObjectBodyInput) {
+  if (body instanceof Readable) return body;
+  if (typeof body === "string") return Readable.from([body]);
+  return Readable.from([body]);
+}

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

@@ -0,0 +1,62 @@
+import type { TDatabaseSchema } from "@tulip-systems/core/config";
+import { bulkActionSchema } from "@tulip-systems/core/router";
+import { initRPC } from "@tulip-systems/core/router/server";
+import { z } from "zod";
+import type { GoogleDrive } from "./service.server";
+import {
+  createGoogleDriveFolderInputSchema,
+  getGoogleDriveNodesByParentIdInputSchema,
+  googleDriveNodeSchema,
+  googleDriveNodeWithChildrenSchema,
+  listGoogleDriveTreeInputSchema,
+  updateGoogleDriveNodeInputSchema,
+} from "./validators";
+
+export function createGoogleDriveProcedures<TSchema extends TDatabaseSchema>(
+  drive: GoogleDrive<TSchema>,
+) {
+  const { protectedProcedure } = initRPC<TSchema>();
+
+  return {
+    getNodeWithChildren: protectedProcedure
+      .input(z.object({ id: z.string(), namespace: z.string() }))
+      .output(googleDriveNodeWithChildrenSchema.nullable())
+      .handler(async ({ input }) => drive.getNodeWithChildren(input)),
+    getNodesByParentId: protectedProcedure
+      .input(getGoogleDriveNodesByParentIdInputSchema)
+      .output(z.array(googleDriveNodeSchema))
+      .handler(async ({ input }) => drive.getNodesByParentId(input)),
+    listTree: protectedProcedure
+      .input(listGoogleDriveTreeInputSchema)
+      .handler(async ({ input }) => drive.listTree(input)),
+    getFolderParents: protectedProcedure
+      .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
+      .handler(async ({ input }) => drive.getFolderParents(input)),
+    createFolder: protectedProcedure
+      .input(createGoogleDriveFolderInputSchema)
+      .output(googleDriveNodeSchema)
+      .handler(async ({ input }) => drive.createFolder(input)),
+    updateNode: protectedProcedure
+      .input(z.object({ id: z.string(), data: updateGoogleDriveNodeInputSchema }))
+      .output(googleDriveNodeSchema)
+      .handler(async ({ input }) => drive.updateNode(input.id, input.data)),
+    moveNode: protectedProcedure
+      .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
+      .output(googleDriveNodeSchema)
+      .handler(async ({ input }) =>
+        drive.moveNode({ id: input.id, parentId: input.parentId ?? null }),
+      ),
+    archiveNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.array(googleDriveNodeSchema))
+      .handler(async ({ input }) => drive.archiveNodes(input.ids)),
+    restoreNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.array(googleDriveNodeSchema))
+      .handler(async ({ input }) => drive.restoreNodes(input.ids)),
+    deleteNodes: protectedProcedure
+      .input(bulkActionSchema)
+      .output(z.void())
+      .handler(async ({ input }) => drive.deleteNodes(input.ids)),
+  };
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Node table
+ */
+
+/**
+ * Drive schema
+ **/
+const googleDriveSchema = {};
+export type GoogleDriveSchema = typeof googleDriveSchema;

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

@@ -0,0 +1,7 @@
+import { resolveFiltersSearchParams } from "@tulip-systems/core/data-tables";
+import { googleDriveTreeFilters } from "../config/filters";
+
+/**
+ * Filters
+ */
+export const googleDriveTreeFilterSearchParams = resolveFiltersSearchParams(googleDriveTreeFilters);