@rapidmx/crm-plugin 0.1.0

package/dist/types/util/Csv.d.ts

@@ -0,0 +1,26 @@
+/** Thrown for a CSV the parser can't read. */
+export declare class CsvError extends Error {
+    constructor(message: string);
+}
+/** What `parseCsv()` gives up at. */
+export interface CsvLimits {
+    maxRows?: number;
+    maxColumns?: number;
+    maxFieldLength?: number;
+}
+/**
+ * Parses RFC 4180 CSV into rows of fields: fields separated by `delimiter` (a comma unless given; `detectDelimiter()` can pick one),
+ * rows by CRLF or LF, a field in double quotes may hold the delimiter, line breaks and `""` for a quote. A leading UTF-8 byte order
+ * mark is dropped, and so are lines that are entirely empty. Throws a `CsvError` for an unterminated quote or when `limits` are
+ * exceeded.
+ */
+export declare function parseCsv(text: string, delimiter?: string, limits?: CsvLimits): string[][];
+/** The delimiter of a CSV file, from its first line: whichever of comma, semicolon or tab appears most outside quotes (comma on a tie). */
+export declare function detectDelimiter(text: string): string;
+/**
+ * One CSV field: quoted when it holds a comma, a quote or a line break. A value starting with `=`, `+`, `-`, `@`, a tab or a carriage
+ * return gets a leading `'`, so a spreadsheet opening the file reads it as text instead of running it as a formula (CSV injection).
+ */
+export declare function csvField(value: unknown): string;
+/** One CSV line (CRLF-terminated) of `values`. */
+export declare function csvLine(values: unknown[]): string;

package/dist/types/util/ImportMapping.d.ts

@@ -0,0 +1,23 @@
+import { CrmObjectType, ImportColumnMapping, PropertyDefinition } from "../models/types.js";
+/** The import target of a contact column holding its company's name: the company is found by name, or created. */
+export declare const COMPANY_NAME_TARGET = "company";
+/** The contact and company fields an import may fill, with how their text is read (`number`: as a number). */
+export declare const IMPORT_FIELDS: Readonly<Record<CrmObjectType.CONTACT | CrmObjectType.COMPANY, Readonly<Record<string, "text" | "number">>>>;
+/**
+ * Every target a column of an `objectType` import may map to: the record's `importFields`, `tags`, `properties.<key>` for each of its
+ * custom properties, and for contacts `company` (the company's name).
+ */
+export declare function importTargets(objectType: CrmObjectType, importFields: Readonly<Record<string, "text" | "number">>, definitions: readonly PropertyDefinition[]): string[];
+/** A mapping guessed from the header: each column mapped to the target whose name, alias or property label it matches, once. */
+export declare function suggestMapping(columns: readonly string[], targets: readonly string[], definitions: readonly PropertyDefinition[]): ImportColumnMapping[];
+/**
+ * Checks a mapping from a start request against the CSV's `columns` and the allowed `targets`: one entry per column (a missing one is
+ * skipped), each target used once, and the required one (`email` for contacts, `name` for companies) mapped.
+ */
+export declare function validateMapping(raw: unknown, columns: readonly string[], targets: readonly string[], required: string): ImportColumnMapping[];
+/**
+ * One CSV row as a create request: each mapped, non-empty cell read as its target's type (numbers, booleans as true/yes/1 and
+ * false/no/0, dates, `;`- or `,`-separated tags and multi-select values), plus `extraTags`. A cell that isn't a valid value for its
+ * target is a 400 naming the column.
+ */
+export declare function rowToBody(row: readonly string[], mapping: readonly ImportColumnMapping[], importFields: Readonly<Record<string, "text" | "number">>, definitions: readonly PropertyDefinition[], extraTags: readonly string[]): Record<string, unknown>;

package/dist/types/util/Mailer.d.ts

