@tulip-systems/drive 0.8.1 → 0.8.2

package/dist/lib/contracts.d.mts

@@ -0,0 +1,101 @@
+import { DriveFolderParent, DriveNode, DriveNodeBase, DriveNodeChild, DriveNodeWithChildren } from "./dto.mjs";
+import { CreateDriveFolderInput, GetDriveNodesByParentIdInput, ListDriveTreeInput, PresignDriveFileInput, UpdateDriveNodeInput, UploadDriveFileInput } from "./validators.mjs";
+import { TableQueryResponse } from "@tulip-systems/core/data-tables/server";
+
+//#region src/lib/contracts.d.ts
+type DrivePresignedUploadResult<TNode extends DriveNodeBase = DriveNode> = {
+  uploadId: string;
+  presignedUrl: string;
+  node: TNode;
+};
+/**
+ * Read-only drive operations every provider should be able to support.
+ * This is the base contract for provider-agnostic consumers and intentionally
+ * excludes storage, upload, preview generation, readonly, and soft-delete
+ * behavior because those are provider capabilities, not universal drive reads.
+ */
+interface DriveReader<TNode extends DriveNodeBase = DriveNodeBase, TNodeWithChildren extends DriveNodeWithChildren<TNode> = DriveNodeWithChildren<TNode>, TNodeChild extends DriveNodeChild<TNode> = DriveNodeChild<TNode>> {
+  getNodeById(id: string): Promise<TNode | null>;
+  getNodeWithChildren(input: {
+    id: string;
+    namespace: string;
+  }): Promise<TNodeWithChildren | null>;
+  getNodesByParentId(input: GetDriveNodesByParentIdInput): Promise<TNode[]>;
+  listTree(input: ListDriveTreeInput): Promise<TableQueryResponse<TNode>>;
+  getFolderParents(input: {
+    id: string | null;
+    namespace: string;
+  }): Promise<Array<DriveFolderParent<TNode>>>;
+  getNodeChildren(ids: string[]): Promise<TNodeChild[]>;
+}
+/**
+ * Optional capability for providers that can mutate the node tree.
+ * Providers that are read-only, remote-index-only, or permission-limited should
+ * not implement this contract.
+ */
+interface DriveNodeMutations<TNode extends DriveNodeBase = DriveNodeBase> {
+  createFolder(input: CreateDriveFolderInput): Promise<TNode>;
+  updateNode(id: string, data: UpdateDriveNodeInput): Promise<TNode>;
+  moveNode(input: {
+    id: string;
+    parentId: string | null;
+  }): Promise<TNode>;
+  deleteNode(id: string): Promise<void>;
+  deleteNodes(ids: string[]): Promise<void>;
+}
+/**
+ * Optional capability for providers that accept a file body directly.
+ * The body type is provider-specific so the base contracts do not depend on any
+ * storage package or runtime upload representation.
+ */
+interface DriveDirectUpload<TNode extends DriveNodeBase = DriveNodeBase, TBody = unknown> {
+  uploadFile(input: UploadDriveFileInput & {
+    body: TBody;
+  }): Promise<TNode>;
+}
+/**
+ * Optional capability for providers that create upload sessions/URLs.
+ * The returned metadata is provider-specific; local/object-storage providers can
+ * expose asset metadata here without leaking storage concepts into the base Drive
+ * contract.
+ */
+interface DrivePresignedUpload<TNode extends DriveNodeBase = DriveNodeBase, TResult extends DrivePresignedUploadResult<TNode> = DrivePresignedUploadResult<TNode>> {
+  presignUpload(input: PresignDriveFileInput): Promise<TResult>;
+  confirmUpload(uploadId: string): Promise<TNode>;
+}
+/**
+ * Optional capability for providers that generate and persist preview variants.
+ * This is useful for local/object-storage providers. Providers with native
+ * previews, such as Google Drive, should not implement this just as a no-op.
+ */
+interface DrivePreviewGenerator {
+  generatePreviews(input: {
+    id: string;
+  }): Promise<void>;
+}
+/**
+ * Optional capability for providers that can lock/unlock nodes.
+ * Google Drive maps this to `contentRestrictions.readOnly`; local drive maps it
+ * to its readonly flag. This is intentionally not part of the base reader
+ * contract because not every provider can honestly enforce it.
+ */
+interface DriveReadonly<TNode extends DriveNodeBase = DriveNodeBase> {
+  setReadonly(ids: string[], readonly: boolean): Promise<TNode[]>;
+}
+/**
+ * Optional capability for providers that support soft removal.
+ * Local drive maps this to archive state; Google Drive maps this to trash.
+ */
+interface DriveArchive<TNode extends DriveNodeBase = DriveNodeBase> {
+  archiveNodes(ids: string[]): Promise<TNode[]>;
+  restoreNodes(ids: string[]): Promise<TNode[]>;
+}
+/**
+ * Base provider-agnostic Drive contract.
+ * Additional behavior should be composed by intersecting optional capability
+ * contracts, for example `Drive<TNode> & DriveNodeMutations<TNode>`.
+ */
+type Drive<TNode extends DriveNodeBase = DriveNodeBase> = DriveReader<TNode>;
+//#endregion
+export { Drive, DriveArchive, DriveDirectUpload, DriveNodeMutations, DrivePresignedUpload, DrivePresignedUploadResult, DrivePreviewGenerator, DriveReader, DriveReadonly };
+//# sourceMappingURL=contracts.d.mts.map

