@tulip-systems/drive 0.8.1 → 0.8.2

package/dist/providers/google/lib/service.server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.server.mjs","names":["#getFile","#toNode","#parentQuery","#idQuery","#typeQuery","#contentTypeQuery","#archiveQuery","#searchQuery","#listChildren","#buildQuery","#orderBy","#pageCursorAt","#listNodes","#walkParents","#walkChildren","#setTrashed"],"sources":["../../../../src/providers/google/lib/service.server.ts"],"sourcesContent":["import type { TDatabaseSchema } from \"@tulip-systems/core/config\";\nimport type { TableQuerySchema } from \"@tulip-systems/core/data-tables\";\nimport type { TableQueryResponse } from \"@tulip-systems/core/data-tables/server\";\nimport type { Database } from \"@tulip-systems/core/database/server\";\nimport { ServerError } from \"@tulip-systems/core/router/server\";\nimport type { ObjectBodyInput } from \"@tulip-systems/core/storage\";\nimport { type drive_v3, google } from \"googleapis\";\nimport type {\n  DriveArchive,\n  DriveDirectUpload,\n  DriveNodeMutations,\n  DriveReader,\n} from \"@/lib/contracts\";\nimport { GOOGLE_DRIVE_FOLDER_MIME_TYPE, GOOGLE_DRIVE_NODE_FIELDS } from \"./constants\";\nimport { GoogleDriveNodeDTO } from \"./dto\";\nimport { escapeGoogleDriveQueryValue, isGoogleNotFound, toGoogleDriveReadable } from \"./helpers\";\nimport type {\n  CreateGoogleDriveFolderInput,\n  GetGoogleDriveNodesByParentIdSchema,\n  GoogleDriveNode,\n  GoogleDriveNodeChild,\n  GoogleDriveNodeWithChildren,\n  GoogleDriveTableFilters,\n  ListGoogleDriveTreeSchema,\n  UpdateGoogleDriveNodeInput,\n  UploadGoogleDriveFileInput,\n} from \"./validators\";\n\nconst DEFAULT_PAGE_SIZE = 10;\nconst CHILDREN_PAGE_SIZE = 1000;\n\n/**\n * Drive Service Config\n */\nexport type GoogleDriveConfig<TSchema extends TDatabaseSchema> = Pick<drive_v3.Options, \"auth\"> & {\n  db: Database<TSchema>;\n};\n\n/**\n * Google Drive provider.\n *\n * A single service instance can operate on multiple Google shared drives. The\n * shared Drive `namespace` is the Google `driveId`, so namespace is supplied by\n * method inputs rather than by the constructor.\n */\nexport class GoogleDrive<TSchema extends TDatabaseSchema>\n  implements\n    DriveReader<GoogleDriveNode, GoogleDriveNodeWithChildren, GoogleDriveNodeChild>,\n    DriveNodeMutations<GoogleDriveNode>,\n    DriveDirectUpload<GoogleDriveNode, ObjectBodyInput>,\n    DriveArchive<GoogleDriveNode>\n{\n  readonly client: drive_v3.Drive;\n\n  constructor(config: GoogleDriveConfig<TSchema>) {\n    this.client = google.drive({ auth: config.auth, version: \"v3\" });\n  }\n\n  /**\n   * Fetches raw Google Drive metadata for a file or folder.\n   *\n   * Google Drive uses the same `files.get` endpoint for files and folders. We\n   * request only `GOOGLE_DRIVE_NODE_FIELDS` so DTO mapping receives a predictable\n   * shape and we avoid over-fetching provider metadata.\n   *\n   * A Google 404 is translated to `null` to match the public `getNodeById`\n   * contract. All other errors are rethrown because they represent real failures\n   * such as insufficient permissions, invalid credentials, quota limits, or API\n   * outages.\n   */\n  async #getFile(id: string): Promise<drive_v3.Schema$File | null> {\n    try {\n      const result = await this.client.files.get({\n        fileId: id,\n        supportsAllDrives: true,\n        fields: GOOGLE_DRIVE_NODE_FIELDS,\n      });\n\n      return result.data;\n    } catch (error) {\n      if (isGoogleNotFound(error)) return null;\n      throw error;\n    }\n  }\n\n  /**\n   * Loads a single Google Drive file/folder by its Google file id.\n   *\n   * Returns `null` when Google reports the file does not exist or is not visible to\n   * the authenticated account. Other Google API errors are allowed to bubble up so\n   * callers do not accidentally treat permission, quota, or transport failures as\n   * missing data.\n   *\n   * The returned Google metadata is normalized into the shared Drive node shape by\n   * `#toNode`, which also validates that Google returned the minimum metadata we\n   * need to identify the node and its namespace.\n   */\n  async getNodeById(id: string): Promise<GoogleDriveNode | null> {\n    const file = await this.#getFile(id);\n    return file ? this.#toNode(file) : null;\n  }\n\n  /**\n   * Converts a table sort field into a Google Drive `orderBy` value.\n   *\n   * Google Drive only accepts a fixed set of field names in `files.list.orderBy`.\n   * The table layer uses provider-neutral names such as `createdAt` and\n   * `updatedAt`, so this method maps those aliases to Google's native field names.\n   *\n   * Unknown sort fields intentionally fall back to `modifiedTime desc` instead of\n   * being passed through, because Google returns a 400 for unsupported order fields.\n   */\n  #orderBy(input: Pick<TableQuerySchema, \"sort\" | \"order\">): string {\n    const direction = input.order === \"asc\" ? \"\" : \" desc\";\n\n    switch (input.sort) {\n      case \"name\":\n        return `name${direction}`;\n      case \"createdAt\":\n      case \"createdTime\":\n        return `createdTime${direction}`;\n      case \"updatedAt\":\n      case \"modifiedTime\":\n        return `modifiedTime${direction}`;\n      default:\n        return \"modifiedTime desc\";\n    }\n  }\n\n  /**\n   * Scopes results to a parent folder.\n   *\n   * Google Drive represents folder membership as `'<folderId>' in parents`.\n   * A `null` parent maps to the provider namespace/root drive id.\n   * An `undefined` parent means no parent filter should be applied.\n   */\n  #parentQuery(input: Pick<GoogleDriveTableFilters, \"namespace\" | \"parentId\">): string | null {\n    if (input.parentId === undefined) return null;\n\n    const parentId = input.parentId ?? input.namespace;\n    return `'${escapeGoogleDriveQueryValue(parentId)}' in parents`;\n  }\n\n  /**\n   * Filters results to a specific set of Google file ids.\n   */\n  #idQuery(nodeIds?: string[] | null): string | null {\n    if (!nodeIds?.length) return null;\n    return `(${nodeIds.map((id) => `id = '${escapeGoogleDriveQueryValue(id)}'`).join(\" or \")})`;\n  }\n\n  /**\n   * Converts provider-neutral node types to Google Drive MIME-type filters.\n   *\n   * Google Drive folders are identified by their folder MIME type. Every other\n   * MIME type is treated as a file.\n   */\n  #typeQuery(types?: Array<\"file\" | \"folder\"> | null): string | null {\n    if (types?.length !== 1) return null;\n\n    return types[0] === \"folder\"\n      ? `mimeType = '${GOOGLE_DRIVE_FOLDER_MIME_TYPE}'`\n      : `mimeType != '${GOOGLE_DRIVE_FOLDER_MIME_TYPE}'`;\n  }\n\n  /**\n   * Filters files by MIME type.\n   *\n   * This only applies to files. Folder filtering should use `#typeQuery`.\n   */\n  #contentTypeQuery(contentTypes?: string[] | null): string | null {\n    if (!contentTypes?.length) return null;\n\n    return `(${contentTypes\n      .map((contentType) => `mimeType = '${escapeGoogleDriveQueryValue(contentType)}'`)\n      .join(\" or \")})`;\n  }\n\n  /**\n   * Filters archived/active nodes.\n   *\n   * Google Drive calls this state `trashed`; the shared Drive contract calls it\n   * archived/soft-deleted. By default we return active nodes only.\n   */\n  #archiveQuery(isArchived?: boolean | null): string | null {\n    return `trashed = ${isArchived === true ? \"true\" : \"false\"}`;\n  }\n\n  /**\n   * Applies a name search.\n   *\n   * Google Drive supports `name contains '<value>'`, which is a substring match.\n   */\n  #searchQuery(search?: string | null): string | null {\n    if (!search) return null;\n\n    return `name contains '${escapeGoogleDriveQueryValue(search)}'`;\n  }\n\n  #buildQuery(input: GoogleDriveTableFilters & Pick<TableQuerySchema, \"search\">): string {\n    return [\n      this.#parentQuery(input),\n      this.#idQuery(input.nodeIds),\n      this.#typeQuery(input.types),\n      this.#contentTypeQuery(input.contentTypes),\n      this.#archiveQuery(input.isArchived),\n      this.#searchQuery(input.search),\n    ]\n      .filter((clause): clause is string => typeof clause === \"string\" && clause.length > 0)\n      .join(\" and \");\n  }\n\n  /**\n   * Lists the direct children of a Google Drive folder.\n   *\n   * Google Drive stores both files and folders behind the `files.list` endpoint.\n   * This helper translates our drive query input into a Google Drive search query\n   * and returns only the immediate children for the requested parent.\n   *\n   * The result is paginated by Google, so we keep requesting pages until all\n   * matching children are loaded. Recursive traversal is intentionally not handled\n   * here; callers that need full subtrees should use `getNodeChildren`.\n   */\n  async #listChildren(input: GetGoogleDriveNodesByParentIdSchema) {\n    const filters = input?.filters;\n    const files: drive_v3.Schema$File[] = [];\n    let pageToken: string | undefined;\n\n    do {\n      const result = await this.client.files.list({\n        pageToken,\n        pageSize: CHILDREN_PAGE_SIZE,\n        corpora: \"drive\",\n        driveId: input.filters.namespace,\n        includeItemsFromAllDrives: true,\n        supportsAllDrives: true,\n        q: this.#buildQuery({\n          namespace: input.filters.namespace,\n          parentId: input.filters.parentId,\n          nodeIds: filters?.nodeIds,\n          types: filters?.types,\n          contentTypes: filters?.contentTypes,\n          isArchived: filters?.isArchived,\n          search: input?.search,\n        }),\n        orderBy: this.#orderBy(input),\n        fields: `nextPageToken, files(${GOOGLE_DRIVE_NODE_FIELDS})`,\n      });\n\n      files.push(...(result.data.files ?? []));\n      pageToken = result.data.nextPageToken ?? undefined;\n    } while (pageToken);\n\n    return files.map((file) => this.#toNode(file));\n  }\n\n  /**\n   * Loads a node and its direct children within a namespace.\n   *\n   * Google Drive does not enforce our provider-neutral `namespace` at `files.get`\n   * time, so the node is fetched by id first and then checked against the requested\n   * namespace/shared drive. A missing node or namespace mismatch returns\n   * `null`, matching the shared Drive reader contract.\n   *\n   * Only direct children are loaded. Recursive traversal is handled separately by\n   * `getNodeChildren`.\n   */\n  async getNodeWithChildren(input: {\n    id: string;\n    namespace: string;\n  }): Promise<GoogleDriveNodeWithChildren | null> {\n    const node = await this.getNodeById(input.id);\n    if (!node || node.namespace !== input.namespace) return null;\n\n    const children = await this.#listChildren({\n      filters: {\n        parentId: node.id,\n        namespace: node.namespace,\n        isArchived: false,\n      },\n    });\n\n    return { ...node, children };\n  }\n\n  /**\n   * Lists the direct children of a parent folder.\n   *\n   * This is the Google Drive implementation of the shared Drive reader method. It\n   * delegates to `#listChildren`, which translates the provider-neutral filters,\n   * search, and sorting options into a Google Drive `files.list` query.\n   *\n   * Only immediate children are returned. Recursive traversal is handled by\n   * `getNodeChildren`.\n   */\n  async getNodesByParentId(input: GetGoogleDriveNodesByParentIdSchema): Promise<GoogleDriveNode[]> {\n    return this.#listChildren(input);\n  }\n\n  /**\n   * Resolves the Google Drive page token for a numeric table cursor.\n   *\n   * The shared table API uses numeric cursors (`0`, `1`, `2`, ...), while Google\n   * Drive pagination uses opaque `nextPageToken` values. To bridge that mismatch,\n   * we walk Google pages until we reach the requested table page.\n   *\n   * The intermediate requests only fetch file ids because their content is thrown\n   * away; we only need each response's `nextPageToken`.\n   *\n   * Returns `exhausted: true` when Google runs out of pages before the requested\n   * cursor is reached.\n   */\n  async #pageCursorAt(\n    input: {\n      namespace: string;\n      q: string;\n      limit: number;\n      cursor?: number;\n      orderBy?: string;\n    },\n    remainingPages: number,\n    pageToken?: string,\n  ): Promise<{ pageToken?: string; exhausted: boolean }> {\n    if (remainingPages === 0) return { pageToken, exhausted: false };\n\n    const result = await this.client.files.list({\n      pageSize: input.limit,\n      pageToken,\n      corpora: \"drive\",\n      driveId: input.namespace,\n      includeItemsFromAllDrives: true,\n      supportsAllDrives: true,\n      q: input.q,\n      orderBy: input.orderBy,\n      fields: \"nextPageToken, files(id)\",\n    });\n\n    const nextPageToken = result.data.nextPageToken ?? undefined;\n    if (!nextPageToken) return { exhausted: true };\n\n    return this.#pageCursorAt(input, remainingPages - 1, nextPageToken);\n  }\n\n  /**\n   * Lists Google Drive nodes using the shared table pagination shape.\n   *\n   * The shared table API uses numeric cursors, but Google Drive uses opaque page\n   * tokens. Before fetching the requested page, `#pageCursorAt` advances through\n   * Google pages until it resolves the page token for the requested numeric cursor.\n   *\n   * Google Drive does not return a total row count for `files.list`, so pagination\n   * totals are estimated from the current cursor, returned page size, and whether\n   * Google reports another page. The estimate is only meant to support table/infinite\n   * pagination controls; it should not be treated as an exact item count.\n   */\n  async #listNodes(input: {\n    namespace: string;\n    q: string;\n    limit?: number;\n    cursor?: number;\n    orderBy?: string;\n  }): Promise<TableQueryResponse<GoogleDriveNode>> {\n    const limit = input.limit ?? DEFAULT_PAGE_SIZE;\n    const cursor = input.cursor ?? 0;\n    const pageCursor = await this.#pageCursorAt({ ...input, limit }, cursor);\n\n    if (pageCursor.exhausted) {\n      return {\n        data: [],\n        pagination: {\n          total: cursor * limit,\n          totalPages: Math.max(1, cursor),\n          limit,\n          hasNextPage: false,\n          hasPreviousPage: cursor > 0,\n          cursor,\n          nextCursor: null,\n          previousCursor: cursor > 0 ? cursor - 1 : null,\n        },\n      };\n    }\n\n    const result = await this.client.files.list({\n      pageSize: limit,\n      pageToken: pageCursor.pageToken,\n      corpora: \"drive\",\n      driveId: input.namespace,\n      includeItemsFromAllDrives: true,\n      supportsAllDrives: true,\n      q: input.q,\n      orderBy: input.orderBy,\n      fields: `nextPageToken, files(${GOOGLE_DRIVE_NODE_FIELDS})`,\n    });\n\n    const data = result.data.files?.map((file) => this.#toNode(file)) ?? [];\n    const hasNextPage = result.data.nextPageToken != null;\n\n    // Google does not expose an exact total for this query. Estimate enough rows\n    // for the current page and one possible next page so pagination remains usable.\n    const total = cursor * limit + data.length + (hasNextPage ? limit : 0);\n\n    return {\n      data,\n      pagination: {\n        total,\n        totalPages: Math.max(1, Math.ceil(total / limit)),\n        limit,\n        hasNextPage,\n        hasPreviousPage: cursor > 0,\n        cursor,\n        nextCursor: hasNextPage ? cursor + 1 : null,\n        previousCursor: cursor > 0 ? cursor - 1 : null,\n      },\n    };\n  }\n\n  /**\n   * Lists one page of Google Drive nodes for a tree/folder view.\n   *\n   * The public input uses the shared table-query shape: pagination, sorting,\n   * search, and drive filters. This method translates that input into the internal\n   * Google Drive list request shape used by `#listNodes`.\n   *\n   * Google Drive does not expose a native tree endpoint. This returns only the\n   * direct children for the requested `parentId`; recursive traversal is handled\n   * by `getNodeChildren`.\n   */\n  async listTree(input: ListGoogleDriveTreeSchema): Promise<TableQueryResponse<GoogleDriveNode>> {\n    return this.#listNodes({\n      namespace: input.filters.namespace,\n      limit: input.limit,\n      cursor: input.cursor,\n      orderBy: this.#orderBy(input),\n      q: this.#buildQuery({\n        namespace: input.filters.namespace,\n        parentId: input.filters.parentId,\n        nodeIds: input.filters.nodeIds,\n        types: input.filters.types,\n        contentTypes: input.filters.contentTypes,\n        isArchived: input.filters.isArchived,\n        search: input.search,\n      }),\n    });\n  }\n\n  /**\n   * Walks from a Google Drive node up through its parent chain.\n   *\n   * Google Drive only exposes direct parents, so breadcrumbs must be resolved one\n   * node at a time. The `seen` set prevents accidental infinite loops if Google\n   * ever returns cyclic or inconsistent parent metadata.\n   *\n   * `seen` is treated immutably so each recursive call receives its own traversal\n   * state instead of mutating caller-owned state.\n   */\n  async #walkParents(\n    currentId: string | null,\n    namespace: string,\n    depth = 0,\n    seen = new Set<string>(),\n  ): Promise<Array<Pick<GoogleDriveNode, \"id\" | \"name\" | \"parentId\"> & { depth: number }>> {\n    if (!currentId || seen.has(currentId)) return [];\n\n    const node = await this.getNodeById(currentId);\n    if (!node || node.namespace !== namespace) return [];\n\n    const nextSeen = new Set([...seen, node.id]);\n\n    return [\n      { id: node.id, name: node.name, parentId: node.parentId, depth },\n      ...(await this.#walkParents(node.parentId, namespace, depth + 1, nextSeen)),\n    ];\n  }\n\n  /**\n   * Resolves the breadcrumb parent chain for a Google Drive node.\n   *\n   * A `null` id represents the namespace root and therefore has no parent chain.\n   * The returned list is ordered from the root-most ancestor to the requested\n   * node, matching breadcrumb display order.\n   */\n  async getFolderParents(input: {\n    id: string | null;\n    namespace: string;\n  }): Promise<Array<Pick<GoogleDriveNode, \"id\" | \"name\" | \"parentId\"> & { depth: number }>> {\n    if (!input.id) return [];\n\n    const parents = await this.#walkParents(input.id, input.namespace);\n    return parents.toSorted((a, b) => Number(b.depth) - Number(a.depth));\n  }\n\n  /**\n   * Walks a Google Drive subtree breadth-first.\n   *\n   * Google Drive has no recursive children endpoint, so folder descendants must be\n   * loaded one folder at a time. The returned rows include the starting nodes and\n   * all descendants with their relative depth.\n   */\n  async #walkChildren(\n    queue: { id: string; depth: number }[],\n    seen: ReadonlySet<string> = new Set(),\n  ): Promise<GoogleDriveNodeChild[]> {\n    const [current, ...rest] = queue;\n    if (!current) return [];\n\n    if (seen.has(current.id)) {\n      return this.#walkChildren(rest, seen);\n    }\n\n    const node = await this.getNodeById(current.id);\n    if (!node) {\n      return this.#walkChildren(rest, seen);\n    }\n\n    const nextSeen = new Set([...seen, node.id]);\n    const currentChild = {\n      id: node.id,\n      type: node.type,\n      parentId: node.parentId,\n      depth: current.depth,\n    } satisfies GoogleDriveNodeChild;\n\n    if (node.type !== \"folder\") {\n      return [currentChild, ...(await this.#walkChildren(rest, nextSeen))];\n    }\n\n    const children = await this.#listChildren({\n      filters: {\n        namespace: node.namespace,\n        parentId: node.id,\n        isArchived: false,\n      },\n    });\n\n    const nextQueue = [\n      ...rest,\n      ...children.map((child) => ({\n        id: child.id,\n        depth: current.depth + 1,\n      })),\n    ];\n\n    return [currentChild, ...(await this.#walkChildren(nextQueue, nextSeen))];\n  }\n\n  /**\n   * Resolves the subtree for one or more Google Drive nodes.\n   */\n  async getNodeChildren(ids: string[]): Promise<GoogleDriveNodeChild[]> {\n    const uniqueIds = Array.from(new Set(ids));\n    return this.#walkChildren(uniqueIds.map((id) => ({ id, depth: 0 })));\n  }\n\n  /**\n   * Creates a Google Drive folder in the requested parent.\n   *\n   * Google Drive represents folders as files with the special folder MIME type.\n   * Creating a folder therefore uses the same `files.create` endpoint as file\n   * uploads, but without a media body.\n   *\n   * A `null` or missing `parentId` means \"create in the namespace root\", where the\n   * namespace is the shared drive id/root folder used by this provider.\n   */\n  async createFolder(input: CreateGoogleDriveFolderInput): Promise<GoogleDriveNode> {\n    const result = await this.client.files.create({\n      requestBody: {\n        name: input.name,\n        parents: [input.parentId ?? input.namespace],\n        mimeType: GOOGLE_DRIVE_FOLDER_MIME_TYPE,\n      },\n      supportsAllDrives: true,\n      fields: GOOGLE_DRIVE_NODE_FIELDS,\n    });\n\n    return this.#toNode(result.data);\n  }\n\n  /**\n   * Uploads a file body to Google Drive and returns the created node.\n   *\n   * Google Drive creates files through `files.create` with two parts:\n   * metadata in `requestBody` and the actual file content in `media.body`.\n   *\n   * A `null` or missing `parentId` means \"upload to the namespace root\", where the\n   * namespace is the Google shared drive/root id used by this provider.\n   *\n   * The input body can be a provider-neutral object body type. `toReadable`\n   * normalizes it into a Node.js readable stream because the Google API client\n   * expects stream-compatible media bodies.\n   */\n  async uploadFile(\n    input: UploadGoogleDriveFileInput & { body: ObjectBodyInput },\n  ): Promise<GoogleDriveNode> {\n    const result = await this.client.files.create({\n      requestBody: {\n        name: input.name,\n        parents: [input.parentId ?? input.namespace],\n        mimeType: input.contentType ?? undefined,\n      },\n      media: {\n        mimeType: input.contentType ?? undefined,\n        body: toGoogleDriveReadable(input.body),\n      },\n      supportsAllDrives: true,\n      fields: GOOGLE_DRIVE_NODE_FIELDS,\n    });\n\n    return this.#toNode(result.data);\n  }\n\n  /**\n   * Updates mutable Google Drive node metadata.\n   *\n   * Google Drive uses `files.update` for metadata changes such as renaming and\n   * moving a file/folder to or from the trash. The shared Drive API calls this\n   * soft-delete state \"archived\"; Google Drive exposes it as `trashed`, so\n   * `data.isArchived` is translated directly to Google's `trashed` field.\n   *\n   * Parent changes are intentionally not handled here. Moving a node requires\n   * Google Drive's `addParents`/`removeParents` API and should go through\n   * `moveNode` instead.\n   */\n  async updateNode(id: string, data: UpdateGoogleDriveNodeInput): Promise<GoogleDriveNode> {\n    const result = await this.client.files.update({\n      fileId: id,\n      requestBody: {\n        name: data.name,\n        trashed: data.isArchived,\n      },\n      supportsAllDrives: true,\n      fields: GOOGLE_DRIVE_NODE_FIELDS,\n    });\n\n    return this.#toNode(result.data);\n  }\n\n  /**\n   * Moves a Google Drive node to another parent folder.\n   *\n   * Google Drive does not allow parent changes through the normal metadata\n   * `requestBody`. Moving requires `addParents` and `removeParents` on\n   * `files.update`, so this operation is intentionally separate from `updateNode`.\n   *\n   * A `null` parent means \"move to the namespace root\". For this provider, the\n   * namespace is the Google shared drive/root id.\n   */\n  async moveNode(input: { id: string; parentId: string | null }): Promise<GoogleDriveNode> {\n    const node = await this.getNodeById(input.id);\n    if (!node) {\n      throw new ServerError(\"NOT_FOUND\", { message: \"Node not found\" });\n    }\n\n    if (node.readonly) {\n      throw new ServerError(\"BAD_REQUEST\", { message: \"Node is readonly and cannot be changed\" });\n    }\n\n    if (input.parentId === input.id) {\n      throw new ServerError(\"BAD_REQUEST\", { message: \"Node cannot be moved into itself\" });\n    }\n\n    // Prevent creating cycles by moving a folder into one of its descendants.\n    if (input.parentId) {\n      const subtree = await this.getNodeChildren([input.id]);\n\n      if (subtree.some((child) => child.id === input.parentId)) {\n        throw new ServerError(\"BAD_REQUEST\", {\n          message: \"Node cannot be moved into one of its descendants\",\n        });\n      }\n    }\n\n    const result = await this.client.files.update({\n      fileId: input.id,\n      addParents: input.parentId ?? node.namespace,\n      removeParents: node.googleParents.join(\",\") || undefined,\n      supportsAllDrives: true,\n      fields: GOOGLE_DRIVE_NODE_FIELDS,\n    });\n\n    return this.#toNode(result.data);\n  }\n\n  /**\n   * Updates the Google Drive trash state for multiple nodes.\n   *\n   * Google Drive exposes archive/restore behavior through the `trashed` metadata\n   * field on `files.update`. Each node requires a separate API request, so updates\n   * are executed in parallel after duplicate ids are removed.\n   */\n  async #setTrashed(ids: string[], trashed: boolean): Promise<GoogleDriveNode[]> {\n    const uniqueIds = [...new Set(ids)];\n\n    const results = await Promise.all(\n      uniqueIds.map((id) =>\n        this.client.files.update({\n          fileId: id,\n          requestBody: { trashed },\n          supportsAllDrives: true,\n          fields: GOOGLE_DRIVE_NODE_FIELDS,\n        }),\n      ),\n    );\n\n    return results.map((result) => this.#toNode(result.data));\n  }\n\n  /**\n   * Moves Google Drive nodes to trash.\n   *\n   * The shared Drive API calls this \"archive\", while Google Drive calls the same\n   * state `trashed`. This is a soft-delete operation; nodes can be restored with\n   * `restoreNodes`.\n   */\n  async archiveNodes(ids: string[]): Promise<GoogleDriveNode[]> {\n    return this.#setTrashed(ids, true);\n  }\n\n  /**\n   * Restores Google Drive nodes from trash.\n   *\n   * This reverses `archiveNodes` by setting Google Drive's `trashed` flag back to\n   * `false`.\n   */\n  async restoreNodes(ids: string[]): Promise<GoogleDriveNode[]> {\n    return this.#setTrashed(ids, false);\n  }\n\n  /**\n   * Permanently deletes a Google Drive node.\n   *\n   * This uses Google Drive `files.delete`, which removes the file/folder rather\n   * than moving it to trash. Soft deletion/trashing should go through the archive\n   * method instead.\n   */\n  async deleteNode(id: string): Promise<void> {\n    await this.client.files.delete({\n      fileId: id,\n      supportsAllDrives: true,\n    });\n  }\n\n  /**\n   * Permanently deletes multiple Google Drive nodes.\n   *\n   * Duplicate ids are removed before issuing delete requests so the same Google\n   * file is not deleted more than once. Deletions are executed in parallel because\n   * Google Drive exposes deletion as one request per file id.\n   *\n   * This is a hard delete. Soft deletion/trashing should go through the archive\n   * method instead.\n   */\n  async deleteNodes(ids: string[]): Promise<void> {\n    const uniqueIds = [...new Set(ids)];\n\n    await Promise.all(\n      uniqueIds.map((id) =>\n        this.client.files.delete({\n          fileId: id,\n          supportsAllDrives: true,\n        }),\n      ),\n    );\n  }\n\n  /**\n   * Converts raw Google Drive file metadata into the provider's normalized node DTO.\n   *\n   * Google Drive API responses are loosely typed and may omit fields that our\n   * drive abstraction requires, such as `id` or a namespace/root identifier. Those\n   * cases indicate an invalid provider response rather than a caller error, so\n   * they are normalized to an internal server error.\n   *\n   * Any unexpected mapping error is rethrown so it can be handled by the normal\n   * server error boundary/logging path.\n   */\n  #toNode(file: drive_v3.Schema$File): GoogleDriveNode {\n    try {\n      return GoogleDriveNodeDTO.create({ file });\n    } catch (error) {\n      if (\n        error instanceof Error &&\n        [\"Google Drive file has no id\", \"Google Drive file has no namespace\"].includes(\n          error.message,\n        )\n      ) {\n        throw new ServerError(\"INTERNAL_SERVER_ERROR\", { message: error.message });\n      }\n\n      throw error;\n    }\n  }\n}\n"],"mappings":";;;;;;;AA4BA,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;;;;;;;;AAgB3B,IAAa,cAAb,MAMA;CACE,AAAS;CAET,YAAY,QAAoC;AAC9C,OAAK,SAAS,OAAO,MAAM;GAAE,MAAM,OAAO;GAAM,SAAS;GAAM,CAAC;;;;;;;;;;;;;;CAelE,OAAMA,QAAS,IAAkD;AAC/D,MAAI;AAOF,WANe,MAAM,KAAK,OAAO,MAAM,IAAI;IACzC,QAAQ;IACR,mBAAmB;IACnB,QAAQ;IACT,CAAC,EAEY;WACP,OAAO;AACd,OAAI,iBAAiB,MAAM,CAAE,QAAO;AACpC,SAAM;;;;;;;;;;;;;;;CAgBV,MAAM,YAAY,IAA6C;EAC7D,MAAM,OAAO,MAAM,MAAKA,QAAS,GAAG;AACpC,SAAO,OAAO,MAAKC,OAAQ,KAAK,GAAG;;;;;;;;;;;;CAarC,SAAS,OAAyD;EAChE,MAAM,YAAY,MAAM,UAAU,QAAQ,KAAK;AAE/C,UAAQ,MAAM,MAAd;GACE,KAAK,OACH,QAAO,OAAO;GAChB,KAAK;GACL,KAAK,cACH,QAAO,cAAc;GACvB,KAAK;GACL,KAAK,eACH,QAAO,eAAe;GACxB,QACE,QAAO;;;;;;;;;;CAWb,aAAa,OAA+E;AAC1F,MAAI,MAAM,aAAa,OAAW,QAAO;AAGzC,SAAO,IAAI,4BADM,MAAM,YAAY,MAAM,UACO,CAAC;;;;;CAMnD,SAAS,SAA0C;AACjD,MAAI,CAAC,SAAS,OAAQ,QAAO;AAC7B,SAAO,IAAI,QAAQ,KAAK,OAAO,SAAS,4BAA4B,GAAG,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC;;;;;;;;CAS3F,WAAW,OAAwD;AACjE,MAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,SAAO,MAAM,OAAO,WAChB,eAAe,8BAA8B,KAC7C,gBAAgB,8BAA8B;;;;;;;CAQpD,kBAAkB,cAA+C;AAC/D,MAAI,CAAC,cAAc,OAAQ,QAAO;AAElC,SAAO,IAAI,aACR,KAAK,gBAAgB,eAAe,4BAA4B,YAAY,CAAC,GAAG,CAChF,KAAK,OAAO,CAAC;;;;;;;;CASlB,cAAc,YAA4C;AACxD,SAAO,aAAa,eAAe,OAAO,SAAS;;;;;;;CAQrD,aAAa,QAAuC;AAClD,MAAI,CAAC,OAAQ,QAAO;AAEpB,SAAO,kBAAkB,4BAA4B,OAAO,CAAC;;CAG/D,YAAY,OAA2E;AACrF,SAAO;GACL,MAAKC,YAAa,MAAM;GACxB,MAAKC,QAAS,MAAM,QAAQ;GAC5B,MAAKC,UAAW,MAAM,MAAM;GAC5B,MAAKC,iBAAkB,MAAM,aAAa;GAC1C,MAAKC,aAAc,MAAM,WAAW;GACpC,MAAKC,YAAa,MAAM,OAAO;GAChC,CACE,QAAQ,WAA6B,OAAO,WAAW,YAAY,OAAO,SAAS,EAAE,CACrF,KAAK,QAAQ;;;;;;;;;;;;;CAclB,OAAMC,aAAc,OAA4C;EAC9D,MAAM,UAAU,OAAO;EACvB,MAAM,QAAgC,EAAE;EACxC,IAAI;AAEJ,KAAG;GACD,MAAM,SAAS,MAAM,KAAK,OAAO,MAAM,KAAK;IAC1C;IACA,UAAU;IACV,SAAS;IACT,SAAS,MAAM,QAAQ;IACvB,2BAA2B;IAC3B,mBAAmB;IACnB,GAAG,MAAKC,WAAY;KAClB,WAAW,MAAM,QAAQ;KACzB,UAAU,MAAM,QAAQ;KACxB,SAAS,SAAS;KAClB,OAAO,SAAS;KAChB,cAAc,SAAS;KACvB,YAAY,SAAS;KACrB,QAAQ,OAAO;KAChB,CAAC;IACF,SAAS,MAAKC,QAAS,MAAM;IAC7B,QAAQ,wBAAwB,yBAAyB;IAC1D,CAAC;AAEF,SAAM,KAAK,GAAI,OAAO,KAAK,SAAS,EAAE,CAAE;AACxC,eAAY,OAAO,KAAK,iBAAiB;WAClC;AAET,SAAO,MAAM,KAAK,SAAS,MAAKT,OAAQ,KAAK,CAAC;;;;;;;;;;;;;CAchD,MAAM,oBAAoB,OAGsB;EAC9C,MAAM,OAAO,MAAM,KAAK,YAAY,MAAM,GAAG;AAC7C,MAAI,CAAC,QAAQ,KAAK,cAAc,MAAM,UAAW,QAAO;EAExD,MAAM,WAAW,MAAM,MAAKO,aAAc,EACxC,SAAS;GACP,UAAU,KAAK;GACf,WAAW,KAAK;GAChB,YAAY;GACb,EACF,CAAC;AAEF,SAAO;GAAE,GAAG;GAAM;GAAU;;;;;;;;;;;;CAa9B,MAAM,mBAAmB,OAAwE;AAC/F,SAAO,MAAKA,aAAc,MAAM;;;;;;;;;;;;;;;CAgBlC,OAAMG,aACJ,OAOA,gBACA,WACqD;AACrD,MAAI,mBAAmB,EAAG,QAAO;GAAE;GAAW,WAAW;GAAO;EAchE,MAAM,iBAZS,MAAM,KAAK,OAAO,MAAM,KAAK;GAC1C,UAAU,MAAM;GAChB;GACA,SAAS;GACT,SAAS,MAAM;GACf,2BAA2B;GAC3B,mBAAmB;GACnB,GAAG,MAAM;GACT,SAAS,MAAM;GACf,QAAQ;GACT,CAAC,EAE2B,KAAK,iBAAiB;AACnD,MAAI,CAAC,cAAe,QAAO,EAAE,WAAW,MAAM;AAE9C,SAAO,MAAKA,aAAc,OAAO,iBAAiB,GAAG,cAAc;;;;;;;;;;;;;;CAerE,OAAMC,UAAW,OAMgC;EAC/C,MAAM,QAAQ,MAAM,SAAS;EAC7B,MAAM,SAAS,MAAM,UAAU;EAC/B,MAAM,aAAa,MAAM,MAAKD,aAAc;GAAE,GAAG;GAAO;GAAO,EAAE,OAAO;AAExE,MAAI,WAAW,UACb,QAAO;GACL,MAAM,EAAE;GACR,YAAY;IACV,OAAO,SAAS;IAChB,YAAY,KAAK,IAAI,GAAG,OAAO;IAC/B;IACA,aAAa;IACb,iBAAiB,SAAS;IAC1B;IACA,YAAY;IACZ,gBAAgB,SAAS,IAAI,SAAS,IAAI;IAC3C;GACF;EAGH,MAAM,SAAS,MAAM,KAAK,OAAO,MAAM,KAAK;GAC1C,UAAU;GACV,WAAW,WAAW;GACtB,SAAS;GACT,SAAS,MAAM;GACf,2BAA2B;GAC3B,mBAAmB;GACnB,GAAG,MAAM;GACT,SAAS,MAAM;GACf,QAAQ,wBAAwB,yBAAyB;GAC1D,CAAC;EAEF,MAAM,OAAO,OAAO,KAAK,OAAO,KAAK,SAAS,MAAKV,OAAQ,KAAK,CAAC,IAAI,EAAE;EACvE,MAAM,cAAc,OAAO,KAAK,iBAAiB;EAIjD,MAAM,QAAQ,SAAS,QAAQ,KAAK,UAAU,cAAc,QAAQ;AAEpE,SAAO;GACL;GACA,YAAY;IACV;IACA,YAAY,KAAK,IAAI,GAAG,KAAK,KAAK,QAAQ,MAAM,CAAC;IACjD;IACA;IACA,iBAAiB,SAAS;IAC1B;IACA,YAAY,cAAc,SAAS,IAAI;IACvC,gBAAgB,SAAS,IAAI,SAAS,IAAI;IAC3C;GACF;;;;;;;;;;;;;CAcH,MAAM,SAAS,OAAgF;AAC7F,SAAO,MAAKW,UAAW;GACrB,WAAW,MAAM,QAAQ;GACzB,OAAO,MAAM;GACb,QAAQ,MAAM;GACd,SAAS,MAAKF,QAAS,MAAM;GAC7B,GAAG,MAAKD,WAAY;IAClB,WAAW,MAAM,QAAQ;IACzB,UAAU,MAAM,QAAQ;IACxB,SAAS,MAAM,QAAQ;IACvB,OAAO,MAAM,QAAQ;IACrB,cAAc,MAAM,QAAQ;IAC5B,YAAY,MAAM,QAAQ;IAC1B,QAAQ,MAAM;IACf,CAAC;GACH,CAAC;;;;;;;;;;;;CAaJ,OAAMI,YACJ,WACA,WACA,QAAQ,GACR,uBAAO,IAAI,KAAa,EAC+D;AACvF,MAAI,CAAC,aAAa,KAAK,IAAI,UAAU,CAAE,QAAO,EAAE;EAEhD,MAAM,OAAO,MAAM,KAAK,YAAY,UAAU;AAC9C,MAAI,CAAC,QAAQ,KAAK,cAAc,UAAW,QAAO,EAAE;EAEpD,MAAM,WAAW,IAAI,IAAI,CAAC,GAAG,MAAM,KAAK,GAAG,CAAC;AAE5C,SAAO,CACL;GAAE,IAAI,KAAK;GAAI,MAAM,KAAK;GAAM,UAAU,KAAK;GAAU;GAAO,EAChE,GAAI,MAAM,MAAKA,YAAa,KAAK,UAAU,WAAW,QAAQ,GAAG,SAAS,CAC3E;;;;;;;;;CAUH,MAAM,iBAAiB,OAGmE;AACxF,MAAI,CAAC,MAAM,GAAI,QAAO,EAAE;AAGxB,UADgB,MAAM,MAAKA,YAAa,MAAM,IAAI,MAAM,UAAU,EACnD,UAAU,GAAG,MAAM,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,MAAM,CAAC;;;;;;;;;CAUtE,OAAMC,aACJ,OACA,uBAA4B,IAAI,KAAK,EACJ;EACjC,MAAM,CAAC,SAAS,GAAG,QAAQ;AAC3B,MAAI,CAAC,QAAS,QAAO,EAAE;AAEvB,MAAI,KAAK,IAAI,QAAQ,GAAG,CACtB,QAAO,MAAKA,aAAc,MAAM,KAAK;EAGvC,MAAM,OAAO,MAAM,KAAK,YAAY,QAAQ,GAAG;AAC/C,MAAI,CAAC,KACH,QAAO,MAAKA,aAAc,MAAM,KAAK;EAGvC,MAAM,WAAW,IAAI,IAAI,CAAC,GAAG,MAAM,KAAK,GAAG,CAAC;EAC5C,MAAM,eAAe;GACnB,IAAI,KAAK;GACT,MAAM,KAAK;GACX,UAAU,KAAK;GACf,OAAO,QAAQ;GAChB;AAED,MAAI,KAAK,SAAS,SAChB,QAAO,CAAC,cAAc,GAAI,MAAM,MAAKA,aAAc,MAAM,SAAS,CAAE;EAGtE,MAAM,WAAW,MAAM,MAAKN,aAAc,EACxC,SAAS;GACP,WAAW,KAAK;GAChB,UAAU,KAAK;GACf,YAAY;GACb,EACF,CAAC;EAEF,MAAM,YAAY,CAChB,GAAG,MACH,GAAG,SAAS,KAAK,WAAW;GAC1B,IAAI,MAAM;GACV,OAAO,QAAQ,QAAQ;GACxB,EAAE,CACJ;AAED,SAAO,CAAC,cAAc,GAAI,MAAM,MAAKM,aAAc,WAAW,SAAS,CAAE;;;;;CAM3E,MAAM,gBAAgB,KAAgD;EACpE,MAAM,YAAY,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC;AAC1C,SAAO,MAAKA,aAAc,UAAU,KAAK,QAAQ;GAAE;GAAI,OAAO;GAAG,EAAE,CAAC;;;;;;;;;;;;CAatE,MAAM,aAAa,OAA+D;EAChF,MAAM,SAAS,MAAM,KAAK,OAAO,MAAM,OAAO;GAC5C,aAAa;IACX,MAAM,MAAM;IACZ,SAAS,CAAC,MAAM,YAAY,MAAM,UAAU;IAC5C,UAAU;IACX;GACD,mBAAmB;GACnB,QAAQ;GACT,CAAC;AAEF,SAAO,MAAKb,OAAQ,OAAO,KAAK;;;;;;;;;;;;;;;CAgBlC,MAAM,WACJ,OAC0B;EAC1B,MAAM,SAAS,MAAM,KAAK,OAAO,MAAM,OAAO;GAC5C,aAAa;IACX,MAAM,MAAM;IACZ,SAAS,CAAC,MAAM,YAAY,MAAM,UAAU;IAC5C,UAAU,MAAM,eAAe;IAChC;GACD,OAAO;IACL,UAAU,MAAM,eAAe;IAC/B,MAAM,sBAAsB,MAAM,KAAK;IACxC;GACD,mBAAmB;GACnB,QAAQ;GACT,CAAC;AAEF,SAAO,MAAKA,OAAQ,OAAO,KAAK;;;;;;;;;;;;;;CAelC,MAAM,WAAW,IAAY,MAA4D;EACvF,MAAM,SAAS,MAAM,KAAK,OAAO,MAAM,OAAO;GAC5C,QAAQ;GACR,aAAa;IACX,MAAM,KAAK;IACX,SAAS,KAAK;IACf;GACD,mBAAmB;GACnB,QAAQ;GACT,CAAC;AAEF,SAAO,MAAKA,OAAQ,OAAO,KAAK;;;;;;;;;;;;CAalC,MAAM,SAAS,OAA0E;EACvF,MAAM,OAAO,MAAM,KAAK,YAAY,MAAM,GAAG;AAC7C,MAAI,CAAC,KACH,OAAM,IAAI,YAAY,aAAa,EAAE,SAAS,kBAAkB,CAAC;AAGnE,MAAI,KAAK,SACP,OAAM,IAAI,YAAY,eAAe,EAAE,SAAS,0CAA0C,CAAC;AAG7F,MAAI,MAAM,aAAa,MAAM,GAC3B,OAAM,IAAI,YAAY,eAAe,EAAE,SAAS,oCAAoC,CAAC;AAIvF,MAAI,MAAM,UAGR;QAFgB,MAAM,KAAK,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAE1C,MAAM,UAAU,MAAM,OAAO,MAAM,SAAS,CACtD,OAAM,IAAI,YAAY,eAAe,EACnC,SAAS,oDACV,CAAC;;EAIN,MAAM,SAAS,MAAM,KAAK,OAAO,MAAM,OAAO;GAC5C,QAAQ,MAAM;GACd,YAAY,MAAM,YAAY,KAAK;GACnC,eAAe,KAAK,cAAc,KAAK,IAAI,IAAI;GAC/C,mBAAmB;GACnB,QAAQ;GACT,CAAC;AAEF,SAAO,MAAKA,OAAQ,OAAO,KAAK;;;;;;;;;CAUlC,OAAMc,WAAY,KAAe,SAA8C;EAC7E,MAAM,YAAY,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC;AAanC,UAXgB,MAAM,QAAQ,IAC5B,UAAU,KAAK,OACb,KAAK,OAAO,MAAM,OAAO;GACvB,QAAQ;GACR,aAAa,EAAE,SAAS;GACxB,mBAAmB;GACnB,QAAQ;GACT,CAAC,CACH,CACF,EAEc,KAAK,WAAW,MAAKd,OAAQ,OAAO,KAAK,CAAC;;;;;;;;;CAU3D,MAAM,aAAa,KAA2C;AAC5D,SAAO,MAAKc,WAAY,KAAK,KAAK;;;;;;;;CASpC,MAAM,aAAa,KAA2C;AAC5D,SAAO,MAAKA,WAAY,KAAK,MAAM;;;;;;;;;CAUrC,MAAM,WAAW,IAA2B;AAC1C,QAAM,KAAK,OAAO,MAAM,OAAO;GAC7B,QAAQ;GACR,mBAAmB;GACpB,CAAC;;;;;;;;;;;;CAaJ,MAAM,YAAY,KAA8B;EAC9C,MAAM,YAAY,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC;AAEnC,QAAM,QAAQ,IACZ,UAAU,KAAK,OACb,KAAK,OAAO,MAAM,OAAO;GACvB,QAAQ;GACR,mBAAmB;GACpB,CAAC,CACH,CACF;;;;;;;;;;;;;CAcH,QAAQ,MAA6C;AACnD,MAAI;AACF,UAAO,mBAAmB,OAAO,EAAE,MAAM,CAAC;WACnC,OAAO;AACd,OACE,iBAAiB,SACjB,CAAC,+BAA+B,qCAAqC,CAAC,SACpE,MAAM,QACP,CAED,OAAM,IAAI,YAAY,yBAAyB,EAAE,SAAS,MAAM,SAAS,CAAC;AAG5E,SAAM"}

