ab-ecosystem-cpass 1.0.6 → 1.0.8

package/dist/resources/data-stores.js

@@ -0,0 +1,530 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStoreRecords = exports.DataStoreCollections = exports.DataStores = void 0;
+const paths_1 = require("./paths");
+const BASE = paths_1.DATASTORE;
+const storePath = (store) => `${BASE}/${(0, paths_1.seg)(store)}`;
+const collectionsPath = (store) => `${storePath(store)}/collections`;
+const collectionPath = (store, collection) => `${collectionsPath(store)}/${(0, paths_1.seg)(collection)}`;
+const recordsPath = (store, collection) => `${collectionPath(store, collection)}/records`;
+/**
+ * Data stores: a MongoDB **you** own, registered with the platform.
+ *
+ * ```ts
+ * const store = await crm.dataStores.create({
+ *   title: 'Orders DB',
+ *   credentials: {
+ *     type: 'field',
+ *     host: 'cluster0.ab12c.mongodb.net',
+ *     username: 'crm_writer',
+ *     password: process.env.ORDERS_DB_PASSWORD!,
+ *     database: 'shop',
+ *   },
+ * });
+ *
+ * const orders = await crm.dataStoreCollections.create(store.id, {
+ *   title: 'Orders',
+ *   fields: [
+ *     { name: 'order_no', type: 'String' },
+ *     { name: 'total', type: 'Number' },
+ *     { name: 'paid', type: 'Boolean', default: false },
+ *   ],
+ * });
+ *
+ * await crm.dataStoreRecords.insert(store.id, orders.id, {
+ *   record: { order_no: 'A-1001', total: 49.9 },
+ * });
+ * ```
+ *
+ * ## What the platform holds, and what it does not
+ *
+ * It holds the credential -- encrypted -- and the schemas you declare. It holds
+ * **none of your data**: records are read from and written to your cluster on
+ * every call, so nothing here is a copy that can go stale, and nothing here
+ * survives you revoking the credential.
+ *
+ * Which also means every record call costs a round trip to your database. The
+ * platform keeps the connection open between calls, so that is one query's
+ * latency rather than a fresh TLS handshake each time, but a loop of a thousand
+ * single inserts is a thousand round trips: send them as one `insert` with
+ * `records` instead.
+ *
+ * ## Deleting never deletes your data
+ *
+ * `remove()` on a store forgets the credential and the schemas. `remove()` on a
+ * collection forgets the declaration. **Neither touches your database** -- the
+ * collections and every document in them are exactly as they were, and
+ * re-registering the same credential with the same collection name reads it all
+ * straight back. Deleting *records* is the only thing here that deletes
+ * anything of yours.
+ *
+ * ## The host must be reachable from the internet
+ *
+ * A credential pointing at a private or loopback address is refused with
+ * `422 invalid_datastore_host`: the platform would be connecting to its own
+ * network rather than to yours. Atlas users will usually also need to allow the
+ * platform's egress addresses in their project's IP access list -- the symptom
+ * otherwise is `502 datastore_unreachable` with a server-selection timeout.
+ */
+class DataStores {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * `POST /v1/datastores` -- 201 with the store.
+     *
+     * ### Payload
+     *
+     * | Field | Type | Required | Notes |
+     * | --- | --- | --- | --- |
+     * | `title` | string | yes | What you call it. 1-120 characters. |
+     * | `credentials` | object | yes | Either form below. |
+     *
+     * **`credentials.type: 'field'`**
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `host` | string | Hostname only: `cluster0.ab12c.mongodb.net`. |
+     * | `username` | string | |
+     * | `password` | string | Encrypted at rest; never returned. |
+     * | `database` | string | |
+     *
+     * Assembled into `mongodb+srv://…?retryWrites=true&w=majority`, with both
+     * halves of the credential percent-encoded -- so a password containing `@`,
+     * `/` or `?` works, which it did not in the legacy panel.
+     *
+     * **`credentials.type: 'string'`**
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `uri` | string | `mongodb://` or `mongodb+srv://`, and it must name a database. |
+     *
+     * ### What happens before the row is written
+     *
+     * The credential is checked for shape, the host is resolved and refused if it
+     * is private, and a connection is opened and pinged. Only then is anything
+     * stored -- so a 201 means the database really did accept these credentials,
+     * and a store you can see is a store that worked at least once.
+     *
+     * | Status | Code | Meaning |
+     * | --- | --- | --- |
+     * | 422 | `validation_failed` | Malformed URI, a host with a scheme in it, or no database named. |
+     * | 422 | `invalid_datastore_host` | The host does not resolve, or resolves somewhere private. |
+     * | 502 | `datastore_auth_failed` | The database refused the username or password. |
+     * | 502 | `datastore_unreachable` | No answer in time -- usually an IP access list. |
+     *
+     * Scope: `datastores:write`.
+     */
+    create(input) {
+        return this.http.request('POST', BASE, { body: input });
+    }
+    /**
+     * `GET /v1/datastores` -- offset paginated, newest first.
+     *
+     * | Query | Type | Default | Notes |
+     * | --- | --- | --- | --- |
+     * | `page` | number | `1` | 1-based. |
+     * | `rows` | number | `25` | 1-100. |
+     * | `search` | string | — | Case-insensitive match on the title. |
+     *
+     * Scope: `datastores:read`.
+     */
+    list(query = {}) {
+        return this.http.request('GET', BASE, { query });
+    }
+    /** `GET /v1/datastores/:store`. Scope: `datastores:read`. */
+    get(store) {
+        return this.http.request('GET', storePath(store));
+    }
+    /**
+     * `PATCH /v1/datastores/:store` -- rename, re-point, or both.
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `title` | string | |
+     * | `credentials` | object | Replaced whole, and tested before it is stored. |
+     *
+     * A partial credential is not accepted: send all four fields, or the whole
+     * URI. New credentials go through the same checks as `create`, and the old
+     * connection is dropped -- so the next record call reads from the new cluster
+     * rather than from a connection that happens to still be open.
+     *
+     * Scope: `datastores:write`.
+     */
+    update(store, input) {
+        return this.http.request('PATCH', storePath(store), { body: input });
+    }
+    /**
+     * `DELETE /v1/datastores/:store` -- 204.
+     *
+     * Forgets the credential and every schema declared on it. **Your database is
+     * not touched**: the collections and all their documents remain, and
+     * registering the same credential again with the same collection names reads
+     * them straight back.
+     *
+     * Scope: `datastores:write`.
+     */
+    remove(store) {
+        return this.http.request('DELETE', storePath(store));
+    }
+    /**
+     * `POST /v1/datastores/:store/test` -- connect, and report.
+     *
+     * ```ts
+     * const { ok, database, collections, latencyMs } = await crm.dataStores.test(store.id);
+     * ```
+     *
+     * The answer to "is it us or them". A credential that worked last month may
+     * have been rotated, an Atlas project may be paused, an IP access list may
+     * have been tightened -- each of which this distinguishes by status code
+     * rather than leaving to be inferred from a failing record call.
+     *
+     * `collections` is also what you need in order to point a new schema at a
+     * collection that already exists. It is empty when the database user has no
+     * `listCollections` privilege, which is a perfectly good credential -- not a
+     * sign the database is empty.
+     *
+     * A POST rather than a GET because it opens a connection and updates
+     * `verifiedAt`. Scope: `datastores:read`.
+     */
+    test(store) {
+        return this.http.request('POST', `${storePath(store)}/test`);
+    }
+}
+exports.DataStores = DataStores;
+/**
+ * The collections you declare over a data store: a name, and the fields in it.
+ *
+ * ```ts
+ * const customers = await crm.dataStoreCollections.create(store.id, {
+ *   title: 'Customers',
+ *   fields: [
+ *     { name: 'Email', type: 'String' },       // stored as `email`
+ *     { name: 'Signed Up', type: 'Date' },     // stored as `signed_up`
+ *     { name: 'Credits', type: 'Number', default: 0 },
+ *     { name: 'Tags', type: 'Array' },
+ *   ],
+ * });
+ *
+ * customers.fields.map((field) => field.name); // ['email','signed_up','credits','tags']
+ * ```
+ *
+ * ## Field names are slugged, once
+ *
+ * The server normalises every name -- punctuation dropped, spaces and hyphens to
+ * underscores, lowercased -- and the normalised name is both what comes back and
+ * what the document actually stores. **Use the returned names as your record
+ * keys.** The legacy panel slugged the name for the database but kept the
+ * original in the schema, so a field called `First Name` stored under
+ * `first_name` while the schema said otherwise, and records written against the
+ * schema's spelling silently went nowhere.
+ *
+ * ## Declaring a collection does not create one
+ *
+ * Mongo creates a collection on its first write, so a new schema addresses a
+ * collection that does not exist yet. Reads against it correctly return an empty
+ * page rather than failing.
+ *
+ * ## Editing fields rewrites nothing
+ *
+ * `update()` changes validation and coercion from the next call onward. It does
+ * not migrate documents: dropping a field hides the values under that key
+ * (re-declare it and they are back), and changing a field's type leaves old
+ * documents holding the old type. The collection a schema points at cannot be
+ * changed at all -- every record ever written through it lives there.
+ */
+class DataStoreCollections {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * `POST /v1/datastores/:store/collections` -- 201.
+     *
+     * | Field | Type | Required | Notes |
+     * | --- | --- | --- | --- |
+     * | `title` | string | yes | 1-120 characters. |
+     * | `fields` | array | yes | 1-100 fields; see below. |
+     * | `collection` | string | no | An existing collection to adopt. Immutable afterwards. |
+     * | `show_in_chat` | boolean | no | Default `false`. Whether the chat panel offers it. |
+     * | `display.theme` | string | no | Presentation only. |
+     * | `display.fields` | string[] | no | Field names to show, in order. Presentation only. |
+     *
+     * **Each field**
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `name` | string | Slugged by the server; the slug is the document key. |
+     * | `type` | `String` `Number` `Boolean` `Date` `Array` | |
+     * | `label` | string | Display only. |
+     * | `default` | string \| number \| boolean | `String`, `Number` and `Boolean` only. |
+     *
+     * Omit `collection` and the server generates `<id>_<slugged title>`, which
+     * cannot collide with anything already in your database. Supply it to point at
+     * a collection you already have -- the way to use a database with data in it
+     * rather than duplicating it.
+     *
+     * | Status | Code | Meaning |
+     * | --- | --- | --- |
+     * | 404 | `not_found` | No such store in this account. |
+     * | 409 | `conflict` | This store already has a schema for that collection name. |
+     * | 422 | `validation_failed` | A field name that slugs to nothing, a duplicate after slugging, or a default of the wrong type. |
+     *
+     * Scope: `datastores:write`.
+     */
+    create(store, input) {
+        return this.http.request('POST', collectionsPath(store), { body: input });
+    }
+    /**
+     * `GET /v1/datastores/:store/collections` -- offset paginated,
+     * newest first. `page`, `rows`, and `search` on the title.
+     *
+     * Scope: `datastores:read`.
+     */
+    list(store, query = {}) {
+        return this.http.request('GET', collectionsPath(store), { query });
+    }
+    /**
+     * `GET /v1/datastores/:store/collections/:collection`.
+     *
+     * Both ids are checked: a collection id belonging to a different store -- even
+     * one of your own -- is a 404 rather than a match.
+     *
+     * Scope: `datastores:read`.
+     */
+    get(store, collection) {
+        return this.http.request('GET', collectionPath(store, collection));
+    }
+    /**
+     * `PATCH /v1/datastores/:store/collections/:collection`.
+     *
+     * `title`, `fields`, `show_in_chat` and `display`. Not `collection`: a schema
+     * points at one collection for its whole life, and re-pointing it would orphan
+     * every record written through it. Point a new schema at the other collection
+     * instead.
+     *
+     * Scope: `datastores:write`.
+     */
+    update(store, collection, input) {
+        return this.http.request('PATCH', collectionPath(store, collection), {
+            body: input,
+        });
+    }
+    /**
+     * `DELETE /v1/datastores/:store/collections/:collection` -- 204.
+     *
+     * Forgets the declaration. **Your collection and its documents remain** --
+     * declaring the same collection name again reads the same records back.
+     *
+     * Scope: `datastores:write`.
+     */
+    remove(store, collection) {
+        return this.http.request('DELETE', collectionPath(store, collection));
+    }
+}
+exports.DataStoreCollections = DataStoreCollections;
+/**
+ * The records in a data store collection -- documents in **your** database.
+ *
+ * ```ts
+ * await crm.dataStoreRecords.insert(store.id, orders.id, {
+ *   records: [{ order_no: 'A-1', total: 10 }, { order_no: 'A-2', total: 20 }],
+ * });
+ *
+ * const { data, pagination } = await crm.dataStoreRecords.search(store.id, orders.id, {
+ *   filter: { paid: false, total: { $gte: 20 } },
+ *   sort: 'total',
+ *   order: 'desc',
+ * });
+ * ```
+ *
+ * ## Writes are validated against the declaration
+ *
+ * Keys must be declared field names, and values are coerced to the declared
+ * type -- `"42"` into a `Number` field is stored as `42`, an ISO string into a
+ * `Date` field as a date. An **undeclared key is a 422 naming it**, which is the
+ * one deliberate break from the legacy endpoint: there, an unknown key was
+ * dropped silently, so a typo meant data quietly went nowhere.
+ *
+ * `null` clears a field. `created_on` and `updated_on` are stamped by the server
+ * -- unix seconds, or real dates if the collection declared them as `Date` --
+ * and ignored if you send them. `id` cannot be written.
+ *
+ * ## Reads return everything that is stored
+ *
+ * Including keys the schema does not declare, because the documents are yours
+ * and may have been written by something else. `_id` reads back as `id`.
+ *
+ * ## There is no aggregation endpoint
+ *
+ * Deliberately: a pipeline can read other collections with `$lookup` and write
+ * them with `$merge`, which would make a schema's boundary meaningless, and
+ * `$function` runs JavaScript on your cluster. The same three operators are
+ * refused inside a filter. For anything that needs a pipeline, use your own
+ * credentials and your own driver -- it is your database.
+ */
+class DataStoreRecords {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records` -- 201.
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `record` | object | One record. Exactly one of this or `records`. |
+     * | `records` | object[] | 1-1000 records. |
+     *
+     * ```ts
+     * const { inserted, ids } = await crm.dataStoreRecords.insert(store, collection, {
+     *   records: rows,
+     * });
+     * ```
+     *
+     * A batch is **unordered**: one document rejected by a unique index of yours
+     * does not abandon the rest, so `inserted` may be lower than what you sent.
+     * `ids` are in the order the documents were sent.
+     *
+     * Prefer one call with `records` over a loop of single inserts -- each call is
+     * a round trip to your cluster.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    insert(store, collection, input) {
+        return this.http.request('POST', recordsPath(store, collection), {
+            body: input,
+        });
+    }
+    /**
+     * `GET /v1/datastores/:store/collections/:collection/records`
+     *
+     * | Query | Type | Default | Notes |
+     * | --- | --- | --- | --- |
+     * | `page` | number | `1` | 1-based. |
+     * | `rows` | number | `25` | 1-100. |
+     * | `sort` | string | `created_on` | Any field name. |
+     * | `order` | `asc` \| `desc` | `desc` | |
+     *
+     * `_id` is appended to the sort as a tiebreaker, so paging is reproducible
+     * even when the sort field repeats -- or does not exist, which it will not on
+     * an adopted collection that something else wrote.
+     *
+     * Scope: `datastore-records:read`.
+     */
+    list(store, collection, query = {}) {
+        return this.http.request('GET', recordsPath(store, collection), {
+            query,
+        });
+    }
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records/search`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `filter` | object | A Mongo query. Required; `{}` matches everything. |
+     * | `page` `rows` `sort` `order` | | As `list`. |
+     *
+     * ```ts
+     * await crm.dataStoreRecords.search(store, collection, {
+     *   filter: {
+     *     $or: [{ status: 'open' }, { total: { $gte: 100 } }],
+     *     signed_up: { $gte: '2026-01-01' },   // coerced to a Date for a Date field
+     *     tags: 'vip',                         // an Array field contains this
+     *   },
+     * });
+     * ```
+     *
+     * A POST because a Mongo filter is a nested object and encoding one into a
+     * query string is a different argument in every HTTP client. It reads and
+     * changes nothing.
+     *
+     * Operand values are coerced per declared field, so dates and numbers written
+     * as JSON strings match. `$where`, `$function` and `$accumulator` are refused
+     * with `422 filter_operator_not_allowed`, and a filter nested deeper than ten
+     * levels or holding more than 500 keys with `422 filter_too_complex`.
+     *
+     * Scope: `datastore-records:read`.
+     */
+    search(store, collection, input) {
+        return this.http.request('POST', `${recordsPath(store, collection)}/search`, { body: input });
+    }
+    /**
+     * `GET /v1/datastores/:store/collections/:collection/records/:record`
+     *
+     * 404 when there is no such document. Scope: `datastore-records:read`.
+     */
+    get(store, collection, record) {
+        return this.http.request('GET', `${recordsPath(store, collection)}/${(0, paths_1.seg)(record)}`);
+    }
+    /**
+     * `PATCH /v1/datastores/:store/collections/:collection/records/:record`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `record` | object | The fields to change. Validated exactly as an insert. |
+     *
+     * A `$set` of those fields and nothing else -- keys you leave out are
+     * untouched, and `null` clears a value. `updated_on` is stamped; `created_on`
+     * cannot be moved. Returns the record as it is after the write.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    update(store, collection, record, input) {
+        return this.http.request('PATCH', `${recordsPath(store, collection)}/${(0, paths_1.seg)(record)}`, { body: input });
+    }
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records/bulk-update`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `filter` | object | Required and **non-empty**. |
+     * | `update` | object | The fields to set on every match. |
+     *
+     * ```ts
+     * const { matched, modified } = await crm.dataStoreRecords.bulkUpdate(store, collection, {
+     *   filter: { status: 'pending', created_on: { $lt: cutoff } },
+     *   update: { status: 'expired' },
+     * });
+     * ```
+     *
+     * `{}` as the filter is refused: it matches the whole collection, and a
+     * one-character slip that rewrites every record is not something to make
+     * convenient. `modified` is lower than `matched` where a record already held
+     * the values.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    bulkUpdate(store, collection, input) {
+        return this.http.request('POST', `${recordsPath(store, collection)}/bulk-update`, { body: input });
+    }
+    /**
+     * `DELETE /v1/datastores/:store/collections/:collection/records/:record`
+     *
+     * 404 when there is no such document. This one really does delete your data.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    remove(store, collection, record) {
+        return this.http.request('DELETE', `${recordsPath(store, collection)}/${(0, paths_1.seg)(record)}`);
+    }
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records/bulk-delete`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `filter` | object | Required and **non-empty**. |
+     *
+     * Deletes every match, irreversibly, from your database. The empty filter is
+     * refused for the same reason as in `bulkUpdate` -- emptying a collection
+     * deliberately means paging through it.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    bulkRemove(store, collection, input) {
+        return this.http.request('POST', `${recordsPath(store, collection)}/bulk-delete`, { body: input });
+    }
+}
+exports.DataStoreRecords = DataStoreRecords;
+//# sourceMappingURL=data-stores.js.map

package/dist/resources/data-stores.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-stores.js","sourceRoot":"","sources":["../../src/resources/data-stores.ts"],"names":[],"mappings":"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"}

package/dist/resources/paths.d.ts

@@ -8,5 +8,11 @@
  */
 export declare const AUDIENCE = "/v1/audience";
 export declare const CHANNELS = "/v1/channels";
+/**
+ * The data store service, which the gateway proxies at its own path rather than
+ * under another service's prefix -- it is a service of its own, with its own
+ * database and its own deployment.
+ */
+export declare const DATASTORE = "/v1/datastores";
 /** Path segments are escaped: an id from a caller must not be able to add one. */
 export declare const seg: (value: string) => string;

package/dist/resources/paths.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.seg = exports.CHANNELS = exports.AUDIENCE = void 0;
+exports.seg = exports.DATASTORE = exports.CHANNELS = exports.AUDIENCE = void 0;
 /**
  * Where each service sits behind the gateway.
  *
@@ -11,6 +11,12 @@ exports.seg = exports.CHANNELS = exports.AUDIENCE = void 0;
  */
 exports.AUDIENCE = '/v1/audience';
 exports.CHANNELS = '/v1/channels';
+/**
+ * The data store service, which the gateway proxies at its own path rather than
+ * under another service's prefix -- it is a service of its own, with its own
+ * database and its own deployment.
+ */
+exports.DATASTORE = '/v1/datastores';
 /** Path segments are escaped: an id from a caller must not be able to add one. */
 const seg = (value) => encodeURIComponent(String(value));
 exports.seg = seg;

package/dist/resources/paths.js.map

@@ -1 +1 @@
-{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../src/resources/paths.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACU,QAAA,QAAQ,GAAG,cAAc,CAAC;AAC1B,QAAA,QAAQ,GAAG,cAAc,CAAC;AAEvC,kFAAkF;AAC3E,MAAM,GAAG,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAAnE,QAAA,GAAG,OAAgE"}
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../src/resources/paths.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACU,QAAA,QAAQ,GAAG,cAAc,CAAC;AAC1B,QAAA,QAAQ,GAAG,cAAc,CAAC;AAEvC;;;;GAIG;AACU,QAAA,SAAS,GAAG,gBAAgB,CAAC;AAE1C,kFAAkF;AAC3E,MAAM,GAAG,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAAnE,QAAA,GAAG,OAAgE"}