n8n-nodes-lifespace 0.1.0 → 0.1.2

package/README.md

@@ -2,155 +2,283 @@
 
 Official n8n community nodes for integrating workflows and AI agents with LifeSpace.
 
-## Status
+## Install in n8n
 
-The package currently provides:
+The npm package is:
 
-- a LifeSpace Connection credential using a Connection Base URL plus an opaque `lsp_pat_*` Service API Token;
-- a LifeSpace Webhook credential for storing event-subscription signing secrets outside workflow parameters;
-- a LifeSpace node with generic Model Record operations plus an advanced connection-relative API request escape hatch;
-- discovery-driven Model, Action, Create/Update field, Query and Action Input UX against the connection's current LifeSpace authority;
-- a LifeSpace Trigger that receives signed LifeSpace domain-event webhooks;
-- the official `n8n-node` development toolchain;
-- CI for lint and build validation;
-- a GitHub Actions npm publishing path with provenance support.
+```text
+n8n-nodes-lifespace
+```
 
-Domain-specific UX and AI-tool surfaces will be added only against stable upstream LifeSpace contracts/discovery metadata.
+### Self-hosted n8n: install from the UI
 
-## Architecture boundary
+You must be an n8n instance Owner or Admin.
 
-LifeSpace is the source of truth for identity, authorization, domain models, contracts and events. This repository is an n8n-specific adapter and must not become a second copy of LifeSpace business contracts.
+1. Open **Settings → Community Nodes**.
+2. Select **Install**.
+3. Enter:
 
-LifeSpace does not depend on n8n. n8n is one optional orchestration and integration runtime that consumes LifeSpace APIs and events.
+   ```text
+   n8n-nodes-lifespace
+   ```
 
-## Development
+4. Confirm the community-node warning.
+5. Select **Install**.
+6. Return to a workflow and search for **LifeSpace**.
 
-Requirements:
+To pin a release, use for example:
 
-- Node.js 22.22.0 or newer;
-- npm;
-- a local n8n instance for interactive node testing.
+```text
+n8n-nodes-lifespace@0.1.0
+```
 
-Install and validate:
+### Self-hosted n8n: manual npm installation
 
 ```bash
-npm install
-npm run lint
-npm run build
+mkdir -p ~/.n8n/nodes
+cd ~/.n8n/nodes
+npm install n8n-nodes-lifespace
 ```
 
-Run the node in a local n8n development instance:
+Restart n8n afterwards. In queue mode, install the package anywhere that may execute workflows.
 