package/dist/providers/google/lib/validators.d.mts

@@ -0,0 +1,303 @@
+import { DriveNodeChild } from "../../../lib/dto.mjs";
+import z$1 from "zod";
+
+//#region src/providers/google/lib/validators.d.ts
+/**
+ * GoogleDriveNode schema
+ * @description zod schema for validating the shape of a GoogleDriveNode
+ */
+declare const googleDriveNodeSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  createdAt: z$1.ZodDate;
+  updatedAt: z$1.ZodDate;
+  name: z$1.ZodString;
+  namespace: z$1.ZodString;
+  type: z$1.ZodEnum<{
+    file: "file";
+    folder: "folder";
+  }>;
+  subtype: z$1.ZodEnum<{
+    image: "image";
+    document: "document";
+    spreadsheet: "spreadsheet";
+    video: "video";
+    audio: "audio";
+    archive: "archive";
+    other: "other";
+  }>;
+  size: z$1.ZodNullable<z$1.ZodNumber>;
+  contentType: z$1.ZodNullable<z$1.ZodString>;
+  readonly: z$1.ZodBoolean;
+  hidden: z$1.ZodBoolean;
+  archivedAt: z$1.ZodNullable<z$1.ZodDate>;
+  parentId: z$1.ZodNullable<z$1.ZodString>;
+  links: z$1.ZodObject<{
+    view: z$1.ZodNullable<z$1.ZodString>;
+    download: z$1.ZodNullable<z$1.ZodString>;
+    preview: z$1.ZodNullable<z$1.ZodString>;
+    thumbnail: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  availability: z$1.ZodEnum<{
+    ready: "ready";
+    pending: "pending";
+    failed: "failed";
+  }>;
+  provider: z$1.ZodLiteral<"google">;
+  googleDriveId: z$1.ZodNullable<z$1.ZodString>;
+  mimeType: z$1.ZodNullable<z$1.ZodString>;
+  webViewLink: z$1.ZodNullable<z$1.ZodString>;
+  webContentLink: z$1.ZodNullable<z$1.ZodString>;
+  thumbnailLink: z$1.ZodNullable<z$1.ZodString>;
+  trashed: z$1.ZodBoolean;
+  trashedAt: z$1.ZodNullable<z$1.ZodDate>;
+  googleParents: z$1.ZodArray<z$1.ZodString>;
+  canEdit: z$1.ZodNullable<z$1.ZodBoolean>;
+}, z$1.core.$strip>;
+type GoogleDriveNode = z$1.infer<typeof googleDriveNodeSchema>;
+type GoogleDriveNodeChild = DriveNodeChild<GoogleDriveNode>;
+/**
+ * GoogleDriveNodeWithChildren schema
+ * @description zod schema for validating the shape of a GoogleDriveNode with children
+ */
+declare const googleDriveNodeWithChildrenSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  createdAt: z$1.ZodDate;
+  updatedAt: z$1.ZodDate;
+  name: z$1.ZodString;
+  namespace: z$1.ZodString;
+  type: z$1.ZodEnum<{
+    file: "file";
+    folder: "folder";
+  }>;
+  subtype: z$1.ZodEnum<{
+    image: "image";
+    document: "document";
+    spreadsheet: "spreadsheet";
+    video: "video";
+    audio: "audio";
+    archive: "archive";
+    other: "other";
+  }>;
+  size: z$1.ZodNullable<z$1.ZodNumber>;
+  contentType: z$1.ZodNullable<z$1.ZodString>;
+  readonly: z$1.ZodBoolean;
+  hidden: z$1.ZodBoolean;
+  archivedAt: z$1.ZodNullable<z$1.ZodDate>;
+  parentId: z$1.ZodNullable<z$1.ZodString>;
+  links: z$1.ZodObject<{
+    view: z$1.ZodNullable<z$1.ZodString>;
+    download: z$1.ZodNullable<z$1.ZodString>;
+    preview: z$1.ZodNullable<z$1.ZodString>;
+    thumbnail: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  availability: z$1.ZodEnum<{
+    ready: "ready";
+    pending: "pending";
+    failed: "failed";
+  }>;
+  provider: z$1.ZodLiteral<"google">;
+  googleDriveId: z$1.ZodNullable<z$1.ZodString>;
+  mimeType: z$1.ZodNullable<z$1.ZodString>;
+  webViewLink: z$1.ZodNullable<z$1.ZodString>;
+  webContentLink: z$1.ZodNullable<z$1.ZodString>;
+  thumbnailLink: z$1.ZodNullable<z$1.ZodString>;
+  trashed: z$1.ZodBoolean;
+  trashedAt: z$1.ZodNullable<z$1.ZodDate>;
+  googleParents: z$1.ZodArray<z$1.ZodString>;
+  canEdit: z$1.ZodNullable<z$1.ZodBoolean>;
+  children: z$1.ZodArray<z$1.ZodObject<{
+    id: z$1.ZodString;
+    createdAt: z$1.ZodDate;
+    updatedAt: z$1.ZodDate;
+    name: z$1.ZodString;
+    namespace: z$1.ZodString;
+    type: z$1.ZodEnum<{
+      file: "file";
+      folder: "folder";
+    }>;
+    subtype: z$1.ZodEnum<{
+      image: "image";
+      document: "document";
+      spreadsheet: "spreadsheet";
+      video: "video";
+      audio: "audio";
+      archive: "archive";
+      other: "other";
+    }>;
+    size: z$1.ZodNullable<z$1.ZodNumber>;
+    contentType: z$1.ZodNullable<z$1.ZodString>;
+    readonly: z$1.ZodBoolean;
+    hidden: z$1.ZodBoolean;
+    archivedAt: z$1.ZodNullable<z$1.ZodDate>;
+    parentId: z$1.ZodNullable<z$1.ZodString>;
+    links: z$1.ZodObject<{
+      view: z$1.ZodNullable<z$1.ZodString>;
+      download: z$1.ZodNullable<z$1.ZodString>;
+      preview: z$1.ZodNullable<z$1.ZodString>;
+      thumbnail: z$1.ZodNullable<z$1.ZodString>;
+    }, z$1.core.$strip>;
+    availability: z$1.ZodEnum<{
+      ready: "ready";
+      pending: "pending";
+      failed: "failed";
+    }>;
+    provider: z$1.ZodLiteral<"google">;
+    googleDriveId: z$1.ZodNullable<z$1.ZodString>;
+    mimeType: z$1.ZodNullable<z$1.ZodString>;
+    webViewLink: z$1.ZodNullable<z$1.ZodString>;
+    webContentLink: z$1.ZodNullable<z$1.ZodString>;
+    thumbnailLink: z$1.ZodNullable<z$1.ZodString>;
+    trashed: z$1.ZodBoolean;
+    trashedAt: z$1.ZodNullable<z$1.ZodDate>;
+    googleParents: z$1.ZodArray<z$1.ZodString>;
+    canEdit: z$1.ZodNullable<z$1.ZodBoolean>;
+  }, z$1.core.$strip>>;
+}, z$1.core.$strip>;
+type GoogleDriveNodeWithChildren = z$1.infer<typeof googleDriveNodeWithChildrenSchema>;
+/**
+ * Create drive folder input schema
+ * @description zod schema for validating the input of the create drive folder command
+ */
+declare const createGoogleDriveFolderInputSchema: z$1.ZodObject<{
+  name: z$1.ZodString;
+  namespace: z$1.ZodString;
+  parentId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+}, z$1.core.$strip>;
+type CreateGoogleDriveFolderInput = z$1.input<typeof createGoogleDriveFolderInputSchema>;
+type CreateGoogleDriveFolderSchema = z$1.infer<typeof createGoogleDriveFolderInputSchema>;
+/**
+ * Update drive node input schema
+ * @description zod schema for validating the input of the update drive node command
+ */
+declare const updateGoogleDriveNodeInputSchema: z$1.ZodObject<{
+  name: z$1.ZodOptional<z$1.ZodString>;
+  isArchived: z$1.ZodOptional<z$1.ZodBoolean>;
+}, z$1.core.$strip>;
+type UpdateGoogleDriveNodeInput = z$1.input<typeof updateGoogleDriveNodeInputSchema>;
+type UpdateGoogleDriveNodeSchema = z$1.infer<typeof updateGoogleDriveNodeInputSchema>;
+/**
+ * Upload drive file input schema
+ * @description zod schema for validating the input of the upload drive file command
+ */
+declare const uploadGoogleDriveFileInputSchema: z$1.ZodObject<{
+  name: z$1.ZodString;
+  namespace: z$1.ZodString;
+  parentId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+}, z$1.core.$strip>;
+type UploadGoogleDriveFileInput = z$1.input<typeof uploadGoogleDriveFileInputSchema>;
+type UploadGoogleDriveFileSchema = z$1.infer<typeof uploadGoogleDriveFileInputSchema>;
+/**
+ * Filters
+ */
+declare const googleDriveTableFiltersSchema: z$1.ZodPipe<z$1.ZodObject<{
+  types: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodEnum<{
+    file: "file";
+    folder: "folder";
+  }>>>>;
+  contentTypes: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodString>>>;
+  nodeIds: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodString>>>;
+  isArchived: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodBoolean>>;
+  namespace: z$1.ZodString;
+  parentId: z$1.ZodNullable<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodTransform<{
+  isArchived: boolean;
+  namespace: string;
+  parentId: string | null;
+  types?: ("file" | "folder")[] | null | undefined;
+  contentTypes?: string[] | null | undefined;
+  nodeIds?: string[] | null | undefined;
+}, {
+  namespace: string;
+  parentId: string | null;
+  types?: ("file" | "folder")[] | null | undefined;
+  contentTypes?: string[] | null | undefined;
+  nodeIds?: string[] | null | undefined;
+  isArchived?: boolean | null | undefined;
+}>>;
+type GoogleDriveTableFilters = z$1.infer<typeof googleDriveTableFiltersSchema>;
+type GoogleDriveTableFiltersInput = z$1.input<typeof googleDriveTableFiltersSchema>;
+/**
+ * List drive tree input schema
+ * @description zod schema for validating the input of the list drive tree command
+ */
+declare const listGoogleDriveTreeInputSchema: z$1.ZodObject<{
+  cursor: z$1.ZodPipe<z$1.ZodDefault<z$1.ZodOptional<z$1.ZodCoercedNumber<unknown>>>, z$1.ZodTransform<number, number>>;
+  limit: z$1.ZodPipe<z$1.ZodDefault<z$1.ZodOptional<z$1.ZodCoercedNumber<unknown>>>, z$1.ZodTransform<number, number>>;
+  sort: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  order: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>>;
+  search: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  filters: z$1.ZodPipe<z$1.ZodObject<{
+    types: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodEnum<{
+      file: "file";
+      folder: "folder";
+    }>>>>;
+    contentTypes: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodString>>>;
+    nodeIds: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodString>>>;
+    isArchived: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodBoolean>>;
+    namespace: z$1.ZodString;
+    parentId: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>, z$1.ZodTransform<{
+    isArchived: boolean;
+    namespace: string;
+    parentId: string | null;
+    types?: ("file" | "folder")[] | null | undefined;
+    contentTypes?: string[] | null | undefined;
+    nodeIds?: string[] | null | undefined;
+  }, {
+    namespace: string;
+    parentId: string | null;
+    types?: ("file" | "folder")[] | null | undefined;
+    contentTypes?: string[] | null | undefined;
+    nodeIds?: string[] | null | undefined;
+    isArchived?: boolean | null | undefined;
+  }>>;
+}, z$1.core.$strip>;
+type ListGoogleDriveTreeInput = z$1.input<typeof listGoogleDriveTreeInputSchema>;
+type ListGoogleDriveTreeSchema = z$1.infer<typeof listGoogleDriveTreeInputSchema>;
+/**
+ * Get drive nodes by parent id input schema
+ * @description zod schema for validating the input of the get drive nodes by parent id command
+ */
+declare const getGoogleDriveNodesByParentIdInputSchema: z$1.ZodObject<{
+  sort: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  search: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  order: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>>;
+  filters: z$1.ZodPipe<z$1.ZodObject<{
+    types: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodEnum<{
+      file: "file";
+      folder: "folder";
+    }>>>>;
+    contentTypes: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodString>>>;
+    nodeIds: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodString>>>;
+    isArchived: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodBoolean>>;
+    namespace: z$1.ZodString;
+    parentId: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>, z$1.ZodTransform<{
+    isArchived: boolean;
+    namespace: string;
+    parentId: string | null;
+    types?: ("file" | "folder")[] | null | undefined;
+    contentTypes?: string[] | null | undefined;
+    nodeIds?: string[] | null | undefined;
+  }, {
+    namespace: string;
+    parentId: string | null;
+    types?: ("file" | "folder")[] | null | undefined;
+    contentTypes?: string[] | null | undefined;
+    nodeIds?: string[] | null | undefined;
+    isArchived?: boolean | null | undefined;
+  }>>;
+}, z$1.core.$strip>;
+type GetGoogleDriveNodesByParentIdInput = z$1.input<typeof getGoogleDriveNodesByParentIdInputSchema>;
+type GetGoogleDriveNodesByParentIdSchema = z$1.infer<typeof getGoogleDriveNodesByParentIdInputSchema>;
+//#endregion
+export { CreateGoogleDriveFolderInput, CreateGoogleDriveFolderSchema, GetGoogleDriveNodesByParentIdInput, GetGoogleDriveNodesByParentIdSchema, GoogleDriveNode, GoogleDriveNodeChild, GoogleDriveNodeWithChildren, GoogleDriveTableFilters, GoogleDriveTableFiltersInput, ListGoogleDriveTreeInput, ListGoogleDriveTreeSchema, UpdateGoogleDriveNodeInput, UpdateGoogleDriveNodeSchema, UploadGoogleDriveFileInput, UploadGoogleDriveFileSchema, createGoogleDriveFolderInputSchema, getGoogleDriveNodesByParentIdInputSchema, googleDriveNodeSchema, googleDriveNodeWithChildrenSchema, googleDriveTableFiltersSchema, listGoogleDriveTreeInputSchema, updateGoogleDriveNodeInputSchema, uploadGoogleDriveFileInputSchema };
+//# sourceMappingURL=validators.d.mts.map

package/dist/providers/google/lib/validators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../../../../src/providers/google/lib/validators.ts"],"mappings":";;;;;;AAeA;;cAAa,qBAAA,EAAqB,GAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8DtB,eAAA,GAAkB,GAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,KACjC,oBAAA,GAAuB,cAAA,CAAe,eAAA;;;;;cAMrC,iCAAA,EAAiC,GAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIlC,2BAAA,GAA8B,GAAA,CAAE,KAAA,QAAa,iCAAA;;;;;cAM5C,kCAAA,EAAkC,GAAA,CAAA,SAAA;;;;;KAEnC,4BAAA,GAA+B,GAAA,CAAE,KAAA,QAAa,kCAAA;AAAA,KAC9C,6BAAA,GAAgC,GAAA,CAAE,KAAA,QAAa,kCAAA;;;;;cAM9C,gCAAA,EAAgC,GAAA,CAAA,SAAA;;;;KAIjC,0BAAA,GAA6B,GAAA,CAAE,KAAA,QAAa,gCAAA;AAAA,KAC5C,2BAAA,GAA8B,GAAA,CAAE,KAAA,QAAa,gCAAA;;;;;cAM5C,gCAAA,EAAgC,GAAA,CAAA,SAAA;;;;;;;KAEjC,0BAAA,GAA6B,GAAA,CAAE,KAAA,QAAa,gCAAA;AAAA,KAC5C,2BAAA,GAA8B,GAAA,CAAE,KAAA,QAAa,gCAAA;;;;cAK5C,6BAAA,EAA6B,GAAA,CAAA,OAAA,CAAA,GAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAE9B,uBAAA,GAA0B,GAAA,CAAE,KAAA,QAAa,6BAAA;AAAA,KACzC,4BAAA,GAA+B,GAAA,CAAE,KAAA,QAAa,6BAAA;;;;;cAM7C,8BAAA,EAA8B,GAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAE/B,wBAAA,GAA2B,GAAA,CAAE,KAAA,QAAa,8BAAA;AAAA,KAC1C,yBAAA,GAA4B,GAAA,CAAE,KAAA,QAAa,8BAAA;;;;;cAM1C,wCAAA,EAAwC,GAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEzC,kCAAA,GAAqC,GAAA,CAAE,KAAA,QAC1C,wCAAA;AAAA,KAEG,mCAAA,GAAsC,GAAA,CAAE,KAAA,QAC3C,wCAAA"}

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

@@ -0,0 +1,59 @@
+import { driveNodeSchema } from "../../../lib/dto.mjs";
+import { createDriveFolderInputSchema, driveTableFiltersSchema, getNodesByParentIdInputSchema, listDriveTreeInputSchema, updateDriveNodeInputSchema, uploadDriveFileInputSchema } from "../../../lib/validators.mjs";
+import z$1 from "zod";
+
+//#region src/providers/google/lib/validators.ts
+/**
+* GoogleDriveNode schema
+* @description zod schema for validating the shape of a GoogleDriveNode
+*/
+const googleDriveNodeSchema = driveNodeSchema.extend({
+	provider: z$1.literal("google"),
+	googleDriveId: z$1.string().nullable(),
+	mimeType: z$1.string().nullable(),
+	webViewLink: z$1.string().nullable(),
+	webContentLink: z$1.string().nullable(),
+	thumbnailLink: z$1.string().nullable(),
+	trashed: z$1.boolean(),
+	trashedAt: z$1.date().nullable(),
+	googleParents: z$1.array(z$1.string()),
+	canEdit: z$1.boolean().nullable()
+});
+/**
+* GoogleDriveNodeWithChildren schema
+* @description zod schema for validating the shape of a GoogleDriveNode with children
+*/
+const googleDriveNodeWithChildrenSchema = googleDriveNodeSchema.extend({ children: z$1.array(googleDriveNodeSchema) });
+/**
+* Create drive folder input schema
+* @description zod schema for validating the input of the create drive folder command
+*/
+const createGoogleDriveFolderInputSchema = createDriveFolderInputSchema;
+/**
+* Update drive node input schema
+* @description zod schema for validating the input of the update drive node command
+*/
+const updateGoogleDriveNodeInputSchema = updateDriveNodeInputSchema.extend({ isArchived: z$1.boolean().optional() });
+/**
+* Upload drive file input schema
+* @description zod schema for validating the input of the upload drive file command
+*/
+const uploadGoogleDriveFileInputSchema = uploadDriveFileInputSchema;
+/**
+* Filters
+*/
+const googleDriveTableFiltersSchema = driveTableFiltersSchema;
+/**
+* List drive tree input schema
+* @description zod schema for validating the input of the list drive tree command
+*/
+const listGoogleDriveTreeInputSchema = listDriveTreeInputSchema;
+/**
+* Get drive nodes by parent id input schema
+* @description zod schema for validating the input of the get drive nodes by parent id command
+*/
+const getGoogleDriveNodesByParentIdInputSchema = getNodesByParentIdInputSchema;
+
+//#endregion
+export { createGoogleDriveFolderInputSchema, getGoogleDriveNodesByParentIdInputSchema, googleDriveNodeSchema, googleDriveNodeWithChildrenSchema, googleDriveTableFiltersSchema, listGoogleDriveTreeInputSchema, updateGoogleDriveNodeInputSchema, uploadGoogleDriveFileInputSchema };
+//# sourceMappingURL=validators.mjs.map

package/dist/providers/google/lib/validators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.mjs","names":["z"],"sources":["../../../../src/providers/google/lib/validators.ts"],"sourcesContent":["import z from \"zod\";\nimport { type DriveNodeChild, driveNodeSchema } from \"@/lib/dto\";\nimport {\n  createDriveFolderInputSchema,\n  driveTableFiltersSchema,\n  getNodesByParentIdInputSchema,\n  listDriveTreeInputSchema,\n  updateDriveNodeInputSchema,\n  uploadDriveFileInputSchema,\n} from \"@/lib/validators\";\n\n/**\n * GoogleDriveNode schema\n * @description zod schema for validating the shape of a GoogleDriveNode\n */\nexport const googleDriveNodeSchema = driveNodeSchema.extend({\n  /**\n   * Constant discriminator for Google-backed nodes.\n   * Maps to the provider implementation, not to a Google Drive API field.\n   */\n  provider: z.literal(\"google\"),\n  /**\n   * Native Google shared drive id from `drive_v3.Schema$File.driveId`.\n   * We keep this provider-specific field only as source metadata. The shared\n   * `DriveNode.namespace` field is the canonical namespace used by callers.\n   */\n  googleDriveId: z.string().nullable(),\n  /**\n   * Original Google Drive MIME type from `drive_v3.Schema$File.mimeType`.\n   * The common `contentType` field uses the same source for files and `null`\n   * for folders so consumers can treat folders consistently across providers.\n   */\n  mimeType: z.string().nullable(),\n  /**\n   * Browser view URL from `drive_v3.Schema$File.webViewLink`.\n   * This is Google Drive's closest equivalent to a provider-neutral view URL.\n   */\n  webViewLink: z.string().nullable(),\n\n  /**\n   * Download URL from `drive_v3.Schema$File.webContentLink`.\n   * Google only returns this for binary files, not for all Google-native docs.\n   */\n  webContentLink: z.string().nullable(),\n  /**\n   * Thumbnail URL from `drive_v3.Schema$File.thumbnailLink`.\n   * Google provides this opportunistically, so the common `links.thumbnail`\n   * field is nullable.\n   */\n  thumbnailLink: z.string().nullable(),\n  /**\n   * Native Google trash state from `drive_v3.Schema$File.trashed`.\n   * The common `archivedAt` field derives from this because the local provider\n   * models soft removal as archive while Google Drive models it as trash.\n   */\n  trashed: z.boolean(),\n  /**\n   * Native Google trash timestamp from `drive_v3.Schema$File.trashedTime`.\n   * The common `archivedAt` field uses this when available, falling back to the\n   * modified time when Google only exposes `trashed: true`.\n   */\n  trashedAt: z.date().nullable(),\n  /**\n   * Raw Google parent ids from `drive_v3.Schema$File.parents`.\n   * The common `parentId` field uses the first parent, with the configured\n   * namespace converted to `null` so root nodes match the local provider shape.\n   */\n  googleParents: z.array(z.string()),\n\n  /**\n   * Google edit capability from `drive_v3.Schema$File.capabilities.canEdit`.\n   * The common `readonly` field is true when Google content restrictions mark\n   * the file readonly or when Google says the user cannot edit the file.\n   */\n  canEdit: z.boolean().nullable(),\n});\n\nexport type GoogleDriveNode = z.infer<typeof googleDriveNodeSchema>;\nexport type GoogleDriveNodeChild = DriveNodeChild<GoogleDriveNode>;\n\n/**\n * GoogleDriveNodeWithChildren schema\n * @description zod schema for validating the shape of a GoogleDriveNode with children\n */\nexport const googleDriveNodeWithChildrenSchema = googleDriveNodeSchema.extend({\n  children: z.array(googleDriveNodeSchema),\n});\n\nexport type GoogleDriveNodeWithChildren = z.infer<typeof googleDriveNodeWithChildrenSchema>;\n\n/**\n * Create drive folder input schema\n * @description zod schema for validating the input of the create drive folder command\n */\nexport const createGoogleDriveFolderInputSchema = createDriveFolderInputSchema;\n\nexport type CreateGoogleDriveFolderInput = z.input<typeof createGoogleDriveFolderInputSchema>;\nexport type CreateGoogleDriveFolderSchema = z.infer<typeof createGoogleDriveFolderInputSchema>;\n\n/**\n * Update drive node input schema\n * @description zod schema for validating the input of the update drive node command\n */\nexport const updateGoogleDriveNodeInputSchema = updateDriveNodeInputSchema.extend({\n  isArchived: z.boolean().optional(),\n});\n\nexport type UpdateGoogleDriveNodeInput = z.input<typeof updateGoogleDriveNodeInputSchema>;\nexport type UpdateGoogleDriveNodeSchema = z.infer<typeof updateGoogleDriveNodeInputSchema>;\n\n/**\n * Upload drive file input schema\n * @description zod schema for validating the input of the upload drive file command\n */\nexport const uploadGoogleDriveFileInputSchema = uploadDriveFileInputSchema;\n\nexport type UploadGoogleDriveFileInput = z.input<typeof uploadGoogleDriveFileInputSchema>;\nexport type UploadGoogleDriveFileSchema = z.infer<typeof uploadGoogleDriveFileInputSchema>;\n\n/**\n * Filters\n */\nexport const googleDriveTableFiltersSchema = driveTableFiltersSchema;\n\nexport type GoogleDriveTableFilters = z.infer<typeof googleDriveTableFiltersSchema>;\nexport type GoogleDriveTableFiltersInput = z.input<typeof googleDriveTableFiltersSchema>;\n\n/**\n * List drive tree input schema\n * @description zod schema for validating the input of the list drive tree command\n */\nexport const listGoogleDriveTreeInputSchema = listDriveTreeInputSchema;\n\nexport type ListGoogleDriveTreeInput = z.input<typeof listGoogleDriveTreeInputSchema>;\nexport type ListGoogleDriveTreeSchema = z.infer<typeof listGoogleDriveTreeInputSchema>;\n\n/**\n * Get drive nodes by parent id input schema\n * @description zod schema for validating the input of the get drive nodes by parent id command\n */\nexport const getGoogleDriveNodesByParentIdInputSchema = getNodesByParentIdInputSchema;\n\nexport type GetGoogleDriveNodesByParentIdInput = z.input<\n  typeof getGoogleDriveNodesByParentIdInputSchema\n>;\nexport type GetGoogleDriveNodesByParentIdSchema = z.infer<\n  typeof getGoogleDriveNodesByParentIdInputSchema\n>;\n"],"mappings":";;;;;;;;;AAeA,MAAa,wBAAwB,gBAAgB,OAAO;CAK1D,UAAUA,IAAE,QAAQ,SAAS;CAM7B,eAAeA,IAAE,QAAQ,CAAC,UAAU;CAMpC,UAAUA,IAAE,QAAQ,CAAC,UAAU;CAK/B,aAAaA,IAAE,QAAQ,CAAC,UAAU;CAMlC,gBAAgBA,IAAE,QAAQ,CAAC,UAAU;CAMrC,eAAeA,IAAE,QAAQ,CAAC,UAAU;CAMpC,SAASA,IAAE,SAAS;CAMpB,WAAWA,IAAE,MAAM,CAAC,UAAU;CAM9B,eAAeA,IAAE,MAAMA,IAAE,QAAQ,CAAC;CAOlC,SAASA,IAAE,SAAS,CAAC,UAAU;CAChC,CAAC;;;;;AASF,MAAa,oCAAoC,sBAAsB,OAAO,EAC5E,UAAUA,IAAE,MAAM,sBAAsB,EACzC,CAAC;;;;;AAQF,MAAa,qCAAqC;;;;;AASlD,MAAa,mCAAmC,2BAA2B,OAAO,EAChF,YAAYA,IAAE,SAAS,CAAC,UAAU,EACnC,CAAC;;;;;AASF,MAAa,mCAAmC;;;;AAQhD,MAAa,gCAAgC;;;;;AAS7C,MAAa,iCAAiC;;;;;AAS9C,MAAa,2CAA2C"}

package/dist/providers/local/components/command-file-update.d.mts

@@ -0,0 +1,18 @@
+import { UpdateLocalDriveNodeInput } from "../lib/validators.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
+
+//#region src/providers/local/components/command-file-update.d.ts
+type LocalDriveFileUpdateCommandProps<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = {
+  defaultValues: Partial<UpdateLocalDriveNodeInput>;
+  variables: (values: UpdateLocalDriveNodeInput) => TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+};
+declare function LocalDriveFileUpdateCommand<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown>({
+  defaultValues,
+  variables,
+  mutation
+}: LocalDriveFileUpdateCommandProps<TData, TError, TVariables, TOnMutateResult>): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { LocalDriveFileUpdateCommand, LocalDriveFileUpdateCommandProps };
+//# sourceMappingURL=command-file-update.d.mts.map

package/dist/providers/local/components/command-file-update.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-file-update.d.mts","names":[],"sources":["../../../../src/providers/local/components/command-file-update.tsx"],"mappings":";;;;;KA6BY,gCAAA,2BAED,YAAA;EAIT,aAAA,EAAe,OAAA,CAAQ,yBAAA;EACvB,SAAA,GAAY,MAAA,EAAQ,yBAAA,KAA8B,UAAA;EAClD,QAAA,EAAU,eAAA,CAAgB,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,eAAA;AAAA;AAAA,iBAGvC,2BAAA,2BAEL,YAAA,kDAAA,CAAA;EAIT,aAAA;EACA,SAAA;EACA;AAAA,GACC,gCAAA,CAAiC,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,eAAA,IAAgB,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/providers/local/components/command-file-update.mjs

@@ -0,0 +1,48 @@
+"use client";
+
+import { updateLocalDriveNodeInputSchema } from "../lib/validators.mjs";
+import { Input } from "@tulip-systems/core/components";
+import { CommandFormDialog, CommandFormDialogCancel, CommandFormDialogContent, CommandFormDialogFields, CommandFormDialogFooter, CommandFormDialogHeader, CommandFormDialogSubmit, CommandFormDialogTitle, CommandFormDialogTrigger, CommandLabel } from "@tulip-systems/core/commands/client";
+import { FilePen } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Form, FormControl, FormField, FormItem, FormLabel, FormMessage } from "@tulip-systems/core/components/client";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useForm } from "react-hook-form";
+
+//#region src/providers/local/components/command-file-update.tsx
+function LocalDriveFileUpdateCommand({ defaultValues, variables, mutation }) {
+	const form = useForm({
+		resolver: zodResolver(updateLocalDriveNodeInputSchema),
+		defaultValues
+	});
+	return /* @__PURE__ */ jsx(Form, {
+		...form,
+		children: /* @__PURE__ */ jsxs(CommandFormDialog, { children: [/* @__PURE__ */ jsxs(CommandFormDialogTrigger, {
+			label: "Wijzigen",
+			children: [/* @__PURE__ */ jsx(FilePen, { className: "size-4" }), /* @__PURE__ */ jsx(CommandLabel, {})]
+		}), /* @__PURE__ */ jsxs(CommandFormDialogContent, {
+			variables,
+			mutation,
+			children: [
+				/* @__PURE__ */ jsx(CommandFormDialogHeader, { children: /* @__PURE__ */ jsx(CommandFormDialogTitle, { children: "Bestand wijzigen" }) }),
+				/* @__PURE__ */ jsx(CommandFormDialogFields, { children: /* @__PURE__ */ jsx(FormField, {
+					control: form.control,
+					name: "name",
+					render: ({ field }) => /* @__PURE__ */ jsxs(FormItem, { children: [
+						/* @__PURE__ */ jsx(FormLabel, { children: "Naam" }),
+						/* @__PURE__ */ jsx(FormControl, { children: /* @__PURE__ */ jsx(Input, {
+							...field,
+							value: field.value ?? ""
+						}) }),
+						/* @__PURE__ */ jsx(FormMessage, {})
+					] })
+				}) }),
+				/* @__PURE__ */ jsxs(CommandFormDialogFooter, { children: [/* @__PURE__ */ jsx(CommandFormDialogCancel, { children: "Annuleren" }), /* @__PURE__ */ jsx(CommandFormDialogSubmit, { children: "Opslaan" })] })
+			]
+		})] })
+	});
+}
+
+//#endregion
+export { LocalDriveFileUpdateCommand };
+//# sourceMappingURL=command-file-update.mjs.map

