n8n-nodes-pnpjs-sp 0.1.0

package/dist/credentials/PnPJsApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import { ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class PnPJsApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    test: ICredentialTestRequest;
+}

package/dist/credentials/PnPJsApi.credentials.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnPJsApi = void 0;
+class PnPJsApi {
+    constructor() {
+        this.name = 'pnpJsApi';
+        this.displayName = 'PnPJS SharePoint API';
+        this.documentationUrl = 'https://pnp.github.io/pnpjs/';
+        this.properties = [
+            {
+                displayName: 'SharePoint Site URL',
+                name: 'siteUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://tenant.sharepoint.com/sites/mysite',
+                required: true,
+                description: 'Full URL of the SharePoint site, including the site path if applicable',
+            },
+            {
+                displayName: 'Authentication Method',
+                name: 'authMethod',
+                type: 'options',
+                options: [
+                    {
+                        name: 'App-Only (Client Credentials)',
+                        value: 'appOnly',
+                        description: 'Uses Microsoft Entra ID app registration with client credentials flow',
+                    },
+                    {
+                        name: 'Access Token',
+                        value: 'accessToken',
+                        description: 'Directly provide an OAuth 2.0 access token',
+                    },
+                ],
+                default: 'appOnly',
+                description: 'How to authenticate with SharePoint',
+            },
+            {
+                displayName: 'Tenant ID',
+                name: 'tenantId',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: { show: { authMethod: ['appOnly'] } },
+                description: 'Microsoft Entra ID (Azure AD) tenant ID',
+            },
+            {
+                displayName: 'Client ID',
+                name: 'clientId',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: { show: { authMethod: ['appOnly'] } },
+                description: 'Application (client) ID of the app registration',
+            },
+            {
+                displayName: 'Client Secret',
+                name: 'clientSecret',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                displayOptions: { show: { authMethod: ['appOnly'] } },
+                description: 'Client secret value from the app registration',
+            },
+            {
+                displayName: 'Access Token',
+                name: 'accessToken',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                displayOptions: { show: { authMethod: ['accessToken'] } },
+                description: 'OAuth 2.0 access token for SharePoint. Must have appropriate permissions.',
+            },
+        ];
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.siteUrl.replace(/\\/+$/, "")}}',
+                url: '/_api/web?$select=Title,Url',
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                },
+            },
+        };
+    }
+}
+exports.PnPJsApi = PnPJsApi;

package/dist/nodes/PnPJs/GenericFunctions.d.ts

@@ -0,0 +1,14 @@
+import { IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions, IWebhookFunctions, IDataObject } from 'n8n-workflow';
+export interface ISpCredentials {
+    siteUrl: string;
+    authMethod: string;
+    tenantId?: string;
+    clientId?: string;
+    clientSecret?: string;
+    accessToken?: string;
+}
+export declare function getSharePointAccessToken(this: IExecuteFunctions | IHookFunctions | ILoadOptionsFunctions | IWebhookFunctions): Promise<string>;
+export declare function getFormDigest(this: IExecuteFunctions | IHookFunctions | ILoadOptionsFunctions | IWebhookFunctions, siteUrl: string, accessToken: string): Promise<string>;
+export declare function sharePointApiRequest(this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions | IWebhookFunctions, method: string, endpoint: string, body?: IDataObject, qs?: IDataObject, binaryResponse?: boolean): Promise<any>;
+export declare function sharePointApiRequestAllItems(this: IExecuteFunctions | ILoadOptionsFunctions, method: string, endpoint: string, body?: IDataObject, qs?: IDataObject): Promise<any[]>;
+export declare function buildListEndpoint(listIdentifier: string): string;