package/dist/lib/contracts.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.mts","names":[],"sources":["../../src/lib/contracts.ts"],"mappings":";;;;;KAiBY,0BAAA,eAAyC,aAAA,GAAgB,SAAA;EACnE,QAAA;EACA,YAAA;EACA,IAAA,EAAM,KAAA;AAAA;;;;;;;UASS,WAAA,eACD,aAAA,GAAgB,aAAA,4BACJ,qBAAA,CAAsB,KAAA,IAAS,qBAAA,CAAsB,KAAA,sBAC5D,cAAA,CAAe,KAAA,IAAS,cAAA,CAAe,KAAA;EAE1D,WAAA,CAAY,EAAA,WAAa,OAAA,CAAQ,KAAA;EAEjC,mBAAA,CAAoB,KAAA;IAAS,EAAA;IAAY,SAAA;EAAA,IAAsB,OAAA,CAAQ,iBAAA;EAEvE,kBAAA,CAAmB,KAAA,EAAO,4BAAA,GAA+B,OAAA,CAAQ,KAAA;EAEjE,QAAA,CAAS,KAAA,EAAO,kBAAA,GAAqB,OAAA,CAAQ,kBAAA,CAAmB,KAAA;EAEhE,gBAAA,CAAiB,KAAA;IACf,EAAA;IACA,SAAA;EAAA,IACE,OAAA,CAAQ,KAAA,CAAM,iBAAA,CAAkB,KAAA;EAEpC,eAAA,CAAgB,GAAA,aAAgB,OAAA,CAAQ,UAAA;AAAA;;;;;;UAQzB,kBAAA,eAAiC,aAAA,GAAgB,aAAA;EAChE,YAAA,CAAa,KAAA,EAAO,sBAAA,GAAyB,OAAA,CAAQ,KAAA;EACrD,UAAA,CAAW,EAAA,UAAY,IAAA,EAAM,oBAAA,GAAuB,OAAA,CAAQ,KAAA;EAC5D,QAAA,CAAS,KAAA;IAAS,EAAA;IAAY,QAAA;EAAA,IAA4B,OAAA,CAAQ,KAAA;EAClE,UAAA,CAAW,EAAA,WAAa,OAAA;EACxB,WAAA,CAAY,GAAA,aAAgB,OAAA;AAAA;;;;;;UAQb,iBAAA,eAAgC,aAAA,GAAgB,aAAA;EAC/D,UAAA,CAAW,KAAA,EAAO,oBAAA;IAAyB,IAAA,EAAM,KAAA;EAAA,IAAU,OAAA,CAAQ,KAAA;AAAA;;;;;;;UASpD,oBAAA,eACD,aAAA,GAAgB,aAAA,kBACd,0BAAA,CAA2B,KAAA,IAAS,0BAAA,CAA2B,KAAA;EAE/E,aAAA,CAAc,KAAA,EAAO,qBAAA,GAAwB,OAAA,CAAQ,OAAA;EAErD,aAAA,CAAc,QAAA,WAAmB,OAAA,CAAQ,KAAA;AAAA;;;;;;UAQ1B,qBAAA;EACf,gBAAA,CAAiB,KAAA;IAAS,EAAA;EAAA,IAAe,OAAA;AAAA;;;;;;;UAS1B,aAAA,eAA4B,aAAA,GAAgB,aAAA;EAC3D,WAAA,CAAY,GAAA,YAAe,QAAA,YAAoB,OAAA,CAAQ,KAAA;AAAA;;;;;UAOxC,YAAA,eAA2B,aAAA,GAAgB,aAAA;EAC1D,YAAA,CAAa,GAAA,aAAgB,OAAA,CAAQ,KAAA;EACrC,YAAA,CAAa,GAAA,aAAgB,OAAA,CAAQ,KAAA;AAAA;;;;;;KAQ3B,KAAA,eAAoB,aAAA,GAAgB,aAAA,IAAiB,WAAA,CAAY,KAAA"}

