@tulip-systems/drive 0.10.0 → 0.10.2

package/dist/providers/local/lib/validators.mjs

@@ -3,8 +3,8 @@ import { createDriveFolderInputSchema, presignDriveFileInputSchema, updateDriveN
 import { imageVariants } from "./constants.mjs";
 import { localDriveFilters } from "../config/filters.mjs";
 import { z } from "zod";
-import { resolveFiltersSchema, tableQuerySchema } from "@tulip-systems/core/data-tables";
-import { getAssetURLSchema, storageAssetVisibilitySchema } from "@tulip-systems/core/storage";
+import { resolveFiltersSchema, tableQueryPaginationResponseSchema, tableQuerySchema } from "@tulip-systems/core/data-tables";
+import { getAssetURLSchema, selectStorageAssetSchema, storageAssetVisibilitySchema } from "@tulip-systems/core/storage";
 
 //#region src/providers/local/lib/validators.ts
 const localDriveNodeSchema = driveNodeSchema.extend({
@@ -12,6 +12,41 @@ const localDriveNodeSchema = driveNodeSchema.extend({
 	assetId: z.string().nullable()
 });
 /**
+* File node & folder node
+*/
+const localDriveFileNodeSchema = localDriveNodeSchema.extend({ type: z.literal("file") });
+const localDriveFolderNodeSchema = localDriveNodeSchema.extend({ type: z.literal("folder") });
+/**
+* Node with asset
+*/
+const localDriveNodeWithAssetSchema = localDriveNodeSchema.extend({ asset: selectStorageAssetSchema.nullable() });
+/**
+* Presign upload response
+*/
+const localDrivePresignUploadOutputSchema = z.object({
+	uploadId: z.string(),
+	presignedUrl: z.string(),
+	node: localDriveFileNodeSchema,
+	asset: selectStorageAssetSchema
+});
+/**
+* Node parent
+*/
+const localDriveNodeParentSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	parentId: z.string().nullable(),
+	depth: z.number()
+});
+/**
+* Tree response
+*/
+const localDriveTreeResponseSchema = z.object({
+	data: z.array(localDriveNodeWithAssetSchema),
+	pagination: tableQueryPaginationResponseSchema
+});
+const localDriveFlatResponseSchema = localDriveTreeResponseSchema;
+/**
 * Node with children
 */
 const localDriveNodeWithChildrenSchema = localDriveNodeSchema.extend({ children: z.array(localDriveNodeSchema) });
@@ -92,4 +127,4 @@ const getLocalDriveNodesByParentIdInputSchema = tableQuerySchema.pick({
 }).extend({ filters: localDriveTreeFiltersSchema });
 
 //#endregion
-export { createLocalDriveFolderInputSchema, getLocalDriveNodesByParentIdInputSchema, getLocalFileURLSchema, getLocalFileURLSchemaDefaults, listLocalDriveFlatInputSchema, listLocalDriveTreeInputSchema, localDriveFlatFiltersSchema, localDriveNodeSchema, localDriveNodeWithChildrenSchema, localDriveTreeFiltersSchema, presignLocalDriveFileInputSchema, updateLocalDriveNodeInputSchema, uploadLocalDriveFileInputSchema };
+export { createLocalDriveFolderInputSchema, getLocalDriveNodesByParentIdInputSchema, getLocalFileURLSchema, getLocalFileURLSchemaDefaults, listLocalDriveFlatInputSchema, listLocalDriveTreeInputSchema, localDriveFileNodeSchema, localDriveFlatFiltersSchema, localDriveFlatResponseSchema, localDriveFolderNodeSchema, localDriveNodeParentSchema, localDriveNodeSchema, localDriveNodeWithAssetSchema, localDriveNodeWithChildrenSchema, localDrivePresignUploadOutputSchema, localDriveTreeFiltersSchema, localDriveTreeResponseSchema, presignLocalDriveFileInputSchema, updateLocalDriveNodeInputSchema, uploadLocalDriveFileInputSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tulip-systems/drive",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "type": "module",
   "sideEffects": false,
   "license": "AGPL-3.0",
@@ -28,7 +28,7 @@
     "@dnd-kit/utilities": "^3.2.2",
     "@hookform/resolvers": "^5.2.2",
     "@orpc/client": "^1.14.2",
-    "@orpc/contract": "^1.14.2",
+    "@orpc/contract": "1.14.2",
     "@orpc/server": "^1.14.2",
     "@orpc/tanstack-query": "^1.14.2",
     "@tanstack/react-query": "^5.100.9",
@@ -65,7 +65,7 @@
     "uuid": "^14.0.0",
     "vaul": "^1.1.2",
     "zod": "^4.4.3",
-    "@tulip-systems/core": "0.10.0"
+    "@tulip-systems/core": "0.10.2"
   },
   "peerDependencies": {
     "@tailwindcss/typography": "^0.5.19",

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

@@ -1,62 +1,66 @@
-import type { TDatabaseSchema } from "@tulip-systems/core/config";
+import { oc } from "@orpc/contract";
 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,
+  googleDriveNodeParentSchema,
   googleDriveNodeSchema,
   googleDriveNodeWithChildrenSchema,
+  googleDriveTreeResponseSchema,
   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)),