package/dist/nodes/PnPJs/GenericFunctions.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharePointAccessToken = getSharePointAccessToken;
+exports.getFormDigest = getFormDigest;
+exports.sharePointApiRequest = sharePointApiRequest;
+exports.sharePointApiRequestAllItems = sharePointApiRequestAllItems;
+exports.buildListEndpoint = buildListEndpoint;
+const n8n_workflow_1 = require("n8n-workflow");
+async function getSharePointAccessToken() {
+    const credentials = await this.getCredentials('pnpJsApi');
+    if (credentials.authMethod === 'accessToken') {
+        return credentials.accessToken;
+    }
+    const tenantId = credentials.tenantId;
+    const clientId = credentials.clientId;
+    const clientSecret = credentials.clientSecret;
+    const siteUrl = credentials.siteUrl;
+    const urlObj = new URL(siteUrl);
+    const hostname = urlObj.hostname;
+    const scope = `https://${hostname}/.default`;
+    const tokenEndpoint = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
+    const body = new URLSearchParams({
+        client_id: clientId,
+        client_secret: clientSecret,
+        scope,
+        grant_type: 'client_credentials',
+    });
+    const options = {
+        method: 'POST',
+        url: tokenEndpoint,
+        body: body.toString(),
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        json: false,
+    };
+    const response = await this.helpers.httpRequest(options);
+    let parsed;
+    try {
+        parsed = typeof response === 'string' ? JSON.parse(response) : response;
+    }
+    catch {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), {
+            message: 'Failed to acquire SharePoint access token',
+            description: 'Invalid response from token endpoint',
+        });
+    }
+    if (parsed.error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), {
+            message: `Token acquisition failed: ${parsed.error_description || parsed.error}`,
+            description: JSON.stringify(parsed),
+        });
+    }
+    return parsed.access_token;
+}
+async function getFormDigest(siteUrl, accessToken) {
+    const cleanUrl = siteUrl.replace(/\/+$/, '');
+    const options = {
+        method: 'POST',
+        url: `${cleanUrl}/_api/contextinfo`,
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+        },
+    };
+    const response = await this.helpers.httpRequest(options);
+    const respData = response;
+    const d = respData.d;
+    if (d) {
+        const ctxInfo = d.GetContextWebInformation;
+        return ctxInfo?.FormDigestValue || '';
+    }
+    return '';
+}
+async function sharePointApiRequest(method, endpoint, body, qs, binaryResponse = false) {
+    const credentials = await this.getCredentials('pnpJsApi');
+    const siteUrl = credentials.siteUrl.replace(/\/+$/, '');
+    const accessToken = await getSharePointAccessToken.call(this);
+    const url = `${siteUrl}/_api${endpoint}`;
+    const headers = {
+        Accept: 'application/json',
+        Authorization: `Bearer ${accessToken}`,
+    };
+    if (['POST', 'PUT', 'PATCH', 'MERGE'].includes(method) && body) {
+        const digest = await getFormDigest.call(this, siteUrl, accessToken);
+        headers['X-RequestDigest'] = digest;
+        headers['Content-Type'] = 'application/json;odata=verbose';
+    }
+    if (method === 'MERGE') {
+        headers['X-HTTP-Method'] = 'MERGE';
+        method = 'POST';
+    }
+    const options = {
+        method: method,
+        url,
+        headers,
+        json: !binaryResponse,
+    };
+    if (body) {
+        options.body = body;
+    }
+    if (qs) {
+        const queryString = Object.entries(qs)
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+            .join('&');
+        options.url = `${url}?${queryString}`;
+    }
+    try {
+        const response = await this.helpers.httpRequest(options);
+        if (binaryResponse) {
+            return response;
+        }
+        const data = response;
+        if (data && data.d) {
+            return data.d;
+        }
+        return data;
+    }
+    catch (error) {
+        if (error instanceof n8n_workflow_1.NodeApiError) {
+            throw error;
+        }
+        let message = 'SharePoint API request failed';
+        let description = error.message || '';
+        if (error.response) {
+            const status = error.response.status;
+            const statusText = error.response.statusText || '';
+            message = `HTTP ${status}: ${statusText}`;
+            let responseData = error.response.data;
+            if (typeof responseData === 'string') {
+                try {
+                    responseData = JSON.parse(responseData);
+                }
+                catch (e) {
+                    // ignore parse error, use raw string
+                }
+            }
+            if (responseData && responseData.error) {
+                const apiError = responseData.error;
+                const msg = apiError.message;
+                const msgValue = typeof msg === 'object' ? msg.value : msg;
+                description = `${msgValue || JSON.stringify(responseData)}`;
+            }
+            else {
+                description = JSON.stringify(responseData);
+            }
+        }
+        else if (error.code === 'ECONNREFUSED') {
+            message = 'Connection refused - SharePoint server is unreachable';
+            description = `Unable to connect to ${url}`;
+        }
+        else if (error.code === 'ENOTFOUND') {
+            message = 'Host not found - Invalid URL or DNS issue';
+            description = `Cannot resolve hostname: ${siteUrl}`;
+        }
+        else if (error.code === 'ETIMEDOUT') {
+            message = 'Connection timeout - Server is not responding';
+            description = 'Request timed out';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), {
+            message,
+            description,
+            httpCode: error.response?.status,
+        });
+    }
+}
+async function sharePointApiRequestAllItems(method, endpoint, body, qs) {
+    const allItems = [];
+    const response = await sharePointApiRequest.call(this, method, endpoint, body, qs);
+    const data = response;
+    const results = data.results || data;
+    if (Array.isArray(results)) {
+        allItems.push(...results);
+    }
+    else {
+        return [results];
+    }
+    return allItems;
+}
+function buildListEndpoint(listIdentifier) {
+    if (listIdentifier.startsWith("'") || listIdentifier.startsWith('guid')) {
+        return `/lists(${listIdentifier})`;
+    }
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(listIdentifier)) {
+        return `/lists(guid'${listIdentifier}')`;
+    }
+    return `/lists/getByTitle('${encodeURIComponent(listIdentifier).replace(/'/g, "''")}')`;
+}

package/dist/nodes/PnPJs/PnPJs.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class PnPJs implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}