package/dist/lib/dto.d.mts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+
+//#region src/lib/dto.d.ts
+/**
+ * Drive node provider
+ */
+declare const driveNodeProviderSchema: z.ZodEnum<{
+  local: "local";
+  google: "google";
+}>;
+type DriveNodeProvider = z.infer<typeof driveNodeProviderSchema>;
+/**
+ * Drive node type
+ */
+declare const driveNodeTypeSchema: z.ZodEnum<{
+  file: "file";
+  folder: "folder";
+}>;
+type DriveNodeType = z.infer<typeof driveNodeTypeSchema>;
+/**
+ * Drive node subtype
+ */
+declare const driveNodeSubtypeSchema: z.ZodEnum<{
+  image: "image";
+  document: "document";
+  spreadsheet: "spreadsheet";
+  video: "video";
+  audio: "audio";
+  archive: "archive";
+  other: "other";
+}>;
+type DriveNodeSubtype = z.infer<typeof driveNodeSubtypeSchema>;
+/**
+ * Node availability
+ */
+declare const driveNodeAvailabilitySchema: z.ZodEnum<{
+  ready: "ready";
+  pending: "pending";
+  failed: "failed";
+}>;
+type DriveNodeAvailability = z.infer<typeof driveNodeAvailabilitySchema>;
+/**
+ * Node links
+ */
+declare const driveNodeLinksSchema: z.ZodObject<{
+  view: z.ZodNullable<z.ZodString>;
+  download: z.ZodNullable<z.ZodString>;
+  preview: z.ZodNullable<z.ZodString>;
+  thumbnail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type DriveNodeLinks = z.infer<typeof driveNodeLinksSchema>;
+/**
+ * Node
+ */
+declare const driveNodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  provider: z.ZodEnum<{
+    local: "local";
+    google: "google";
+  }>;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+  name: z.ZodString;
+  namespace: z.ZodString;
+  type: z.ZodEnum<{
+    file: "file";
+    folder: "folder";
+  }>;
+  subtype: z.ZodEnum<{
+    image: "image";
+    document: "document";
+    spreadsheet: "spreadsheet";
+    video: "video";
+    audio: "audio";
+    archive: "archive";
+    other: "other";
+  }>;
+  size: z.ZodNullable<z.ZodNumber>;
+  contentType: z.ZodNullable<z.ZodString>;
+  readonly: z.ZodBoolean;
+  hidden: z.ZodBoolean;
+  archivedAt: z.ZodNullable<z.ZodDate>;
+  parentId: z.ZodNullable<z.ZodString>;
+  links: z.ZodObject<{
+    view: z.ZodNullable<z.ZodString>;
+    download: z.ZodNullable<z.ZodString>;
+    preview: z.ZodNullable<z.ZodString>;
+    thumbnail: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  availability: z.ZodEnum<{
+    ready: "ready";
+    pending: "pending";
+    failed: "failed";
+  }>;
+}, z.core.$strip>;
+type DriveNode = z.infer<typeof driveNodeSchema>;
+type DriveNodeBase = Omit<DriveNode, "provider">;
+/**
+ * Node with children
+ */
+type DriveNodeWithChildren<TNode extends DriveNodeBase = DriveNode> = TNode & {
+  children: TNode[];
+};
+/**
+ * Node parent and child types
+ */
+type DriveFolderParent<TNode extends DriveNodeBase = DriveNode> = Pick<TNode, "id" | "name" | "parentId"> & {
+  depth: number;
+};
+/**
+ * Node child type
+ */
+type DriveNodeChild<TNode extends DriveNodeBase = DriveNode> = TNode & {
+  depth: number;
+};
+//#endregion
+export { DriveFolderParent, DriveNode, DriveNodeAvailability, DriveNodeBase, DriveNodeChild, DriveNodeLinks, DriveNodeProvider, DriveNodeSubtype, DriveNodeType, DriveNodeWithChildren, driveNodeAvailabilitySchema, driveNodeLinksSchema, driveNodeProviderSchema, driveNodeSchema, driveNodeSubtypeSchema, driveNodeTypeSchema };
+//# sourceMappingURL=dto.d.mts.map

package/dist/lib/dto.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.d.mts","names":[],"sources":["../../src/lib/dto.ts"],"mappings":";;;;;AAMA;cAAa,uBAAA,EAAuB,CAAA,CAAA,OAAA;;;;KACxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;;;;cAKlC,mBAAA,EAAmB,CAAA,CAAA,OAAA;;;;KACpB,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;;;;cAK9B,sBAAA,EAAsB,CAAA,CAAA,OAAA;;;;;;;;;KACvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;;;AAN9C;cAWa,2BAAA,EAA2B,CAAA,CAAA,OAAA;;;;;KAC5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA;;;AAPnD;cAYa,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;KAMrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;;;;cAK/B,eAAA,EAAe,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBhB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA;AAAA,KAC3B,aAAA,GAAgB,IAAA,CAAK,SAAA;;;;KAKrB,qBAAA,eAAoC,aAAA,GAAgB,SAAA,IAAa,KAAA;EAC3E,QAAA,EAAU,KAAA;AAAA;;;;KAMA,iBAAA,eAAgC,aAAA,GAAgB,SAAA,IAAa,IAAA,CACvE,KAAA;EAGA,KAAA;AAAA;;;;KAMU,cAAA,eAA6B,aAAA,GAAgB,SAAA,IAAa,KAAA;EAAU,KAAA;AAAA"}

package/dist/lib/dto.mjs

@@ -0,0 +1,58 @@
+import { DRIVE_NODE_SUBTYPES, DRIVE_NODE_TYPES, DRIVE_PROVIDERS } from "./constants.mjs";
+import { z } from "zod";
+
+//#region src/lib/dto.ts
+/**
+* Drive node provider
+*/
+const driveNodeProviderSchema = z.enum(DRIVE_PROVIDERS);
+/**
+* Drive node type
+*/
+const driveNodeTypeSchema = z.enum(DRIVE_NODE_TYPES);
+/**
+* Drive node subtype
+*/
+const driveNodeSubtypeSchema = z.enum(DRIVE_NODE_SUBTYPES);
+/**
+* Node availability
+*/
+const driveNodeAvailabilitySchema = z.enum([
+	"ready",
+	"pending",
+	"failed"
+]);
+/**
+* Node links
+*/
+const driveNodeLinksSchema = z.object({
+	view: z.string().nullable(),
+	download: z.string().nullable(),
+	preview: z.string().nullable(),
+	thumbnail: z.string().nullable()
+});
+/**
+* Node
+*/
+const driveNodeSchema = z.object({
+	id: z.string(),
+	provider: driveNodeProviderSchema,
+	createdAt: z.date(),
+	updatedAt: z.date(),
+	name: z.string(),
+	namespace: z.string(),
+	type: driveNodeTypeSchema,
+	subtype: driveNodeSubtypeSchema,
+	size: z.number().nullable(),
+	contentType: z.string().nullable(),
+	readonly: z.boolean(),
+	hidden: z.boolean(),
+	archivedAt: z.date().nullable(),
+	parentId: z.string().nullable(),
+	links: driveNodeLinksSchema,
+	availability: driveNodeAvailabilitySchema
+});
+
+//#endregion
+export { driveNodeAvailabilitySchema, driveNodeLinksSchema, driveNodeProviderSchema, driveNodeSchema, driveNodeSubtypeSchema, driveNodeTypeSchema };
+//# sourceMappingURL=dto.mjs.map

package/dist/lib/dto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.mjs","names":[],"sources":["../../src/lib/dto.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { DRIVE_NODE_SUBTYPES, DRIVE_NODE_TYPES, DRIVE_PROVIDERS } from \"./constants\";\n\n/**\n * Drive node provider\n */\nexport const driveNodeProviderSchema = z.enum(DRIVE_PROVIDERS);\nexport type DriveNodeProvider = z.infer<typeof driveNodeProviderSchema>;\n\n/**\n * Drive node type\n */\nexport const driveNodeTypeSchema = z.enum(DRIVE_NODE_TYPES);\nexport type DriveNodeType = z.infer<typeof driveNodeTypeSchema>;\n\n/**\n * Drive node subtype\n */\nexport const driveNodeSubtypeSchema = z.enum(DRIVE_NODE_SUBTYPES);\nexport type DriveNodeSubtype = z.infer<typeof driveNodeSubtypeSchema>;\n\n/**\n * Node availability\n */\nexport const driveNodeAvailabilitySchema = z.enum([\"ready\", \"pending\", \"failed\"]);\nexport type DriveNodeAvailability = z.infer<typeof driveNodeAvailabilitySchema>;\n\n/**\n * Node links\n */\nexport const driveNodeLinksSchema = z.object({\n  view: z.string().nullable(),\n  download: z.string().nullable(),\n  preview: z.string().nullable(),\n  thumbnail: z.string().nullable(),\n});\nexport type DriveNodeLinks = z.infer<typeof driveNodeLinksSchema>;\n\n/**\n * Node\n */\nexport const driveNodeSchema = z.object({\n  id: z.string(),\n  provider: driveNodeProviderSchema,\n  createdAt: z.date(),\n  updatedAt: z.date(),\n  name: z.string(),\n  namespace: z.string(),\n  type: driveNodeTypeSchema,\n  subtype: driveNodeSubtypeSchema,\n  size: z.number().nullable(),\n  contentType: z.string().nullable(),\n  readonly: z.boolean(),\n  hidden: z.boolean(),\n  archivedAt: z.date().nullable(),\n  parentId: z.string().nullable(),\n  links: driveNodeLinksSchema,\n  availability: driveNodeAvailabilitySchema,\n});\nexport type DriveNode = z.infer<typeof driveNodeSchema>;\nexport type DriveNodeBase = Omit<DriveNode, \"provider\">;\n\n/**\n * Node with children\n */\nexport type DriveNodeWithChildren<TNode extends DriveNodeBase = DriveNode> = TNode & {\n  children: TNode[];\n};\n\n/**\n * Node parent and child types\n */\nexport type DriveFolderParent<TNode extends DriveNodeBase = DriveNode> = Pick<\n  TNode,\n  \"id\" | \"name\" | \"parentId\"\n> & {\n  depth: number;\n};\n\n/**\n * Node child type\n */\nexport type DriveNodeChild<TNode extends DriveNodeBase = DriveNode> = TNode & { depth: number };\n"],"mappings":";;;;;;;AAMA,MAAa,0BAA0B,EAAE,KAAK,gBAAgB;;;;AAM9D,MAAa,sBAAsB,EAAE,KAAK,iBAAiB;;;;AAM3D,MAAa,yBAAyB,EAAE,KAAK,oBAAoB;;;;AAMjE,MAAa,8BAA8B,EAAE,KAAK;CAAC;CAAS;CAAW;CAAS,CAAC;;;;AAMjF,MAAa,uBAAuB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,CAAC,UAAU;CAC3B,UAAU,EAAE,QAAQ,CAAC,UAAU;CAC/B,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC9B,WAAW,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;;;;AAMF,MAAa,kBAAkB,EAAE,OAAO;CACtC,IAAI,EAAE,QAAQ;CACd,UAAU;CACV,WAAW,EAAE,MAAM;CACnB,WAAW,EAAE,MAAM;CACnB,MAAM,EAAE,QAAQ;CAChB,WAAW,EAAE,QAAQ;CACrB,MAAM;CACN,SAAS;CACT,MAAM,EAAE,QAAQ,CAAC,UAAU;CAC3B,aAAa,EAAE,QAAQ,CAAC,UAAU;CAClC,UAAU,EAAE,SAAS;CACrB,QAAQ,EAAE,SAAS;CACnB,YAAY,EAAE,MAAM,CAAC,UAAU;CAC/B,UAAU,EAAE,QAAQ,CAAC,UAAU;CAC/B,OAAO;CACP,cAAc;CACf,CAAC"}