@@ -0,0 +1,24 @@
+import type { MailTransport } from "@rapidmx/restapi";
+import type { WorkspaceSender } from "../models/types.js";
+/** One message the CRM sends itself (not a campaign): a confirmation, a notification. */
+export interface SystemMessage {
+    sender: Pick<WorkspaceSender, "fromAddress" | "fromName" | "replyToAddress">;
+    to: string;
+    subject: string;
+    text: string;
+    html: string;
+    headers?: Record<string, string>;
+    /** The `Message-ID` header, with angle brackets; generated when not given. */
+    messageId?: string;
+}
+/** Escapes text for HTML. */
+export declare function escapeHtml(text: string): string;
+/** A small, complete HTML email: a heading, paragraphs, and an optional button link. Everything given is escaped. */
+export declare function simpleHtml(heading: string, paragraphs: string[], button?: {
+    label: string;
+    href: string;
+}): string;
+/** Composes `message` as `multipart/alternative` MIME. */
+export declare function composeMessage(message: SystemMessage): Promise<Buffer>;
+/** Sends `message` through the server's mail transport, from its sender's address. Throws when the transport accepts no recipient. */
+export declare function sendSystemMessage(transport: MailTransport, message: SystemMessage): Promise<void>;

package/dist/types/util/PropertyValues.d.ts

@@ -0,0 +1,31 @@
+import { type RepoUtils } from "@rapidrest/service-core";
+import { CrmObjectType, PropertyDefinition, PropertyValue } from "../models/types.js";
+/** The `PropertyValue.key` tags are stored under. Never a custom property's key: those can't be one of a record's own fields. */
+export declare const TAGS_KEY = "tags";
+/** How many custom property values one request may set. */
+export declare const MAX_PROPERTIES_PER_WRITE = 200;
+/** The columns one stored value fills. */
+export type StoredValue = Pick<PropertyValue, "stringValue" | "numberValue" | "dateValue">;
+/** A property's value as the API shows it: text, a number, a boolean, an ISO date string, or a list of option values. */
+export type PropertyViewValue = string | number | boolean | string[];
+/**
+ * The stored rows for a `properties` object from a request: for each key, the rows to write in place of the record's current ones
+ * (none, to clear it with `null`). Every key must name one of `definitions` for `objectType`, and every value must suit its type.
+ */
+export declare function readProperties(raw: unknown, definitions: readonly PropertyDefinition[], objectType: CrmObjectType): Map<string, StoredValue[]>;
+/** The rows one property value is stored as, or a 400. */
+export declare function storedValues(definition: PropertyDefinition, value: unknown): StoredValue[];
+/** Replaces the rows of one key of one record with `values`. */
+export declare function writeValues(repo: RepoUtils<any>, valueClass: any, record: {
+    workspaceUid: string;
+    objectType: CrmObjectType;
+    objectUid: string;
+}, key: string, values: readonly StoredValue[]): Promise<void>;
+/** Deletes every custom property value and tag of the records `objectUids`. */
+export declare function deleteValues(repo: RepoUtils<any>, objectUids: readonly string[]): Promise<void>;
+/** Every stored value of each of `objectUids`, grouped by record and then by key. */
+export declare function readValues(repo: RepoUtils<any>, objectUids: readonly string[]): Promise<Map<string, Record<string, PropertyValue[]>>>;
+/** The API view of one record's stored values: `{ key: value }` for each custom property that has one (tags are left out). */
+export declare function propertiesView(values: Record<string, PropertyValue[]> | undefined, definitions: readonly PropertyDefinition[]): Record<string, PropertyViewValue>;
+/** The stored values of one record as `evaluateFilter()` takes them: `{ key: [value, ...] }`, dates as `Date`s. */
+export declare function filterValues(values: Record<string, PropertyValue[]> | undefined): Record<string, unknown[]>;

package/dist/types/util/Secrets.d.ts

@@ -0,0 +1,10 @@
+import { RepoUtils } from "@rapidrest/service-core";
+import type { CrmSetting } from "../models/types.js";
+/** The `CrmSetting` key of the generated token key. */
+export declare const TOKEN_SECRET_KEY = "token-secret";
+/**
+ * The generated key tokens and tracking links are signed with, kept as a `CrmSetting` so every server copy (routes and jobs alike)
+ * signs and checks with the same key: read, or generated and saved on first use. Two copies generating one at once both read back
+ * whichever was saved first (the key is unique).
+ */
+export declare function readOrCreateTokenSecret(repo: RepoUtils<CrmSetting>, settingClass: any): Promise<string>;

