feat: return Libre Graph driveItem from write ops

Drop the invented {success, resource, operation, spaceId, path, name}
envelope from folder:create, file:upload, file/folder:copy/move, and
file:download. Resolve the resulting item via Graph after each WebDAV
write and return the driveItem directly, so write outputs match the
read outputs (folder:list, share, user) that already return raw Graph
types. file/folder:delete returns {}.

webUrl on the returned driveItem stays empty until
opencloud-eu/opencloud#2744 lands server-side; once it does, the field
arrives populated without any node-side change.

Closes #7.

Author: dschmidt

nodes/OpenCloud/OpenCloud.node.ts

@@ -11,7 +11,7 @@ import type {
 } from 'n8n-workflow';
 import { NodeApiError, NodeConnectionTypes, NodeOperationError } from 'n8n-workflow';
 
-import type { DriveItemsResponse, DrivesResponse } from './GenericFunctions';
+import type { DriveItem, DriveItemsResponse, DrivesResponse } from './GenericFunctions';
 import { openCloudApiRequest } from './GenericFunctions';
 
 function driveChildrenUrl(driveId: string, itemId: string): string {
@@ -36,14 +36,37 @@ function lastSegment(path: string): string {
 	return segments.length === 0 ? '' : segments[segments.length - 1];
 }
 
+/**
+ * Returns the item id at `rawPath` within `driveId`. The drive root is a
+ * special case: OpenCloud's root item id equals the drive id, so an empty
+ * path resolves without a Graph call. Subpaths delegate to resolvePathToItem.
+ */
 async function resolvePathToItemId(
 	context: IExecuteFunctions,
 	driveId: string,
 	rawPath: string,
 	itemIndex: number,
 ): Promise<string> {
+	if (splitPath(rawPath).length === 0) return driveId;
+	return (await resolvePathToItem(context, driveId, rawPath, itemIndex)).id!;
+}
+
+async function resolvePathToItem(
+	context: IExecuteFunctions,
+	driveId: string,
+	rawPath: string,
+	itemIndex: number,
+): Promise<DriveItem> {
 	const segments = splitPath(rawPath);
+	if (segments.length === 0) {
+		throw new NodeOperationError(
+			context.getNode(),
+			'Cannot resolve an empty path to a drive item',
+			{ itemIndex },
+		);
+	}
 	let currentItemId = driveId;
+	let lastMatch: DriveItem | undefined;
 	for (let i = 0; i < segments.length; i++) {
 		const segment = segments[i];
 		const isLast = i === segments.length - 1;
@@ -69,8 +92,9 @@ async function resolvePathToItemId(
 			);
 		}
 		currentItemId = match.id;
+		lastMatch = match;
 	}
-	return currentItemId;
+	return lastMatch!;
 }
 
 export class OpenCloud implements INodeType {
@@ -814,7 +838,6 @@ export class OpenCloud implements INodeType {
 					const nameSegments = splitPath(name);
 					const parentSegments = splitPath(parentPath);
 					const finalPath = '/' + [...parentSegments, ...nameSegments].join('/');
-					const finalName = nameSegments[nameSegments.length - 1];
 
 					for (let j = 0; j < nameSegments.length; j++) {
 						const segPath = '/' + [...parentSegments, ...nameSegments.slice(0, j + 1)].join('/');
@@ -839,15 +862,9 @@ export class OpenCloud implements INodeType {
 						}
 					}
 
+					const createdItem = await resolvePathToItem(this, driveId, finalPath, i);
 					returnData.push({
-						json: {
-							success: true,
-							resource: 'folder',
-							operation: 'create',
-							spaceId: driveId,
-							path: finalPath,
-							name: finalName,
-						},
+						json: createdItem as unknown as IDataObject,
 						pairedItem: { item: i },
 					});
 				} else if (resource === 'file' && operation === 'upload') {
@@ -887,15 +904,9 @@ export class OpenCloud implements INodeType {
 						false,
 					);
 
+					const uploadedItem = await resolvePathToItem(this, driveId, filePath, i);
 					returnData.push({
-						json: {
-							success: true,
-							resource: 'file',
-							operation: 'upload',
-							spaceId: driveId,
-							path: filePath,
-							name,
-						},
+						json: uploadedItem as unknown as IDataObject,
 						pairedItem: { item: i },
 					});
 				} else if (resource === 'file' && operation === 'download') {
@@ -924,21 +935,14 @@ export class OpenCloud implements INodeType {
 
 					const fileName = lastSegment(rawPath);
 					const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data as unknown as string);
-					const newItem: INodeExecutionData = {
-						json: {
-							success: true,
-							resource: 'file',
-							operation: 'download',
-							spaceId: driveId,
-							path: rawPath,
-							name: fileName,
-						},
+					const downloadedItem = await resolvePathToItem(this, driveId, rawPath, i);
+					returnData.push({
+						json: downloadedItem as unknown as IDataObject,
 						binary: {
 							[outputProp]: await this.helpers.prepareBinaryData(buffer, fileName),
 						},
 						pairedItem: { item: i },
-					};
-					returnData.push(newItem);
+					});
 				} else if (
 					(operation === 'copy' || operation === 'move') &&
 					(resource === 'folder' || resource === 'file')
@@ -998,17 +1002,9 @@ export class OpenCloud implements INodeType {
 						throw error;
 					}
 
+					const movedItem = await resolvePathToItem(this, destDriveId, destFullPath, i);
 					returnData.push({
-						json: {
-							success: true,
-							resource,
-							operation,
-							sourceSpaceId: driveId,
-							sourcePath: srcPath,
-							destinationSpaceId: destDriveId,
-							destinationPath: destFullPath,
-							name: destName,
-						},
+						json: movedItem as unknown as IDataObject,
 						pairedItem: { item: i },
 					});
 				} else if (operation === 'share' && (resource === 'folder' || resource === 'file')) {
@@ -1099,14 +1095,10 @@ export class OpenCloud implements INodeType {
 
 					await openCloudApiRequest.call(this, 'DELETE', url, '', {}, false);
 
+					// Item no longer exists, nothing meaningful to return. Empty object
+					// keeps the per-input-item output slot wired for pairedItem.
 					returnData.push({
-						json: {
-							success: true,
-							resource,
-							operation: 'delete',
-							spaceId: driveId,
-							path: rawPath,
-						},
+						json: {},
 						pairedItem: { item: i },
 					});
 				}

nodes/OpenCloud/__tests__/OpenCloud.node.test.ts

@@ -77,30 +77,31 @@ describe('OpenCloud node', () => {
 		it('create → list → delete a folder under tmp root', async () => {
 			const folderName = `folder-${Date.now()}`;
 			const folderPath = tmpPath(folderName);
+			const parentItemId = `${driveId}!parent`;
+			const subItemId = `${driveId}!sub`;
 
 			// Create
 			if (!IS_INTEGRATION) {
 				nock(TEST_SERVER)
-					.intercept(`/dav/spaces/${driveIdEnc}${encodePath(TMP_ROOT)}`, 'MKCOL')
-					.optionally()
-					.reply(201)
 					.intercept(`/dav/spaces/${driveIdEnc}${encodePath(folderPath)}`, 'MKCOL')
 					.reply(201);
+				// Post-MKCOL path-walk resolves the new folder to a driveItem.
+				nockChildrenWalk(
+					[{ id: parentItemId, name: TMP_ROOT.slice(1), folder: {} }],
+					[{ id: subItemId, name: folderName, folder: {} }],
+				);
 			}
-			// Make sure the parent exists in integration mode (idempotent).
 			if (IS_INTEGRATION) await ensureFolder(driveId, TMP_ROOT);
-			const created = await runCreate(driveId, '', TMP_ROOT.slice(1)).catch(() => null); // ok if exists
-			void created;
 			const createdSub = await runCreate(driveId, TMP_ROOT, folderName);
-			expect(createdSub).toMatchObject({ success: true, name: folderName });
+			expect(createdSub).toMatchObject({ name: folderName, folder: {} });
+			expect(typeof createdSub.id).toBe('string');
 
 			// List parent — folder should appear
 			if (!IS_INTEGRATION) {
-				// Mock the path-walk + children listing
-				nockChildrenWalk([{ id: `${driveId}!parent`, name: TMP_ROOT.slice(1), folder: {} }]);
+				nockChildrenWalk([{ id: parentItemId, name: TMP_ROOT.slice(1), folder: {} }]);
 				nock(TEST_SERVER)
-					.get(`/graph/v1.0/drives/${driveIdEnc}/items/${encodeURIComponent(`${driveId}!parent`)}/children`)
-					.reply(200, { value: [{ id: 'child', name: folderName, folder: {} }] });
+					.get(`/graph/v1.0/drives/${driveIdEnc}/items/${encodeURIComponent(parentItemId)}/children`)
+					.reply(200, { value: [{ id: subItemId, name: folderName, folder: {} }] });
 			}
 			const { fns: listFns } = makeExecuteFunctions({
 				parameters: { resource: 'folder', operation: 'list', space: driveId, path: TMP_ROOT },
@@ -117,7 +118,7 @@ describe('OpenCloud node', () => {
 				parameters: { resource: 'folder', operation: 'delete', space: driveId, path: folderPath },
 			});
 			const deleted = await node.execute.call(delFns);
-			expect(deleted[0][0].json).toMatchObject({ success: true, path: folderPath });
+			expect(deleted[0][0].json).toEqual({});
 		});
 	});
 
@@ -130,11 +131,17 @@ describe('OpenCloud node', () => {
 			if (IS_INTEGRATION) await ensureFolder(driveId, TMP_ROOT);
 
 			// Upload
+			const parentItemId = `${driveId}!parent`;
+			const fileItemId = `${driveId}!file`;
 			if (!IS_INTEGRATION) {
 				nock(TEST_SERVER)
 					.put(`/dav/spaces/${driveIdEnc}${encodePath(filePath)}`, content)
 					.matchHeader('Content-Type', 'text/plain; charset=utf-8')
 					.reply(201);
+				nockChildrenWalk(
+					[{ id: parentItemId, name: TMP_ROOT.slice(1), folder: {} }],
+					[{ id: fileItemId, name: fileName, file: { mimeType: 'text/plain' } }],
+				);
 			}
 			const uploaded = await runOnceJson({
 				resource: 'file',
@@ -145,13 +152,18 @@ describe('OpenCloud node', () => {
 				binaryDataUpload: false,
 				fileContent: content,
 			});
-			expect(uploaded).toMatchObject({ success: true, name: fileName });
+			expect(uploaded).toMatchObject({ name: fileName, file: { mimeType: 'text/plain' } });
+			expect(typeof uploaded.id).toBe('string');
 
 			// Download
 			if (!IS_INTEGRATION) {
 				nock(TEST_SERVER)
 					.get(`/dav/spaces/${driveIdEnc}${encodePath(filePath)}`)
 					.reply(200, Buffer.from(content), { 'Content-Type': 'text/plain' });
+				nockChildrenWalk(
+					[{ id: parentItemId, name: TMP_ROOT.slice(1), folder: {} }],
+					[{ id: fileItemId, name: fileName, file: { mimeType: 'text/plain' } }],
+				);
 			}
 			const { fns: dlFns } = makeExecuteFunctions({
 				parameters: {
@@ -165,6 +177,7 @@ describe('OpenCloud node', () => {
 			const downloaded = await node.execute.call(dlFns);
 			const binary = downloaded[0][0].binary as Record<string, { data: string }>;
 			expect(Buffer.from(binary.data.data, 'base64').toString('utf8')).toBe(content);
+			expect(downloaded[0][0].json).toMatchObject({ name: fileName, file: { mimeType: 'text/plain' } });
 
 			// Delete
 			if (!IS_INTEGRATION) {
@@ -191,6 +204,10 @@ describe('OpenCloud node', () => {
 					.put(`/dav/spaces/${driveIdEnc}${encodePath(filePath)}`)
 					.matchHeader('Content-Type', 'application/octet-stream')
 					.reply(201);
+				nockChildrenWalk(
+					[{ id: `${driveId}!parent`, name: TMP_ROOT.slice(1), folder: {} }],
+					[{ id: `${driveId}!img`, name: fileName, file: { mimeType: 'image/png' } }],
+				);
 			}
 			const { fns } = makeExecuteFunctions({
 				parameters: {
@@ -234,17 +251,26 @@ describe('OpenCloud node', () => {
 					.intercept(`/dav/spaces/${driveIdEnc}${encodePath(srcPath)}`, 'COPY')
 					.matchHeader('Destination', `${TEST_SERVER}/dav/spaces/${driveIdEnc}${encodePath(copyPath)}`)
 					.reply(201);
+				nockChildrenWalk(
+					[{ id: `${driveId}!parent`, name: TMP_ROOT.slice(1), folder: {} }],
+					[{ id: `${driveId}!copy`, name: 'copy.txt', file: { mimeType: 'text/plain' } }],
+				);
 			}
-			await runOnceJson({
+			const copied = await runOnceJson({
 				resource: 'file', operation: 'copy', space: driveId,
 				path: srcPath, destSpace: '', destParentPath: TMP_ROOT, destName: 'copy.txt',
 			});
+			expect(copied).toMatchObject({ name: 'copy.txt', file: { mimeType: 'text/plain' } });
 
 			if (!IS_INTEGRATION) {
 				nock(TEST_SERVER)
 					.intercept(`/dav/spaces/${driveIdEnc}${encodePath(copyPath)}`, 'MOVE')
 					.matchHeader('Destination', `${TEST_SERVER}/dav/spaces/${driveIdEnc}${encodePath(renamedPath)}`)
 					.reply(201);
+				nockChildrenWalk(
+					[{ id: `${driveId}!parent`, name: TMP_ROOT.slice(1), folder: {} }],
+					[{ id: `${driveId}!ren`, name: 'renamed.txt', file: { mimeType: 'text/plain' } }],
+				);
 			}
 			await runOnceJson({
 				resource: 'file', operation: 'move', space: driveId,
@@ -451,15 +477,21 @@ describe('OpenCloud node', () => {
 		});
 
 		mockOnly.it('cross-space folder COPY (mock — depends on a second drive)', async () => {
-			const otherDriveEnc = encodeURIComponent('storage-users-2$other-space-id');
+			const otherDriveId = 'storage-users-2$other-space-id';
+			const otherDriveEnc = encodeURIComponent(otherDriveId);
 			nock(TEST_SERVER)
 				.intercept(`/dav/spaces/${driveIdEnc}/Documents/Reports`, 'COPY')
 				.matchHeader('Destination', `${TEST_SERVER}/dav/spaces/${otherDriveEnc}/Shared/Reports`)
-				.reply(201);
+				.reply(201)
+				// Post-COPY path-walk on the destination drive.
+				.get(`/graph/v1.0/drives/${otherDriveEnc}/items/${otherDriveEnc}/children`)
+				.reply(200, { value: [{ id: `${otherDriveId}!shared`, name: 'Shared', folder: {} }] })
+				.get(`/graph/v1.0/drives/${otherDriveEnc}/items/${encodeURIComponent(`${otherDriveId}!shared`)}/children`)
+				.reply(200, { value: [{ id: `${otherDriveId}!reports`, name: 'Reports', folder: {} }] });
 			await runOnceJson({
 				resource: 'folder', operation: 'copy', space: driveId,
 				path: '/Documents/Reports',
-				destSpace: 'storage-users-2$other-space-id',
+				destSpace: otherDriveId,
 				destParentPath: '/Shared', destName: '',
 			});
 		});