package/dist/lib/helpers.d.mts

@@ -0,0 +1,18 @@
+import { DriveNode } from "./dto.mjs";
+
+//#region src/lib/helpers.d.ts
+/**
+ * Check if the node is a file
+ */
+declare function isFile(node: Pick<DriveNode, "type">): node is DriveNode;
+/**
+ * Check if the node is a folder
+ */
+declare function isFolder(node: Pick<DriveNode, "type">): node is DriveNode;
+/**
+ * Render bytes
+ */
+declare function renderBytes(bytes: number): string;
+//#endregion
+export { isFile, isFolder, renderBytes };
+//# sourceMappingURL=helpers.d.mts.map

package/dist/lib/helpers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.mts","names":[],"sources":["../../src/lib/helpers.ts"],"mappings":";;;;;AAKA;iBAAgB,MAAA,CAAO,IAAA,EAAM,IAAA,CAAK,SAAA,YAAqB,IAAA,IAAQ,SAAA;;;;iBAO/C,QAAA,CAAS,IAAA,EAAM,IAAA,CAAK,SAAA,YAAqB,IAAA,IAAQ,SAAA;;;;iBAOjD,WAAA,CAAY,KAAA"}

package/dist/lib/helpers.mjs

@@ -0,0 +1,37 @@
+//#region src/lib/helpers.ts
+/**
+* Check if the node is a file
+*/
+function isFile(node) {
+	return node.type === "file";
+}
+/**
+* Check if the node is a folder
+*/
+function isFolder(node) {
+	return node.type === "folder";
+}
+/**
+* Render bytes
+*/
+function renderBytes(bytes) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB",
+		"PB"
+	];
+	let size = bytes;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex++;
+	}
+	return `${size.toFixed(2)}${units[unitIndex]}`;
+}
+
+//#endregion
+export { isFile, isFolder, renderBytes };
+//# sourceMappingURL=helpers.mjs.map