-```bash
-npm run dev
+## Quick start
+
+Create a **LifeSpace API** credential for Runtime Discovery and LifeSpace API calls.
+
+It contains:
+
+- **API Base URL**, for example:
+
+  ```text
+  https://api.example.com/api/v1
+  ```
+
+- **Service API Token**, an opaque LifeSpace `lsp_pat_*` token.
+
+The API Base URL is the LifeSpace Core API root. Do not include a Space ID or Record Type path.
+
+The token is shown only when it is created or rotated. Store it in n8n immediately; do not put it in workflow fields, URLs, source files, or workflow exports.
+
+A **LifeSpace Trigger** additionally uses a **LifeSpace Webhook Signing** credential containing the endpoint-scoped HMAC signing secret. This is deliberately separate from the API credential: the Service API Token authenticates outbound n8n → LifeSpace calls, while the signing secret verifies inbound LifeSpace → n8n deliveries and rotates with its Webhook Endpoint. The Trigger still reuses the LifeSpace API credential for Space/Record Type discovery, so API context is not duplicated.
+
+Runtime Discovery determines which Spaces, Record Types, fields, queries, Actions and relation lookup capabilities the current API credential can use. Execution authorization is still enforced by LifeSpace from the current principal, credential scope, Application × Model Access and current Space/Data Grant authority.
+
+## Generated Record UX
+
+Create/Update now keep scalar fields in n8n Resource Mapper while using native n8n controls for LifeSpace calendar-date fields and supported relations. Single Person relations use a selector; multi-Person relations use multi-select. List / Query offers typed filter variants for text, enum, boolean, number, date/time and authorized Person relations, while retaining the raw legacy filter as an expression/compatibility escape hatch.
+
+Core Kernel 0.24 adds the optional human-readable `spaceName` Runtime Discovery projection. The node displays it when present and continues to submit the stable `spc_*` ID; Core 0.23 remains compatible and falls back to displaying the raw Space ID.
+
+## LifeSpace contract compatibility
+
+This package follows the current LifeSpace Core Kernel `0.24.0` contract family.
+
+The UX depends on these Kernel capabilities:
+
+- `0.18.0`: cross-Space current-principal Runtime Discovery at `GET /api/v1/me/_discovery`;
+- `0.19.0`: authoritative server defaults exposed in Runtime Discovery;
+- `0.20.0`: Action semantic input separated from optimistic-concurrency metadata;
+- `0.21.0`: invitation-token transport hardening retained by the current baseline;
+- `0.22.0`: authoritative field `title` metadata plus ordered repeatable Generic Query sort metadata;
+- `0.23.0`: authorized source-field-aware Relation Target Lookup for `person` / `person_list` fields;
+- `0.24.0`: authorized human-readable `spaceName` projection in Runtime Discovery while `spaceId` remains the stable identifier.
+
+Ordinary Record CRUD/Action routes remain model-contract surfaces derived from published Model Definitions; the n8n adapter does not maintain a second copy of those schemas.
+
+## Expressions and variables
+
+Runtime/business inputs follow normal n8n expression behavior. A value that can be entered or selected in the node can also be supplied through an n8n expression unless it is deliberately a structural control.
+
+Examples:
+
+```text
+{{$json.spaceId}}
+{{$json.recordId}}
+{{$vars.lifeSpaceRecordType}}
 ```
 
-## Credentials
+Discovery-backed selectors such as **Space**, **Record Type**, **Filter Field**, **Sort Field** and **Action** support the normal n8n pattern: choose a value from the list, or switch the parameter to an expression and provide the corresponding stable ID/key.
 
-Create and authorize the integration in LifeSpace Web first. The Web configuration owns the target Space and its granted model permissions, then exposes the values to copy into n8n:
+The same applies to ordinary values such as Record ID, Search, Filter Value, Return All, Limit, Sort Direction, Cursor, explicit Version, API Method, API Path and JSON Body.
 
-- **Connection Base URL**, for example `https://core.aisr.online/api/v1/spaces/spc_...`;
-- **Service API Token**, an opaque `lsp_pat_*` token issued for that connection.
+Two boundaries are intentional:
 
-The Credential represents one already-configured LifeSpace connection. Individual LifeSpace nodes therefore do not ask for a Space ID.
+- **Resource** and **Operation** are structural node controls and do not accept expressions because they determine which parameter schema and execution path the node has.
+- **Fields** and **Action Input** use n8n's `resourceMapper`. The mapper container is structural, but each generated field value inside it remains expression-capable. This includes relation-backed field values: the UI can offer authorized Person options while an expression can still supply a stable Person ID or ID list.
 
-The Connection Base URL carries routing context only. Authorization still comes from the Service API Token plus LifeSpace credential scopes, Application × Model Access and current Space/Data Grant authority. Revoking the token or grant invalidates the connection without changing the n8n workflow.
+For **Filters** and **Sorts**, add the required rows in the node UI and use expressions inside each row's Field/Operator/Value or Field/Direction inputs. The number of rows is treated as workflow structure rather than per-item data. This avoids relying on whole-array expressions for n8n `fixedCollection` parameters.
 
-Do not store real tokens in source code, workflow examples or repository files.
+If **Record Type** itself varies per input item and those Record Types have different schemas, one discovery-generated mapper cannot safely represent every possible schema at design time. In that case, branch to separate LifeSpace nodes per schema or use **API Request** for a deliberately fully dynamic request.
 
-## LifeSpace Model Record
+A Trigger has no upstream input item. Trigger parameters can still use stable n8n variables/expressions, but should not rely on previous-item `$json` data. Because LifeSpace Webhook Endpoint/Event Subscription configuration is external to the Trigger today, variable-driven Trigger filters should remain stable with that external subscription configuration.
 
-The **Model Record** resource is a thin adapter over LifeSpace Generic Runtime routes. It supports:
+Credentials are intentionally static secure configuration and are not workflow-expression inputs.
 
-- Create;
-- Get;
-- List / Query;
-- Update with optimistic concurrency;
-- Delete with optimistic concurrency;
-- Execute Action for published Capability/workflow actions.
+## Use the LifeSpace node
 
