@tadnt2003/n8n-nodes-infisical 0.2.0 → 0.3.0

package/dist/utils/auth.d.ts

@@ -0,0 +1,5 @@
+import { IDataObject, IExecuteFunctions } from 'n8n-workflow';
+export declare function getInfisicalToken(helpers: IExecuteFunctions['helpers'], credentials: IDataObject): Promise<{
+    apiUrl: string;
+    accessToken: string;
+}>;

package/dist/utils/auth.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInfisicalToken = void 0;
+async function getInfisicalToken(helpers, credentials) {
+    const apiUrl = credentials.apiUrl.replace(/\/$/, '');
+    const authType = credentials.authType || 'serviceToken';
+    if (authType === 'universalAuth') {
+        const clientId = credentials.clientId;
+        const clientSecret = credentials.clientSecret;
+        const parts = [
+            `clientId=${encodeURIComponent(clientId)}`,
+            `clientSecret=${encodeURIComponent(clientSecret)}`,
+        ];
+        if (credentials.organizationSlug) {
+            parts.push(`organizationSlug=${encodeURIComponent(credentials.organizationSlug)}`);
+        }
+        const tokenResponse = await helpers.httpRequest({
+            method: 'POST',
+            url: `${apiUrl}/v1/auth/universal-auth/login`,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: parts.join('&'),
+        });
+        return { apiUrl, accessToken: tokenResponse.accessToken };
+    }
+    return { apiUrl, accessToken: credentials.apiKey };
+}
+exports.getInfisicalToken = getInfisicalToken;

package/dist/utils/folderOperations.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeFolderOperation(ctx: IExecuteFunctions, apiUrl: string, baseHeaders: Record<string, string>, operation: string, i: number): Promise<INodeExecutionData[]>;