package/dist/types/util/Tokens.d.ts

@@ -0,0 +1,30 @@
+/** What a token lets its bearer do. */
+export type TokenPurpose = "prefs" | "confirm" | "unsub";
+/** What a signed token says. */
+export interface TokenPayload {
+    /** The purpose - a token is only accepted for its own. */
+    p: TokenPurpose;
+    /** The workspace. */
+    w: string;
+    /** The contact. */
+    c: string;
+    /** The lists it concerns (a confirmation's lists; an unsubscribe link's lists - none: every list). */
+    l?: string[];
+    /** The outbound message an unsubscribe link came in, so the unsubscribe counts in its campaign's statistics. */
+    s?: string;
+    /** When it stops working, in seconds since the epoch. None: it doesn't. */
+    x?: number;
+}
+/** The longest token accepted, so a huge string is refused before any work. */
+export declare const MAX_TOKEN_LENGTH = 2048;
+/**
+ * A token carrying `payload`, signed with `secret` (HMAC-SHA256): `<base64url JSON>.<base64url MAC>`. The link in every email a
+ * contact gets carries one, so the preference center and one-click unsubscribe work without an account - and without the link's
+ * contact or workspace being guessable or changeable.
+ */
+export declare function signToken(payload: TokenPayload, secret: string): string;
+/**
+ * The payload of a token signed with `secret` for `purpose`, or `undefined` for anything else: malformed, forged, for another
+ * purpose, or expired. The signature is compared in constant time.
+ */
+export declare function verifyToken(token: unknown, secret: string, purpose: TokenPurpose, now?: Date): TokenPayload | undefined;

package/dist/types/util/Validation.d.ts

@@ -0,0 +1,59 @@
+import { ApiError } from "@rapidrest/core";
+/** The longest one-line text field (a name, a title, a job title...). */
+export declare const MAX_SHORT_TEXT = 256;
+/** The longest multi-line text field (a note, a description). */
+export declare const MAX_LONG_TEXT = 20000;
+/** The longest email address (RFC 5321). */
+export declare const MAX_EMAIL_LENGTH = 254;
+/** How many tags one record may carry, and how long one may be. */
+export declare const MAX_TAGS = 50;
+export declare const MAX_TAG_LENGTH = 64;
+/** A 400 `ApiError` with `message`. */
+export declare function badRequest(message: string): ApiError;
+/** A 409 `ApiError` with `message`. */
+export declare function conflict(message: string): ApiError;
+/** Whether `body` is a plain JSON object. */
+export declare function isObject(body: unknown): body is Record<string, unknown>;
+/** `body` as a plain object, or a 400. */
+export declare function requireObject(body: unknown): Record<string, unknown>;
+/**
+ * A text field: trimmed, at most `max` characters. `undefined` when absent; `null` when explicitly cleared (`null` or empty),
+ * which only an optional field allows. A required field that is missing or empty is a 400.
+ */
+export declare function readText(body: Record<string, unknown>, field: string, options?: {
+    required?: boolean;
+    max?: number;
+}): string | null | undefined;
+/** An email address, lowercased. The same absent/cleared/required rules as `readText()`. */
+export declare function readEmail(body: Record<string, unknown>, field: string, options?: {
+    required?: boolean;
+}): string | null | undefined;
+/** Whether `value` looks like one email address. */
+export declare function isEmail(value: string): boolean;
+/** One of `allowed`. `undefined` when absent; `null` when explicitly cleared, which only an optional field allows. */
+export declare function readEnum<T extends string>(body: Record<string, unknown>, field: string, allowed: readonly T[], options?: {
+    required?: boolean;
+}): T | null | undefined;
+/** A finite number, optionally an integer within `[min, max]`. `undefined` when absent; `null` when cleared. */
+export declare function readNumber(body: Record<string, unknown>, field: string, options?: {
+    integer?: boolean;
+    min?: number;
+    max?: number;
+}): number | null | undefined;
+/** A boolean. `undefined` when absent. */
+export declare function readBoolean(body: Record<string, unknown>, field: string): boolean | undefined;
+/** A date from an ISO 8601 string. `undefined` when absent; `null` when cleared. */
+export declare function readDate(body: Record<string, unknown>, field: string): Date | null | undefined;
+/** `raw` as a valid date, from an ISO 8601 string or a `Date`, or `undefined`. */
+export declare function parseDate(raw: unknown): Date | undefined;
+/** One tag, normalized: trimmed, lowercased, inner whitespace collapsed. `undefined` when it is empty or too long. */
+export declare function normalizeTag(raw: unknown): string | undefined;
+/** A list of tags, normalized and de-duplicated. `undefined` when absent. */
+export declare function readTags(body: Record<string, unknown>, field?: string): string[] | undefined;
+/** A page of a list: `limit` between 1 and `maxLimit` (default 50), `page` from 0. */
+export declare function readPaging(limit: unknown, page: unknown, maxLimit?: number): {
+    limit: number;
+    page: number;
+};
+/** A company's web domain from a domain, a URL or an email address: lowercase, without scheme, path, port or `www.`. */
+export declare function normalizeDomain(raw: string): string | undefined;

