@tulip-systems/drive-local 0.11.1

package/dist/root/lib/database/contracts.d.mts

@@ -0,0 +1,112 @@
+import { LocalDriveFiltersSchema, LocalDrivePresignedUrlFiltersSchema, LocalDriveVariantFiltersSchema } from "../../config/filters.mjs";
+import { LocalDriveTableSortsSchema } from "../../config/sorting.mjs";
+import { ImageVariant } from "../constants.mjs";
+import { LocalNode } from "../validators.mjs";
+import { LocalDriveDatabaseNodeFiltersSchema } from "./filters.mjs";
+import { SelectStorageAssetSchema } from "@tulip-systems/storage";
+//#region src/root/lib/database/contracts.d.ts
+type LocalDriveDatabaseNodeWithAsset = LocalNode & {
+  asset: SelectStorageAssetSchema | null;
+};
+type LocalDriveDatabaseListResult<TData> = {
+  data: TData[];
+  total: number;
+};
+type LocalDriveDatabaseListNodesWithAssetInput = {
+  filters: LocalDriveFiltersSchema;
+  sorts?: LocalDriveTableSortsSchema;
+  limit: number;
+  offset: number;
+};
+type LocalDriveDatabaseFindFirstNodeInput = {
+  filters?: LocalDriveDatabaseNodeFiltersSchema;
+};
+type LocalDriveDatabaseFindNodesInput = {
+  filters?: LocalDriveDatabaseNodeFiltersSchema;
+  sorts?: LocalDriveTableSortsSchema;
+  limit?: number;
+  offset?: number;
+};
+type LocalDriveDatabaseNodeParent = Pick<LocalNode, "id" | "name" | "parentId"> & {
+  depth: number;
+};
+type LocalDriveDatabaseNodeChild = LocalNode & {
+  depth: number;
+};
+type LocalDriveDatabasePresignedUrl = {
+  url: string;
+  expiresAt: Date;
+};
+type LocalDriveDatabaseNodeVariant = {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  nodeId: string;
+  assetId: string;
+  variant: ImageVariant;
+  width: number;
+};
+type LocalDriveDatabaseFindVariantsInput = {
+  filters?: LocalDriveVariantFiltersSchema;
+  limit?: number;
+  offset?: number;
+};
+type LocalDriveDatabaseFindFirstPresignedUrlInput = {
+  filters?: LocalDrivePresignedUrlFiltersSchema;
+};
+type LocalDriveDatabaseUpdateNodeInput = Partial<Pick<LocalNode, "archivedAt" | "contentType" | "hidden" | "name" | "parentId" | "readonly" | "size">>;
+type LocalDriveDatabaseUpdateNodesInput = {
+  filters: LocalDriveDatabaseNodeFiltersSchema;
+  data: LocalDriveDatabaseUpdateNodeInput;
+};
+type LocalDriveDatabaseDeleteNodesInput = {
+  filters: LocalDriveDatabaseNodeFiltersSchema;
+};
+type LocalDriveDatabaseCreateNodeInput = {
+  type: Exclude<LocalNode["type"], null>;
+  name: string;
+  namespace: string;
+  parentId?: string | null;
+  size?: number | null;
+  contentType?: string | null;
+  hidden?: boolean;
+  readonly?: boolean;
+  subtype?: LocalNode["subtype"];
+  assetId?: string | null;
+};
+type UpsertLocalDrivePresignedUrlInput = {
+  nodeId: string;
+  url: string;
+  variant: ImageVariant;
+  variantId?: string | null;
+  disposition: "inline" | "attachment";
+  expiresAt: Date;
+};
+type LocalDriveDatabaseCreateVariantInput = {
+  nodeId: string;
+  assetId: string;
+  variant: ImageVariant;
+  width: number;
+};
+interface LocalDriveDatabaseProvider {
+  findNodeById(id: string): Promise<LocalNode | null>;
+  findFirstNode(input?: LocalDriveDatabaseFindFirstNodeInput): Promise<LocalNode | null>;
+  findNodes(input?: LocalDriveDatabaseFindNodesInput): Promise<LocalNode[]>;
+  listNodesWithAsset(input: LocalDriveDatabaseListNodesWithAssetInput): Promise<LocalDriveDatabaseListResult<LocalDriveDatabaseNodeWithAsset>>;
+  getNodeParents(input: {
+    id: string | null;
+    namespace: string;
+  }): Promise<LocalDriveDatabaseNodeParent[]>;
+  getNodeChildren(ids: string[]): Promise<LocalDriveDatabaseNodeChild[]>;
+  createNode(input: LocalDriveDatabaseCreateNodeInput): Promise<LocalNode | null>;
+  updateNodeById(id: string, data: LocalDriveDatabaseUpdateNodeInput): Promise<LocalNode | null>;
+  updateNodes(input: LocalDriveDatabaseUpdateNodesInput): Promise<LocalNode[]>;
+  deleteNodeById(id: string): Promise<void>;
+  deleteNodes(input: LocalDriveDatabaseDeleteNodesInput): Promise<void>;
+  findVariants(input?: LocalDriveDatabaseFindVariantsInput): Promise<LocalDriveDatabaseNodeVariant[]>;
+  createVariant(input: LocalDriveDatabaseCreateVariantInput): Promise<void>;
+  findFirstPresignedUrl(input?: LocalDriveDatabaseFindFirstPresignedUrlInput): Promise<LocalDriveDatabasePresignedUrl | null>;
+  upsertPresignedUrl(input: UpsertLocalDrivePresignedUrlInput): Promise<void>;
+}
+//#endregion
+export { LocalDriveDatabaseCreateNodeInput, LocalDriveDatabaseCreateVariantInput, LocalDriveDatabaseDeleteNodesInput, LocalDriveDatabaseFindFirstNodeInput, LocalDriveDatabaseFindFirstPresignedUrlInput, LocalDriveDatabaseFindNodesInput, LocalDriveDatabaseFindVariantsInput, LocalDriveDatabaseListNodesWithAssetInput, LocalDriveDatabaseListResult, LocalDriveDatabaseNodeChild, LocalDriveDatabaseNodeParent, LocalDriveDatabaseNodeVariant, LocalDriveDatabaseNodeWithAsset, LocalDriveDatabasePresignedUrl, LocalDriveDatabaseProvider, LocalDriveDatabaseUpdateNodeInput, LocalDriveDatabaseUpdateNodesInput, UpsertLocalDrivePresignedUrlInput };