package/dist/lib/helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.mjs","names":[],"sources":["../../src/lib/helpers.ts"],"sourcesContent":["import type { DriveNode } from \"./dto\";\n\n/**\n * Check if the node is a file\n */\nexport function isFile(node: Pick<DriveNode, \"type\">): node is DriveNode {\n  return node.type === \"file\";\n}\n\n/**\n * Check if the node is a folder\n */\nexport function isFolder(node: Pick<DriveNode, \"type\">): node is DriveNode {\n  return node.type === \"folder\";\n}\n\n/**\n * Render bytes\n */\nexport function renderBytes(bytes: number) {\n  const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\"];\n\n  let size = bytes;\n  let unitIndex = 0;\n\n  while (size >= 1024 && unitIndex < units.length - 1) {\n    size /= 1024;\n    unitIndex++;\n  }\n\n  return `${size.toFixed(2)}${units[unitIndex]}`;\n}\n"],"mappings":";;;;AAKA,SAAgB,OAAO,MAAkD;AACvE,QAAO,KAAK,SAAS;;;;;AAMvB,SAAgB,SAAS,MAAkD;AACzE,QAAO,KAAK,SAAS;;;;;AAMvB,SAAgB,YAAY,OAAe;CACzC,MAAM,QAAQ;EAAC;EAAK;EAAM;EAAM;EAAM;EAAM;EAAK;CAEjD,IAAI,OAAO;CACX,IAAI,YAAY;AAEhB,QAAO,QAAQ,QAAQ,YAAY,MAAM,SAAS,GAAG;AACnD,UAAQ;AACR;;AAGF,QAAO,GAAG,KAAK,QAAQ,EAAE,GAAG,MAAM"}

