@klardaten/n8n-nodes-datevconnect 1.0.1 → 1.0.3

package/dist/nodes/DocumentManagement/handlers/InfoResourceHandler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for info operations
+ */
+class InfoResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "get":
+                await this.getInfo(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for info`);
+        }
+    }
+    async getInfo(authContext, sendSuccess) {
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchInfo({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+        });
+        sendSuccess(response);
+    }
+}
+exports.InfoResourceHandler = InfoResourceHandler;

package/dist/nodes/DocumentManagement/handlers/PropertyTemplateResourceHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTemplateResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for property template operations
+ */
+class PropertyTemplateResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case 'getAll':
+                await this.getPropertyTemplates(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unsupported operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async getPropertyTemplates(authContext, sendSuccess) {
+        const filter = this.getOptionalString('filter');
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchPropertyTemplates({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            filter,
+        });
+        sendSuccess(response);
+    }
+}
+exports.PropertyTemplateResourceHandler = PropertyTemplateResourceHandler;

package/dist/nodes/DocumentManagement/handlers/SecureAreaResourceHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecureAreaResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for secure area operations
+ */
+class SecureAreaResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case 'getAll':
+                await this.getSecureAreas(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unsupported operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async getSecureAreas(authContext, sendSuccess) {
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchSecureAreas({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+        });
+        sendSuccess(response);
+    }
+}
+exports.SecureAreaResourceHandler = SecureAreaResourceHandler;

package/dist/nodes/DocumentManagement/types.js

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

package/dist/nodes/DocumentManagement/utils.js

@@ -0,0 +1,116 @@
+"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");
+/**
+ * Converts an error to a standardized error object
+ */
+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" };
+}
+/**
+ * Extracts error message from an error object
+ */
+function toErrorMessage(error) {
+    return toErrorObject(error).message;
+}
+/**
+ * Normalizes various data types to an array of objects
+ */
+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 }];
+}
+/**
+ * Parses a JSON parameter with proper error handling
+ */
+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;
+}
+/**
+ * Gets an optional string parameter
+ */
+function getOptionalString(context, parameterName, itemIndex) {
+    const value = context.getNodeParameter(parameterName, itemIndex, "");
+    return value.trim() || undefined;
+}
+/**
+ * Gets a required string parameter
+ */
+function getRequiredString(context, parameterName, itemIndex) {
+    const value = getOptionalString(context, parameterName, itemIndex);
+    if (!value) {
+        throw new Error(`Parameter '${parameterName}' is required`);
+    }
+    return value;
+}
+/**
+ * Gets a number parameter with default value
+ */
+function getNumberParameter(context, parameterName, itemIndex, defaultValue) {
+    const value = context.getNodeParameter(parameterName, itemIndex, defaultValue);
+    return value;
+}
+/**
+ * Builds query parameters object from optional values
+ */
+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;
+}
+/**
+ * Gets required JSON data from parameter
+ */
+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);
+}

package/dist/nodes/IdentityAndAccessManagement/IdentityAndAccessManagement.config.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identityAndAccessManagementNodeDescription = void 0;
+exports.identityAndAccessManagementNodeDescription = {
+    displayName: "Klardaten DATEVconnect: Identity & Access",
+    name: "identityAndAccessManagement",
+    icon: "file:../klardaten.svg",
+    group: ["transform"],
+    version: 1,
+    description: "Work with DATEV Identity and Access Management (SCIM) endpoints",
+    defaults: {
+        name: "Identity & Access Management",
+    },
+    inputs: ["main"],
+    outputs: ["main"],
+    credentials: [
+        {
+            name: "datevConnectApi",
+            required: true,
+        },
+    ],
+    properties: [
+        {
+            displayName: "Resource",
+            name: "resource",
+            type: "options",
+            noDataExpression: true,
+            options: [
+                {
+                    name: "Current User",
+                    value: "currentUser",
+                },
+                {
+                    name: "Group",
+                    value: "group",
+                },
+                {
+                    name: "Resource Type",
+                    value: "resourceType",
+                },
+                {
+                    name: "Schema",
+                    value: "schema",
+                },
+                {
+                    name: "Service Provider Config",
+                    value: "serviceProviderConfig",
+                },
+                {
+                    name: "User",
+                    value: "user",
+                },
+            ],
+            default: "user",
+        },
+        // Service Provider Config operations
+        {
+            displayName: "Operation",
+            name: "operation",
+            type: "options",
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ["serviceProviderConfig"],
+                },
+            },
+            options: [
+                {
+                    name: "Get",
+                    value: "get",
+                    action: "Get service provider config",
+                    description: "Retrieve the SCIM service provider configuration",
+                },
+            ],
+            default: "get",
+        },
+        // Resource Type operations
+        {
+            displayName: "Operation",
+            name: "operation",
+            type: "options",
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ["resourceType"],
+                },
+            },
+            options: [
+                {
+                    name: "Get Many",
+                    value: "getAll",
+                    action: "Get many resource types",
+                    description: "Retrieve the available SCIM resource types",
+                },
+            ],
+            default: "getAll",
+        },
+        // Schema operations
+        {
+            displayName: "Operation",
+            name: "operation",
+            type: "options",
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ["schema"],
+                },
+            },
+            options: [
+                {
+                    name: "Get Many",
+                    value: "getAll",
+                    action: "Get many schemas",
+                    description: "List the supported SCIM schemas",
+                },
+                {
+                    name: "Get",
+                    value: "get",
+                    action: "Get schema",
+                    description: "Retrieve a single SCIM schema by ID",
+                },
+            ],
+            default: "getAll",
+        },
+        // User operations
+        {
+            displayName: "Operation",
+            name: "operation",
+            type: "options",
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                },
+            },
+            options: [
+                {
+                    name: "Create",
+                    value: "create",
+                    action: "Create a user",
+                    description: "Create a new DATEV IAM user",
+                },
+                {
+                    name: "Delete",
+                    value: "delete",
+                    action: "Delete a user",
+                    description: "Delete a DATEV IAM user",
+                },
+                {
+                    name: "Get",
+                    value: "get",
+                    action: "Get a user",
+                    description: "Retrieve a single DATEV IAM user",
+                },
+                {
+                    name: "Get Many",
+                    value: "getAll",
+                    action: "Get many users",
+                    description: "List DATEV IAM users",
+                },
+                {
+                    name: "Update",
+                    value: "update",
+                    action: "Update a user",
+                    description: "Update an existing DATEV IAM user",
+                },
+            ],
+            default: "getAll",
+        },
+        // Current user operations
+        {
+            displayName: "Operation",
+            name: "operation",
+            type: "options",
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ["currentUser"],
+                },
+            },
+            options: [
+                {
+                    name: "Get",
+                    value: "get",
+                    action: "Get current user",
+                    description: "Fetch the currently authenticated DATEV IAM user",
+                },
+            ],
+            default: "get",
+        },
+        // Group operations
+        {
+            displayName: "Operation",
+            name: "operation",
+            type: "options",
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ["group"],
+                },
+            },
+            options: [
+                {
+                    name: "Create",
+                    value: "create",
+                    action: "Create a group",
+                    description: "Create a new DATEV IAM group",
+                },
+                {
+                    name: "Delete",
+                    value: "delete",
+                    action: "Delete a group",
+                    description: "Delete a DATEV IAM group",
+                },
+                {
+                    name: "Get",
+                    value: "get",
+                    action: "Get a group",
+                    description: "Retrieve a single DATEV IAM group",
+                },
+                {
+                    name: "Get Many",
+                    value: "getAll",
+                    action: "Get many groups",
+                    description: "List DATEV IAM groups",
+                },
+                {
+                    name: "Update",
+                    value: "update",
+                    action: "Update a group",
+                    description: "Update an existing DATEV IAM group",
+                },
+            ],
+            default: "getAll",
+        },
+        // Schema parameters
+        {
+            displayName: "Schema ID",
+            name: "schemaId",
+            type: "string",
+            required: true,
+            default: "",
+            description: "Full SCIM schema ID (e.g. urn:ietf:params:scim:schemas:core:2.0:User)",
+            displayOptions: {
+                show: {
+                    resource: ["schema"],
+                    operation: ["get"],
+                },
+            },
+        },
+        // User parameters
+        {
+            displayName: "User ID",
+            name: "userId",
+            type: "string",
+            required: true,
+            default: "",
+            description: "ID of the DATEV IAM user",
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                    operation: ["get", "update", "delete"],
+                },
+            },
+        },
+        {
+            displayName: "Filter",
+            name: "filter",
+            type: "string",
+            default: "",
+            description: "Optional SCIM filter expression",
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                    operation: ["getAll"],
+                },
+            },
+        },
+        {
+            displayName: "Attributes",
+            name: "attributes",
+            type: "string",
+            default: "",
+            description: "Optional comma-separated list of SCIM attributes to return",
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                    operation: ["getAll"],
+                },
+            },
+        },
+        {
+            displayName: "Start Index",
+            name: "startIndex",
+            type: "number",
+            typeOptions: {
+                minValue: 1,
+            },
+            default: 1,
+            description: "1-based index of the first result to return",
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                    operation: ["getAll"],
+                },
+            },
+        },
+        {
+            displayName: "Count",
+            name: "count",
+            type: "number",
+            typeOptions: {
+                minValue: 1,
+            },
+            default: 100,
+            description: "Maximum number of results to return",
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                    operation: ["getAll"],
+                },
+            },
+        },
+        {
+            displayName: "User Data",
+            name: "userData",
+            type: "json",
+            required: true,
+            default: "{}",
+            description: "Full SCIM user payload",
+            displayOptions: {
+                show: {
+                    resource: ["user"],
+                    operation: ["create", "update"],
+                },
+            },
+        },
+        // Group parameters
+        {
+            displayName: "Group ID",
+            name: "groupId",
+            type: "string",
+            required: true,
+            default: "",
+            description: "ID of the DATEV IAM group",
+            displayOptions: {
+                show: {
+                    resource: ["group"],
+                    operation: ["get", "update", "delete"],
+                },
+            },
+        },
+        {
+            displayName: "Group Data",
+            name: "groupData",
+            type: "json",
+            required: true,
+            default: "{}",
+            description: "Full SCIM group payload",
+            displayOptions: {
+                show: {
+                    resource: ["group"],
+                    operation: ["create", "update"],
+                },
+            },
+        },
+    ],
+};