package/dist/providers/local/components/command-file-update.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-file-update.mjs","names":[],"sources":["../../../../src/providers/local/components/command-file-update.tsx"],"sourcesContent":["\"use client\";\n\nimport { zodResolver } from \"@hookform/resolvers/zod\";\nimport type { DefaultError, MutationOptions } from \"@tanstack/react-query\";\nimport {\n  CommandFormDialog,\n  CommandFormDialogCancel,\n  CommandFormDialogContent,\n  CommandFormDialogFields,\n  CommandFormDialogFooter,\n  CommandFormDialogHeader,\n  CommandFormDialogSubmit,\n  CommandFormDialogTitle,\n  CommandFormDialogTrigger,\n  CommandLabel,\n} from \"@tulip-systems/core/commands/client\";\nimport { Input } from \"@tulip-systems/core/components\";\nimport {\n  Form,\n  FormControl,\n  FormField,\n  FormItem,\n  FormLabel,\n  FormMessage,\n} from \"@tulip-systems/core/components/client\";\nimport { FilePen } from \"lucide-react\";\nimport { useForm } from \"react-hook-form\";\nimport { type UpdateLocalDriveNodeInput, updateLocalDriveNodeInputSchema } from \"../lib/validators\";\n\nexport type LocalDriveFileUpdateCommandProps<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> = {\n  defaultValues: Partial<UpdateLocalDriveNodeInput>;\n  variables: (values: UpdateLocalDriveNodeInput) => TVariables;\n  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;\n};\n\nexport function LocalDriveFileUpdateCommand<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n>({\n  defaultValues,\n  variables,\n  mutation,\n}: LocalDriveFileUpdateCommandProps<TData, TError, TVariables, TOnMutateResult>) {\n  const form = useForm<UpdateLocalDriveNodeInput>({\n    resolver: zodResolver(updateLocalDriveNodeInputSchema),\n    defaultValues,\n  });\n\n  return (\n    <Form {...form}>\n      <CommandFormDialog>\n        <CommandFormDialogTrigger label=\"Wijzigen\">\n          <FilePen className=\"size-4\" />\n          <CommandLabel />\n        </CommandFormDialogTrigger>\n\n        <CommandFormDialogContent variables={variables} mutation={mutation}>\n          <CommandFormDialogHeader>\n            <CommandFormDialogTitle>Bestand wijzigen</CommandFormDialogTitle>\n          </CommandFormDialogHeader>\n\n          <CommandFormDialogFields>\n            <FormField\n              control={form.control}\n              name=\"name\"\n              render={({ field }) => (\n                <FormItem>\n                  <FormLabel>Naam</FormLabel>\n                  <FormControl>\n                    <Input {...field} value={field.value ?? \"\"} />\n                  </FormControl>\n                  <FormMessage />\n                </FormItem>\n              )}\n            />\n          </CommandFormDialogFields>\n\n          <CommandFormDialogFooter>\n            <CommandFormDialogCancel>Annuleren</CommandFormDialogCancel>\n            <CommandFormDialogSubmit>Opslaan</CommandFormDialogSubmit>\n          </CommandFormDialogFooter>\n        </CommandFormDialogContent>\n      </CommandFormDialog>\n    </Form>\n  );\n}\n"],"mappings":";;;;;;;;;;;;AAwCA,SAAgB,4BAKd,EACA,eACA,WACA,YAC+E;CAC/E,MAAM,OAAO,QAAmC;EAC9C,UAAU,YAAY,gCAAgC;EACtD;EACD,CAAC;AAEF,QACE,oBAAC;EAAK,GAAI;YACR,qBAAC,gCACC,qBAAC;GAAyB,OAAM;cAC9B,oBAAC,WAAQ,WAAU,WAAW,EAC9B,oBAAC,iBAAe;IACS,EAE3B,qBAAC;GAAoC;GAAqB;;IACxD,oBAAC,qCACC,oBAAC,oCAAuB,qBAAyC,GACzC;IAE1B,oBAAC,qCACC,oBAAC;KACC,SAAS,KAAK;KACd,MAAK;KACL,SAAS,EAAE,YACT,qBAAC;MACC,oBAAC,uBAAU,SAAgB;MAC3B,oBAAC,yBACC,oBAAC;OAAM,GAAI;OAAO,OAAO,MAAM,SAAS;QAAM,GAClC;MACd,oBAAC,gBAAc;SACN;MAEb,GACsB;IAE1B,qBAAC,sCACC,oBAAC,qCAAwB,cAAmC,EAC5D,oBAAC,qCAAwB,YAAiC,IAClC;;IACD,IACT;GACf"}