-  };
-}
+export const googleDriveRouterContract = {
+  /**
+   * Get node with children
+   */
+  getNodeWithChildren: oc
+    .input(z.object({ id: z.string(), namespace: z.string() }))
+    .output(googleDriveNodeWithChildrenSchema.nullable()),
+  /**
+   * Get folders by parent id
+   */
+  getNodesByParentId: oc
+    .input(getGoogleDriveNodesByParentIdInputSchema)
+    .output(z.array(googleDriveNodeSchema)),
+  /**
+   * List tree nodes with pagination and search.
+   */
+  listTree: oc.input(listGoogleDriveTreeInputSchema).output(googleDriveTreeResponseSchema),
+  /**
+   * Get parents of a folder
+   */
+  getFolderParents: oc
+    .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
+    .output(z.array(googleDriveNodeParentSchema)),
+  /**
+   * Create a folder
+   */
+  createFolder: oc.input(createGoogleDriveFolderInputSchema).output(googleDriveNodeSchema),
+  /**
+   * Update node
+   */
+  updateNode: oc
+    .input(z.object({ id: z.string(), data: updateGoogleDriveNodeInputSchema }))
+    .output(googleDriveNodeSchema),
+  /**
+   * Move node
+   */
+  moveNode: oc
+    .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
+    .output(googleDriveNodeSchema),
+  /**
+   * Archive nodes
+   */
+  archiveNodes: oc.input(bulkActionSchema).output(z.array(googleDriveNodeSchema)),
+  /**
+   * Restore nodes
+   */
+  restoreNodes: oc.input(bulkActionSchema).output(z.array(googleDriveNodeSchema)),
+  /**
+   * Delete nodes
+   */
+  deleteNodes: oc.input(bulkActionSchema).output(z.void()),
+};

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

@@ -1,6 +1,6 @@
-import type { TDatabaseSchema } from "@tulip-systems/core/config";
 import type { TableQuerySchema } from "@tulip-systems/core/data-tables";
 import type { TableQueryResponse } from "@tulip-systems/core/data-tables/server";
+import type { TDatabaseSchema } from "@tulip-systems/core/database";
 import type { Database } from "@tulip-systems/core/database/server";
 import { ServerError } from "@tulip-systems/core/router/server";
 import type { ObjectBodyInput } from "@tulip-systems/core/storage";

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

