@opencloud-eu/n8n-nodes-opencloud 0.1.0

package/dist/nodes/OpenCloud/OpenCloud.node.js

@@ -0,0 +1,1151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCloud = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+function driveChildrenUrl(driveId, itemId) {
+    return `/graph/v1.0/drives/${encodeURIComponent(driveId)}/items/${encodeURIComponent(itemId)}/children`;
+}
+function splitPath(rawPath) {
+    return rawPath
+        .split('/')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+}
+function joinPath(segments) {
+    return segments.length === 0 ? '' : '/' + segments.map(encodeURIComponent).join('/');
+}
+function spaceWebDavUrl(serverUrl, driveId, path) {
+    const base = serverUrl.replace(/\/+$/, '');
+    return `${base}/dav/spaces/${encodeURIComponent(driveId)}${joinPath(splitPath(path))}`;
+}
+function lastSegment(path) {
+    const segments = splitPath(path);
+    return segments.length === 0 ? '' : segments[segments.length - 1];
+}
+async function resolvePathToItemId(context, driveId, rawPath, itemIndex) {
+    if (splitPath(rawPath).length === 0)
+        return driveId;
+    return (await resolvePathToItem(context, driveId, rawPath, itemIndex)).id;
+}
+async function resolvePathToItem(context, driveId, rawPath, itemIndex) {
+    var _a;
+    const segments = splitPath(rawPath);
+    if (segments.length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Cannot resolve an empty path to a drive item', { itemIndex });
+    }
+    let currentItemId = driveId;
+    let lastMatch;
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const isLast = i === segments.length - 1;
+        const stepResponse = (await GenericFunctions_1.openCloudApiRequest.call(context, 'GET', driveChildrenUrl(driveId, currentItemId), '', {}, true));
+        const match = ((_a = stepResponse.value) !== null && _a !== void 0 ? _a : []).find((child) => child.name === segment && (isLast || child.folder));
+        if (!(match === null || match === void 0 ? void 0 : match.id)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Path not found: ${rawPath}`, { description: `Could not resolve segment "${segment}".`, itemIndex });
+        }
+        currentItemId = match.id;
+        lastMatch = match;
+    }
+    return lastMatch;
+}
+class OpenCloud {
+    constructor() {
+        this.description = {
+            displayName: 'OpenCloud',
+            name: 'openCloud',
+            icon: 'file:opencloud.svg',
+            group: ['input'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Access data on OpenCloud',
+            defaults: {
+                name: 'OpenCloud',
+            },
+            usableAsTool: true,
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'openCloudApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'File',
+                            value: 'file',
+                        },
+                        {
+                            name: 'Folder',
+                            value: 'folder',
+                        },
+                        {
+                            name: 'Space',
+                            value: 'space',
+                        },
+                        {
+                            name: 'User',
+                            value: 'user',
+                        },
+                    ],
+                    default: 'folder',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List all drives (Personal, Shares, Project) the authenticated user can see',
+                            action: 'List spaces',
+                        },
+                        {
+                            name: 'Share',
+                            value: 'share',
+                            description: 'Create a public link or invite a user/group to the space (drive root)',
+                            action: 'Share a space',
+                        },
+                    ],
+                    default: 'list',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a user (admin only)',
+                            action: 'Create a user',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a user (admin only)',
+                            action: 'Delete a user',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Retrieve a single user by ID',
+                            action: 'Get a user',
+                        },
+                        {
+                            name: 'Get Many',
+                            value: 'getAll',
+                            description: 'List many users',
+                            action: 'Get many users',
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            description: 'Update a user',
+                            action: 'Update a user',
+                        },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'User ID',
+                    name: 'userId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'b1f74ec4-dd7e-11ef-a543-03775734d0f7',
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['get', 'update', 'delete'],
+                        },
+                    },
+                    description: 'GUID of the user. Use the User → Get Many operation to find IDs.',
+                },
+                {
+                    displayName: 'Username',
+                    name: 'userName',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'jdoe',
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Login name (onPremisesSamAccountName). Must be unique on the server.',
+                },
+                {
+                    displayName: 'Display Name',
+                    name: 'displayName',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'Jane Doe',
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Email',
+                    name: 'email',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'jane@example.com',
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Password',
+                    name: 'password',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Initial password. Must satisfy the server\'s password policy.',
+                },
+                {
+                    displayName: 'Update Fields',
+                    name: 'updateFields',
+                    type: 'collection',
+                    placeholder: 'Add field',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['update'],
+                        },
+                    },
+                    options: [
+                        { displayName: 'Display Name', name: 'displayName', type: 'string', default: '' },
+                        { displayName: 'Email', name: 'mail', type: 'string', default: '' },
+                        {
+                            displayName: 'Password',
+                            name: 'password',
+                            type: 'string',
+                            typeOptions: { password: true },
+                            default: '',
+                            description: 'New password. Must satisfy the server policy.',
+                        },
+                        {
+                            displayName: 'Account Enabled',
+                            name: 'accountEnabled',
+                            type: 'boolean',
+                            default: true,
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Copy',
+                            value: 'copy',
+                            description: 'Copy a folder',
+                            action: 'Copy a folder',
+                        },
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a new folder',
+                            action: 'Create a folder',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a folder',
+                            action: 'Delete a folder',
+                        },
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List the contents of a folder',
+                            action: 'List a folder',
+                        },
+                        {
+                            name: 'Move',
+                            value: 'move',
+                            description: 'Move (or rename) a folder',
+                            action: 'Move a folder',
+                        },
+                        {
+                            name: 'Share',
+                            value: 'share',
+                            description: 'Create a public sharing link for a folder',
+                            action: 'Share a folder',
+                        },
+                    ],
+                    default: 'list',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Copy',
+                            value: 'copy',
+                            description: 'Copy a file',
+                            action: 'Copy a file',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a file',
+                            action: 'Delete a file',
+                        },
+                        {
+                            name: 'Download',
+                            value: 'download',
+                            description: 'Download a file',
+                            action: 'Download a file',
+                        },
+                        {
+                            name: 'Move',
+                            value: 'move',
+                            description: 'Move (or rename) a file',
+                            action: 'Move a file',
+                        },
+                        {
+                            name: 'Share',
+                            value: 'share',
+                            description: 'Create a public sharing link for a file',
+                            action: 'Share a file',
+                        },
+                        {
+                            name: 'Upload',
+                            value: 'upload',
+                            description: 'Upload a file',
+                            action: 'Upload a file',
+                        },
+                    ],
+                    default: 'upload',
+                },
+                {
+                    displayName: 'Space Name or ID',
+                    name: 'space',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSpaces',
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The OpenCloud space (drive) to operate in. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    displayOptions: {
+                        show: {
+                            resource: ['folder', 'file'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Name or ID',
+                    name: 'space',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSpaces',
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The OpenCloud space (drive) to operate in. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['share'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Path',
+                    name: 'path',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                            operation: ['list', 'create', 'delete', 'copy', 'move', 'share'],
+                        },
+                    },
+                    placeholder: '/Documents',
+                    description: 'Folder path within the selected space. For Create, this is the parent folder. For Copy/Move, this is the source folder. Leave empty for the space root.',
+                },
+                {
+                    displayName: 'Path',
+                    name: 'path',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['delete', 'download', 'copy', 'move', 'share'],
+                        },
+                    },
+                    placeholder: '/Documents/report.pdf',
+                    description: 'Full path of the file within the selected space',
+                },
+                {
+                    displayName: 'Destination Space Name or ID',
+                    name: 'destSpace',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSpaces',
+                    },
+                    default: '',
+                    description: 'Target space (drive) for the copy or move. Leave empty to use the source space. For Move, must be the same storage as source — cross-storage moves are rejected by the server. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['copy', 'move'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Destination Parent Path',
+                    name: 'destParentPath',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['copy', 'move'],
+                        },
+                    },
+                    placeholder: '/Archive',
+                    description: 'Folder under which to place the copied/moved item. Leave empty for the space root.',
+                },
+                {
+                    displayName: 'New Name',
+                    name: 'destName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['copy', 'move'],
+                        },
+                    },
+                    placeholder: '(keep source name)',
+                    description: 'Optional new name for the copied/moved item. Leave empty to keep the source name.',
+                },
+                {
+                    displayName: 'Parent Path',
+                    name: 'path',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                        },
+                    },
+                    placeholder: '/Documents',
+                    description: 'Folder to upload the file into. Leave empty for the space root.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                        },
+                    },
+                    placeholder: 'report.pdf',
+                    description: 'Filename to create in the parent folder',
+                },
+                {
+                    displayName: 'Binary File',
+                    name: 'binaryDataUpload',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                        },
+                    },
+                    description: 'Whether to read the file bytes from a binary property on the input item. Turn off to upload literal text content from the field below.',
+                },
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                            binaryDataUpload: [true],
+                        },
+                    },
+                    description: 'Name of the binary property on the input item that contains the file bytes',
+                },
+                {
+                    displayName: 'File Content',
+                    name: 'fileContent',
+                    type: 'string',
+                    typeOptions: { rows: 4 },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                            binaryDataUpload: [false],
+                        },
+                    },
+                    placeholder: 'Hello, OpenCloud!',
+                    description: 'Literal text content to upload as the file. Sent with Content-Type text/plain.',
+                },
+                {
+                    displayName: 'Put Output File in Field',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['download'],
+                        },
+                    },
+                    description: 'Name of the binary property on the output item to store the downloaded bytes in',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                            operation: ['create'],
+                        },
+                    },
+                    placeholder: 'Reports/2024',
+                    description: 'Name of the folder to create. Use forward slashes to create nested folders in one step (e.g. "Reports/2024" creates Reports and, inside it, 2024). Each missing level is created automatically.',
+                },
+                {
+                    displayName: 'Recipient Type',
+                    name: 'recipientType',
+                    type: 'options',
+                    default: 'publicLink',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder', 'space'],
+                            operation: ['share'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Group',
+                            value: 'group',
+                            description: 'Invite a group (by name or ID) with a unified role',
+                        },
+                        {
+                            name: 'Public Link',
+                            value: 'publicLink',
+                            description: 'Generate a shareable URL (createLink). Anyone with the URL can access according to the link type.',
+                        },
+                        {
+                            name: 'User',
+                            value: 'user',
+                            description: 'Invite a specific user (by name or ID) with a unified role',
+                        },
+                    ],
+                    description: 'How to share the resource',
+                },
+                {
+                    displayName: 'Link Type Name or ID',
+                    name: 'linkType',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getLinkTypes',
+                        loadOptionsDependsOn: ['resource'],
+                    },
+                    default: 'view',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder', 'space'],
+                            operation: ['share'],
+                            recipientType: ['publicLink'],
+                        },
+                    },
+                    description: 'Permission level granted by the link. The list is filtered by resource type (e.g. Upload and Create Only only apply to folders). Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Password',
+                    name: 'password',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder', 'space'],
+                            operation: ['share'],
+                            recipientType: ['publicLink'],
+                        },
+                    },
+                    description: 'Optional password protecting the link. The server may require a password and may enforce a password policy (see the `password_policy` capability).',
+                },
+                {
+                    displayName: 'Recipient',
+                    name: 'recipientId',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
+                    required: true,
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            typeOptions: {
+                                searchListMethod: 'searchRecipients',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'By ID',
+                            name: 'id',
+                            type: 'string',
+                            placeholder: 'b1f74ec4-dd7e-11ef-a543-03775734d0f7',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: '^[0-9a-fA-F-]+$',
+                                        errorMessage: 'Recipient ID must be a GUID (hex digits and dashes)',
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder', 'space'],
+                            operation: ['share'],
+                            recipientType: ['user', 'group'],
+                        },
+                    },
+                    description: 'User or group to invite. Search the directory (admin or matching the server\'s minimum search length for regular users), or paste a known ID.',
+                },
+                {
+                    displayName: 'Role Name or ID',
+                    name: 'role',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getShareRoles',
+                        loadOptionsDependsOn: ['resource'],
+                    },
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder', 'space'],
+                            operation: ['share'],
+                            recipientType: ['user', 'group'],
+                        },
+                    },
+                    description: 'Unified role granted to the recipient. The list is filtered by resource type. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Expiration',
+                    name: 'expirationDateTime',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder', 'space'],
+                            operation: ['share'],
+                        },
+                    },
+                    placeholder: '2026-12-31T23:59:59Z',
+                    description: 'Optional ISO-8601 timestamp when the link or invite should expire. Leave empty for no expiration.',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getSpaces() {
+                    var _a;
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', '/graph/v1.0/me/drives', '', {}, true));
+                    return ((_a = response.value) !== null && _a !== void 0 ? _a : []).map((drive) => {
+                        var _a, _b;
+                        return ({
+                            name: `${drive.name} (${(_a = drive.driveType) !== null && _a !== void 0 ? _a : 'drive'})`,
+                            value: (_b = drive.id) !== null && _b !== void 0 ? _b : '',
+                        });
+                    });
+                },
+                async getLinkTypes() {
+                    const catalog = [
+                        {
+                            value: 'view',
+                            name: 'View',
+                            description: 'Recipients can view the item',
+                            appliesTo: ['file', 'folder', 'space'],
+                        },
+                        {
+                            value: 'edit',
+                            name: 'Edit',
+                            description: 'Recipients can view and edit',
+                            appliesTo: ['file', 'folder', 'space'],
+                        },
+                        {
+                            value: 'upload',
+                            name: 'Upload',
+                            description: 'Recipients can add new items (folder only)',
+                            appliesTo: ['folder'],
+                        },
+                        {
+                            value: 'createOnly',
+                            name: 'Create Only',
+                            description: 'Recipients can add but not list (folder only)',
+                            appliesTo: ['folder'],
+                        },
+                    ];
+                    const resource = this.getCurrentNodeParameter('resource');
+                    return catalog
+                        .filter((entry) => !resource || entry.appliesTo.includes(resource))
+                        .map((entry) => ({
+                        name: entry.name,
+                        value: entry.value,
+                        description: entry.description,
+                    }));
+                },
+                async getShareRoles() {
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', '/graph/v1beta1/roleManagement/permissions/roleDefinitions', '', {}, true));
+                    const resource = this.getCurrentNodeParameter('resource');
+                    let conditionMatch = null;
+                    if (resource === 'file')
+                        conditionMatch = '@Resource.File';
+                    else if (resource === 'folder')
+                        conditionMatch = '@Resource.Folder';
+                    else if (resource === 'space')
+                        conditionMatch = '@Resource.Root';
+                    const roleApplies = (role) => {
+                        var _a;
+                        if (!conditionMatch)
+                            return true;
+                        return ((_a = role.rolePermissions) !== null && _a !== void 0 ? _a : []).some((p) => { var _a; return ((_a = p.condition) !== null && _a !== void 0 ? _a : '').includes(conditionMatch); });
+                    };
+                    return (response !== null && response !== void 0 ? response : [])
+                        .filter((role) => typeof role.id === 'string' && role.id.length > 0)
+                        .filter(roleApplies)
+                        .map((role) => {
+                        var _a, _b;
+                        return ({
+                            name: (_a = role.displayName) !== null && _a !== void 0 ? _a : role.id,
+                            value: role.id,
+                            description: (_b = role.description) !== null && _b !== void 0 ? _b : undefined,
+                        });
+                    });
+                },
+            },
+            listSearch: {
+                async searchRecipients(filter, paginationToken) {
+                    var _a;
+                    const recipientType = this.getCurrentNodeParameter('recipientType') || 'user';
+                    const basePath = recipientType === 'group' ? '/graph/v1.0/groups' : '/graph/v1.0/users';
+                    const params = ['$top=100'];
+                    if (filter && filter.trim().length > 0) {
+                        params.push(`$search=${encodeURIComponent(`"${filter.trim()}"`)}`);
+                    }
+                    const endpoint = typeof paginationToken === 'string' && paginationToken.length > 0
+                        ? paginationToken
+                        : `${basePath}?${params.join('&')}`;
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', endpoint, '', {}, true));
+                    const results = ((_a = response.value) !== null && _a !== void 0 ? _a : [])
+                        .filter((entry) => typeof entry.id === 'string' && entry.id.length > 0)
+                        .map((entry) => {
+                        var _a, _b, _c;
+                        const label = (_b = (_a = entry.displayName) !== null && _a !== void 0 ? _a : entry.onPremisesSamAccountName) !== null && _b !== void 0 ? _b : entry.id;
+                        const hint = (_c = entry.mail) !== null && _c !== void 0 ? _c : entry.onPremisesSamAccountName;
+                        return {
+                            name: hint && hint !== label ? `${label} (${hint})` : label,
+                            value: entry.id,
+                        };
+                    });
+                    return {
+                        results,
+                        paginationToken: response['@odata.nextLink'],
+                    };
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (resource === 'space' && operation === 'list') {
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', '/graph/v1.0/me/drives', '', {}, true));
+                    for (const drive of (_a = response.value) !== null && _a !== void 0 ? _a : []) {
+                        returnData.push({
+                            json: drive,
+                            pairedItem: { item: i },
+                        });
+                    }
+                }
+                else if (resource === 'user' && operation === 'getAll') {
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', '/graph/v1.0/users', '', {}, true));
+                    for (const user of (_b = response.value) !== null && _b !== void 0 ? _b : []) {
+                        returnData.push({ json: user, pairedItem: { item: i } });
+                    }
+                }
+                else if (resource === 'user' && operation === 'get') {
+                    const userId = this.getNodeParameter('userId', i);
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', `/graph/v1.0/users/${encodeURIComponent(userId)}`, '', {}, true));
+                    returnData.push({ json: response, pairedItem: { item: i } });
+                }
+                else if (resource === 'user' && operation === 'create') {
+                    const userName = this.getNodeParameter('userName', i).trim();
+                    const displayName = this.getNodeParameter('displayName', i).trim();
+                    const email = this.getNodeParameter('email', i).trim();
+                    const password = this.getNodeParameter('password', i);
+                    if (!userName || !displayName || !email || !password) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Username, Display Name, Email, and Password are all required', { itemIndex: i });
+                    }
+                    const body = {
+                        onPremisesSamAccountName: userName,
+                        displayName,
+                        mail: email,
+                        passwordProfile: { password },
+                    };
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'POST', '/graph/v1.0/users', body, { 'Content-Type': 'application/json' }, true));
+                    returnData.push({ json: response, pairedItem: { item: i } });
+                }
+                else if (resource === 'user' && operation === 'update') {
+                    const userId = this.getNodeParameter('userId', i);
+                    const updates = this.getNodeParameter('updateFields', i, {});
+                    if (Object.keys(updates).length === 0) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'At least one field to update is required', { itemIndex: i });
+                    }
+                    const body = { ...updates };
+                    if (typeof body.password === 'string' && body.password.length > 0) {
+                        body.passwordProfile = { password: body.password };
+                    }
+                    delete body.password;
+                    const updatedUser = (await GenericFunctions_1.openCloudApiRequest.call(this, 'PATCH', `/graph/v1.0/users/${encodeURIComponent(userId)}`, body, { 'Content-Type': 'application/json' }, true));
+                    returnData.push({ json: updatedUser, pairedItem: { item: i } });
+                }
+                else if (resource === 'user' && operation === 'delete') {
+                    const userId = this.getNodeParameter('userId', i);
+                    await GenericFunctions_1.openCloudApiRequest.call(this, 'DELETE', `/graph/v1.0/users/${encodeURIComponent(userId)}`, '', {}, true);
+                    returnData.push({ json: {}, pairedItem: { item: i } });
+                }
+                else if (resource === 'folder' && operation === 'list') {
+                    const driveId = this.getNodeParameter('space', i);
+                    const rawPath = this.getNodeParameter('path', i);
+                    const targetItemId = await resolvePathToItemId(this, driveId, rawPath, i);
+                    const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', driveChildrenUrl(driveId, targetItemId), '', {}, true));
+                    for (const driveItem of (_c = response.value) !== null && _c !== void 0 ? _c : []) {
+                        returnData.push({
+                            json: driveItem,
+                            pairedItem: { item: i },
+                        });
+                    }
+                }
+                else if (resource === 'folder' && operation === 'create') {
+                    const driveId = this.getNodeParameter('space', i);
+                    const parentPath = this.getNodeParameter('path', i);
+                    const name = this.getNodeParameter('name', i);
+                    if (!name.trim()) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Folder name is required', {
+                            itemIndex: i,
+                        });
+                    }
+                    const credentials = await this.getCredentials('openCloudApi');
+                    const nameSegments = splitPath(name);
+                    const parentSegments = splitPath(parentPath);
+                    const finalPath = '/' + [...parentSegments, ...nameSegments].join('/');
+                    for (let j = 0; j < nameSegments.length; j++) {
+                        const segPath = '/' + [...parentSegments, ...nameSegments.slice(0, j + 1)].join('/');
+                        const url = spaceWebDavUrl(credentials.serverUrl, driveId, segPath);
+                        try {
+                            await GenericFunctions_1.openCloudApiRequest.call(this, 'MKCOL', url, '', {}, false);
+                        }
+                        catch (error) {
+                            const httpCode = String((_e = (_d = error.httpCode) !== null && _d !== void 0 ? _d : error.statusCode) !== null && _e !== void 0 ? _e : '');
+                            if (httpCode === '405')
+                                continue;
+                            throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { itemIndex: i });
+                        }
+                    }
+                    const createdItem = await resolvePathToItem(this, driveId, finalPath, i);
+                    returnData.push({
+                        json: createdItem,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'file' && operation === 'upload') {
+                    const driveId = this.getNodeParameter('space', i);
+                    const parentPath = this.getNodeParameter('path', i);
+                    const name = this.getNodeParameter('name', i);
+                    const isBinary = this.getNodeParameter('binaryDataUpload', i, true);
+                    if (!name.trim()) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'File name is required', {
+                            itemIndex: i,
+                        });
+                    }
+                    let body;
+                    let contentType;
+                    if (isBinary) {
+                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
+                        this.helpers.assertBinaryData(i, binaryProperty);
+                        body = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
+                        contentType = 'application/octet-stream';
+                    }
+                    else {
+                        body = this.getNodeParameter('fileContent', i, '');
+                        contentType = 'text/plain; charset=utf-8';
+                    }
+                    const credentials = await this.getCredentials('openCloudApi');
+                    const filePath = '/' + [...splitPath(parentPath), name].join('/');
+                    const url = spaceWebDavUrl(credentials.serverUrl, driveId, filePath);
+                    await GenericFunctions_1.openCloudApiRequest.call(this, 'PUT', url, body, { 'Content-Type': contentType }, false);
+                    const uploadedItem = await resolvePathToItem(this, driveId, filePath, i);
+                    returnData.push({
+                        json: uploadedItem,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'file' && operation === 'download') {
+                    const driveId = this.getNodeParameter('space', i);
+                    const rawPath = this.getNodeParameter('path', i);
+                    const outputProp = this.getNodeParameter('binaryProperty', i);
+                    if (!rawPath.trim()) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Path is required for download', {
+                            itemIndex: i,
+                        });
+                    }
+                    const credentials = await this.getCredentials('openCloudApi');
+                    const url = spaceWebDavUrl(credentials.serverUrl, driveId, rawPath);
+                    const data = (await GenericFunctions_1.openCloudApiRequest.call(this, 'GET', url, '', {}, false, 'arraybuffer'));
+                    const fileName = lastSegment(rawPath);
+                    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                    returnData.push({
+                        json: items[i].json,
+                        binary: {
+                            [outputProp]: await this.helpers.prepareBinaryData(buffer, fileName),
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if ((operation === 'copy' || operation === 'move') &&
+                    (resource === 'folder' || resource === 'file')) {
+                    const driveId = this.getNodeParameter('space', i);
+                    const srcPath = this.getNodeParameter('path', i);
+                    const destDriveIdRaw = this.getNodeParameter('destSpace', i, '');
+                    const destDriveId = destDriveIdRaw || driveId;
+                    const destParentPath = this.getNodeParameter('destParentPath', i);
+                    const destNameRaw = this.getNodeParameter('destName', i, '').trim();
+                    if (!srcPath.trim()) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Source path is required', {
+                            itemIndex: i,
+                        });
+                    }
+                    const destName = destNameRaw || lastSegment(srcPath);
+                    if (!destName) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Destination name could not be derived from source — set "New Name"', { itemIndex: i });
+                    }
+                    const credentials = await this.getCredentials('openCloudApi');
+                    const srcUrl = spaceWebDavUrl(credentials.serverUrl, driveId, srcPath);
+                    const destFullPath = '/' + [...splitPath(destParentPath), destName].join('/');
+                    const destUrl = spaceWebDavUrl(credentials.serverUrl, destDriveId, destFullPath);
+                    const httpMethod = (operation === 'copy' ? 'COPY' : 'MOVE');
+                    try {
+                        await GenericFunctions_1.openCloudApiRequest.call(this, httpMethod, srcUrl, '', { Destination: destUrl }, false);
+                    }
+                    catch (error) {
+                        const httpCode = String((_g = (_f = error.httpCode) !== null && _f !== void 0 ? _f : error.statusCode) !== null && _g !== void 0 ? _g : '');
+                        if (operation === 'move' && httpCode === '502') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Cross-storage move not supported', {
+                                description: 'OpenCloud cannot move items between different storage providers. Use Copy followed by Delete instead.',
+                                itemIndex: i,
+                            });
+                        }
+                        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { itemIndex: i });
+                    }
+                    const destinationItem = await resolvePathToItem(this, destDriveId, destFullPath, i);
+                    returnData.push({
+                        json: destinationItem,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'share' &&
+                    (resource === 'folder' || resource === 'file' || resource === 'space')) {
+                    const driveId = this.getNodeParameter('space', i);
+                    const recipientType = this.getNodeParameter('recipientType', i, 'publicLink');
+                    const expirationDateTime = this.getNodeParameter('expirationDateTime', i, '').trim();
+                    let endpointBase;
+                    if (resource === 'space') {
+                        endpointBase = `/graph/v1beta1/drives/${encodeURIComponent(driveId)}/root`;
+                    }
+                    else {
+                        const rawPath = this.getNodeParameter('path', i);
+                        if (!rawPath.trim()) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Path is required for share', {
+                                itemIndex: i,
+                            });
+                        }
+                        const itemId = await resolvePathToItemId(this, driveId, rawPath, i);
+                        endpointBase = `/graph/v1beta1/drives/${encodeURIComponent(driveId)}/items/${encodeURIComponent(itemId)}`;
+                    }
+                    if (recipientType === 'publicLink') {
+                        const linkType = this.getNodeParameter('linkType', i);
+                        const password = this.getNodeParameter('password', i, '').trim();
+                        const body = { type: linkType };
+                        if (password)
+                            body.password = password;
+                        if (expirationDateTime)
+                            body.expirationDateTime = expirationDateTime;
+                        try {
+                            const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'POST', `${endpointBase}/createLink`, body, { 'Content-Type': 'application/json' }, true));
+                            returnData.push({
+                                json: response,
+                                pairedItem: { item: i },
+                            });
+                        }
+                        catch (error) {
+                            const code = String((_l = (_j = (_h = error.httpCode) !== null && _h !== void 0 ? _h : error.statusCode) !== null && _j !== void 0 ? _j : (_k = error.cause) === null || _k === void 0 ? void 0 : _k.statusCode) !== null && _l !== void 0 ? _l : '');
+                            if (code === '400') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Public link rejected: password requirement not met', {
+                                    description: 'The server may require a password for this link type and may enforce a password policy (min length, character classes, etc). See the `password_policy` and `files_sharing.public.password` capabilities for the exact rules.',
+                                    itemIndex: i,
+                                });
+                            }
+                            throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { itemIndex: i });
+                        }
+                    }
+                    else {
+                        const recipientId = this.getNodeParameter('recipientId', i, '', {
+                            extractValue: true,
+                        }).trim();
+                        const role = this.getNodeParameter('role', i).trim();
+                        if (!recipientId) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Recipient ID is required for invite', { itemIndex: i });
+                        }
+                        if (!role) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Role is required for invite', {
+                                itemIndex: i,
+                            });
+                        }
+                        const body = {
+                            recipients: [
+                                {
+                                    objectId: recipientId,
+                                    '@libre.graph.recipient.type': recipientType,
+                                },
+                            ],
+                            roles: [role],
+                        };
+                        if (expirationDateTime)
+                            body.expirationDateTime = expirationDateTime;
+                        const response = (await GenericFunctions_1.openCloudApiRequest.call(this, 'POST', `${endpointBase}/invite`, body, { 'Content-Type': 'application/json' }, true));
+                        for (const permission of (_m = response.value) !== null && _m !== void 0 ? _m : []) {
+                            returnData.push({
+                                json: permission,
+                                pairedItem: { item: i },
+                            });
+                        }
+                    }
+                }
+                else if (operation === 'delete' && (resource === 'folder' || resource === 'file')) {
+                    const driveId = this.getNodeParameter('space', i);
+                    const rawPath = this.getNodeParameter('path', i);
+                    if (!rawPath.trim()) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Path is required for delete', {
+                            itemIndex: i,
+                        });
+                    }
+                    const credentials = await this.getCredentials('openCloudApi');
+                    const url = spaceWebDavUrl(credentials.serverUrl, driveId, rawPath);
+                    await GenericFunctions_1.openCloudApiRequest.call(this, 'DELETE', url, '', {}, false);
+                    returnData.push({
+                        json: {},
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const e = error;
+                    returnData.push({
+                        json: {
+                            error: e.message,
+                            ...(e.description ? { errorDescription: e.description } : {}),
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                if (error instanceof n8n_workflow_1.NodeApiError || error instanceof n8n_workflow_1.NodeOperationError) {
+                    throw error;
+                }
+                throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.OpenCloud = OpenCloud;
+//# sourceMappingURL=OpenCloud.node.js.map