package/dist/providers/local/components/command-file-upload.d.mts

@@ -0,0 +1,11 @@
+import { ComponentProps } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/providers/local/components/command-file-upload.d.ts
+declare function LocalDriveFilesUploadCommand({
+  className,
+  ...props
+}: ComponentProps<"div">): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { LocalDriveFilesUploadCommand };
+//# sourceMappingURL=command-file-upload.d.mts.map

package/dist/providers/local/components/command-file-upload.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-file-upload.d.mts","names":[],"sources":["../../../../src/providers/local/components/command-file-upload.tsx"],"mappings":";;;;iBASgB,4BAAA,CAAA;EAA+B,SAAA;EAAA,GAAc;AAAA,GAAS,cAAA,UAAqB,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/providers/local/components/command-file-upload.mjs

@@ -0,0 +1,35 @@
+"use client";
+
+import { useLocalDriveUploadZone } from "./upload-zone-context.client.mjs";
+import { Input } from "@tulip-systems/core/components";
+import { cn } from "@tulip-systems/core/lib";
+import { CommandEmpty, CommandLabel } from "@tulip-systems/core/commands/client";
+import { UploadIcon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/providers/local/components/command-file-upload.tsx
+function LocalDriveFilesUploadCommand({ className, ...props }) {
+	const { onUpload } = useLocalDriveUploadZone();
+	return /* @__PURE__ */ jsxs(CommandEmpty, {
+		...props,
+		className: cn("relative gap-2", className),
+		label: "Upload",
+		children: [
+			/* @__PURE__ */ jsx(UploadIcon, { className: "h-3 w-3" }),
+			/* @__PURE__ */ jsx(CommandLabel, {}),
+			/* @__PURE__ */ jsx(Input, {
+				type: "file",
+				className: "absolute inset-0 z-10 h-full w-full cursor-pointer opacity-0",
+				multiple: true,
+				onChange: (event) => {
+					if (!event.target.files) return;
+					Array.from(event.target.files).forEach(onUpload);
+				}
+			})
+		]
+	});
+}
+
+//#endregion
+export { LocalDriveFilesUploadCommand };
+//# sourceMappingURL=command-file-upload.mjs.map

package/dist/providers/local/components/command-file-upload.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-file-upload.mjs","names":[],"sources":["../../../../src/providers/local/components/command-file-upload.tsx"],"sourcesContent":["\"use client\";\n\nimport { CommandEmpty, CommandLabel } from \"@tulip-systems/core/commands/client\";\nimport { Input } from \"@tulip-systems/core/components\";\nimport { cn } from \"@tulip-systems/core/lib\";\nimport { UploadIcon } from \"lucide-react\";\nimport type { ComponentProps } from \"react\";\nimport { useLocalDriveUploadZone } from \"./upload-zone-context.client\";\n\nexport function LocalDriveFilesUploadCommand({ className, ...props }: ComponentProps<\"div\">) {\n  const { onUpload } = useLocalDriveUploadZone();\n\n  return (\n    <CommandEmpty {...props} className={cn(\"relative gap-2\", className)} label=\"Upload\">\n      <UploadIcon className=\"h-3 w-3\" />\n      <CommandLabel />\n\n      <Input\n        type=\"file\"\n        className=\"absolute inset-0 z-10 h-full w-full cursor-pointer opacity-0\"\n        multiple\n        onChange={(event) => {\n          if (!event.target.files) return;\n          Array.from(event.target.files).forEach(onUpload);\n        }}\n      />\n    </CommandEmpty>\n  );\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,6BAA6B,EAAE,WAAW,GAAG,SAAgC;CAC3F,MAAM,EAAE,aAAa,yBAAyB;AAE9C,QACE,qBAAC;EAAa,GAAI;EAAO,WAAW,GAAG,kBAAkB,UAAU;EAAE,OAAM;;GACzE,oBAAC,cAAW,WAAU,YAAY;GAClC,oBAAC,iBAAe;GAEhB,oBAAC;IACC,MAAK;IACL,WAAU;IACV;IACA,WAAW,UAAU;AACnB,SAAI,CAAC,MAAM,OAAO,MAAO;AACzB,WAAM,KAAK,MAAM,OAAO,MAAM,CAAC,QAAQ,SAAS;;KAElD;;GACW"}

