@tulip-systems/drive-local 0.11.1

package/dist/database/drizzle/lib/adapter.mjs

@@ -0,0 +1,520 @@
+import { localDriveFiltersParser, localDrivePresignedUrlFiltersParser, localDriveVariantFiltersParser } from "../../../root/config/filters.mjs";
+import { localDriveTableSortsParser } from "../../../root/config/sorting.mjs";
+import { localDriveDatabaseNodeFiltersParser } from "../../../root/lib/database/filters.mjs";
+import { compileLocalDriveDatabaseNodeFiltersToDrizzle, compileLocalDriveFiltersToDrizzle, compileLocalDrivePresignedUrlFiltersToDrizzle, compileLocalDriveSortsToDrizzle, compileLocalDriveVariantFiltersToDrizzle } from "./compilers.mjs";
+import { and, eq, inArray, sql } from "drizzle-orm";
+//#region src/database/drizzle/lib/adapter.ts
+/**
+* Creates the Drizzle database adapter for the local drive package.
+*
+* The local drive package owns the drive behavior, but the consumer app owns the
+* Drizzle schema and migrations. Pass the app's `db` instance and a schema map
+* with the local drive tables under the expected contract keys.
+*
+* @example
+* import { localDriveDrizzleAdapter } from "@tulip-systems/drive-local/drizzle";
+* import { LocalDrive } from "@tulip-systems/drive-local/server";
+* import * as driveSchema from "@/server/drive-local/schema";
+* import * as storageSchema from "@/server/storage/schema";
+*
+* export const drive = new LocalDrive({
+*   database: localDriveDrizzleAdapter({
+*     db,
+*     schema: { ...driveSchema, storageAssets: storageSchema.storageAssets },
+*   }),
+*   storage,
+* });
+*
+* @example
+* // You can also remap app-owned table names to the local drive contract keys.
+* localDriveDrizzleAdapter({
+*   db,
+*   schema: {
+*     nodes: driveNodes,
+*     nodeVariants: driveNodeVariants,
+*     nodePresignedUrls: driveNodePresignedUrls,
+*     storageAssets: assets,
+*   },
+* });
+*/
+function localDriveDrizzleAdapter({ db, schema }) {
+	const { nodePresignedUrls, nodeVariants, nodes, storageAssets } = schema;
+	function parseNodeSorts(sorts) {
+		const parsedSorts = localDriveTableSortsParser.parse(sorts);
+		return compileLocalDriveSortsToDrizzle(nodes).parse(parsedSorts);
+	}
+	function parseNodeFilters(filters) {
+		const parsedFilters = localDriveFiltersParser.parse(filters);
+		return compileLocalDriveFiltersToDrizzle(nodes).parse(parsedFilters);
+	}
+	function parseDatabaseNodeFilters(filters) {
+		const parsedFilters = localDriveDatabaseNodeFiltersParser.parse(filters);
+		return compileLocalDriveDatabaseNodeFiltersToDrizzle(nodes).parse(parsedFilters);
+	}
+	function parseVariantFilters(filters) {
+		const parsedFilters = localDriveVariantFiltersParser.parse(filters);
+		return compileLocalDriveVariantFiltersToDrizzle(nodeVariants).parse(parsedFilters);
+	}
+	function parsePresignedUrlFilters(filters) {
+		const parsedFilters = localDrivePresignedUrlFiltersParser.parse(filters);
+		return compileLocalDrivePresignedUrlFiltersToDrizzle(nodePresignedUrls).parse(parsedFilters);
+	}
+	return {
+		db,
+		schema,
+		/**
+		* Finds a local drive node by its primary id.
+		*
+		* @example
+		* const node = await database.findNodeById("019d...");
+		*/
+		findNodeById: async (id) => {
+			const [node] = await db.select({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId
+			}).from(nodes).where(eq(nodes.id, id)).limit(1);
+			return node ?? null;
+		},
+		/**
+		* Finds the first local drive node matching the provided database filters.
+		*
+		* @example
+		* const node = await database.findFirstNode({ filters: { assetIds: [asset.id] } });
+		*/
+		findFirstNode: async (input) => {
+			let query = db.select({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId
+			}).from(nodes).$dynamic();
+			if (input?.filters) {
+				const where = parseDatabaseNodeFilters(input.filters);
+				query = query.where(where);
+			}
+			const [node] = await query.limit(1);
+			return node ?? null;
+		},
+		/**
+		* Finds local drive nodes matching the provided filters, sorts, and pagination limits.
+		*
+		* @example
+		* const nodes = await database.findNodes({
+		*   filters: { namespace: "products", parentId: null },
+		*   sorts: [{ key: "name", direction: "asc" }],
+		* });
+		*/
+		findNodes: async (input = {}) => {
+			let query = db.select({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId
+			}).from(nodes).$dynamic();
+			if (input.filters) {
+				const where = parseDatabaseNodeFilters(input.filters);
+				query = query.where(where);
+			}
+			if (input.sorts) {
+				const orderBy = parseNodeSorts(input.sorts);
+				query = query.orderBy(...orderBy);
+			}
+			if (input.limit !== void 0) query = query.limit(input.limit);
+			if (input.offset !== void 0) query = query.offset(input.offset);
+			return await query;
+		},
+		/**
+		* Lists paginated nodes with their linked storage asset.
+		*
+		* @example
+		* const result = await database.listNodesWithAsset({
+		*   limit: 20,
+		*   offset: 0,
+		*   filters: { namespace: "products", parentId: null },
+		*   sorts: [],
+		* });
+		*/
+		listNodesWithAsset: async ({ filters, limit, offset, sorts }) => {
+			const [data, total] = await db.transaction(async (tx) => {
+				const where = parseNodeFilters(filters);
+				let query = tx.select({
+					id: nodes.id,
+					createdAt: nodes.createdAt,
+					updatedAt: nodes.updatedAt,
+					name: nodes.name,
+					namespace: nodes.namespace,
+					type: nodes.type,
+					subtype: nodes.subtype,
+					size: nodes.size,
+					contentType: nodes.contentType,
+					readonly: nodes.readonly,
+					hidden: nodes.hidden,
+					archivedAt: nodes.archivedAt,
+					parentId: nodes.parentId,
+					assetId: nodes.assetId,
+					asset: {
+						id: storageAssets.id,
+						createdAt: storageAssets.createdAt,
+						updatedAt: storageAssets.updatedAt,
+						provider: storageAssets.provider,
+						bucket: storageAssets.bucket,
+						key: storageAssets.key,
+						status: storageAssets.status,
+						visibility: storageAssets.visibility,
+						size: storageAssets.size,
+						contentType: storageAssets.contentType,
+						uploadId: storageAssets.uploadId,
+						name: storageAssets.name,
+						metadata: storageAssets.metadata,
+						etag: storageAssets.etag,
+						uploadedAt: storageAssets.uploadedAt,
+						deletedAt: storageAssets.deletedAt
+					}
+				}).from(nodes).leftJoin(storageAssets, eq(nodes.assetId, storageAssets.id)).$dynamic();
+				if (where) query = query.where(where);
+				if (sorts && sorts.length > 0) {
+					const orderBy = parseNodeSorts(sorts);
+					query = query.orderBy(...orderBy);
+				}
+				return [await query.limit(limit).offset(offset), await tx.$count(nodes, where)];
+			});
+			return {
+				data,
+				total
+			};
+		},
+		/**
+		* Resolves the ancestor chain for a folder or file within a namespace.
+		*
+		* @example
+		* const parents = await database.getNodeParents({ id: node.id, namespace: "products" });
+		*/
+		getNodeParents: async (input) => {
+			if (!input.id) return [];
+			const startNodeQuery = db.select({
+				id: nodes.id,
+				name: nodes.name,
+				parentId: nodes.parentId,
+				depth: sql`0`.as("depth")
+			}).from(nodes).where(and(eq(nodes.id, input.id), eq(nodes.namespace, input.namespace)));
+			const alias = "parent_nodes";
+			const parentNodesQueryAlias = startNodeQuery.as(alias);
+			const recursiveQueryName = sql.raw(`"${alias}"`);
+			const recursiveQuery = startNodeQuery.unionAll(db.select({
+				id: nodes.id,
+				name: nodes.name,
+				parentId: nodes.parentId,
+				depth: sql`${parentNodesQueryAlias.depth} + 1`
+			}).from(nodes).innerJoin(recursiveQueryName, eq(nodes.id, parentNodesQueryAlias.parentId)));
+			return (await db.execute(sql`WITH RECURSIVE ${recursiveQueryName} AS ${recursiveQuery}
+          SELECT
+            ${parentNodesQueryAlias.id} as id,
+            ${parentNodesQueryAlias.name} as name,
+            ${parentNodesQueryAlias.parentId} as "parentId",
+            ${parentNodesQueryAlias.depth}::int as depth
+          FROM ${recursiveQueryName}`)).rows ?? [];
+		},
+		/**
+		* Resolves all recursive descendants for one or more nodes.
+		*
+		* @example
+		* const descendants = await database.getNodeChildren([folder.id]);
+		*/
+		getNodeChildren: async (ids) => {
+			if (ids.length === 0) return [];
+			const startNodeQuery = db.select({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId,
+				depth: sql`0`.as("depth")
+			}).from(nodes).where(inArray(nodes.id, ids));
+			const alias = "child_nodes";
+			const childNodesQueryAlias = startNodeQuery.as(alias);
+			const recursiveQueryName = sql.raw(`"${alias}"`);
+			const recursiveQuery = startNodeQuery.unionAll(db.select({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId,
+				depth: sql`${childNodesQueryAlias.depth} + 1`
+			}).from(nodes).innerJoin(recursiveQueryName, eq(nodes.parentId, childNodesQueryAlias.id)));
+			return (await db.execute(sql`WITH RECURSIVE ${recursiveQueryName} AS ${recursiveQuery}
+          SELECT
+            ${childNodesQueryAlias.id} as id,
+            ${childNodesQueryAlias.createdAt} as "createdAt",
+            ${childNodesQueryAlias.updatedAt} as "updatedAt",
+            ${childNodesQueryAlias.name} as name,
+            ${childNodesQueryAlias.namespace} as namespace,
+            ${childNodesQueryAlias.type} as type,
+            ${childNodesQueryAlias.subtype} as subtype,
+            ${childNodesQueryAlias.size} as size,
+            ${childNodesQueryAlias.contentType} as "contentType",
+            ${childNodesQueryAlias.readonly} as readonly,
+            ${childNodesQueryAlias.hidden} as hidden,
+            ${childNodesQueryAlias.archivedAt} as "archivedAt",
+            ${childNodesQueryAlias.parentId} as "parentId",
+            ${childNodesQueryAlias.assetId} as "assetId",
+            MIN(${childNodesQueryAlias.depth})::int as depth
+          FROM ${recursiveQueryName}
+          GROUP BY
+            ${childNodesQueryAlias.id},
+            ${childNodesQueryAlias.createdAt},
+            ${childNodesQueryAlias.updatedAt},
+            ${childNodesQueryAlias.name},
+            ${childNodesQueryAlias.namespace},
+            ${childNodesQueryAlias.type},
+            ${childNodesQueryAlias.subtype},
+            ${childNodesQueryAlias.size},
+            ${childNodesQueryAlias.contentType},
+            ${childNodesQueryAlias.readonly},
+            ${childNodesQueryAlias.hidden},
+            ${childNodesQueryAlias.archivedAt},
+            ${childNodesQueryAlias.parentId},
+            ${childNodesQueryAlias.assetId}
+        `)).rows ?? [];
+		},
+		/**
+		* Creates a node row.
+		*
+		* @example
+		* const node = await database.createNode({
+		*   type: "file",
+		*   name: "manual.pdf",
+		*   namespace: "products",
+		*   subtype: "document",
+		*   assetId: asset.id,
+		* });
+		*/
+		createNode: async (input) => {
+			const [node] = await db.insert(nodes).values(input).returning({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId
+			});
+			return node ?? null;
+		},
+		/**
+		* Updates a node row by primary id.
+		*
+		* @example
+		* const updated = await database.updateNodeById(node.id, { name: "Updated name" });
+		*/
+		updateNodeById: async (id, data) => {
+			const [node] = await db.update(nodes).set(data).where(eq(nodes.id, id)).returning({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId
+			});
+			return node ?? null;
+		},
+		/**
+		* Updates nodes matching the provided filters.
+		*
+		* @example
+		* const [updated] = await database.updateNodes({
+		*   filters: { nodeIds: [node.id] },
+		*   data: { name: "Updated name" },
+		* });
+		*/
+		updateNodes: async ({ data, filters }) => {
+			const where = parseDatabaseNodeFilters(filters);
+			if (!where) return [];
+			return await db.update(nodes).set(data).where(where).returning({
+				id: nodes.id,
+				createdAt: nodes.createdAt,
+				updatedAt: nodes.updatedAt,
+				name: nodes.name,
+				namespace: nodes.namespace,
+				type: nodes.type,
+				subtype: nodes.subtype,
+				size: nodes.size,
+				contentType: nodes.contentType,
+				readonly: nodes.readonly,
+				hidden: nodes.hidden,
+				archivedAt: nodes.archivedAt,
+				parentId: nodes.parentId,
+				assetId: nodes.assetId
+			});
+		},
+		/**
+		* Deletes a node by primary id and relies on database cascades for dependent rows.
+		*
+		* @example
+		* await database.deleteNodeById(node.id);
+		*/
+		deleteNodeById: async (id) => {
+			await db.delete(nodes).where(eq(nodes.id, id));
+		},
+		/**
+		* Deletes nodes matching the provided filters.
+		*
+		* @example
+		* await database.deleteNodes({ filters: { nodeIds: [node.id] } });
+		*/
+		deleteNodes: async ({ filters }) => {
+			const where = parseDatabaseNodeFilters(filters);
+			if (!where) return;
+			await db.delete(nodes).where(where);
+		},
+		/**
+		* Finds generated variants matching the provided filters.
+		*
+		* @example
+		* const variants = await database.findVariants({ filters: { nodeIds: [node.id] } });
+		*/
+		findVariants: async (input = {}) => {
+			let query = db.select({
+				id: nodeVariants.id,
+				createdAt: nodeVariants.createdAt,
+				updatedAt: nodeVariants.updatedAt,
+				nodeId: nodeVariants.nodeId,
+				assetId: nodeVariants.assetId,
+				variant: nodeVariants.variant,
+				width: nodeVariants.width
+			}).from(nodeVariants).$dynamic();
+			if (input.filters) {
+				const where = parseVariantFilters(input.filters);
+				if (where) query = query.where(where);
+			}
+			if (input.limit !== void 0) query = query.limit(input.limit);
+			if (input.offset !== void 0) query = query.offset(input.offset);
+			return await query;
+		},
+		/**
+		* Records a generated image variant and its storage asset.
+		*
+		* @example
+		* await database.createVariant({
+		*   nodeId: node.id,
+		*   assetId: previewAsset.id,
+		*   variant: "preview-640",
+		*   width: 640,
+		* });
+		*/
+		createVariant: async (input) => {
+			await db.insert(nodeVariants).values(input);
+		},
+		/**
+		* Finds the first cached presigned URL matching the provided filters.
+		*
+		* @example
+		* const cached = await database.findFirstPresignedUrl({
+		*   filters: { nodeId: node.id, variant: "main", disposition: "inline" },
+		* });
+		*/
+		findFirstPresignedUrl: async (input) => {
+			let query = db.select({
+				url: nodePresignedUrls.url,
+				expiresAt: nodePresignedUrls.expiresAt
+			}).from(nodePresignedUrls).$dynamic();
+			if (input?.filters) {
+				const where = parsePresignedUrlFilters(input.filters);
+				if (where) query = query.where(where);
+			}
+			const [presignedUrl] = await query.limit(1);
+			return presignedUrl ?? null;
+		},
+		/**
+		* Creates or refreshes the cached presigned URL for a node variant.
+		*
+		* @example
+		* await database.upsertPresignedUrl({
+		*   nodeId: node.id,
+		*   variant: "main",
+		*   disposition: "attachment",
+		*   url,
+		*   expiresAt,
+		* });
+		*/
+		upsertPresignedUrl: async (input) => {
+			await db.insert(nodePresignedUrls).values(input).onConflictDoUpdate({
+				target: [
+					nodePresignedUrls.nodeId,
+					nodePresignedUrls.variant,
+					nodePresignedUrls.disposition
+				],
+				set: {
+					url: input.url,
+					expiresAt: input.expiresAt
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { localDriveDrizzleAdapter };