package/dist/utils/folderOperations.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFolderOperation = void 0;
+async function executeFolderOperation(ctx, apiUrl, baseHeaders, operation, i) {
+    const result = [];
+    // ── getFolderById ─────────────────────────────────────────────────────
+    if (operation === 'getFolderById') {
+        const folderId = ctx.getNodeParameter('folderId', i);
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v2/folders/${encodeURIComponent(folderId)}`,
+            headers: baseHeaders,
+        });
+        result.push({ json: response.folder, pairedItem: { item: i } });
+    }
+    else {
+        // All remaining operations share projectId / environment / folderPath
+        const projectId = ctx.getNodeParameter('projectId', i);
+        const environment = ctx.getNodeParameter('environment', i);
+        const folderPath = ctx.getNodeParameter('folderPath', i);
+        // ── listFolders ───────────────────────────────────────────────────
+        if (operation === 'listFolders') {
+            const listFolderOptions = ctx.getNodeParameter('listFolderOptions', i, {});
+            const qs = { projectId, environment, path: folderPath };
+            if (listFolderOptions.recursive !== undefined)
+                qs.recursive = listFolderOptions.recursive;
+            if (listFolderOptions.lastSecretModified)
+                qs.lastSecretModified = listFolderOptions.lastSecretModified;
+            const response = await ctx.helpers.httpRequest({
+                method: 'GET',
+                url: `${apiUrl}/v2/folders`,
+                headers: baseHeaders,
+                qs,
+            });
+            const folders = response.folders;
+            for (const folder of folders) {
+                result.push({ json: folder, pairedItem: { item: i } });
+            }
+            // ── createFolder ───────────────────────────────────────────────────
+        }
+        else if (operation === 'createFolder') {
+            const folderName = ctx.getNodeParameter('folderName', i);
+            const createFolderOptions = ctx.getNodeParameter('createFolderOptions', i, {});
+            const body = {
+                projectId,
+                environment,
+                name: folderName,
+                path: folderPath,
+            };
+            if (createFolderOptions.description !== undefined)
+                body.description = createFolderOptions.description;
+            const response = await ctx.helpers.httpRequest({
+                method: 'POST',
+                url: `${apiUrl}/v2/folders`,
+                headers: baseHeaders,
+                body: JSON.stringify(body),
+            });
+            result.push({ json: response.folder, pairedItem: { item: i } });
+            // ── updateFolder ───────────────────────────────────────────────────
+        }
+        else if (operation === 'updateFolder') {
+            const folderId = ctx.getNodeParameter('folderId', i);
+            const folderName = ctx.getNodeParameter('folderName', i);
+            const updateFolderOptions = ctx.getNodeParameter('updateFolderOptions', i, {});
+            const body = {
+                projectId,
+                environment,
+                name: folderName,
+                path: folderPath,
+            };
+            if (updateFolderOptions.description !== undefined)
+                body.description = updateFolderOptions.description;
+            const response = await ctx.helpers.httpRequest({
+                method: 'PATCH',
+                url: `${apiUrl}/v2/folders/${encodeURIComponent(folderId)}`,
+                headers: baseHeaders,
+                body: JSON.stringify(body),
+            });
+            result.push({ json: response.folder, pairedItem: { item: i } });
+            // ── deleteFolder ───────────────────────────────────────────────────
+        }
+        else if (operation === 'deleteFolder') {
+            const folderIdOrName = ctx.getNodeParameter('folderIdOrName', i);
+            const deleteFolderOptions = ctx.getNodeParameter('deleteFolderOptions', i, {});
+            const body = {
+                projectId,
+                environment,
+                path: folderPath,
+            };
+            if (deleteFolderOptions.forceDelete)
+                body.forceDelete = deleteFolderOptions.forceDelete;
+            const response = await ctx.helpers.httpRequest({
+                method: 'DELETE',
+                url: `${apiUrl}/v2/folders/${encodeURIComponent(folderIdOrName)}`,
+                headers: baseHeaders,
+                body: JSON.stringify(body),
+            });
+            result.push({ json: response.folder, pairedItem: { item: i } });
+        }
+    }
+    return result;
+}
+exports.executeFolderOperation = executeFolderOperation;

package/dist/utils/projectOperations.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeProjectOperation(ctx: IExecuteFunctions, apiUrl: string, baseHeaders: Record<string, string>, operation: string, i: number): Promise<INodeExecutionData[]>;

package/dist/utils/projectOperations.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeProjectOperation = void 0;
+async function executeProjectOperation(ctx, apiUrl, baseHeaders, operation, i) {
+    const result = [];
+    // ── getAll ────────────────────────────────────────────────────────────
+    if (operation === 'getAll') {
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v1/projects`,
+            headers: baseHeaders,
+        });
+        const projects = response.projects;
+        for (const project of projects) {
+            result.push({ json: project, pairedItem: { item: i } });
+        }
+        // ── get ───────────────────────────────────────────────────────────────
+    }
+    else if (operation === 'get') {
+        const projectId = ctx.getNodeParameter('projectId', i);
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v1/projects/${encodeURIComponent(projectId)}`,
+            headers: baseHeaders,
+        });
+        result.push({ json: response.project, pairedItem: { item: i } });
+        // ── getBySlug ─────────────────────────────────────────────────────────
+    }
+    else if (operation === 'getBySlug') {
+        const slug = ctx.getNodeParameter('slug', i);
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v1/projects/slug/${encodeURIComponent(slug)}`,
+            headers: baseHeaders,
+        });
+        // Response body is the project object directly (no wrapper key)
+        result.push({ json: response, pairedItem: { item: i } });
+        // ── getSecretSnapshots ────────────────────────────────────────────────
+    }
+    else if (operation === 'getSecretSnapshots') {
+        const projectId = ctx.getNodeParameter('projectId', i);
+        const environment = ctx.getNodeParameter('snapshotEnvironment', i);
+        const snapshotOptions = ctx.getNodeParameter('snapshotOptions', i, {});
+        const qs = { environment };
+        if (snapshotOptions.secretPath)
+            qs.path = snapshotOptions.secretPath;
+        if (snapshotOptions.offset !== undefined && snapshotOptions.offset !== '')
+            qs.offset = snapshotOptions.offset;
+        if (snapshotOptions.limit !== undefined && snapshotOptions.limit !== '')
+            qs.limit = snapshotOptions.limit;
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v1/projects/${encodeURIComponent(projectId)}/secret-snapshots`,
+            headers: baseHeaders,
+            qs,
+        });
+        const snapshots = response.secretSnapshots;
+        for (const snapshot of snapshots) {
+            result.push({ json: snapshot, pairedItem: { item: i } });
+        }
+        // ── getUserMemberships ────────────────────────────────────────────────
+    }
+    else if (operation === 'getUserMemberships') {
+        const projectId = ctx.getNodeParameter('projectId', i);
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v1/projects/${encodeURIComponent(projectId)}/memberships`,
+            headers: baseHeaders,
+        });
+        const memberships = response.memberships;
+        for (const membership of memberships) {
+            result.push({ json: membership, pairedItem: { item: i } });
+        }
+        // ── getUserByUsername ─────────────────────────────────────────────────
+    }
+    else if (operation === 'getUserByUsername') {
+        const projectId = ctx.getNodeParameter('projectId', i);
+        const username = ctx.getNodeParameter('username', i);
+        const response = await ctx.helpers.httpRequest({
+            method: 'POST',
+            url: `${apiUrl}/v1/projects/${encodeURIComponent(projectId)}/memberships/details`,
+            headers: baseHeaders,
+            body: JSON.stringify({ username }),
+        });
+        result.push({ json: response.membership, pairedItem: { item: i } });
+    }
+    return result;
+}
+exports.executeProjectOperation = executeProjectOperation;