package/dist/providers/local/components/command-folder-create.d.mts

@@ -0,0 +1,18 @@
+import { CreateLocalDriveFolderInput } from "../lib/validators.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
+
+//#region src/providers/local/components/command-folder-create.d.ts
+type LocalDriveFoldersCreateCommandProps<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = {
+  defaultValues?: Partial<CreateLocalDriveFolderInput>;
+  variables: (values: CreateLocalDriveFolderInput) => TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+};
+declare function LocalDriveFoldersCreateCommand<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown>({
+  defaultValues,
+  variables,
+  mutation
+}: LocalDriveFoldersCreateCommandProps<TData, TError, TVariables, TOnMutateResult>): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { LocalDriveFoldersCreateCommand, LocalDriveFoldersCreateCommandProps };
+//# sourceMappingURL=command-folder-create.d.mts.map

package/dist/providers/local/components/command-folder-create.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-folder-create.d.mts","names":[],"sources":["../../../../src/providers/local/components/command-folder-create.tsx"],"mappings":";;;;;KAkCY,mCAAA,2BAED,YAAA;EAIT,aAAA,GAAgB,OAAA,CAAQ,2BAAA;EACxB,SAAA,GAAY,MAAA,EAAQ,2BAAA,KAAgC,UAAA;EACpD,QAAA,EAAU,eAAA,CAAgB,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,eAAA;AAAA;AAAA,iBAGvC,8BAAA,2BAEL,YAAA,kDAAA,CAAA;EAIT,aAAA;EACA,SAAA;EACA;AAAA,GACC,mCAAA,CAAoC,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,eAAA,IAAgB,kBAAA,CAAA,GAAA,CAAA,OAAA"}