package/dist/root/lib/database/filters.d.mts

@@ -0,0 +1,28 @@
+import { z as z$1 } from "zod";
+//#region src/root/lib/database/filters.d.ts
+declare const localDriveDatabaseNodeFiltersSchema: z$1.ZodObject<{
+  search: z$1.ZodOptional<z$1.ZodString>;
+  types: z$1.ZodOptional<z$1.ZodArray<z$1.ZodEnum<{
+    readonly folder: "folder";
+    readonly file: "file";
+  }>>>;
+  contentTypes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+  nodeIds: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+  assetIds: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+  namespace: z$1.ZodOptional<z$1.ZodString>;
+  parentId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  subtypes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodEnum<{
+    readonly image: "image";
+    readonly document: "document";
+    readonly spreadsheet: "spreadsheet";
+    readonly video: "video";
+    readonly audio: "audio";
+    readonly archive: "archive";
+    readonly other: "other";
+  }>>>;
+  isArchived: z$1.ZodOptional<z$1.ZodBoolean>;
+  hidden: z$1.ZodOptional<z$1.ZodBoolean>;
+}, z$1.core.$strip>;
+type LocalDriveDatabaseNodeFiltersSchema = z$1.infer<typeof localDriveDatabaseNodeFiltersSchema>;
+//#endregion
+export { LocalDriveDatabaseNodeFiltersSchema, localDriveDatabaseNodeFiltersSchema };

package/dist/root/lib/database/filters.mjs