-The node loads its Model selector from `{Connection Base URL}/_discovery`. The list contains only models the current connection can currently use after LifeSpace applies credential scopes, Application × Model Access and current Space membership/Data Grants. The **Action** selector is then loaded dynamically from the selected model and is filtered by the same discovery authority.
+The normal n8n-facing resource is **Record**. LifeSpace still owns **Model** semantics internally; the adapter uses **Record Type** for the workflow-facing selection.
 
-### Discovery-driven fields
+Supported operations:
 
-Create and Update use n8n's resource-mapper UI driven directly by the selected model's bounded Runtime Discovery metadata instead of a handwritten `Fields (JSON)` contract.
+- **Create**;
+- **Get**;
+- **List / Query**;
+- **Update**;
+- **Delete**;
+- **Execute Action**.
 
-- required Create fields follow LifeSpace field metadata;
-- read-only fields are excluded;
-- immutable fields are additionally excluded from Update;
-- enum fields render as options;
-- number, boolean, datetime and list fields use the corresponding n8n input types;
-- LifeSpace date-only fields intentionally remain strings so `YYYY-MM-DD` values are never converted into timezone-bearing instants;
-- automatic input-data mapping is intentionally disabled for now so unrelated incoming keys are not silently sent to LifeSpace's strict model schema.
+### Choose Space and Record Type
 
-### Discovery-driven query
+For Record operations:
 
-List / Query uses bounded query metadata from LifeSpace Runtime Discovery rather than a free-form JSON request.
+1. choose a **Space** from `/me/_discovery`;
+2. choose a **Record Type** available in that Space;
+3. configure the operation.
 
-- searchable fields enable the Search input only where the model declares search support;
-- filter fields are limited to the model's published filterable fields;
-- equality and supported range operators map to LifeSpace Generic Runtime query parameters;
-- sort fields are limited to published sortable fields;
-- pagination uses the LifeSpace `limit` and opaque `cursor` contract;
-- the node does not invent query operators or field semantics that are absent from upstream Discovery metadata.
+You normally do not type Space IDs or model keys manually.
 
-### Discovery-driven Action Input
+### Create
 
-Execute Action uses a second resource-mapper driven by the selected action's bounded input metadata from LifeSpace Runtime Discovery.
+Writable fields are generated from Runtime Discovery.
 
-- Model Definition v1 workflow actions currently expose the optimistic-concurrency `version` input;
-- the `record-occurrence` Capability action exposes `version`, `occurredOn` and optional `note` according to the upstream contract;
-- required/optional status, primitive input types, date-only handling and length/range constraints come from LifeSpace metadata;
-- the node does not copy action schemas into this package or accept an unrestricted Action Input JSON object for normal use.
+LifeSpace server defaults are authoritative. A field that is `required` but has a declared server default is not required from the n8n user. Read-only state owned by a LifeSpace Action/Capability is not exposed as a normal Create/Update field.
 
-LifeSpace Core remains authoritative for validation and authorization when an operation executes. Runtime Discovery is a dynamic UX/capability preview, not an execution-authorization proof.
+For example, lifecycle state such as Task status can remain server/Action-owned instead of being manually entered by the workflow author.
 
-The node does not use the privileged `model-admin/contracts/*` surface for ordinary workflow discovery and does not copy model definitions into this repository.
+When Runtime Discovery advertises supported Relation Target Lookup, `person` and `person_list` fields are rendered from the current authorized `{ id, label }` target projection instead of asking the workflow author to type raw `per_*` identifiers. The displayed value is the LifeSpace Person label, while the workflow payload still stores and submits the stable Person ID.
 
-The **API Request** resource remains available as an advanced escape hatch for paths relative to the configured Connection Base URL.
+Older compatible Discovery responses without relation lookup metadata retain the raw-ID field behavior. `record` / `record_list` fields also retain raw-ID behavior until LifeSpace defines canonical generic Record reference-label semantics; the adapter does not guess labels from fields such as `name`, `title` or `summary`.
 
-## LifeSpace Trigger
+The current n8n UI loads bounded relation options when the relevant field is configured. Very large target sets should use expressions with stable IDs until n8n exposes a searchable dynamic relation option surface that can consume LifeSpace's paginated/searchable lookup directly.
 