package/dist/types/util/WorkspaceAccess.d.ts

@@ -0,0 +1,24 @@
+import { ApiError, type JWTUser } from "@rapidrest/core";
+import { type ACLRecord, ACLUtils } from "@rapidrest/service-core";
+import { WorkspaceAction, WorkspaceRole } from "../models/types.js";
+/** The actions each role is granted on its workspace's `AccessControlList`. An owner holds `FULL` (`*`), which includes them all. */
+export declare const ROLE_ACTIONS: Readonly<Record<WorkspaceRole, readonly string[]>>;
+/** The roles from the most to the least privileged. */
+export declare const ROLE_ORDER: readonly WorkspaceRole[];
+/** Whether `value` is a `WorkspaceRole`. */
+export declare function isWorkspaceRole(value: unknown): value is WorkspaceRole;
+/** The ACL record granting `userUid` the actions of `role`. */
+export declare function memberRecord(userUid: string, role: WorkspaceRole): ACLRecord;
+/**
+ * Rejects a caller who doesn't hold `action` on the workspace with a 404 - the same answer a workspace that doesn't exist gets, so a
+ * stranger can't tell which workspace uids are real. A member who can read the workspace but not do `action` gets a 403.
+ *
+ * Trusted roles are stripped first (`stripTrustedRoles()`): `ACLUtils.hasPermission()` answers `true` for an administrator on
+ * anything, and a deployment administrator has no business in a workspace they aren't a member of - the same rule restapi applies to
+ * mailboxes.
+ */
+export declare function assertWorkspaceAccess(aclUtils: ACLUtils, trustedRoles: readonly string[], user: JWTUser | undefined, workspaceUid: string, action: WorkspaceAction): Promise<void>;
+/** A 404 `ApiError`. */
+export declare function notFound(): ApiError;
+/** A 403 `ApiError`. */
+export declare function forbidden(): ApiError;

package/dist/types/webhooks/Deliveries.d.ts