package/dist/lib/helpers.server.d.mts

@@ -0,0 +1,14 @@
+import { DriveViewMode } from "../components/view.client.mjs";
+import "server-cli-only";
+import { cookies } from "next/headers";
+
+//#region src/lib/helpers.server.d.ts
+/**
+ * Helper function to get the drive view mode from cookies
+ * @param cookiesStore - The cookies store from Next.js headers
+ * @returns The drive view mode ("grid" or "list") or undefined if not set
+ */
+declare function getDriveViewModeFromCookies(cookiesStore: Awaited<ReturnType<typeof cookies>>): DriveViewMode | undefined;
+//#endregion
+export { getDriveViewModeFromCookies };
+//# sourceMappingURL=helpers.server.d.mts.map

package/dist/lib/helpers.server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.server.d.mts","names":[],"sources":["../../src/lib/helpers.server.ts"],"mappings":";;;;;;;AAWA;;;iBAAgB,2BAAA,CAA4B,YAAA,EAAc,OAAA,CAAQ,UAAA,QAAkB,OAAA,KAC7B,aAAA"}

package/dist/lib/helpers.server.mjs

@@ -0,0 +1,16 @@
+import { DRIVE_VIEW_COOKIE } from "./constants.mjs";
+import "server-cli-only";
+
+//#region src/lib/helpers.server.ts
+/**
+* Helper function to get the drive view mode from cookies
+* @param cookiesStore - The cookies store from Next.js headers
+* @returns The drive view mode ("grid" or "list") or undefined if not set
+*/
+function getDriveViewModeFromCookies(cookiesStore) {
+	return cookiesStore.get(DRIVE_VIEW_COOKIE)?.value;
+}
+
+//#endregion
+export { getDriveViewModeFromCookies };
+//# sourceMappingURL=helpers.server.mjs.map

package/dist/lib/helpers.server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.server.mjs","names":[],"sources":["../../src/lib/helpers.server.ts"],"sourcesContent":["import \"server-cli-only\";\n\nimport type { cookies } from \"next/headers\";\nimport type { DriveViewMode } from \"@/components/view.client\";\nimport { DRIVE_VIEW_COOKIE } from \"./constants\";\n\n/**\n * Helper function to get the drive view mode from cookies\n * @param cookiesStore - The cookies store from Next.js headers\n * @returns The drive view mode (\"grid\" or \"list\") or undefined if not set\n */\nexport function getDriveViewModeFromCookies(cookiesStore: Awaited<ReturnType<typeof cookies>>) {\n  return cookiesStore.get(DRIVE_VIEW_COOKIE)?.value as DriveViewMode | undefined;\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,4BAA4B,cAAmD;AAC7F,QAAO,aAAa,IAAI,kBAAkB,EAAE"}

package/dist/lib/search-params.d.mts