-LifeSpace event subscriptions are currently managed by an authenticated LifeSpace user with Space-management permission. A service token intentionally cannot create or modify subscriptions.
+### Update and Delete
 
-To use the trigger:
+LifeSpace uses optimistic concurrency.
 
-1. add a LifeSpace Trigger to an n8n workflow and activate the workflow;
-2. copy the node's production webhook URL;
-3. create a LifeSpace Webhook Endpoint for the target Space and use that URL as its destination;
-4. attach one or more LifeSpace Event Subscription filters for the required model/events to that endpoint;
-5. create a **LifeSpace Webhook API** credential and store the endpoint's one-time signing secret in that credential;
-6. attach the credential to the Trigger and optionally set expected Space/model filters as an additional local check;
-7. use LifeSpace's endpoint test action to verify delivery.
+By default the node reads the current Record version immediately before Update/Delete and sends that version with the mutation. This keeps the ordinary n8n UI free from mandatory internal `version` entry while preserving stale-write protection for the actual mutation race.
 
-The signing secret is intentionally stored as an n8n Credential rather than as a workflow parameter. Workflow exports therefore reference the credential instead of embedding the secret as ordinary node configuration.
+If a workflow intentionally needs to bind a known version, add **Concurrency Options → Version**.
 
-The trigger validates `X-LifeSpace-Timestamp` and `X-LifeSpace-Signature` using the upstream LifeSpace HMAC-SHA256 contract before emitting workflow data.
+### List / Query
 
-## Publishing and verification
+The normal UI supports:
+
+- optional **Search**;
+- one or more **Filters**;
+- **Return All** to follow `nextCursor` automatically;
+- **Limit** when Return All is disabled.
+
+Use **Sorts → Add Sort** to add zero or more sort criteria in priority order. Sortable model fields use authoritative `title` metadata from Runtime Discovery, while envelope fields such as `createdAt` / `updatedAt` are offered only when Discovery advertises them. Multiple criteria are sent as ordered repeated `sort=field:direction` query parameters.
+
+Advanced **Options** contain manual **Cursor** as an escape hatch.
+
+If Sorts is omitted, the adapter omits the query parameter and LifeSpace supplies its deterministic default order. Existing workflow exports that still contain the former single `options.sortField` / `options.sortDirection` parameters remain executable for compatibility.
+
+### Execute Action
+
+Choose an Action from Runtime Discovery.
+
+**Action Input** contains only semantic/domain inputs. LifeSpace concurrency metadata is not rendered as a business field. For the current `record-version` contract, the node reads the current Record version immediately before Action execution and sends it using the transport declared by Runtime Discovery.
+
+This means actions such as `complete` / `reopen` no longer ask users to type an internal version value.
+
+### Advanced API Request
 
-This repository is public and is intended to remain eligible for n8n community-node verification.
+The **API Request** resource is an escape hatch for LifeSpace routes that do not yet have dedicated node UX.
 