@@ -0,0 +1,73 @@
+import { nodeSubtypes } from "../constants.mjs";
+import { DRIVE_NODE_TYPES } from "@tulip-systems/drive";
+import { arrayFilter, booleanFilter, createFilteringParser, defineFilters, enumFilter, resolveFiltersSchema, stringFilter } from "@tulip-systems/query";
+import { z as z$1 } from "zod";
+//#region src/root/lib/database/filters.ts
+/**
+* Database node filters.
+*
+* These intentionally do not apply lifecycle defaults. Public list filters can
+* default to visible, non-archived nodes, but database mutations and direct
+* lookups must only filter lifecycle state when explicitly requested.
+*/
+const localDriveDatabaseNodeFilters = defineFilters({
+	search: stringFilter.build((value) => value ? {
+		field: "name",
+		operator: "ilike",
+		value: `%${value}%`
+	} : null),
+	types: arrayFilter(enumFilter(DRIVE_NODE_TYPES)).build((value) => value?.length ? {
+		field: "type",
+		operator: "in",
+		value
+	} : null),
+	contentTypes: arrayFilter(stringFilter).build((value) => value?.length ? {
+		field: "contentType",
+		operator: "in",
+		value
+	} : null),
+	nodeIds: arrayFilter(stringFilter).build((value) => value === void 0 ? null : {
+		field: "id",
+		operator: "in",
+		value
+	}),
+	assetIds: arrayFilter(stringFilter).build((value) => value === void 0 ? null : {
+		field: "assetId",
+		operator: "in",
+		value
+	}),
+	namespace: stringFilter.build((value) => value ? {
+		field: "namespace",
+		operator: "eq",
+		value
+	} : null),
+	parentId: stringFilter.options({ schema: z$1.string().nullable() }).build((value) => {
+		if (value === void 0) return null;
+		return value === null ? {
+			field: "parentId",
+			operator: "isNull"
+		} : {
+			field: "parentId",
+			operator: "eq",
+			value
+		};
+	}),
+	subtypes: arrayFilter(enumFilter(nodeSubtypes)).build((value) => value?.length ? {
+		field: "subtype",
+		operator: "in",
+		value
+	} : null),
+	isArchived: booleanFilter.build((value) => value === void 0 ? null : {
+		field: "archivedAt",
+		operator: value ? "isNotNull" : "isNull"
+	}),
+	hidden: booleanFilter.build((value) => value === void 0 ? null : {
+		field: "hidden",
+		operator: "eq",
+		value
+	})
+});
+resolveFiltersSchema(localDriveDatabaseNodeFilters);
+const localDriveDatabaseNodeFiltersParser = createFilteringParser(localDriveDatabaseNodeFilters);
+//#endregion
+export { localDriveDatabaseNodeFilters, localDriveDatabaseNodeFiltersParser };

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

@@ -0,0 +1,33 @@
+import { LocalDriveNodeSubtype } from "./constants.mjs";
+import { GetLocalFileURLSchema, LocalDriveNode, LocalNode } from "./validators.mjs";
+import { ImageLoaderProps } from "next/image";
+//#region src/root/lib/helpers.d.ts
+/**
+ * Convert a LocalNode to LocalDriveNode by adding provider and links
+ * @param node The LocalNode to convert
+ * @returns The converted LocalDriveNode
+ */
+declare function toLocalDriveNode<TNode extends LocalNode>(node: TNode): LocalDriveNode;
+/**
+ * Check if the node is a file
+ */
+declare function isLocalDriveFile(node: Pick<LocalNode, "type">): node is LocalNode;
+/**
+ * Check if the node is a folder
+ */
+declare function isLocalDriveFolder(node: Pick<LocalNode, "type">): node is LocalNode;
+/**
+ * Get file url
+ */
+declare function getLocalDriveFileUrl(id: string, options?: Partial<GetLocalFileURLSchema>): string;
+/**
+ * Image loader
+ */
+declare function localDriveImageLoader({ src, width }: ImageLoaderProps): string;
+declare function inferLocalDriveNodeSubtype(input: Partial<Pick<LocalDriveNode, "name" | "contentType">>): LocalDriveNodeSubtype;
+/**
+ * Render bytes
+ */
+declare function renderBytes(bytes: number): string;
+//#endregion
+export { getLocalDriveFileUrl, inferLocalDriveNodeSubtype, isLocalDriveFile, isLocalDriveFolder, localDriveImageLoader, renderBytes, toLocalDriveNode };

