@klardaten/n8n-nodes-datevconnect 1.0.2 → 1.0.3

package/dist/nodes/IdentityAndAccessManagement/handlers/BaseResourceHandler.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../utils");
+class BaseResourceHandler {
+    constructor(context, itemIndex) {
+        this.context = context;
+        this.itemIndex = itemIndex;
+    }
+    async execute(operation, authContext, returnData) {
+        try {
+            const sendSuccess = (payload) => {
+                const data = payload ? (0, utils_1.normaliseToObjects)(payload) : [{}];
+                data.forEach((item) => {
+                    returnData.push({
+                        json: {
+                            success: true,
+                            ...item,
+                        },
+                        pairedItem: { item: this.itemIndex },
+                    });
+                });
+            };
+            await this.executeOperation(operation, authContext, sendSuccess);
+        }
+        catch (error) {
+            if (this.context.continueOnFail()) {
+                returnData.push({
+                    json: {
+                        error: (0, utils_1.toErrorMessage)(error),
+                    },
+                    pairedItem: { item: this.itemIndex },
+                });
+                return;
+            }
+            if (error instanceof n8n_workflow_1.NodeApiError || error instanceof n8n_workflow_1.NodeOperationError) {
+                throw error;
+            }
+            throw new n8n_workflow_1.NodeApiError(this.context.getNode(), (0, utils_1.toErrorObject)(error), {
+                itemIndex: this.itemIndex,
+            });
+        }
+    }
+    async getCredentials() {
+        const credentials = (await this.context.getCredentials("datevConnectApi"));
+        if (!credentials) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "DATEVconnect credentials are missing");
+        }
+        const { host, email, password, clientInstanceId } = credentials;
+        if (!host || !email || !password || !clientInstanceId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "All DATEVconnect credential fields must be provided");
+        }
+        return credentials;
+    }
+    createAuthContext(credentials, token) {
+        return {
+            host: credentials.host,
+            token,
+            clientInstanceId: credentials.clientInstanceId,
+        };
+    }
+    getOptionalString(name) {
+        return (0, utils_1.getOptionalString)(this.context, name, this.itemIndex);
+    }
+    getRequiredString(name) {
+        return (0, utils_1.getRequiredString)(this.context, name, this.itemIndex);
+    }
+    getNumberParameter(name, defaultValue) {
+        return (0, utils_1.getNumberParameter)(this.context, name, this.itemIndex, defaultValue);
+    }
+    parseJsonParameter(rawValue, parameterLabel) {
+        return (0, utils_1.parseJsonParameter)(rawValue, parameterLabel, this.context, this.itemIndex);
+    }
+    getRequiredJsonData(name) {
+        return (0, utils_1.getRequiredJsonData)(this.context, name, this.itemIndex);
+    }
+    buildQueryParams(params) {
+        return (0, utils_1.buildQueryParams)(params);
+    }
+    validateRequestContext(authContext) {
+        if (!authContext.host || !authContext.token || !authContext.clientInstanceId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "Authentication context is incomplete");
+        }
+    }
+}
+exports.BaseResourceHandler = BaseResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/handlers/CurrentUserResourceHandler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentUserResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const identityAndAccessManagementClient_1 = require("../../../src/services/identityAndAccessManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class CurrentUserResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        if (operation !== "get") {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for currentUser.`, { itemIndex: this.itemIndex });
+        }
+        const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchCurrentUser(authContext);
+        sendSuccess(response);
+    }
+}
+exports.CurrentUserResourceHandler = CurrentUserResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/handlers/GroupResourceHandler.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const identityAndAccessManagementClient_1 = require("../../../src/services/identityAndAccessManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class GroupResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "getAll": {
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchGroups(authContext);
+                sendSuccess(response);
+                return;
+            }
+            case "get": {
+                const groupId = this.getRequiredString("groupId");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchGroup({
+                    ...authContext,
+                    groupId,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "create": {
+                const groupData = this.getRequiredJsonData("groupData");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.createGroup({
+                    ...authContext,
+                    group: groupData,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "update": {
+                const groupId = this.getRequiredString("groupId");
+                const groupData = this.getRequiredJsonData("groupData");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.updateGroup({
+                    ...authContext,
+                    groupId,
+                    group: groupData,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "delete": {
+                const groupId = this.getRequiredString("groupId");
+                const result = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.deleteGroup({
+                    ...authContext,
+                    groupId,
+                });
+                sendSuccess({
+                    groupId,
+                    deleted: true,
+                    ...(result.location ? { location: result.location } : {}),
+                });
+                return;
+            }
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for group.`, { itemIndex: this.itemIndex });
+        }
+    }
+}
+exports.GroupResourceHandler = GroupResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/handlers/ResourceTypeResourceHandler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceTypeResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const identityAndAccessManagementClient_1 = require("../../../src/services/identityAndAccessManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class ResourceTypeResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        if (operation !== "getAll") {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for resourceType.`, { itemIndex: this.itemIndex });
+        }
+        const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchResourceTypes(authContext);
+        sendSuccess(response);
+    }
+}
+exports.ResourceTypeResourceHandler = ResourceTypeResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/handlers/SchemaResourceHandler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const identityAndAccessManagementClient_1 = require("../../../src/services/identityAndAccessManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class SchemaResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "getAll": {
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchSchemas(authContext);
+                sendSuccess(response);
+                return;
+            }
+            case "get": {
+                const schemaId = this.getRequiredString("schemaId");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchSchema({
+                    ...authContext,
+                    schemaId,
+                });
+                sendSuccess(response);
+                return;
+            }
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for schema.`, { itemIndex: this.itemIndex });
+        }
+    }
+}
+exports.SchemaResourceHandler = SchemaResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/handlers/ServiceProviderConfigResourceHandler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceProviderConfigResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const identityAndAccessManagementClient_1 = require("../../../src/services/identityAndAccessManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class ServiceProviderConfigResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        if (operation !== "get") {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for serviceProviderConfig.`, { itemIndex: this.itemIndex });
+        }
+        const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchServiceProviderConfig(authContext);
+        sendSuccess(response);
+    }
+}
+exports.ServiceProviderConfigResourceHandler = ServiceProviderConfigResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/handlers/UserResourceHandler.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const identityAndAccessManagementClient_1 = require("../../../src/services/identityAndAccessManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class UserResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "getAll": {
+                const filter = this.getOptionalString("filter");
+                const attributes = this.getOptionalString("attributes");
+                const startIndex = this.getNumberParameter("startIndex", 1);
+                const count = this.getNumberParameter("count", 100);
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchUsers({
+                    ...authContext,
+                    filter,
+                    attributes,
+                    startIndex,
+                    count,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "get": {
+                const userId = this.getRequiredString("userId");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.fetchUser({
+                    ...authContext,
+                    userId,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "create": {
+                const userData = this.getRequiredJsonData("userData");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.createUser({
+                    ...authContext,
+                    user: userData,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "update": {
+                const userId = this.getRequiredString("userId");
+                const userData = this.getRequiredJsonData("userData");
+                const response = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.updateUser({
+                    ...authContext,
+                    userId,
+                    user: userData,
+                });
+                sendSuccess(response);
+                return;
+            }
+            case "delete": {
+                const userId = this.getRequiredString("userId");
+                const result = await identityAndAccessManagementClient_1.IdentityAndAccessManagementClient.deleteUser({
+                    ...authContext,
+                    userId,
+                });
+                sendSuccess({
+                    userId,
+                    deleted: true,
+                    ...(result.location ? { location: result.location } : {}),
+                });
+                return;
+            }
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for user.`, { itemIndex: this.itemIndex });
+        }
+    }
+}
+exports.UserResourceHandler = UserResourceHandler;

package/dist/nodes/IdentityAndAccessManagement/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/IdentityAndAccessManagement/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toErrorObject = toErrorObject;
+exports.toErrorMessage = toErrorMessage;
+exports.normaliseToObjects = normaliseToObjects;
+exports.parseJsonParameter = parseJsonParameter;
+exports.getOptionalString = getOptionalString;
+exports.getRequiredString = getRequiredString;
+exports.getNumberParameter = getNumberParameter;
+exports.buildQueryParams = buildQueryParams;
+exports.getRequiredJsonData = getRequiredJsonData;
+const n8n_workflow_1 = require("n8n-workflow");
+function toErrorObject(error) {
+    if (error instanceof Error) {
+        return { message: error.message };
+    }
+    if (typeof error === "string") {
+        return { message: error };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+        return { message: String(error.message) };
+    }
+    return { message: "An unknown error occurred" };
+}
+function toErrorMessage(error) {
+    return toErrorObject(error).message;
+}
+function normaliseToObjects(data) {
+    if (data === null || data === undefined) {
+        return [];
+    }
+    if (Array.isArray(data)) {
+        return data.map((item) => {
+            if (item === null || item === undefined) {
+                return {};
+            }
+            if (typeof item === "object") {
+                return item;
+            }
+            return { value: item };
+        });
+    }
+    if (typeof data === "object") {
+        return [data];
+    }
+    return [{ value: data }];
+}
+function parseJsonParameter(value, parameterName, context, itemIndex) {
+    if (typeof value === "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Invalid JSON in parameter '${parameterName}': ${toErrorMessage(error)}`, { itemIndex });
+        }
+    }
+    return value;
+}
+function getOptionalString(context, parameterName, itemIndex) {
+    const value = context.getNodeParameter(parameterName, itemIndex, "");
+    return value.trim() || undefined;
+}
+function getRequiredString(context, parameterName, itemIndex) {
+    const value = getOptionalString(context, parameterName, itemIndex);
+    if (!value) {
+        throw new Error(`Parameter '${parameterName}' is required`);
+    }
+    return value;
+}
+function getNumberParameter(context, parameterName, itemIndex, defaultValue) {
+    const value = context.getNodeParameter(parameterName, itemIndex, defaultValue);
+    return value;
+}
+function buildQueryParams(params) {
+    const query = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== "") {
+            query[key] = String(value);
+        }
+    }
+    return query;
+}
+function getRequiredJsonData(context, parameterName, itemIndex) {
+    const rawValue = context.getNodeParameter(parameterName, itemIndex);
+    if (!rawValue) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Parameter '${parameterName}' is required`, { itemIndex });
+    }
+    return parseJsonParameter(rawValue, parameterName, context, itemIndex);
+}