-Publishing is performed only by `.github/workflows/publish.yml` from a version tag matching `*.*.*`. The workflow grants only `contents: read` plus `id-token: write`, so npm can attach a provenance attestation to the public package.
+Paths are relative to the configured API Base URL, for example:
+
+```text
+/me/_discovery
+```
+
+Use normal Record operations when possible because they benefit from Runtime Discovery metadata and n8n-specific UX.
+
+## Use the LifeSpace Trigger
+
+The **LifeSpace Trigger** receives signed LifeSpace Domain Event webhooks.
+
+LifeSpace Eventing separates:
+
+- **Webhook Endpoint** — reusable callback URL, signing secret and delivery diagnostics for one Space;
+- **Event Subscription** — one Record Type plus selected event types attached to that endpoint.
+
+One Webhook Endpoint can therefore carry events for multiple Record Types through the same n8n callback.
+
+### Trigger setup
+
+1. Add a **LifeSpace Trigger** node.
+2. Attach a **LifeSpace API** credential. The Trigger uses it only for Runtime Discovery and normal LifeSpace API context.
+3. Attach a **LifeSpace Webhook Signing** credential containing the signing secret for this Webhook Endpoint.
+4. Choose the **Space** from Runtime Discovery.
+5. Choose one or more **Record Types**.
+6. Choose the required **Event Types**.
+7. Activate the workflow and copy the production webhook URL.
+8. In the application/LifeSpace integration management surface, configure one **Webhook Endpoint** using that URL.
+9. Store the endpoint's one-time signing secret in the Webhook Signing credential.
+10. Attach one LifeSpace **Event Subscription** per selected Record Type to the same endpoint, with matching event-type filters.
+11. Use the LifeSpace Webhook Endpoint test operation to verify delivery.
+
+The Trigger verifies `X-LifeSpace-Timestamp` and `X-LifeSpace-Signature` with the LifeSpace HMAC-SHA256 contract before emitting workflow data. `endpoint.test` payloads are always accepted after signature verification.
+
+Webhook Endpoint / Event Subscription creation is intentionally not performed by the n8n Service API Token today because LifeSpace treats that configuration as a Space-management operation. The adapter does not bypass that authority boundary.
+
+## What the package provides
+
+- **LifeSpace API** credential for API authentication and Runtime Discovery;
+- **LifeSpace Webhook Signing** credential for endpoint-scoped inbound HMAC verification;
+- **LifeSpace** node with discovery-driven Record operations plus advanced API Request;
+- **LifeSpace Trigger** with signed multi-Record-Type Domain Event filtering;
+- dynamic Space, Record Type, field, relation target, query, Action and Action Input UI based on Runtime Discovery.
+
+LifeSpace remains authoritative for validation, authorization, defaults, Mutation Authority, Action semantics, relation semantics and event contracts. Runtime Discovery and Relation Target Lookup are current capability/reference projections, not execution-authorization proofs.
+
+## Architecture boundary
+
+LifeSpace is the source of truth for Identity, Authority, Shared Reality semantics, contracts and Eventing. This repository is an n8n Adapter and must not become a second LifeSpace business-contract implementation.
+
+LifeSpace does not depend on n8n. n8n is one optional orchestration/integration runtime consuming LifeSpace APIs and events.
+
+The adapter does not use privileged model-admin endpoints for ordinary workflow discovery and does not copy Model Definitions into this repository.
+
+## Development
+
+Requirements:
+
+- Node.js 22.22.0 or newer;
+- npm;
+- local n8n for interactive testing.
+
+Validate:
+
+```bash
+npm install
+npm run lint
+npm test
+```
+
+`npm test` builds the package before running adapter contract tests.
+
+Run a local n8n development instance:
+
+```bash
+npm run dev
+```
+
+## Publishing and verification
 
-Preferred npm authentication is Trusted Publishing through GitHub Actions. A scoped `NPM_TOKEN` is supported only as a fallback. Do not publish a verification candidate directly from a developer workstation.
+This repository is public and is intended to remain eligible for n8n Community Node verification.
 
-Before the first npm release:
+Publishing is performed by `.github/workflows/publish.yml` from a version tag matching `*.*.*`. npm authentication uses Trusted Publishing through GitHub Actions OIDC and provenance.
 
-1. ensure the `n8n-nodes-lifespace` package is available to the publishing npm account;
-2. configure npm Trusted Publishing for `huangshirui/lifespace-n8n-nodes` and workflow `publish.yml`, or install a narrowly scoped fallback `NPM_TOKEN`;
-3. ensure CI passes on the exact release commit;
-4. create the release through the `n8n-node` release flow so the pushed version tag triggers the provenance workflow;
-5. verify the npm package links back to this public GitHub repository and exposes the MIT license and expected node metadata.
+Do not publish a verification candidate directly from a developer workstation and do not add a long-lived npm publishing token to the repository.
 
-The package intentionally has no runtime `dependencies`. It must not read environment variables or the local filesystem. Node UI, help text, errors, README content and examples remain English-only for n8n verification compatibility.
+The package intentionally has no runtime `dependencies`. It must not read environment variables or the local filesystem. Node UI/help text/errors/README/examples remain English-only for n8n verification compatibility.
 
-## Planned surfaces
+## Remaining upstream-dependent UX
 
-- richer relation selectors when LifeSpace exposes an appropriate authorized lookup surface;
-- a more explicit n8n AI Tool experience for approved LifeSpace actions if the generic tool-capable node proves insufficient;
-- delegated Webhook Endpoint / Event Subscription management if LifeSpace later exposes an appropriate user-authorized integration contract;
-- OAuth `client_credentials` support where required.
+The adapter deliberately does not invent missing platform semantics. Remaining relation work is limited to `record` / `record_list` selectors after LifeSpace defines canonical generic Record reference-label semantics. Person relation selection consumes the LifeSpace 0.23 relation lookup contract, and Space labels consume the 0.24 Runtime Discovery projection.
 
 ## License
 