package/dist/root/lib/helpers.mjs

@@ -0,0 +1,78 @@
+import { inferDriveNodeSubtype } from "@tulip-systems/drive";
+//#region src/root/lib/helpers.ts
+/**
+* Convert a LocalNode to LocalDriveNode by adding provider and links
+* @param node The LocalNode to convert
+* @returns The converted LocalDriveNode
+*/
+function toLocalDriveNode(node) {
+	return {
+		...node,
+		type: node.type,
+		readonly: node.readonly ?? false,
+		hidden: node.hidden ?? false,
+		provider: "local",
+		links: {
+			view: node.type === "file" ? getLocalDriveFileUrl(node.id, { disposition: "inline" }) : null,
+			download: node.type === "file" ? getLocalDriveFileUrl(node.id, { disposition: "attachment" }) : null,
+			preview: node.type === "file" ? getLocalDriveFileUrl(node.id) : null,
+			thumbnail: node.type === "file" ? getLocalDriveFileUrl(node.id, { variant: "preview-256" }) : null
+		},
+		availability: "ready"
+	};
+}
+/**
+* Check if the node is a file
+*/
+function isLocalDriveFile(node) {
+	return node.type === "file";
+}
+/**
+* Check if the node is a folder
+*/
+function isLocalDriveFolder(node) {
+	return node.type === "folder";
+}
+/**
+* Get file url
+*/
+function getLocalDriveFileUrl(id, options = {}) {
+	const searchParams = new URLSearchParams();
+	if (options?.variant) searchParams.set("variant", options.variant);
+	if (options?.disposition) searchParams.set("disposition", options.disposition);
+	const queryString = searchParams.toString();
+	return `/api/drive/files/${id}${queryString ? `?${queryString}` : ""}`;
+}
+/**
+* Image loader
+*/
+function localDriveImageLoader({ src, width }) {
+	const url = new URL(src, window.location.origin);
+	url.searchParams.set("variant", `preview-${width}`);
+	return url.toString();
+}
+function inferLocalDriveNodeSubtype(input) {
+	return inferDriveNodeSubtype(input);
+}
+/**
+* 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 { getLocalDriveFileUrl, inferLocalDriveNodeSubtype, isLocalDriveFile, isLocalDriveFolder, localDriveImageLoader, renderBytes, toLocalDriveNode };

package/dist/root/lib/route-handler.server.d.mts

@@ -0,0 +1,36 @@
+import { LocalDrive } from "./service.server.mjs";
+import { NextRequest } from "next/server";
+import { AuthServer, AuthServerSessionCapability } from "@tulip-systems/auth";
+//#region src/root/lib/route-handler.server.d.ts
+type RouteCtx = {
+  params: Promise<{
+    rest?: string[];
+  }>;
+};
+type AuthWithSession = AuthServer<{
+  capabilities: [AuthServerSessionCapability];
+}>;
+type CreateLocalDriveRouteHandlerProps<TAuth extends AuthWithSession> = {
+  auth: TAuth;
+  drive: LocalDrive;
+};
+/**
+ * Creates a catch-all drive route handler for `/api/drive/[[...rest]]`.
+ *
+ * Current support:
+ * - `GET /api/drive/files/:id?variant=:variant&disposition=:disposition`
+ *   resolves a drive node, checks access for private local assets, and redirects
+ *   to a short-lived file URL for the requested node variant.
+ *
+ * @param props - Route handler dependencies.
+ * @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE.
+ */
+declare function createLocalDriveRouteHandler<TAuth extends AuthWithSession>(context: CreateLocalDriveRouteHandlerProps<TAuth>): {
+  GET: (request: NextRequest, ctx: RouteCtx) => Promise<Response>;
+  POST: () => Promise<Response>;
+  PUT: () => Promise<Response>;
+  PATCH: () => Promise<Response>;
+  DELETE: () => Promise<Response>;
+};
+//#endregion
+export { createLocalDriveRouteHandler };