package/dist/utils/secretOperations.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeSecretOperation(ctx: IExecuteFunctions, apiUrl: string, baseHeaders: Record<string, string>, operation: string, i: number): Promise<INodeExecutionData[]>;

package/dist/utils/secretOperations.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSecretOperation = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+async function executeSecretOperation(ctx, apiUrl, baseHeaders, operation, i) {
+    var _a, _b, _c, _d, _e, _f;
+    const projectId = ctx.getNodeParameter('projectId', i);
+    const environment = ctx.getNodeParameter('environment', i);
+    const secretPath = ctx.getNodeParameter('secretPath', i);
+    const result = [];
+    // ── get ───────────────────────────────────────────────────────────────
+    if (operation === 'get') {
+        const secretKey = ctx.getNodeParameter('secretKey', i);
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v4/secrets/${encodeURIComponent(secretKey)}`,
+            headers: baseHeaders,
+            qs: { projectId, environment, secretPath },
+        });
+        result.push({ json: response, pairedItem: { item: i } });
+        // ── getAll ────────────────────────────────────────────────────────────
+    }
+    else if (operation === 'getAll') {
+        const response = await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${apiUrl}/v4/secrets`,
+            headers: baseHeaders,
+            qs: { projectId, environment, secretPath },
+        });
+        const secrets = response.secrets;
+        for (const secret of secrets) {
+            result.push({ json: secret, pairedItem: { item: i } });
+        }
+        // ── create ────────────────────────────────────────────────────────────
+    }
+    else if (operation === 'create') {
+        const secretKey = ctx.getNodeParameter('secretKey', i);
+        const secretValue = ctx.getNodeParameter('secretValue', i);
+        const createOptions = ctx.getNodeParameter('createOptions', i, {});
+        const secretMetadataParam = ctx.getNodeParameter('secretMetadata', i, {});
+        const body = {
+            projectId,
+            environment,
+            secretValue,
+            secretPath,
+            type: (_a = createOptions.type) !== null && _a !== void 0 ? _a : 'shared',
+        };
+        if (createOptions.secretComment)
+            body.secretComment = createOptions.secretComment;
+        if (createOptions.skipMultilineEncoding) {
+            body.skipMultilineEncoding = createOptions.skipMultilineEncoding;
+        }
+        const metadataEntries = (_b = secretMetadataParam.values) !== null && _b !== void 0 ? _b : [];
+        if (metadataEntries.length > 0) {
+            body.secretMetadata = metadataEntries.map((m) => ({ key: m.key, value: m.value }));
+        }
+        const response = await ctx.helpers.httpRequest({
+            method: 'POST',
+            url: `${apiUrl}/v4/secrets/${encodeURIComponent(secretKey)}`,
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
+        result.push({ json: response, pairedItem: { item: i } });
+        // ── update ────────────────────────────────────────────────────────────
+    }
+    else if (operation === 'update') {
+        const secretKey = ctx.getNodeParameter('secretKey', i);
+        const updateOptions = ctx.getNodeParameter('updateOptions', i, {});
+        const secretMetadataParam = ctx.getNodeParameter('secretMetadata', i, {});
+        const body = {
+            projectId,
+            environment,
+            secretPath,
+        };
+        if (updateOptions.secretValue !== undefined && updateOptions.secretValue !== '') {
+            body.secretValue = updateOptions.secretValue;
+        }
+        if (updateOptions.newSecretName)
+            body.newSecretName = updateOptions.newSecretName;
+        if (updateOptions.secretComment !== undefined)
+            body.secretComment = updateOptions.secretComment;
+        if (updateOptions.type)
+            body.type = updateOptions.type;
+        if (updateOptions.skipMultilineEncoding) {
+            body.skipMultilineEncoding = updateOptions.skipMultilineEncoding;
+        }
+        const metadataEntries = (_c = secretMetadataParam.values) !== null && _c !== void 0 ? _c : [];
+        if (metadataEntries.length > 0) {
+            body.secretMetadata = metadataEntries.map((m) => ({ key: m.key, value: m.value }));
+        }
+        const response = await ctx.helpers.httpRequest({
+            method: 'PATCH',
+            url: `${apiUrl}/v4/secrets/${encodeURIComponent(secretKey)}`,
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
+        result.push({ json: response, pairedItem: { item: i } });
+        // ── delete ────────────────────────────────────────────────────────────
+    }
+    else if (operation === 'delete') {
+        const secretKey = ctx.getNodeParameter('secretKey', i);
+        const body = {
+            projectId,
+            environment,
+            secretPath,
+        };
+        const response = await ctx.helpers.httpRequest({
+            method: 'DELETE',
+            url: `${apiUrl}/v4/secrets/${encodeURIComponent(secretKey)}`,
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
+        result.push({ json: response, pairedItem: { item: i } });
+        // ── createMany ────────────────────────────────────────────────────────
+    }
+    else if (operation === 'createMany') {
+        const secretsParam = ctx.getNodeParameter('secrets', i, {});
+        const secretItems = (_d = secretsParam.values) !== null && _d !== void 0 ? _d : [];
+        if (secretItems.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'At least one secret must be added in the Secrets list', { itemIndex: i });
+        }
+        const createManyOptions = ctx.getNodeParameter('createManyOptions', i, {});
+        const effectivePath = createManyOptions.secretPath || secretPath;
+        const secrets = secretItems.map((item) => {
+            var _a;
+            const s = {
+                secretKey: item.secretKey,
+                secretValue: item.secretValue,
+            };
+            if (item.secretComment)
+                s.secretComment = item.secretComment;
+            if (item.skipMultilineEncoding)
+                s.skipMultilineEncoding = item.skipMultilineEncoding;
+            const metaParam = item.secretMetadata;
+            const metaEntries = (_a = metaParam === null || metaParam === void 0 ? void 0 : metaParam.values) !== null && _a !== void 0 ? _a : [];
+            if (metaEntries.length > 0) {
+                s.secretMetadata = metaEntries.map((m) => ({ key: m.key, value: m.value }));
+            }
+            return s;
+        });
+        const body = {
+            projectId,
+            environment,
+            secretPath: effectivePath,
+            secrets,
+        };
+        const response = await ctx.helpers.httpRequest({
+            method: 'POST',
+            url: `${apiUrl}/v4/secrets/batch`,
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
+        const responseData = response;
+        if (Array.isArray(responseData.secrets)) {
+            for (const secret of responseData.secrets) {
+                result.push({ json: secret, pairedItem: { item: i } });
+            }
+        }
+        else {
+            // Approval / policy-gated response
+            result.push({ json: responseData, pairedItem: { item: i } });
+        }
+        // ── updateMany ────────────────────────────────────────────────────────
+    }
+    else if (operation === 'updateMany') {
+        const secretsToUpdateParam = ctx.getNodeParameter('secretsToUpdate', i, {});
+        const secretItems = (_e = secretsToUpdateParam.values) !== null && _e !== void 0 ? _e : [];
+        if (secretItems.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'At least one secret must be added in the Secrets list', { itemIndex: i });
+        }
+        const updateManyOptions = ctx.getNodeParameter('updateManyOptions', i, {});
+        const effectivePath = updateManyOptions.secretPath || secretPath;
+        const secrets = secretItems.map((item) => {
+            var _a;
+            const s = { secretKey: item.secretKey };
+            if (item.secretValue !== undefined && item.secretValue !== '') {
+                s.secretValue = item.secretValue;
+            }
+            if (item.newSecretName)
+                s.newSecretName = item.newSecretName;
+            if (item.secretComment !== undefined && item.secretComment !== '') {
+                s.secretComment = item.secretComment;
+            }
+            if (item.skipMultilineEncoding)
+                s.skipMultilineEncoding = item.skipMultilineEncoding;
+            const metaParam = item.secretMetadata;
+            const metaEntries = (_a = metaParam === null || metaParam === void 0 ? void 0 : metaParam.values) !== null && _a !== void 0 ? _a : [];
+            if (metaEntries.length > 0) {
+                s.secretMetadata = metaEntries.map((m) => ({ key: m.key, value: m.value }));
+            }
+            return s;
+        });
+        const body = {
+            projectId,
+            environment,
+            secretPath: effectivePath,
+            secrets,
+        };
+        if (updateManyOptions.mode)
+            body.mode = updateManyOptions.mode;
+        const response = await ctx.helpers.httpRequest({
+            method: 'PATCH',
+            url: `${apiUrl}/v4/secrets/batch`,
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
+        const responseData = response;
+        if (Array.isArray(responseData.secrets)) {
+            for (const secret of responseData.secrets) {
+                result.push({ json: secret, pairedItem: { item: i } });
+            }
+        }
+        else {
+            // Approval / policy-gated response
+            result.push({ json: responseData, pairedItem: { item: i } });
+        }
+        // ── deleteMany ────────────────────────────────────────────────────────
+    }
+    else if (operation === 'deleteMany') {
+        const secretsToDeleteParam = ctx.getNodeParameter('secretsToDelete', i, {});
+        const secretItems = (_f = secretsToDeleteParam.values) !== null && _f !== void 0 ? _f : [];
+        if (secretItems.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'At least one secret must be added in the Secrets list', { itemIndex: i });
+        }
+        const deleteManyOptions = ctx.getNodeParameter('deleteManyOptions', i, {});
+        const effectivePath = deleteManyOptions.secretPath || secretPath;
+        const secrets = secretItems.map((item) => ({
+            secretKey: item.secretKey,
+            type: item.type || 'shared',
+        }));
+        const body = {
+            projectId,
+            environment,
+            secretPath: effectivePath,
+            secrets,
+        };
+        const response = await ctx.helpers.httpRequest({
+            method: 'DELETE',
+            url: `${apiUrl}/v4/secrets/batch`,
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
+        const responseData = response;
+        if (Array.isArray(responseData.secrets)) {
+            for (const secret of responseData.secrets) {
+                result.push({ json: secret, pairedItem: { item: i } });
+            }
+        }
+        else {
+            // Approval / policy-gated response
+            result.push({ json: responseData, pairedItem: { item: i } });
+        }
+    }
+    return result;
+}
+exports.executeSecretOperation = executeSecretOperation;

package/dist/utils/syncOperations.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeSyncOperation(ctx: IExecuteFunctions, apiUrl: string, baseHeaders: Record<string, string>, operation: string, i: number): Promise<INodeExecutionData[]>;