@@ -0,0 +1,26 @@
+import type { CrmModelClasses, CrmRepos } from "../models/CrmModelClasses.js";
+import { CrmEvent, WebhookEndpoint } from "../models/types.js";
+/** A webhook body: what happened, to whom, and its details. */
+export interface WebhookPayload extends Record<string, unknown> {
+    id: string;
+    type: string;
+    occurredAt: string;
+    workspaceUid: string;
+    contact?: {
+        uid: string;
+        email: string;
+        firstName?: string;
+        lastName?: string;
+    };
+    data: Record<string, unknown>;
+}
+/** Whether `endpoint` takes events of `type`. */
+export declare function wants(endpoint: Pick<WebhookEndpoint, "events" | "enabled">, type: string): boolean;
+/** The body of `event`'s webhooks. */
+export declare function eventPayload(repos: CrmRepos, event: CrmEvent): Promise<WebhookPayload>;
+/** Queues `payload` for each of `endpoints` (`WebhookDeliveryJob` posts it). */
+export declare function enqueueDeliveries(repos: CrmRepos, classes: CrmModelClasses, endpoints: WebhookEndpoint[], payload: WebhookPayload): Promise<number>;
+/** The workspace's enabled endpoints. */
+export declare function enabledEndpoints(repos: CrmRepos, workspaceUid: string): Promise<WebhookEndpoint[]>;
+/** A made-up id, for payloads that aren't a stored event (a test ping, an automation's webhook step). */
+export declare function payloadId(): string;

package/dist/types/webhooks/Webhooks.d.ts

@@ -0,0 +1,43 @@
+import { LookupAddress } from "dns";
+import * as https from "https";
+/** How long a webhook request may take. */
+export declare const WEBHOOK_TIMEOUT_MS = 10000;
+/** The largest body a webhook posts. */
+export declare const MAX_PAYLOAD_BYTES: number;
+/** A new endpoint secret. */
+export declare function newWebhookSecret(): string;
+/**
+ * The signature header of a webhook body: `t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<body>">` - the timestamp is signed too, so a
+ * receiver can refuse replays.
+ */
+export declare function signWebhook(secret: string, body: string, timestamp?: number): string;
+/**
+ * Whether `address` (an IP) is on the public internet: not loopback, private, link-local, carrier-grade NAT, documentation,
+ * multicast or reserved - IPv4, IPv6, and IPv4 mapped into IPv6.
+ */
+export declare function isPublicAddress(address: string): boolean;
+/** Refuses (throws) a webhook address that isn't `https://` on a host name or public address. */
+export declare function checkWebhookUrl(raw: string): URL;
+/** Resolves a host name to its addresses (every one, both families). */
+export type HostLookup = (hostname: string) => Promise<LookupAddress[]>;
+export declare const defaultLookup: HostLookup;
+/** What a webhook request came to. */
+export interface WebhookResult {
+    status: number;
+}
+/** How a webhook is posted: `postWebhook()`, or a double in tests. */
+export type WebhookPoster = (url: string, body: string, secret: string) => Promise<WebhookResult>;
+/** How `postWebhook()` resolves and connects. */
+export interface PostOptions {
+    lookup?: HostLookup;
+    timeoutMs?: number;
+    /** `https.request`, or a double in tests. */
+    request?: typeof https.request;
+}
+/**
+ * Posts `body` to `rawUrl`, signed with `secret`. The host is resolved first and every address it resolves to must be public; the
+ * request then goes to the first of those addresses (with the host name kept for TLS and `Host`), so a name can't be switched to an
+ * internal address between the check and the connection. Redirects aren't followed. Throws on a refused address, a network error or
+ * a timeout; answers the status otherwise (the caller decides what counts as delivered).
+ */
+export declare function postWebhook(rawUrl: string, body: string, secret: string, options?: PostOptions): Promise<WebhookResult>;

package/package.json