package/dist/root/lib/route-handler.server.mjs

@@ -0,0 +1,111 @@
+import { getLocalFileURLSchema } from "./validators.mjs";
+import z from "zod";
+import { ORPCError } from "@orpc/server";
+import { getSession } from "@tulip-systems/auth/next/server";
+import { connection } from "next/server";
+//#region src/root/lib/route-handler.server.ts
+/**
+* Creates a catch-all drive route handler for `/api/drive/[[...rest]]`.
+*
+* Current support:
+* - `GET /api/drive/files/:id?variant=:variant&disposition=:disposition`
+*   resolves a drive node, checks access for private local assets, and redirects
+*   to a short-lived file URL for the requested node variant.
+*
+* @param props - Route handler dependencies.
+* @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE.
+*/
+function createLocalDriveRouteHandler(context) {
+	/**
+	* GET /api/drive/[[...rest]]
+	*
+	* Current route support:
+	* - /api/drive/files/:id?variant=:variant&disposition=:disposition
+	*/
+	async function GET(request, ctx) {
+		const { rest = [] } = await ctx.params;
+		if (rest[0] === "files") {
+			const id = rest[1];
+			if (!id) return Response.json({ error: {
+				code: "BAD_REQUEST",
+				message: "Missing file id"
+			} }, { status: 400 });
+			const searchParams = request.nextUrl.searchParams;
+			const variant = searchParams.get("variant") ?? void 0;
+			const disposition = searchParams.get("disposition") ?? void 0;
+			try {
+				const node = await context.drive.getNodeById(id);
+				if (!node) return Response.json({ error: {
+					code: "NOT_FOUND",
+					message: "Node not found"
+				} }, { status: 404 });
+				if (node.assetId) {
+					const asset = await context.drive.storage.getAssetById(node.assetId);
+					if (!asset) return Response.json({ error: {
+						code: "NOT_FOUND",
+						message: "Asset not found"
+					} }, { status: 404 });
+					if (asset.visibility === "private") {
+						if (!await getSession(context.auth)) return Response.json({ error: {
+							code: "UNAUTHORIZED",
+							message: "Unauthorized"
+						} }, { status: 401 });
+					}
+				}
+				const options = getLocalFileURLSchema.parse({
+					variant,
+					disposition
+				});
+				const url = await context.drive.getURL(node, options);
+				return Response.redirect(url, 307);
+			} catch (error) {
+				if (error instanceof z.ZodError) return Response.json({ error: {
+					code: "BAD_REQUEST",
+					message: "Invalid request input"
+				} }, { status: 400 });
+				if (error instanceof ORPCError) {
+					if (error.code === "BAD_REQUEST") return Response.json({ error: {
+						code: "BAD_REQUEST",
+						message: error.message
+					} }, { status: 400 });
+					if (error.code === "NOT_FOUND") return Response.json({ error: {
+						code: "NOT_FOUND",
+						message: error.message
+					} }, { status: 404 });
+					if (error.code === "UNAUTHORIZED") return Response.json({ error: {
+						code: "UNAUTHORIZED",
+						message: error.message
+					} }, { status: 401 });
+				}
+				console.error("Drive route error", error);
+				return Response.json({ error: {
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Something went wrong"
+				} }, { status: 500 });
+			}
+		}
+		return Response.json({ error: {
+			code: "NOT_FOUND",
+			message: "Route not found"
+		} }, { status: 404 });
+	}
+	/**
+	* POST, PUT, PATCH, DELETE /api/drive/[[...rest]]
+	*/
+	async function POST() {
+		await connection();
+		return Response.json({ error: {
+			code: "NOT_FOUND",
+			message: "Route not found"
+		} }, { status: 404 });
+	}
+	return {
+		GET,
+		POST,
+		PUT: POST,
+		PATCH: POST,
+		DELETE: POST
+	};
+}
+//#endregion
+export { createLocalDriveRouteHandler };