@@ -1,3 +1,4 @@
+import { tableQueryPaginationResponseSchema } from "@tulip-systems/core/data-tables";
 import z from "zod";
 import { type DriveNodeChild, driveNodeSchema } from "@/lib/dto";
 import {
@@ -78,6 +79,28 @@ export const googleDriveNodeSchema = driveNodeSchema.extend({
 export type GoogleDriveNode = z.infer<typeof googleDriveNodeSchema>;
 export type GoogleDriveNodeChild = DriveNodeChild<GoogleDriveNode>;
 
+/**
+ * GoogleDriveNodeParent schema
+ * @description zod schema for validating the shape of a GoogleDriveNode parent
+ */
+export const googleDriveNodeParentSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  parentId: z.string().nullable(),
+  depth: z.number(),
+});
+
+/**
+ * GoogleDriveTreeResponse schema
+ * @description zod schema for validating the shape of a GoogleDriveTreeResponse
+ * @see TableQueryResponse<TData> for the common response shape
+ * @see TableQueryPaginationResponse for the common pagination shape
+ */
+export const googleDriveTreeResponseSchema = z.object({
+  data: z.array(googleDriveNodeSchema),
+  pagination: tableQueryPaginationResponseSchema,
+});
+
 /**
  * GoogleDriveNodeWithChildren schema
  * @description zod schema for validating the shape of a GoogleDriveNode with children

package/src/providers/local/lib/route-handler.server.ts

@@ -1,5 +1,6 @@
-import { getSession } from "@tulip-systems/core/auth/server";
-import type { TDatabaseSchema, TulipContext } from "@tulip-systems/core/config";
+import { getSession, type TAuthServerOptions } from "@tulip-systems/core/auth/server";
+import type { TulipContext } from "@tulip-systems/core/config";
+import type { TDatabaseSchema } from "@tulip-systems/core/database";
 import { ServerError } from "@tulip-systems/core/router/server";
 import { connection, type NextRequest } from "next/server";
 import z from "zod";
@@ -10,10 +11,10 @@ type RouteCtx = {
   params: Promise<{ rest?: string[] }>;
 };
 
-type CreateLocalDriveRouteHandlerProps<TSchema extends TDatabaseSchema> = Pick<
-  TulipContext<TSchema>,
-  "auth"
-> & {
+type CreateLocalDriveRouteHandlerProps<
+  TSchema extends TDatabaseSchema,
+  TAuthOptions extends TAuthServerOptions,
+> = Pick<TulipContext<TSchema, TAuthOptions>, "auth"> & {
   drive: LocalDrive<TSchema>;
 };
 
@@ -28,9 +29,10 @@ type CreateLocalDriveRouteHandlerProps<TSchema extends TDatabaseSchema> = Pick<
  * @param props - Route handler dependencies.
  * @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE.
  */
-export function createLocalDriveRouteHandler<TSchema extends TDatabaseSchema>(
-  context: CreateLocalDriveRouteHandlerProps<TSchema>,
-) {
+export function createLocalDriveRouteHandler<
+  TSchema extends TDatabaseSchema,
+  TAuthOptions extends TAuthServerOptions,
+>(context: CreateLocalDriveRouteHandlerProps<TSchema, TAuthOptions>) {
   /**
    * GET /api/drive/[[...rest]]
    *
@@ -76,7 +78,7 @@ export function createLocalDriveRouteHandler<TSchema extends TDatabaseSchema>(
           }
 
           if (asset.visibility === "private") {
-            const session = await getSession(context);
+            const session = await getSession(context.auth);
 
             if (!session) {
               return Response.json(

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

@@ -1,137 +1,231 @@
+import {
+  type InferContractRouterInputs,
+  type InferContractRouterOutputs,
+  oc,
+} from "@orpc/contract";
 import { bulkActionSchema } from "@tulip-systems/core/router";
-import { initRPC } from "@tulip-systems/core/router/server";
 import { z } from "zod";
-import type { DriveSchema } from "./schema";
-import type { LocalDrive } from "./service.server";
 import {
   createLocalDriveFolderInputSchema,
   getLocalDriveNodesByParentIdInputSchema,
   getLocalFileURLSchema,
   listLocalDriveFlatInputSchema,
   listLocalDriveTreeInputSchema,
+  localDriveFileNodeSchema,
+  localDriveFlatResponseSchema,
+  localDriveNodeParentSchema,
   localDriveNodeSchema,
   localDriveNodeWithChildrenSchema,
+  localDrivePresignUploadOutputSchema,
+  localDriveTreeResponseSchema,
   presignLocalDriveFileInputSchema,
   updateLocalDriveNodeInputSchema,
 } from "./validators";
 
+/**
+ * Local Drive router contract defines the input and output schemas for local drive-related procedures.
+ */
+export const localDriveRouterContract = {
+  /**
+   * Get node with children
+   */
+  getNodeWithChildren: oc
+    .input(z.object({ id: z.string(), namespace: z.string() }))
+    .output(localDriveNodeWithChildrenSchema.nullable()),
+  /**
+   * Get folders by parent id
+   */
+  getNodesByParentId: oc
+    .input(getLocalDriveNodesByParentIdInputSchema)
+    .output(z.array(localDriveNodeSchema)),
+  /**
+   * List tree nodes with pagination and search.
+   */
+  listTree: oc.input(listLocalDriveTreeInputSchema).output(localDriveTreeResponseSchema),
+  /**
+   * List flat nodes with pagination and search.
+   */
+  listFlat: oc.input(listLocalDriveFlatInputSchema).output(localDriveFlatResponseSchema),
+  /**
+   * Get parents of a folder
+   */
+  getFolderParents: oc
+    .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
+    .output(z.array(localDriveNodeParentSchema)),
+  /**
+   * Get url for opening a file
+   */
+  getURL: oc.input(getLocalFileURLSchema.extend({ id: z.string() })).output(z.string().nullable()),
+  /**
+   * Create a direct upload intent for a file
+   */
+  presignUpload: oc
+    .input(presignLocalDriveFileInputSchema)
+    .output(localDrivePresignUploadOutputSchema),
+  /**
+   * Confirm a direct upload intent
+   */
+  confirmUpload: oc.input(z.object({ uploadId: z.string() })).output(localDriveFileNodeSchema),
+  /**
+   * Create a folder
+   */
+  createFolder: oc.input(createLocalDriveFolderInputSchema).output(localDriveNodeSchema),
+  /**
+   * Update node
+   */
+  updateNode: oc
+    .input(z.object({ id: z.string(), data: updateLocalDriveNodeInputSchema }))
+    .output(localDriveNodeSchema),
+  /**
+   * Set readonly
+   */
+  setReadonly: oc
+    .input(bulkActionSchema.extend({ readonly: z.boolean() }))
+    .output(z.array(localDriveNodeSchema)),
+  /**
+   * Move node
+   */
+  moveNode: oc
+    .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
+    .output(localDriveNodeSchema),
+  /**
+   * Archive nodes
+   */
+  archiveNodes: oc.input(bulkActionSchema).output(z.array(localDriveNodeSchema)),
+  /**
+   * Restore nodes
+   */
+  restoreNodes: oc.input(bulkActionSchema).output(z.array(localDriveNodeSchema)),
+  /**
+   * Delete nodes
+   */
+  deleteNodes: oc.input(bulkActionSchema).output(z.void()),
+};
+
+export type LocalDriveRouterContractInputs = InferContractRouterInputs<
+  typeof localDriveRouterContract
+>;
+export type LocalDriveRouterContractOutputs = InferContractRouterOutputs<
+  typeof localDriveRouterContract
+>;
+
 /**
  * Create Drive base procedures
  */
-export function createLocalDriveProcedures(drive: LocalDrive<DriveSchema>) {
-  const { protectedProcedure } = initRPC<DriveSchema>();
+// export function createLocalDriveProcedures(drive: LocalDrive<DriveSchema>) {
+//   const rpc = RPC.init<DriveSchema, TAuthServerOptions>();
 
-  return {
-    /**
-     * Get node with children
-     */
-    getNodeWithChildren: protectedProcedure
-      .input(z.object({ id: z.string(), namespace: z.string() }))
-      .output(localDriveNodeWithChildrenSchema.nullable())
-      .handler(async ({ input }) => drive.getNodeWithChildren(input)),
-    /**
-     * Get folders by parent id
-     */
-    getNodesByParentId: protectedProcedure
-      .input(getLocalDriveNodesByParentIdInputSchema)
-      .output(z.array(localDriveNodeSchema))
-      .handler(async ({ input }) => drive.getNodesByParentId(input)),
-    /**
-     * List tree nodes with pagination and search.
-     */
-    listTree: protectedProcedure
-      .input(listLocalDriveTreeInputSchema)
-      .handler(async ({ input }) => drive.listTree(input)),
-    /**
-     * List flat nodes with pagination and search.
-     */
-    listFlat: protectedProcedure
-      .input(listLocalDriveFlatInputSchema)
-      .handler(async ({ input }) => drive.listFlat(input)),
-    /**
-     * Get parents of a folder
-     */
-    getFolderParents: protectedProcedure
-      .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
-      .handler(async ({ input }) => drive.getFolderParents(input)),
-    /**
-     * Get url for opening a file
-     */
-    getURL: protectedProcedure
-      .input(getLocalFileURLSchema.extend({ id: z.string() }))
-      .output(z.string().nullable())
-      .handler(async ({ input: { id, ...options } }) => {
-        const node = await drive.getNodeById(id);
-        if (!node) return null;
+//   return {
+//     /**
+//      * Get node with children
+//      */
+//     getNodeWithChildren: rpc
+//       .input(z.object({ id: z.string(), namespace: z.string() }))
+//       .output(localDriveNodeWithChildrenSchema.nullable())
+//       .handler(async ({ input }) => drive.getNodeWithChildren(input)),
+//     /**
+//      * Get folders by parent id
+//      */
+//     getNodesByParentId: rpc
+//       .input(getLocalDriveNodesByParentIdInputSchema)
+//       .output(z.array(localDriveNodeSchema))
+//       .handler(async ({ input }) => drive.getNodesByParentId(input)),
+//     /**
+//      * List tree nodes with pagination and search.
+//      */
+//     listTree: rpc
+//       .input(listLocalDriveTreeInputSchema)
+//       .handler(async ({ input }) => drive.listTree(input)),
+//     /**
+//      * List flat nodes with pagination and search.
+//      */
+//     listFlat: rpc
+//       .input(listLocalDriveFlatInputSchema)
+//       .handler(async ({ input }) => drive.listFlat(input)),
+//     /**
+//      * Get parents of a folder
+//      */
+//     getFolderParents: rpc
+//       .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
+//       .handler(async ({ input }) => drive.getFolderParents(input)),
+//     /**
+//      * Get url for opening a file
+//      */
+//     getURL: rpc
+//       .input(getLocalFileURLSchema.extend({ id: z.string() }))
+//       .output(z.string().nullable())
+//       .handler(async ({ input: { id, ...options } }) => {
+//         const node = await drive.getNodeById(id);
+//         if (!node) return null;
 
-        return await drive.getURL(node, options);
-      }),
+//         return await drive.getURL(node, options);
+//       }),
 
-    /**
-     * Create a direct upload intent for a file
-     */
-    presignUpload: protectedProcedure
-      .input(presignLocalDriveFileInputSchema)
-      .handler(async ({ input }) => drive.presignUpload(input)),
-    /**
-     * Confirm a direct upload intent
-     */
-    confirmUpload: protectedProcedure
-      .input(z.object({ uploadId: z.string() }))
-      .handler(async ({ input }) => drive.confirmUpload(input.uploadId)),
-    /**
-     * Create a folder
-     */
-    createFolder: protectedProcedure
-      .input(createLocalDriveFolderInputSchema)
-      .output(localDriveNodeSchema)
-      .handler(async ({ input }) => drive.createFolder(input)),
-    /**
-     * Update node
-     */
-    updateNode: protectedProcedure
-      .input(z.object({ id: z.string(), data: updateLocalDriveNodeInputSchema }))
-      .output(localDriveNodeSchema)
-      .handler(async ({ input }) => drive.updateNode(input.id, input.data)),
-    /**
-     * Set readonly
-     */
-    setReadonly: protectedProcedure
-      .input(bulkActionSchema.extend({ readonly: z.boolean() }))
-      .output(z.array(localDriveNodeSchema))
-      .handler(async ({ input }) => drive.setReadonly(input.ids, input.readonly)),
-    /**
-     * Move node
-     */
-    moveNode: protectedProcedure
-      .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
-      .output(localDriveNodeSchema)
-      .handler(async ({ input }) =>
-        drive.moveNode({
-          id: input.id,
-          parentId: input.parentId ?? null,
-        }),
-      ),
-    /**
-     * Archive nodes
-     */
-    archiveNodes: protectedProcedure
-      .input(bulkActionSchema)
-      .output(z.array(localDriveNodeSchema))
-      .handler(async ({ input }) => drive.archiveNodes(input.ids)),
-    /**
-     * Restore nodes
-     */
-    restoreNodes: protectedProcedure
-      .input(bulkActionSchema)
-      .output(z.array(localDriveNodeSchema))
-      .handler(async ({ input }) => drive.restoreNodes(input.ids)),
-    /**
-     * Delete nodes
-     */
-    deleteNodes: protectedProcedure
-      .input(bulkActionSchema)
-      .output(z.void())
-      .handler(async ({ input }) => drive.deleteNodes(input.ids)),
-  };
-}
+//     /**
+//      * Create a direct upload intent for a file
+//      */
+//     presignUpload: rpc
+//       .input(presignLocalDriveFileInputSchema)
+//       .handler(async ({ input }) => drive.presignUpload(input)),
+//     /**
+//      * Confirm a direct upload intent
+//      */
+//     confirmUpload: rpc
+//       .input(z.object({ uploadId: z.string() }))
+//       .handler(async ({ input }) => drive.confirmUpload(input.uploadId)),
+//     /**
+//      * Create a folder
+//      */
+//     createFolder: rpc
+//       .input(createLocalDriveFolderInputSchema)
+//       .output(localDriveNodeSchema)
+//       .handler(async ({ input }) => drive.createFolder(input)),
+//     /**
+//      * Update node
+//      */
+//     updateNode: rpc
+//       .input(z.object({ id: z.string(), data: updateLocalDriveNodeInputSchema }))
+//       .output(localDriveNodeSchema)
+//       .handler(async ({ input }) => drive.updateNode(input.id, input.data)),
+//     /**
+//      * Set readonly
+//      */
+//     setReadonly: rpc
+//       .input(bulkActionSchema.extend({ readonly: z.boolean() }))
+//       .output(z.array(localDriveNodeSchema))
+//       .handler(async ({ input }) => drive.setReadonly(input.ids, input.readonly)),
+//     /**
+//      * Move node
+//      */
+//     moveNode: rpc
+//       .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
+//       .output(localDriveNodeSchema)
+//       .handler(async ({ input }) =>
+//         drive.moveNode({
+//           id: input.id,
+//           parentId: input.parentId ?? null,
+//         }),
+//       ),
+//     /**
+//      * Archive nodes
+//      */
+//     archiveNodes: rpc
+//       .input(bulkActionSchema)
+//       .output(z.array(localDriveNodeSchema))
+//       .handler(async ({ input }) => drive.archiveNodes(input.ids)),
+//     /**
+//      * Restore nodes
+//      */
+//     restoreNodes: rpc
+//       .input(bulkActionSchema)
+//       .output(z.array(localDriveNodeSchema))
+//       .handler(async ({ input }) => drive.restoreNodes(input.ids)),
+//     /**
+//      * Delete nodes
+//      */
+//     deleteNodes: rpc
+//       .input(bulkActionSchema)
+//       .output(z.void())
+//       .handler(async ({ input }) => drive.deleteNodes(input.ids)),
+//   };
+// }

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

@@ -1,4 +1,4 @@
-import { baseColumns } from "@tulip-systems/core/config";
+import { baseColumns } from "@tulip-systems/core/database";
 import { imageDispositions, storageAssets } from "@tulip-systems/core/storage";
 import { relations } from "drizzle-orm";
 import { type AnyPgColumn, boolean, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";