package/dist/credentials/LifeSpaceApi.credentials.d.ts

@@ -2,7 +2,10 @@ import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INo
 export declare class LifeSpaceApi implements ICredentialType {
     name: string;
     displayName: string;
-    icon: "file:lifespace.svg";
+    icon: {
+        readonly light: "file:lifespace.svg";
+        readonly dark: "file:lifespace.dark.svg";
+    };
     documentationUrl: string;
     properties: INodeProperties[];
     authenticate: IAuthenticateGeneric;

package/dist/credentials/LifeSpaceApi.credentials.js

@@ -4,18 +4,21 @@ exports.LifeSpaceApi = void 0;
 class LifeSpaceApi {
     constructor() {
         this.name = 'lifeSpaceApi';
-        this.displayName = 'LifeSpace Connection API';
-        this.icon = 'file:lifespace.svg';
-        this.documentationUrl = 'https://github.com/huangshirui/LifeSpace';
+        this.displayName = 'LifeSpace API';
+        this.icon = {
+            light: 'file:lifespace.svg',
+            dark: 'file:lifespace.dark.svg',
+        };
+        this.documentationUrl = 'https://github.com/huangshirui/LifeSpace/blob/main/docs/service-authentication.md';
         this.properties = [
             {
-                displayName: 'Connection Base URL',
+                displayName: 'API Base URL',
                 name: 'baseUrl',
                 type: 'string',
                 default: '',
-                placeholder: 'https://core.aisr.online/api/v1/spaces/spc_...',
+                placeholder: 'https://api.example.com/api/v1',
                 required: true,
-                description: 'Copy the Connection Base URL from the LifeSpace Web integration configuration',
+                description: 'LifeSpace Core API root. Do not include a Space or Record Type path.',
             },
             {
                 displayName: 'Service API Token',
@@ -23,8 +26,9 @@ class LifeSpaceApi {
                 type: 'string',
                 typeOptions: { password: true },
                 default: '',
+                placeholder: 'lsp_pat_...',
                 required: true,
-                description: 'Copy the LifeSpace Service API Token (lsp_pat_*) issued for this connection',
+                description: 'Opaque LifeSpace Service API Token used by n8n for API calls and Runtime Discovery',
             },
         ];
         this.authenticate = {
@@ -38,7 +42,7 @@ class LifeSpaceApi {
         this.test = {
             request: {
                 baseURL: '={{$credentials.baseUrl.replace(/\\/$/, "")}}',
-                url: '/_discovery',
+                url: '/me/_discovery',
                 method: 'GET',
             },
         };

package/dist/credentials/LifeSpaceApi.credentials.js.map

@@ -1 +1 @@
-{"version":3,"file":"LifeSpaceApi.credentials.js","sourceRoot":"","sources":["../../credentials/LifeSpaceApi.credentials.ts"],"names":[],"mappings":";;;AAOA,MAAa,YAAY;IAAzB;QACE,SAAI,GAAG,cAAc,CAAC;QAEtB,gBAAW,GAAG,0BAA0B,CAAC;QAEzC,SAAI,GAAG,oBAA6B,CAAC;QAErC,qBAAgB,GAAG,0CAA0C,CAAC;QAE9D,eAAU,GAAsB;YAC9B;gBACE,WAAW,EAAE,qBAAqB;gBAClC,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,gDAAgD;gBAC7D,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,+EAA+E;aAC7F;YACD;gBACE,WAAW,EAAE,mBAAmB;gBAChC,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,6EAA6E;aAC3F;SACF,CAAC;QAEF,iBAAY,GAAyB;YACnC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE;gBACV,OAAO,EAAE;oBACP,aAAa,EAAE,gCAAgC;iBAChD;aACF;SACF,CAAC;QAEF,SAAI,GAA2B;YAC7B,OAAO,EAAE;gBACP,OAAO,EAAE,+CAA+C;gBACxD,GAAG,EAAE,aAAa;gBAClB,MAAM,EAAE,KAAK;aACd;SACF,CAAC;IACJ,CAAC;CAAA;AA9CD,oCA8CC"}
+{"version":3,"file":"LifeSpaceApi.credentials.js","sourceRoot":"","sources":["../../credentials/LifeSpaceApi.credentials.ts"],"names":[],"mappings":";;;AAOA,MAAa,YAAY;IAAzB;QACE,SAAI,GAAG,cAAc,CAAC;QAEtB,gBAAW,GAAG,eAAe,CAAC;QAE9B,SAAI,GAAG;YACL,KAAK,EAAE,oBAAoB;YAC3B,IAAI,EAAE,yBAAyB;SACvB,CAAC;QAEX,qBAAgB,GAAG,mFAAmF,CAAC;QAEvG,eAAU,GAAsB;YAC9B;gBACE,WAAW,EAAE,cAAc;gBAC3B,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,gCAAgC;gBAC7C,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,sEAAsE;aACpF;YACD;gBACE,WAAW,EAAE,mBAAmB;gBAChC,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,aAAa;gBAC1B,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,oFAAoF;aAClG;SACF,CAAC;QAEF,iBAAY,GAAyB;YACnC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE;gBACV,OAAO,EAAE;oBACP,aAAa,EAAE,gCAAgC;iBAChD;aACF;SACF,CAAC;QAEF,SAAI,GAA2B;YAC7B,OAAO,EAAE;gBACP,OAAO,EAAE,+CAA+C;gBACxD,GAAG,EAAE,gBAAgB;gBACrB,MAAM,EAAE,KAAK;aACd;SACF,CAAC;IACJ,CAAC;CAAA;AAlDD,oCAkDC"}

package/dist/credentials/LifeSpaceWebhookApi.credentials.d.ts

@@ -2,7 +2,10 @@ import type { ICredentialType, INodeProperties } from 'n8n-workflow';
 export declare class LifeSpaceWebhookApi implements ICredentialType {
     name: string;
     displayName: string;
-    icon: "file:lifespace.svg";
+    icon: {
+        readonly light: "file:lifespace.svg";
+        readonly dark: "file:lifespace.dark.svg";
+    };
     documentationUrl: string;
     properties: INodeProperties[];
 }

package/dist/credentials/LifeSpaceWebhookApi.credentials.js

@@ -5,17 +5,21 @@ class LifeSpaceWebhookApi {
     constructor() {
         this.name = 'lifeSpaceWebhookApi';
         this.displayName = 'LifeSpace Webhook API';
-        this.icon = 'file:lifespace.svg';
-        this.documentationUrl = 'https://github.com/huangshirui/lifespace-n8n-nodes#lifespace-trigger';
+        this.icon = {
+            light: 'file:lifespace.svg',
+            dark: 'file:lifespace.dark.svg',
+        };
+        this.documentationUrl = 'https://github.com/huangshirui/LifeSpace/blob/main/docs/contracts.md';
         this.properties = [
             {
-                displayName: 'Signing Secret',
+                displayName: 'Webhook Signing Secret',
                 name: 'signingSecret',
                 type: 'string',
                 typeOptions: { password: true },
                 default: '',
+                placeholder: '64-character hexadecimal secret',
                 required: true,
-                description: 'One-time signing secret returned when the LifeSpace event subscription is created or rotated',
+                description: 'Endpoint-scoped signing secret returned by LifeSpace when a Webhook Endpoint is created or rotated',
             },
         ];
     }

package/dist/credentials/LifeSpaceWebhookApi.credentials.js.map

@@ -1 +1 @@
-{"version":3,"file":"LifeSpaceWebhookApi.credentials.js","sourceRoot":"","sources":["../../credentials/LifeSpaceWebhookApi.credentials.ts"],"names":[],"mappings":";;;AAEA,MAAa,mBAAmB;IAAhC;QACE,SAAI,GAAG,qBAAqB,CAAC;QAE7B,gBAAW,GAAG,uBAAuB,CAAC;QAEtC,SAAI,GAAG,oBAA6B,CAAC;QAErC,qBAAgB,GAAG,sEAAsE,CAAC;QAE1F,eAAU,GAAsB;YAC9B;gBACE,WAAW,EAAE,gBAAgB;gBAC7B,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,8FAA8F;aAC5G;SACF,CAAC;IACJ,CAAC;CAAA;AApBD,kDAoBC"}
+{"version":3,"file":"LifeSpaceWebhookApi.credentials.js","sourceRoot":"","sources":["../../credentials/LifeSpaceWebhookApi.credentials.ts"],"names":[],"mappings":";;;AAEA,MAAa,mBAAmB;IAAhC;QACE,SAAI,GAAG,qBAAqB,CAAC;QAE7B,gBAAW,GAAG,uBAAuB,CAAC;QAEtC,SAAI,GAAG;YACL,KAAK,EAAE,oBAAoB;YAC3B,IAAI,EAAE,yBAAyB;SACvB,CAAC;QAEX,qBAAgB,GAAG,sEAAsE,CAAC;QAE1F,eAAU,GAAsB;YAC9B;gBACE,WAAW,EAAE,wBAAwB;gBACrC,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,iCAAiC;gBAC9C,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,oGAAoG;aAClH;SACF,CAAC;IACJ,CAAC;CAAA;AAxBD,kDAwBC"}

package/dist/credentials/lifespace.dark.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="LifeSpace">
+  <defs>
+    <linearGradient id="lifespace-mark-dark" x1="10" y1="54" x2="54" y2="10" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#5C8DFF"/>
+      <stop offset="0.55" stop-color="#69B7FF"/>
+      <stop offset="1" stop-color="#9EDBFF"/>
+    </linearGradient>
+  </defs>
+  <g fill="none" stroke="url(#lifespace-mark-dark)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M28.5 10.5 17.5 17a7 7 0 0 0-3.5 6.1v17.8a7 7 0 0 0 3.5 6.1l11 6.5"/>
+    <path d="M35.5 10.5 46.5 17a7 7 0 0 1 3.5 6.1v17.8a7 7 0 0 1-3.5 6.1l-11 6.5"/>
+  </g>
+  <circle cx="32" cy="32" r="5" fill="url(#lifespace-mark-dark)"/>
+</svg>

package/dist/credentials/lifespace.svg

@@ -1,15 +1,14 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="LifeSpace">
   <defs>
-    <linearGradient id="lifespace-bg" x1="7" y1="57" x2="57" y2="7" gradientUnits="userSpaceOnUse">
+    <linearGradient id="lifespace-mark" x1="10" y1="54" x2="54" y2="10" gradientUnits="userSpaceOnUse">
       <stop offset="0" stop-color="#075FEA"/>
       <stop offset="0.55" stop-color="#087CF5"/>
       <stop offset="1" stop-color="#25A8FF"/>
     </linearGradient>
   </defs>
-  <rect width="64" height="64" rx="14" fill="url(#lifespace-bg)"/>
-  <g fill="none" stroke="#FFFFFF" stroke-width="5" stroke-linecap="round" stroke-linejoin="round">
-    <path d="M29 14.5 19 20.5a5 5 0 0 0-2.5 4.3v14.4a5 5 0 0 0 2.5 4.3l10 6"/>
-    <path d="M35 14.5 45 20.5a5 5 0 0 1 2.5 4.3v14.4a5 5 0 0 1-2.5 4.3l-10 6"/>
+  <g fill="none" stroke="url(#lifespace-mark)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M28.5 10.5 17.5 17a7 7 0 0 0-3.5 6.1v17.8a7 7 0 0 0 3.5 6.1l11 6.5"/>
+    <path d="M35.5 10.5 46.5 17a7 7 0 0 1 3.5 6.1v17.8a7 7 0 0 1-3.5 6.1l-11 6.5"/>
   </g>
-  <circle cx="32" cy="32" r="4.6" fill="#FFFFFF"/>
+  <circle cx="32" cy="32" r="5" fill="url(#lifespace-mark)"/>
 </svg>

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

@@ -3,13 +3,25 @@ export declare class LifeSpace implements INodeType {
     description: INodeTypeDescription;
     methods: {
         loadOptions: {
-            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getSpaces(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getRecordTypes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getActions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getWritableDateFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getSingleRelationFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getMultiRelationFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getRelationTargetsForCurrentField(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getTextFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getEnumFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getBooleanFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getNumericFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getTemporalFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getPersonFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getEnumValuesForCurrentFilter(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getSortableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
         };
         resourceMapping: {
-            getModelFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
+            getRecordFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
             getActionInputFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
         };
     };