@@ -0,0 +1,9 @@
+import * as nuqs_server0 from "nuqs/server";
+
+//#region src/lib/search-params.d.ts
+declare const driveTreeSearchParams: {
+  parentId: nuqs_server0.SingleParserBuilder<string>;
+};
+//#endregion
+export { driveTreeSearchParams };
+//# sourceMappingURL=search-params.d.mts.map

package/dist/lib/search-params.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-params.d.mts","names":[],"sources":["../../src/lib/search-params.ts"],"mappings":";;;cAEa,qBAAA;YAEZ,YAAA,CAAA,mBAAA;AAAA"}

package/dist/lib/search-params.mjs

@@ -0,0 +1,8 @@
+import { parseAsString } from "nuqs/server";
+
+//#region src/lib/search-params.ts
+const driveTreeSearchParams = { parentId: parseAsString };
+
+//#endregion
+export { driveTreeSearchParams };
+//# sourceMappingURL=search-params.mjs.map

package/dist/lib/search-params.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-params.mjs","names":[],"sources":["../../src/lib/search-params.ts"],"sourcesContent":["import { parseAsString } from \"nuqs/server\";\n\nexport const driveTreeSearchParams = {\n  parentId: parseAsString,\n};\n"],"mappings":";;;AAEA,MAAa,wBAAwB,EACnC,UAAU,eACX"}

package/dist/lib/validators.d.mts

