n8n-nodes-thirdfactor-obsidian 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2026 ThirdFactor / Prixa. All rights reserved.
+
+Commercial License
+
+This SDK is proprietary software, provided as part of the ThirdFactor /
+Obsidian KYC platform. Use, reproduction, and distribution are permitted
+only to ThirdFactor customers and partners, solely to integrate applications
+with the ThirdFactor platform, under the terms of your ThirdFactor service
+agreement (or another written agreement with ThirdFactor).
+
+You may not modify, reverse engineer, sublicense, rent, or redistribute this
+SDK except as your agreement expressly allows or applicable law permits
+notwithstanding this limitation.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THIRDFACTOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING FROM
+THE USE OF THE SOFTWARE.
+
+Licensing questions: support@thirdfactor.ai

package/README.md

@@ -0,0 +1,95 @@
+# n8n-nodes-thirdfactor-obsidian
+
+[n8n](https://n8n.io) community nodes for **ThirdFactor Obsidian** — the
+identity-verification (KYC/KYB) platform. A webhook trigger for platform
+events plus an action node for sessions, tags, and standalone AML checks.
+
+## Installation
+
+In n8n: **Settings → Community Nodes → Install** and enter
+`n8n-nodes-thirdfactor-obsidian`, or on a self-hosted instance:
+
+```bash
+npm install n8n-nodes-thirdfactor-obsidian
+```
+
+## Credentials
+
+Create a **ThirdFactor Obsidian API** credential:
+
+| Field | Description |
+|---|---|
+| **Base URL** | Your deployment's API base URL, e.g. `https://api.thirdfactor.example`. |
+| **API Key** | A tenant API key (`sk_…`) from the console (Settings → API Keys). Sent as the `X-API-Key` header. |
+
+The credential test calls `GET /v3/automation/me/` on your deployment.
+
+## ThirdFactor Obsidian Trigger
+
+Webhook trigger backed by the platform's REST-hooks API. When the workflow is
+activated, the node subscribes via `POST /v3/automation/subscriptions/`
+(`source: "n8n"`); deactivating unsubscribes.
+
+- **Events** — multi-select, fetched live from `/v3/automation/events/`
+  (session lifecycle, module results, AML/blocklist/risk/duplicate signals,
+  review cases, contact/document progress, credits).
+- **Workflows** — optional filter; only sessions of the selected verification
+  workflows fire the trigger.
+- **Modules** — optional filter for module-scoped events
+  (e.g. `module.completed` for `AML_SCREENING` only).
+- **Verify Signature** (default on) — validates the `X-Webhook-Signature`
+  header (`t=<unix>,v1=<hex>`, HMAC-SHA256 of `"<t>.<raw_body>"` with the
+  subscription secret) and rejects mismatched or stale (>5 min) deliveries
+  with HTTP 401.
+
+Each delivery arrives as one item:
+
+```json
+{
+  "payload_version": 1,
+  "event": "session.approved",
+  "id": "<delivery uuid>",
+  "created_at": "<iso timestamp>",
+  "data": { "session": { "id": "…", "status": "approved", "vendor_data": "…" } }
+}
+```
+
+To test without waiting for a real event, use **Listen for test event** and
+complete a verification, or fetch a recent payload yourself from
+`GET /v3/automation/samples/<event>/`.
+
+## ThirdFactor Obsidian (action node)
+
+| Resource | Operation | Endpoint |
+|---|---|---|
+| Session | Create | `POST /v3/session/` — returns the hosted verification `url` |
+| Session | Get | `GET /v3/session/<id>/` |
+| Session | Get Decision | `GET /v3/session/<id>/decision/` |
+| Session | Get Many | `GET /v3/session/` (status / page / page size filters) |
+| Session | Add Tag | `POST /v3/session/<id>/tags/` |
+| Tools | AML Check | `POST /v3/tools/aml-check/` (billed per use) |
+
+**Session → Create** offers a dynamic Workflow dropdown (from
+`/v3/workflows/`) plus vendor data, contact email/phone, expiry, metadata
+(JSON), callback URL, and locale.
+
+## Development
+
+```bash
+cd sdks/n8n
+npm install
+npm run build   # tsc + copies the node icon (thirdfactor.png — the product favicon) into dist/
+```
+
+Link into a local n8n for manual testing:
+
+```bash
+npm link
+cd ~/.n8n/custom   # or your n8n custom-extensions dir
+npm link n8n-nodes-thirdfactor-obsidian
+```
+
+## Compatibility
+
+Built against `n8n-workflow` ^1.70 with the community-node API version 1;
+requires Node.js ≥ 18.

package/dist/credentials/ThirdFactorObsidianApi.credentials.d.ts

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

package/dist/credentials/ThirdFactorObsidianApi.credentials.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThirdFactorObsidianApi = void 0;
+class ThirdFactorObsidianApi {
+    constructor() {
+        this.name = 'thirdFactorObsidianApi';
+        this.displayName = 'ThirdFactor Obsidian API';
+        this.documentationUrl = 'https://github.com/thirdfactor/obsidian';
+        this.properties = [
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://api.thirdfactor.example',
+                required: true,
+                description: 'Your ThirdFactor Obsidian API base URL (each deployment has its own domain)',
+            },
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'A tenant API key from the ThirdFactor Obsidian console (starts with "sk_"). Sent as the X-API-Key header.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'X-API-Key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl.replace(new RegExp("/+$"), "")}}',
+                url: '/v3/automation/me/',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.ThirdFactorObsidianApi = ThirdFactorObsidianApi;

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

@@ -0,0 +1,15 @@
+import type { IDataObject, IExecuteFunctions, IHookFunctions, IHttpRequestMethods, ILoadOptionsFunctions, INodePropertyOptions, IWebhookFunctions } from 'n8n-workflow';
+type ObsidianContext = IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions | IWebhookFunctions;
+/**
+ * Authenticated request against the tenant's ThirdFactor Obsidian deployment.
+ * The credential injects the X-API-Key header; the base URL comes from the
+ * same credential so every endpoint path here is deployment-relative.
+ */
+export declare function apiRequest(this: ObsidianContext, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, qs?: IDataObject): Promise<any>;
+/** GET /v3/automation/events/ → options for the events multi-select. */
+export declare function loadEventOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+/** GET /v3/automation/events/ → the module/feature filter vocabulary. */
+export declare function loadFeatureOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+/** GET /v3/workflows/ → workflow dropdown options (bare array response). */
+export declare function loadWorkflowOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+export {};

package/dist/nodes/ThirdFactorObsidian/GenericFunctions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRequest = apiRequest;
+exports.loadEventOptions = loadEventOptions;
+exports.loadFeatureOptions = loadFeatureOptions;
+exports.loadWorkflowOptions = loadWorkflowOptions;
+/**
+ * Authenticated request against the tenant's ThirdFactor Obsidian deployment.
+ * The credential injects the X-API-Key header; the base URL comes from the
+ * same credential so every endpoint path here is deployment-relative.
+ */
+async function apiRequest(method, endpoint, body, qs) {
+    const credentials = await this.getCredentials('thirdFactorObsidianApi');
+    const baseUrl = String(credentials.baseUrl || '').replace(/\/+$/, '');
+    const options = {
+        method,
+        url: `${baseUrl}${endpoint}`,
+        json: true,
+    };
+    if (body && Object.keys(body).length) {
+        options.body = body;
+    }
+    if (qs && Object.keys(qs).length) {
+        options.qs = qs;
+    }
+    return await this.helpers.httpRequestWithAuthentication.call(this, 'thirdFactorObsidianApi', options);
+}
+/** GET /v3/automation/events/ → options for the events multi-select. */
+async function loadEventOptions() {
+    const response = await apiRequest.call(this, 'GET', '/v3/automation/events/');
+    const events = (response === null || response === void 0 ? void 0 : response.events) || [];
+    return events.map((event) => ({
+        name: `${event.group}: ${event.label}`,
+        value: String(event.key),
+        description: String(event.description || ''),
+    }));
+}
+/** GET /v3/automation/events/ → the module/feature filter vocabulary. */
+async function loadFeatureOptions() {
+    const response = await apiRequest.call(this, 'GET', '/v3/automation/events/');
+    const features = (response === null || response === void 0 ? void 0 : response.features) || [];
+    return features.map((feature) => ({ name: feature, value: feature }));
+}
+/** GET /v3/workflows/ → workflow dropdown options (bare array response). */
+async function loadWorkflowOptions() {
+    const response = await apiRequest.call(this, 'GET', '/v3/workflows/');
+    const workflows = (Array.isArray(response) ? response : []);
+    return workflows.map((workflow) => ({
+        name: workflow.verification_type
+            ? `${workflow.name} (${workflow.verification_type})`
+            : String(workflow.name),
+        value: String(workflow.id),
+    }));
+}

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

@@ -0,0 +1,11 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { loadWorkflowOptions } from './GenericFunctions';
+export declare class ThirdFactorObsidian implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getWorkflows: typeof loadWorkflowOptions;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/ThirdFactorObsidian/ThirdFactorObsidian.node.js

@@ -0,0 +1,413 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThirdFactorObsidian = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+class ThirdFactorObsidian {
+    constructor() {
+        this.description = {
+            displayName: 'ThirdFactor Obsidian',
+            name: 'thirdFactorObsidian',
+            icon: 'file:thirdfactor.png',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with the ThirdFactor Obsidian identity-verification platform (sessions, tags, AML checks)',
+            defaults: {
+                name: 'ThirdFactor Obsidian',
+            },
+            inputs: ["main" /* NodeConnectionType.Main */],
+            outputs: ["main" /* NodeConnectionType.Main */],
+            credentials: [
+                {
+                    name: 'thirdFactorObsidianApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Session', value: 'session' },
+                        { name: 'Tools', value: 'tools' },
+                    ],
+                    default: 'session',
+                },
+                // ── Session operations ────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['session'] } },
+                    options: [
+                        {
+                            name: 'Add Tag',
+                            value: 'addTag',
+                            description: 'Apply a tag to a verification session',
+                            action: 'Add a tag to a session',
+                        },
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a hosted verification session and get the verification link',
+                            action: 'Create a verification session',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Retrieve a verification session',
+                            action: 'Get a verification session',
+                        },
+                        {
+                            name: 'Get Decision',
+                            value: 'getDecision',
+                            description: 'Retrieve the decision detail of a session',
+                            action: 'Get a session decision',
+                        },
+                        {
+                            name: 'Get Many',
+                            value: 'getMany',
+                            description: 'List recent verification sessions',
+                            action: 'Get many verification sessions',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Session → Create
+                {
+                    displayName: 'Workflow Name or ID',
+                    name: 'workflowId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getWorkflows',
+                    },
+                    default: '',
+                    displayOptions: { show: { resource: ['session'], operation: ['create'] } },
+                    description: 'The verification workflow to run. Leave empty for the tenant default. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'additionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { resource: ['session'], operation: ['create'] } },
+                    options: [
+                        {
+                            displayName: 'Callback URL',
+                            name: 'callbackUrl',
+                            type: 'string',
+                            default: '',
+                            description: 'Where the hosted flow redirects the applicant after completion (your app, not a webhook)',
+                        },
+                        {
+                            displayName: 'Contact Email',
+                            name: 'contactEmail',
+                            type: 'string',
+                            placeholder: 'name@email.com',
+                            default: '',
+                            description: 'Applicant email address',
+                        },
+                        {
+                            displayName: 'Contact Phone',
+                            name: 'contactPhone',
+                            type: 'string',
+                            default: '',
+                            description: 'Applicant phone in international format, e.g. +9779800000000',
+                        },
+                        {
+                            displayName: 'Expires in (Hours)',
+                            name: 'expiresInHours',
+                            type: 'number',
+                            typeOptions: { minValue: 1, maxValue: 720 },
+                            default: 48,
+                            description: 'How long the verification link stays valid (1-720 hours)',
+                        },
+                        {
+                            displayName: 'Locale',
+                            name: 'locale',
+                            type: 'string',
+                            default: '',
+                            description: 'UI language for the hosted flow (BCP-47-ish, e.g. "en", "ne"). Empty = workflow default.',
+                        },
+                        {
+                            displayName: 'Metadata',
+                            name: 'metadata',
+                            type: 'json',
+                            default: '{}',
+                            description: 'Free-form JSON object stored on the session',
+                        },
+                        {
+                            displayName: 'Vendor Data',
+                            name: 'vendorData',
+                            type: 'string',
+                            default: '',
+                            description: 'Your own reference for this applicant (user ID, application number, …) — echoed back on every event',
+                        },
+                    ],
+                },
+                // Session → Get / Get Decision / Add Tag
+                {
+                    displayName: 'Session ID',
+                    name: 'sessionId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: { resource: ['session'], operation: ['get', 'getDecision', 'addTag'] },
+                    },
+                    description: 'The verification session UUID',
+                },
+                {
+                    displayName: 'Tag',
+                    name: 'tag',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: { show: { resource: ['session'], operation: ['addTag'] } },
+                    description: 'The tag to apply (normalized to lowercase_with_underscores), e.g. "vip"',
+                },
+                // Session → Get Many
+                {
+                    displayName: 'Filters',
+                    name: 'filters',
+                    type: 'collection',
+                    placeholder: 'Add Filter',
+                    default: {},
+                    displayOptions: { show: { resource: ['session'], operation: ['getMany'] } },
+                    options: [
+                        {
+                            displayName: 'Status',
+                            name: 'status',
+                            type: 'options',
+                            options: [
+                                { name: 'Abandoned', value: 'abandoned' },
+                                { name: 'Approved', value: 'approved' },
+                                { name: 'Awaiting User', value: 'awaiting_user' },
+                                { name: 'Declined', value: 'declined' },
+                                { name: 'Expired', value: 'expired' },
+                                { name: 'In Progress', value: 'in_progress' },
+                                { name: 'In Review', value: 'in_review' },
+                                { name: 'KYC Expired', value: 'kyc_expired' },
+                                { name: 'Not Started', value: 'not_started' },
+                                { name: 'Resubmitted', value: 'resubmitted' },
+                            ],
+                            default: 'approved',
+                        },
+                        {
+                            displayName: 'Page',
+                            name: 'page',
+                            type: 'number',
+                            typeOptions: { minValue: 1 },
+                            default: 1,
+                        },
+                        {
+                            displayName: 'Page Size',
+                            name: 'pageSize',
+                            type: 'number',
+                            typeOptions: { minValue: 1, maxValue: 200 },
+                            default: 50,
+                        },
+                    ],
+                },
+                // ── Tools operations ──────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['tools'] } },
+                    options: [
+                        {
+                            name: 'AML Check',
+                            value: 'amlCheck',
+                            description: 'Screen a person against sanctions / PEP / watchlists (billed per use)',
+                            action: 'Run an AML check',
+                        },
+                    ],
+                    default: 'amlCheck',
+                },
+                {
+                    displayName: 'Full Name',
+                    name: 'fullName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['tools'], operation: ['amlCheck'] } },
+                    description: "The person's full name (or set First + Last Name below)",
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'amlAdditionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { resource: ['tools'], operation: ['amlCheck'] } },
+                    options: [
+                        {
+                            displayName: 'Country',
+                            name: 'country',
+                            type: 'string',
+                            default: '',
+                            description: 'Country of residence code, if different from nationality',
+                        },
+                        {
+                            displayName: 'Date of Birth',
+                            name: 'dateOfBirth',
+                            type: 'string',
+                            default: '',
+                            placeholder: '1990-01-31',
+                            description: 'ISO date — improves match precision',
+                        },
+                        {
+                            displayName: 'Document Number',
+                            name: 'documentNumber',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'First Name',
+                            name: 'firstName',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Last Name',
+                            name: 'lastName',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Match Threshold',
+                            name: 'matchThreshold',
+                            type: 'number',
+                            typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 },
+                            default: 0.7,
+                            description: 'Override the confirmed-match score threshold (0-1)',
+                        },
+                        {
+                            displayName: 'Nationality',
+                            name: 'nationality',
+                            type: 'string',
+                            default: '',
+                            description: 'Country code (e.g. NP, US)',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                getWorkflows: GenericFunctions_1.loadWorkflowOptions,
+            },
+        };
+    }
+    async execute() {
+        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 {
+                let responseData;
+                if (resource === 'session' && operation === 'create') {
+                    const body = {};
+                    const workflowId = this.getNodeParameter('workflowId', i, '');
+                    if (workflowId)
+                        body.workflow_id = workflowId;
+                    const extra = this.getNodeParameter('additionalFields', i, {});
+                    if (extra.vendorData)
+                        body.vendor_data = extra.vendorData;
+                    if (extra.contactEmail)
+                        body.contact_email = extra.contactEmail;
+                    if (extra.contactPhone)
+                        body.contact_phone = extra.contactPhone;
+                    if (extra.expiresInHours)
+                        body.expires_in_hours = extra.expiresInHours;
+                    if (extra.callbackUrl)
+                        body.callback_url = extra.callbackUrl;
+                    if (extra.locale)
+                        body.locale = extra.locale;
+                    if (extra.metadata) {
+                        const metadata = typeof extra.metadata === 'string'
+                            ? JSON.parse(extra.metadata)
+                            : extra.metadata;
+                        if (Object.keys(metadata).length)
+                            body.metadata = metadata;
+                    }
+                    responseData = await GenericFunctions_1.apiRequest.call(this, 'POST', '/v3/session/', body);
+                }
+                else if (resource === 'session' && operation === 'get') {
+                    const sessionId = this.getNodeParameter('sessionId', i);
+                    responseData = await GenericFunctions_1.apiRequest.call(this, 'GET', `/v3/session/${sessionId}/`);
+                }
+                else if (resource === 'session' && operation === 'getDecision') {
+                    const sessionId = this.getNodeParameter('sessionId', i);
+                    responseData = await GenericFunctions_1.apiRequest.call(this, 'GET', `/v3/session/${sessionId}/decision/`);
+                }
+                else if (resource === 'session' && operation === 'getMany') {
+                    const filters = this.getNodeParameter('filters', i, {});
+                    const qs = {};
+                    if (filters.status)
+                        qs.status = filters.status;
+                    if (filters.page)
+                        qs.page = filters.page;
+                    if (filters.pageSize)
+                        qs.page_size = filters.pageSize;
+                    responseData = (await GenericFunctions_1.apiRequest.call(this, 'GET', '/v3/session/', undefined, qs));
+                }
+                else if (resource === 'session' && operation === 'addTag') {
+                    const sessionId = this.getNodeParameter('sessionId', i);
+                    const tag = this.getNodeParameter('tag', i);
+                    const response = await GenericFunctions_1.apiRequest.call(this, 'POST', `/v3/session/${sessionId}/tags/`, { tag });
+                    responseData = { ...response, session_id: sessionId };
+                }
+                else if (resource === 'tools' && operation === 'amlCheck') {
+                    const body = {};
+                    const fullName = this.getNodeParameter('fullName', i, '');
+                    if (fullName)
+                        body.full_name = fullName;
+                    const extra = this.getNodeParameter('amlAdditionalFields', i, {});
+                    if (extra.firstName)
+                        body.first_name = extra.firstName;
+                    if (extra.lastName)
+                        body.last_name = extra.lastName;
+                    if (extra.dateOfBirth)
+                        body.date_of_birth = extra.dateOfBirth;
+                    if (extra.nationality)
+                        body.nationality = extra.nationality;
+                    if (extra.country)
+                        body.country = extra.country;
+                    if (extra.documentNumber)
+                        body.document_number = extra.documentNumber;
+                    if (extra.matchThreshold)
+                        body.match_threshold = extra.matchThreshold;
+                    if (!body.full_name && !(body.first_name || body.last_name)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Provide a Full Name, or a First and/or Last Name', { itemIndex: i });
+                    }
+                    responseData = await GenericFunctions_1.apiRequest.call(this, 'POST', '/v3/tools/aml-check/', body);
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported operation "${resource}.${operation}"`, { itemIndex: i });
+                }
+                const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
+                returnData.push(...executionData);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ThirdFactorObsidian = ThirdFactorObsidian;

package/dist/nodes/ThirdFactorObsidian/ThirdFactorObsidianTrigger.node.d.ts

@@ -0,0 +1,20 @@
+import type { IHookFunctions, INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
+import { loadEventOptions, loadFeatureOptions, loadWorkflowOptions } from './GenericFunctions';
+export declare class ThirdFactorObsidianTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getEvents: typeof loadEventOptions;
+            getWorkflows: typeof loadWorkflowOptions;
+            getFeatures: typeof loadFeatureOptions;
+        };
+    };
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/ThirdFactorObsidian/ThirdFactorObsidianTrigger.node.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThirdFactorObsidianTrigger = void 0;
+const crypto_1 = require("crypto");
+const GenericFunctions_1 = require("./GenericFunctions");
+/**
+ * Verify the platform's webhook signature:
+ *   X-Webhook-Signature: t=<unix>,v1=<hex hmac-sha256 of "<t>.<raw_body>">
+ * signed with the subscription secret returned on subscribe.
+ */
+function verifySignature(header, rawBody, secret) {
+    const parts = {};
+    for (const piece of header.split(',')) {
+        const idx = piece.indexOf('=');
+        if (idx > 0) {
+            parts[piece.slice(0, idx).trim()] = piece.slice(idx + 1).trim();
+        }
+    }
+    const timestamp = parts.t;
+    const signature = parts.v1;
+    if (!timestamp || !signature)
+        return false;
+    // Reject stale deliveries (replay guard) — 5 minutes of clock drift allowed.
+    const age = Math.abs(Date.now() / 1000 - Number(timestamp));
+    if (!Number.isFinite(age) || age > 300)
+        return false;
+    const expected = (0, crypto_1.createHmac)('sha256', secret)
+        .update(`${timestamp}.${rawBody}`)
+        .digest('hex');
+    if (expected.length !== signature.length)
+        return false;
+    try {
+        return (0, crypto_1.timingSafeEqual)(new Uint8Array(Buffer.from(expected, 'hex')), new Uint8Array(Buffer.from(signature, 'hex')));
+    }
+    catch {
+        return false;
+    }
+}
+class ThirdFactorObsidianTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'ThirdFactor Obsidian Trigger',
+            name: 'thirdFactorObsidianTrigger',
+            icon: 'file:thirdfactor.png',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["events"].join(", ")}}',
+            description: 'Starts the workflow when ThirdFactor Obsidian events occur (verifications, review cases, AML hits, credits, …)',
+            defaults: {
+                name: 'ThirdFactor Obsidian Trigger',
+            },
+            inputs: [],
+            outputs: ["main" /* NodeConnectionType.Main */],
+            credentials: [
+                {
+                    name: 'thirdFactorObsidianApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Events',
+                    name: 'events',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getEvents',
+                    },
+                    default: [],
+                    required: true,
+                    description: 'The platform events to subscribe to. The list is fetched live from your deployment. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Workflows',
+                    name: 'workflowIds',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getWorkflows',
+                    },
+                    default: [],
+                    description: 'Only receive events for sessions of these verification workflows. Leave empty for all workflows. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Modules',
+                    name: 'features',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getFeatures',
+                    },
+                    default: [],
+                    description: 'Only receive module-scoped events for these verification modules (applies to events like module.completed). Leave empty for all modules. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Verify Signature',
+                    name: 'verifySignature',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to verify the X-Webhook-Signature header (HMAC-SHA256 with the subscription secret) and reject deliveries that do not match',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                getEvents: GenericFunctions_1.loadEventOptions,
+                getWorkflows: GenericFunctions_1.loadWorkflowOptions,
+                getFeatures: GenericFunctions_1.loadFeatureOptions,
+            },
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const staticData = this.getWorkflowStaticData('node');
+                    if (!staticData.subscriptionId) {
+                        return false;
+                    }
+                    const response = await GenericFunctions_1.apiRequest.call(this, 'GET', '/v3/automation/subscriptions/');
+                    const subscriptions = (response === null || response === void 0 ? void 0 : response.subscriptions) || [];
+                    const exists = subscriptions.some((subscription) => subscription.id === staticData.subscriptionId);
+                    if (!exists) {
+                        delete staticData.subscriptionId;
+                        delete staticData.subscriptionSecret;
+                    }
+                    return exists;
+                },
+                async create() {
+                    var _a;
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const events = this.getNodeParameter('events', []);
+                    const workflowIds = this.getNodeParameter('workflowIds', []);
+                    const features = this.getNodeParameter('features', []);
+                    const body = {
+                        url: webhookUrl,
+                        events,
+                        source: 'n8n',
+                        description: `n8n workflow ${(_a = this.getWorkflow().id) !== null && _a !== void 0 ? _a : ''}`.trim(),
+                    };
+                    if (workflowIds.length)
+                        body.workflow_ids = workflowIds;
+                    if (features.length)
+                        body.features = features;
+                    const response = await GenericFunctions_1.apiRequest.call(this, 'POST', '/v3/automation/subscriptions/', body);
+                    if (!(response === null || response === void 0 ? void 0 : response.id)) {
+                        return false;
+                    }
+                    const staticData = this.getWorkflowStaticData('node');
+                    staticData.subscriptionId = response.id;
+                    // The signing secret is returned exactly once, on create.
+                    staticData.subscriptionSecret = response.secret;
+                    return true;
+                },
+                async delete() {
+                    const staticData = this.getWorkflowStaticData('node');
+                    if (staticData.subscriptionId) {
+                        // Idempotent server-side: deleting an already-gone hook succeeds.
+                        await GenericFunctions_1.apiRequest.call(this, 'DELETE', `/v3/automation/subscriptions/${staticData.subscriptionId}/`);
+                        delete staticData.subscriptionId;
+                        delete staticData.subscriptionSecret;
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        var _a, _b, _c;
+        const req = this.getRequestObject();
+        const body = this.getBodyData();
+        const shouldVerify = this.getNodeParameter('verifySignature', true);
+        if (shouldVerify) {
+            const staticData = this.getWorkflowStaticData('node');
+            const secret = staticData.subscriptionSecret;
+            const header = String((_a = this.getHeaderData()['x-webhook-signature']) !== null && _a !== void 0 ? _a : '');
+            const rawBody = (_c = (_b = req.rawBody) === null || _b === void 0 ? void 0 : _b.toString('utf8')) !== null && _c !== void 0 ? _c : JSON.stringify(body);
+            if (!secret || !header || !verifySignature(header, rawBody, secret)) {
+                const response = this.getResponseObject();
+                response.status(401).json({ ok: false, error: 'invalid_signature' });
+                return { noWebhookResponse: true };
+            }
+        }
+        return {
+            workflowData: [this.helpers.returnJsonArray([body])],
+        };
+    }
+}
+exports.ThirdFactorObsidianTrigger = ThirdFactorObsidianTrigger;

package/index.js

@@ -0,0 +1,3 @@
+// n8n loads credentials and nodes from the paths declared in the `n8n`
+// attribute of package.json; this entry point intentionally exports nothing.
+module.exports = {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "n8n-nodes-thirdfactor-obsidian",
+  "version": "0.1.0",
+  "description": "n8n community nodes for ThirdFactor Obsidian — identity verification triggers and actions",
+  "keywords": [
+    "n8n-community-node-package",
+    "thirdfactor",
+    "kyc",
+    "identity-verification",
+    "aml"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "ThirdFactor"
+  },
+  "main": "index.js",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc && node scripts/copy-assets.js",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/ThirdFactorObsidianApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/ThirdFactorObsidian/ThirdFactorObsidian.node.js",
+      "dist/nodes/ThirdFactorObsidian/ThirdFactorObsidianTrigger.node.js"
+    ]
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "devDependencies": {
+    "n8n-workflow": "~1.70.0",
+    "typescript": "^5.5.0"
+  }
+}