@@ -0,0 +1,226 @@
+{
+    "name": "@rapidmx/crm-plugin",
+    "version": "0.1.0",
+    "description": "RapidMX plugin that provides a customer relationship management and marketing platform: contacts, companies, mailing lists, campaigns, automations and sales pipelines.",
+    "repository": "https://github.com/rapidmx/crm-plugin.git",
+    "author": "RapidREST <rapidrests@gmail.com>",
+    "license": "MPL-2.0",
+    "contributors": [
+        "Jean-Philippe Steinmetz"
+    ],
+    "scripts": {
+        "build": "yarn lint && rimraf dist && tsc && tsc -p tsconfig.apps.json",
+        "lint": "eslint ./src ./apps ./test",
+        "local-audit": "yarn install && yarn npm audit -A -R \"$@\"",
+        "checkup": "yarn dlx @yarnpkg/doctor \"$@\"",
+        "dependency-check": "yarn dlx depcheck \"$@\"",
+        "report-coverage": "cat ./coverage/lcov.info | coveralls",
+        "test": "vitest run",
+        "test:prod": "npm run lint && vitest run --coverage",
+        "test:watch": "vitest",
+        "release": "npx @rapidrest/cli release",
+        "prepublish": "yarn build"
+    },
+    "peerDependencies": {
+        "@dnd-kit/core": "6.x",
+        "@rapidmx/restapi": ">=0.26.0 <1",
+        "@rapidmx/web-client": ">=0.26.0 <1",
+        "@rapidrest/core": "6.x",
+        "@rapidrest/react": ">=2.1.0 <3",
+        "@rapidrest/service-core": "2.x",
+        "@tiptap/pm": "3.x",
+        "@tiptap/react": "3.x",
+        "@tiptap/starter-kit": "3.x",
+        "react": "19.x",
+        "react-dom": "19.x",
+        "react-icons": "5.x"
+    },
+    "dependencies": {
+        "@dnd-kit/sortable": "^10.0.0",
+        "html-to-text": "^10.0.1",
+        "liquidjs": "^10.29.0",
+        "mjml": "^5.4.1",
+        "nodemailer": "^10.0.1",
+        "sanitize-html": "^2.17.7"
+    },
+    "devDependencies": {
+        "@dnd-kit/core": "^6.3.1",
+        "@rapidmx/restapi": "^0.26.0",
+        "@rapidmx/web-client": "^0.26.0",
+        "@rapidrest/core": "^6.0.0",
+        "@rapidrest/react": "^2.1.0",
+        "@rapidrest/service-core": "^2.4.0",
+        "@swc/core": "1.16.2",
+        "@testing-library/dom": "^10.4.1",
+        "@testing-library/jest-dom": "^7.0.1",
+        "@testing-library/react": "^16.3.3",
+        "@testing-library/user-event": "^14.6.7",
+        "@tiptap/pm": "^3.31.3",
+        "@tiptap/react": "^3.31.3",
+        "@tiptap/starter-kit": "^3.31.3",
+        "@types/html-to-text": "^9.0.4",
+        "@types/nconf": "^0.10.7",
+        "@types/node": "^26.5.0",
+        "@types/nodemailer": "^8.0.1",
+        "@types/react": "^19.2.18",
+        "@types/react-dom": "^19.2.7",
+        "@types/sanitize-html": "^2.16.2",
+        "@typescript-eslint/eslint-plugin": "^8.70.0",
+        "@typescript-eslint/parser": "^8.70.0",
+        "@vitest/coverage-v8": "^5.0.0",
+        "better-sqlite3": "^13.0.3",
+        "eslint": "^10.10.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-jsdoc": "^64.3.6",
+        "globals": "^17.12.0",
+        "jsdom": "^30.0.1",
+        "lodash-es": "^4.18.1",
+        "mailparser": "^3.9.0",
+        "mongodb": "^7.6.0",
+        "mongodb-memory-server": "^11.2.0",
+        "nconf": "^0.13.0",
+        "openapi3-ts": "^4.6.1",
+        "prom-client": "^15.1.3",
+        "react": "^19.2.8",
+        "react-dom": "^19.2.8",
+        "react-icons": "^5.7.0",
+        "redis": "^6.2.1",
+        "reflect-metadata": "^0.2.2",
+        "rimraf": "^6.1.3",
+        "ts-node": "^10.9.2",
+        "tsx": "^4.23.13",
+        "typeorm": "^1.1.1",
+        "typescript": "^6.0.3",
+        "unplugin-swc": "^1.6.0",
+        "uuid": "^14.0.2",
+        "vite": "^8.2.2",
+        "vitest": "^5.0.0",
+        "winston": "^3.19.0"
+    },
+    "resolutions": {
+        "@rapidmx/restapi": "^0.26.0",
+        "@rapidmx/web-client": "^0.26.0"
+    },
+    "packageManager": "yarn@4.5.3",
+    "engines": {
+        "node": ">=24.0.0"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "type": "module",
+    "main": "dist/lib/index.js",
+    "exports": {
+        ".": {
+            "import": "./dist/lib/index.js",
+            "types": "./dist/types/index.d.ts"
+        },
+        "./mongo": {
+            "import": "./dist/lib/mongo.js",
+            "types": "./dist/types/mongo.d.ts"
+        },
+        "./sql": {
+            "import": "./dist/lib/sql.js",
+            "types": "./dist/types/sql.d.ts"
+        },
+        "./purge": {
+            "import": "./dist/lib/purge.js",
+            "types": "./dist/types/purge.d.ts"
+        }
+    },
+    "typings": "dist/types/index.d.ts",
+    "files": [
+        "apps",
+        "dist"
+    ],
+    "rapidmx": {
+        "plugin": {
+            "apiVersion": 1,
+            "displayName": "CRM",
+            "description": "Adds a customer relationship management app at /crm: shared workspaces of contacts, companies and deals with custom properties, notes, tasks and an activity timeline; mailing lists with signup forms, double opt-in and a subscriber preference center; an email designer, campaigns with tracking and A/B tests, segments, lead scoring and automations; sales pipelines; reports; webhooks and an integration API - and a CRM page in the admin console.",
+            "mailboxScopedData": true,
+            "settings": [
+                {
+                    "key": "mail:crm:public_url",
+                    "label": "Public site address",
+                    "type": "string",
+                    "default": "https://<host>",
+                    "help": "The address the CRM's public pages (signup forms, the preference center, unsubscribe links) are served from, for example https://mail.example.com. Links in CRM emails point here."
+                },
+                {
+                    "key": "mail:crm:workspace_creator_roles",
+                    "label": "Who can create workspaces",
+                    "type": "string",
+                    "default": "",
+                    "help": "A comma-separated list of roles allowed to create CRM workspaces. Leave empty to let every signed-in user create one."
+                },
+                {
+                    "key": "mail:crm:max_workspaces_per_user",
+                    "label": "Workspaces per user",
+                    "type": "number",
+                    "default": 10,
+                    "help": "How many workspaces one user may create."
+                },
+                {
+                    "key": "mail:crm:send_rate_per_minute",
+                    "label": "Campaign messages per minute",
+                    "type": "number",
+                    "default": 600,
+                    "help": "The most campaign messages the whole deployment sends per minute, shared by every workspace. Raise it only as far as your mail server and its reputation allow."
+                },
+                {
+                    "key": "mail:crm:verp",
+                    "label": "Per-message bounce addresses",
+                    "type": "boolean",
+                    "default": true,
+                    "help": "Send each campaign message with its own bounce address (the sender's address plus a +b- tag), so bounces are matched to their message reliably. Needs plus-addressing, which RapidMX has on by default."
+                }
+            ],
+            "ui": {
+                "apps": [
+                    {
+                        "id": "crm",
+                        "host": "www",
+                        "mount": "/crm",
+                        "dir": "apps/crm"
+                    },
+                    {
+                        "id": "subscriptions",
+                        "host": "public",
+                        "mount": "/subscriptions",
+                        "dir": "apps/subscriptions"
+                    },
+                    {
+                        "id": "forms",
+                        "host": "public",
+                        "mount": "/f",
+                        "dir": "apps/f"
+                    },
+                    {
+                        "id": "crm-admin",
+                        "host": "admin",
+                        "mount": "/admin/crm",
+                        "dir": "apps/admin-crm"
+                    }
+                ],
+                "appRail": [
+                    {
+                        "id": "crm",
+                        "label": "CRM",
+                        "href": "/crm",
+                        "icon": "HiOutlineUserGroup"
+                    }
+                ],
+                "adminNav": [
+                    {
+                        "id": "crm",
+                        "label": "CRM",
+                        "href": "/admin/crm",
+                        "icon": "HiOutlineUserGroup"
+                    }
+                ]
+            }
+        }
+    }
+}