@@ -0,0 +1,158 @@
+import { z } from "zod";
+
+//#region src/lib/validators.d.ts
+/**
+ * Create drive folder input schema
+ * @description zod schema for validating the input of the create drive folder command
+ */
+declare const createDriveFolderInputSchema: z.ZodObject<{
+  name: z.ZodString;
+  namespace: z.ZodString;
+  parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type CreateDriveFolderInput = z.input<typeof createDriveFolderInputSchema>;
+type CreateDriveFolderSchema = z.infer<typeof createDriveFolderInputSchema>;
+/**
+ * Update drive node input schema
+ */
+declare const updateDriveNodeInputSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type UpdateDriveNodeInput = z.input<typeof updateDriveNodeInputSchema>;
+type UpdateDriveNodeSchema = z.infer<typeof updateDriveNodeInputSchema>;
+/**
+ * Upload drive file input schema
+ * @description zod schema for validating the input of the upload drive file command
+ */
+declare const uploadDriveFileInputSchema: z.ZodObject<{
+  name: z.ZodString;
+  namespace: z.ZodString;
+  parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  contentType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type UploadDriveFileInput = z.input<typeof uploadDriveFileInputSchema>;
+type UploadDriveFileSchema = z.infer<typeof uploadDriveFileInputSchema>;
+/**
+ * Presign drive file input schema
+ * @description zod schema for validating the input of the presign drive file command
+ */
+declare const presignDriveFileInputSchema: z.ZodObject<{
+  name: z.ZodString;
+  namespace: z.ZodString;
+  parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  contentType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type PresignDriveFileInput = z.input<typeof presignDriveFileInputSchema>;
+type PresignDriveFileSchema = z.infer<typeof presignDriveFileInputSchema>;
+/**
+ * Table filters
+ */
+declare const driveTableFiltersSchema: z.ZodPipe<z.ZodObject<{
+  types: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+    file: "file";
+    folder: "folder";
+  }>>>>;
+  contentTypes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  nodeIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  isArchived: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+  namespace: z.ZodString;
+  parentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.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 NodesTableFilters = z.infer<typeof driveTableFiltersSchema>;
+/**
+ * List tree input schema
+ */
+declare const listDriveTreeInputSchema: z.ZodObject<{
+  cursor: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>, z.ZodTransform<number, number>>;
+  limit: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>, z.ZodTransform<number, number>>;
+  sort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  order: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>>;
+  search: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  filters: z.ZodPipe<z.ZodObject<{
+    types: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+      file: "file";
+      folder: "folder";
+    }>>>>;
+    contentTypes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    nodeIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    isArchived: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    namespace: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>, z.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.core.$strip>;
+type ListDriveTreeInput = z.input<typeof listDriveTreeInputSchema>;
+type ListDriveTreeSchema = z.infer<typeof listDriveTreeInputSchema>;
+/**
+ * Get nodes by parent id input schema
+ */
+declare const getNodesByParentIdInputSchema: z.ZodObject<{
+  sort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  search: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  order: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>>;
+  filters: z.ZodPipe<z.ZodObject<{
+    types: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+      file: "file";
+      folder: "folder";
+    }>>>>;
+    contentTypes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    nodeIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    isArchived: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    namespace: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>, z.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.core.$strip>;
+type GetDriveNodesByParentIdInput = z.input<typeof getNodesByParentIdInputSchema>;
+type GetDriveNodesByParentIdSchema = z.infer<typeof getNodesByParentIdInputSchema>;
+//#endregion
+export { CreateDriveFolderInput, CreateDriveFolderSchema, GetDriveNodesByParentIdInput, GetDriveNodesByParentIdSchema, ListDriveTreeInput, ListDriveTreeSchema, NodesTableFilters, PresignDriveFileInput, PresignDriveFileSchema, UpdateDriveNodeInput, UpdateDriveNodeSchema, UploadDriveFileInput, UploadDriveFileSchema, createDriveFolderInputSchema, driveTableFiltersSchema, getNodesByParentIdInputSchema, listDriveTreeInputSchema, presignDriveFileInputSchema, updateDriveNodeInputSchema, uploadDriveFileInputSchema };
+//# sourceMappingURL=validators.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../../src/lib/validators.ts"],"mappings":";;;;;AAQA;;cAAa,4BAAA,EAA4B,CAAA,CAAA,SAAA;;;;;KAK7B,sBAAA,GAAyB,CAAA,CAAE,KAAA,QAAa,4BAAA;AAAA,KACxC,uBAAA,GAA0B,CAAA,CAAE,KAAA,QAAa,4BAAA;;;;cAKxC,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;KAG3B,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,0BAAA;AAAA,KACtC,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,0BAAA;;;;;cAMtC,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;;;;;KAO3B,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,0BAAA;AAAA,KACtC,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,0BAAA;;;AAxBnD;;cA8Ba,2BAAA,EAA2B,CAAA,CAAA,SAAA;;;;;;;KAQ5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,KACvC,sBAAA,GAAyB,CAAA,CAAE,KAAA,QAAa,2BAAA;;;;cAKvC,uBAAA,EAAuB,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAWxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;;;;cAKlC,wBAAA,EAAwB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIzB,kBAAA,GAAqB,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,KACpC,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,wBAAA;;;;cAKpC,6BAAA,EAA6B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI9B,4BAAA,GAA+B,CAAA,CAAE,KAAA,QAAa,6BAAA;AAAA,KAC9C,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,6BAAA"}

package/dist/lib/validators.mjs

@@ -0,0 +1,66 @@
+import { driveTreeFilters } from "../config/filters.mjs";
+import { z } from "zod";
+import { resolveFiltersSchema, tableQuerySchema } from "@tulip-systems/core/data-tables";
+
+//#region src/lib/validators.ts
+/**
+* Create drive folder input schema
+* @description zod schema for validating the input of the create drive folder command
+*/
+const createDriveFolderInputSchema = z.object({
+	name: z.string(),
+	namespace: z.string(),
+	parentId: z.string().nullable().optional()
+});
+/**
+* Update drive node input schema
+*/
+const updateDriveNodeInputSchema = z.object({ name: z.string().optional() });
+/**
+* Upload drive file input schema
+* @description zod schema for validating the input of the upload drive file command
+*/
+const uploadDriveFileInputSchema = z.object({
+	name: z.string(),
+	namespace: z.string(),
+	parentId: z.string().nullable().optional(),
+	contentType: z.string().nullable().optional(),
+	size: z.number().nullable().optional()
+});
+/**
+* Presign drive file input schema
+* @description zod schema for validating the input of the presign drive file command
+*/
+const presignDriveFileInputSchema = z.object({
+	name: z.string(),
+	namespace: z.string(),
+	parentId: z.string().nullable().optional(),
+	contentType: z.string().nullable().optional(),
+	size: z.number().nullable().optional()
+});
+/**
+* Table filters
+*/
+const driveTableFiltersSchema = resolveFiltersSchema(driveTreeFilters).partial().extend({
+	namespace: z.string(),
+	parentId: z.string().nullable()
+}).transform((input) => ({
+	...input,
+	isArchived: input?.isArchived ?? false
+}));
+/**
+* List tree input schema
+*/
+const listDriveTreeInputSchema = tableQuerySchema.extend({ filters: driveTableFiltersSchema });
+/**
+* Get nodes by parent id input schema
+*/
+const getNodesByParentIdInputSchema = tableQuerySchema.pick({
+	order: true,
+	sort: true,
+	search: true
+}).extend({ filters: driveTableFiltersSchema });
+
+//#endregion
+export { createDriveFolderInputSchema, driveTableFiltersSchema, getNodesByParentIdInputSchema, listDriveTreeInputSchema, presignDriveFileInputSchema, updateDriveNodeInputSchema, uploadDriveFileInputSchema };
+//# sourceMappingURL=validators.mjs.map