mudbase-sdk 1.3.12 → 1.3.13

package/dist/query.js

@@ -0,0 +1,314 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * MUDBASESDK - Fluent query builder
+ *
+ * A Supabase/Appwrite-style chainable query builder layered on top of the generated `DataApi`:
+ *
+ *   const mudbase = new MudbaseQuery({ projectId, configuration });
+ *   const { data } = await mudbase
+ *     .from("posts")
+ *     .select("title", "status")
+ *     .eq("status", "published")
+ *     .eq("authorId.name", "Ada")
+ *     .populate("authorId")
+ *     .sort("-createdAt")
+ *     .limit(10)
+ *     .execute();
+ *
+ * This file is hand-written (not produced by OpenAPI Generator) because
+ * `GET /api/data/projects/{projectId}/collections/{collectionId}/data` accepts several query
+ * params the OpenAPI spec cannot describe as typed fields - most importantly, an unbounded set
+ * of `<relationshipPath>.<field>=value` deep-filter keys (see the backend's
+ * `services/relationshipService.js` `resolveRelationshipFilters` / `resolveRelationshipSortKeys`)
+ * whose *names*, not just their values, are caller-chosen. The generated `DataApi.listData()`'s
+ * typed `ListDataRequest` only covers `page` / `limit` / `sort` / `filter` (confirmed against
+ * `generated/typescript-sdk/src/apis/DataApi.ts` - no `fields`, `populate`, or dotted deep-filter
+ * keys) - this builder is the one place that also emits those dynamic dotted-key query params,
+ * plus `populate` and `fields`.
+ *
+ * It lives in `sdk-extras/typescript/query.ts` in the mudbase-docs repo and is copied into the
+ * generated TypeScript (fetch) SDK's `src/` by `scripts/generate-sdks.js`, then re-exported from
+ * the package entrypoint. Edit it here, never in `generated/`.
+ *
+ * Imports are pre-pointed at the fetch flavor's `./runtime` (`Configuration` + `BASE_PATH`), so
+ * it resolves against exactly what ships to npm - same convention as `realtime.ts`/`webPush.ts`
+ * in this directory. Auth and the HTTP call are hand-assembled with the platform `fetch` (not
+ * `runtime.BaseAPI.request`), matching `webPush.ts`'s style, since this one endpoint's query
+ * shape is what the generated request-builder can't fully express; everything else (bearer/API
+ * key resolution, base path fallback) mirrors the generated `Configuration`'s own semantics
+ * exactly, so it behaves identically to every generated `*Api` call.
+ *
+ * DESIGN NOTES (this is the reference implementation later per-language typed codegen is meant
+ * to follow - see the PR description for the same rationale in one place):
+ *
+ * 1. `.eq(field, value)` routes on whether `field` contains a "." - exactly the same rule the
+ *    backend route itself uses (`routes/data.js`'s `RESERVED_LIST_QUERY_KEYS` set plus "any
+ *    other dotted query key is a relationship-filter candidate"). A plain field name
+ *    (`"status"`) is merged into the JSON `filter` object; a dotted field name
+ *    (`"authorId.name"`) becomes its own top-level query-string key. The SDK does not validate
+ *    that a dotted `.eq()` path names a real declared relationship - the server already treats
+ *    an unrecognized one as a no-op filter key (silently ignored, not an error), so client-side
+ *    validation would require an extra round trip to fetch the project's relationship graph for
+ *    no real safety benefit.
+ * 2. `.sort(...fields)` is intentionally a thin pass-through: each argument is a plain sort
+ *    token exactly as the backend's `?sort=` parses it (`-` prefix for descending, dotted paths
+ *    resolve through a declared relationship server-side per `resolveRelationshipSortKeys`).
+ *    Calling `.sort()` more than once appends further sort keys (matching the common
+ *    `.order().order()` compound-sort idiom other query builders use); calling it again for a
+ *    field already present replaces that field's position and direction with the new call
+ *    rather than duplicating it.
+ * 3. `.populate(...keys)` accepts the same dotted nested-key syntax `?populate=` already accepts
+ *    (e.g. `"comments.authorId"`) - this builder does not attempt to model the relationship
+ *    graph client-side, it only accumulates and de-duplicates the requested keys.
+ * 4. There is no `.gt()`/`.lt()`/`.in()` etc. in this first pass - only `.eq()`, matching the
+ *    task's requested surface. A future pass can extend `filter` with Mongo-style operator
+ *    objects (`{ $gt: value }`) the same `querySanitizer.sanitizeFilter` on the backend already
+ *    accepts; `.eq()`'s plain-field branch already writes into that same `filter` object, so
+ *    adding e.g. `.gt(field, value)` later only needs to merge `{ [field]: { $gt: value } }`
+ *    into it - no shape change to this builder's query-compilation contract.
+ * 5. `toQueryParams()` is a pure function (no network, no auth) so the query-compilation logic
+ *    is unit-testable on its own, independent of `execute()`'s HTTP/auth plumbing.
+ * 6. Auth resolution deliberately checks both a bearer token and an API key (like `webPush.ts`
+ *    does), rather than only one - the backend's `GET .../data` route accepts
+ *    `OrgBearerAuth` / `ProjectBearerAuth` / `ApiKeyAuth` (see its own doc comment in
+ *    `DataApi.ts`), so a caller configured with only an `apiKey` must still get an authenticated
+ *    request out of this builder.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MudbaseQueryBuilder = exports.MudbaseQuery = void 0;
+const runtime_1 = require("./runtime");
+/**
+ * Entry point: `new MudbaseQuery({ projectId, configuration }).from("posts")...`.
+ * Construct one per project (or reuse the same `Configuration` your other SDK calls use).
+ */
+class MudbaseQuery {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        if (!options || !options.projectId) {
+            throw new Error("MudbaseQuery: `projectId` is required");
+        }
+        this.projectId = options.projectId;
+        this.configuration = options.configuration;
+        this.tokenSource = options.token;
+        this.apiKeyValue = options.apiKey;
+        this.basePath = ((_c = (_a = options.basePath) !== null && _a !== void 0 ? _a : (_b = options.configuration) === null || _b === void 0 ? void 0 : _b.basePath) !== null && _c !== void 0 ? _c : runtime_1.BASE_PATH).replace(/\/+$/, "");
+        const f = (_d = options.fetchImpl) !== null && _d !== void 0 ? _d : (typeof fetch !== "undefined" ? fetch : undefined);
+        if (!f) {
+            throw new Error("MudbaseQuery: no `fetch` available - pass `fetchImpl`");
+        }
+        this.fetchImpl = f;
+    }
+    /** Start a query against `collectionSlug` (the collection's `slug`, not its Mongo `_id`). */
+    from(collectionSlug) {
+        return new MudbaseQueryBuilder(this.projectId, collectionSlug, this.basePath, this.tokenSource, this.apiKeyValue, this.configuration, this.fetchImpl);
+    }
+}
+exports.MudbaseQuery = MudbaseQuery;
+class MudbaseQueryBuilder {
+    constructor(projectId, collectionSlug, basePath, tokenSource, apiKeyValue, configuration, fetchImpl) {
+        this.projectId = projectId;
+        this.collectionSlug = collectionSlug;
+        this.basePath = basePath;
+        this.tokenSource = tokenSource;
+        this.apiKeyValue = apiKeyValue;
+        this.configuration = configuration;
+        this.fetchImpl = fetchImpl;
+        this.plainFilter = {};
+        this.dottedFilter = {};
+        this.selectFields = [];
+        this.populateKeys = [];
+        // Ordered by field name (leading "-" stripped) so a repeated `.sort()` call on the same field
+        // replaces its earlier entry instead of duplicating it - see design note 2 above.
+        this.sortFields = new Map();
+    }
+    /** `?fields=a,b,c` - whitelist-project which fields come back. */
+    select(...fields) {
+        for (const field of fields)
+            if (field && this.selectFields.indexOf(field) === -1)
+                this.selectFields.push(field);
+        return this;
+    }
+    /**
+     * Equality filter. A dotted `field` (e.g. `"authorId.name"`) becomes its own deep/relationship
+     * top-level query key; a plain field name is merged into the `filter` JSON object. See design
+     * note 1 above for why the routing rule is exactly "does the name contain a dot," matching the
+     * server's own `RESERVED_LIST_QUERY_KEYS` + dotted-key convention.
+     */
+    eq(field, value) {
+        if (field.includes(".")) {
+            this.dottedFilter[field] = value;
+        }
+        else {
+            this.plainFilter[field] = value;
+        }
+        return this;
+    }
+    /**
+     * `?populate=authorId,comments` (or a dotted nested key like `"comments.authorId"`) - joins a
+     * declared relationship (or legacy reference field) onto each returned document.
+     */
+    populate(...keys) {
+        for (const key of keys)
+            if (key && this.populateKeys.indexOf(key) === -1)
+                this.populateKeys.push(key);
+        return this;
+    }
+    /**
+     * `?sort=-createdAt,title` - accepts the same tokens the backend's `?sort=` parses, including
+     * a dotted relationship-field sort (e.g. `"authorId.name"`, `"-authorId.name"`). See design
+     * note 2 above for the append/replace-by-field semantics across repeated calls.
+     */
+    sort(...fields) {
+        for (const field of fields) {
+            if (!field)
+                continue;
+            const base = field.startsWith("-") ? field.slice(1) : field;
+            this.sortFields.delete(base);
+            this.sortFields.set(base, field);
+        }
+        return this;
+    }
+    /** Page size (server clamps to a max; see the API docs for the current bound). */
+    limit(n) {
+        this.limitValue = n;
+        return this;
+    }
+    /** 1-based page number. */
+    page(n) {
+        this.pageValue = n;
+        return this;
+    }
+    /**
+     * Compile the chain into the query-string params `GET .../data` accepts. Pure and
+     * network-free - the same params `execute()` sends, exposed separately so the
+     * query-compilation logic is directly unit-testable.
+     */
+    toQueryParams() {
+        const params = {};
+        if (this.pageValue !== undefined)
+            params.page = this.pageValue;
+        if (this.limitValue !== undefined)
+            params.limit = this.limitValue;
+        if (this.sortFields.size > 0)
+            params.sort = [...this.sortFields.values()].join(",");
+        if (Object.keys(this.plainFilter).length > 0)
+            params.filter = JSON.stringify(this.plainFilter);
+        if (this.selectFields.length > 0)
+            params.fields = this.selectFields.join(",");
+        if (this.populateKeys.length > 0)
+            params.populate = this.populateKeys.join(",");
+        for (const key of Object.keys(this.dottedFilter)) {
+            params[key] = this.dottedFilter[key];
+        }
+        return params;
+    }
+    /**
+     * Run the query. Resolves to the same shape the generated `DataApi.listData()` resolves to -
+     * `{ data: [...], pagination: {...} }`. Auth (bearer token or API key) and base-path fallback
+     * mirror the generated `Configuration`'s own resolution exactly (see design note 6 above); only
+     * the query-string shape is hand-assembled, since it is the one part the generated client
+     * cannot fully express.
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.basePath}/api/data/projects/${encodeURIComponent(this.projectId)}/collections/${encodeURIComponent(this.collectionSlug)}/data`;
+            const search = new URLSearchParams();
+            const compiled = this.toQueryParams();
+            for (const key of Object.keys(compiled)) {
+                const value = compiled[key];
+                if (value !== undefined)
+                    search.set(key, String(value));
+            }
+            const queryString = search.toString();
+            const res = yield this.fetchImpl(queryString ? `${url}?${queryString}` : url, {
+                method: "GET",
+                headers: yield this.authHeaders(),
+            });
+            const body = yield this.parseJson(res);
+            if (!res.ok) {
+                throw new Error(this.errorMessage(body, `Mudbase query failed (${res.status})`));
+            }
+            return body;
+        });
+    }
+    /** Alias for `.execute()` - reads better at a call site than the more literal name. */
+    get() {
+        return this.execute();
+    }
+    // --- internal helpers ------------------------------------------------------------
+    authHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = { Accept: "application/json" };
+            const token = yield this.resolveToken();
+            if (token) {
+                headers.Authorization = `Bearer ${token}`;
+            }
+            const apiKey = yield this.resolveApiKey();
+            if (apiKey) {
+                headers["X-API-Key"] = apiKey;
+            }
+            return headers;
+        });
+    }
+    resolveToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const src = this.tokenSource;
+            if (typeof src === "string")
+                return src;
+            if (typeof src === "function")
+                return yield src();
+            const at = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.accessToken;
+            if (typeof at === "string")
+                return at;
+            if (typeof at === "function")
+                return yield at();
+            return undefined;
+        });
+    }
+    resolveApiKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.apiKeyValue)
+                return this.apiKeyValue;
+            const ak = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.apiKey;
+            if (typeof ak === "string")
+                return ak;
+            if (typeof ak === "function")
+                return yield ak("X-API-Key");
+            return undefined;
+        });
+    }
+    parseJson(res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const text = yield res.text();
+            if (!text)
+                return {};
+            try {
+                return JSON.parse(text);
+            }
+            catch (_a) {
+                return { error: text };
+            }
+        });
+    }
+    errorMessage(body, fallback) {
+        if (body && typeof body.error === "string" && body.error)
+            return body.error;
+        if (body && typeof body.message === "string" && body.message)
+            return body.message;
+        return fallback;
+    }
+}
+exports.MudbaseQueryBuilder = MudbaseQueryBuilder;

package/dist/runtime.d.ts

@@ -2,7 +2,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/runtime.js

@@ -5,7 +5,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/docs/MultiRoleFeatureApi.md

@@ -577,7 +577,7 @@ async function example() {
     // string
     projectId: projectId_example,
     // SimulateAppPermissionsRequest
-    simulateAppPermissionsRequest: {"role":"customer","method":"POST","pathname":"/api/messaging/projects/685ad30be129932fbb7a1047/messaging/email"},
+    simulateAppPermissionsRequest: {"role":"customer","method":"POST","pathname":"/api/messaging/projects/65f1a2b3c4d5e6f7a8b9c0d1/messaging/email"},
   } satisfies SimulateAppPermissionsOperationRequest;
 
   try {

package/docs/OrgDomainEntryWithDns.md

@@ -1,7 +1,7 @@
 
 # OrgDomainEntryWithDns
 
-Full allowed-domain row (admin and legacy): includes **`dnsTxtHost`** / **`dnsTxtValue`**, optional edge SSL hints (`edge`), staff-published step-3 TXT (`platformDnsVerification` on the manual path), and unified **`dnsRecords`** when the API builds a checklist. **`routingCnameTarget`** mirrors Fly **`dns_requirements.cname`** when ACME has provisioned, else env fallback. Internal edge custom-hostname state is not returned; use `edge`. Fly ACME requires **`CUSTOM_DOMAIN_FLY_ACME_ENABLED`** plus **`FLY_API_TOKEN`** and app slug; edge SSL (SSL-for-SaaS) and Fly ACME cannot both be enabled on the same deployment. Org-facing routes return the compact **`OrgDomainEntryOrgConsole`** shape instead (no raw `verificationToken` or duplicate TXT keys).
+Full allowed-domain row (admin and legacy): includes **`dnsTxtHost`** / **`dnsTxtValue`**, optional managed edge TLS hints, staff-published step-3 TXT (`platformDnsVerification` on the manual path), and unified **`dnsRecords`** when the API builds a checklist. **`routingCnameTarget`** is the managed routing CNAME target when the certificate has provisioned, else the platform default. Org-facing routes return the compact **`OrgDomainEntryOrgConsole`** shape instead (no raw `verificationToken` or duplicate TXT keys).
 
 ## Properties
 

package/docs/OrgEdgeHints.md

@@ -1,7 +1,7 @@
 
 # OrgEdgeHints
 
-Edge SSL (SSL-for-SaaS) custom hostname hints returned after Mudbase verification (when the edge SSL integration is configured)
+Managed edge TLS custom-hostname hints returned after Mudbase verification (when the edge TLS integration is configured)
 
 ## Properties
 

package/docs/OrgPlatformDnsVerificationCustomer.md

@@ -1,7 +1,7 @@
 
 # OrgPlatformDnsVerificationCustomer
 
-Additional DNS record from platform staff (non-Fly path), or first Fly TXT shim when Fly ACME is enabled. Prefer `dnsRecords` for full instructions. `staffNote` may appear in admin org detail only.
+Additional DNS record from platform staff (manual path), or the first certificate-provisioning TXT shim when automated provisioning is enabled. Prefer `dnsRecords` for full instructions. `staffNote` may appear in admin org detail only.
 
 ## Properties
 

package/docs/OrganizationsApi.md

@@ -28,7 +28,7 @@ All URIs are relative to *https://cloud.mudbase.dev*
 | [**orgCustomDomainPlatformReady**](OrganizationsApi.md#orgcustomdomainplatformreadyoperation) | **POST** /api/orgs/{orgId}/projects/{projectId}/domains/{hostname}/platform-ready | Notify platform ops that hosting or edge work is ready (email) |
 | [**orgCustomDomainSubmitCname**](OrganizationsApi.md#orgcustomdomainsubmitcname) | **POST** /api/orgs/{orgId}/projects/{projectId}/domains/{hostname}/submit-cname | Custom domain step 2 (optional): org confirms routing CNAME was added |
 | [**orgCustomDomainSubmitPlatformDnsVerificationDeprecated**](OrganizationsApi.md#orgcustomdomainsubmitplatformdnsverificationdeprecated) | **POST** /api/orgs/{orgId}/projects/{projectId}/domains/{hostname}/submit-platform-dns-verification | Deprecated — use POST .../verify-platform-dns |
-| [**orgCustomDomainVerifyPlatformDns**](OrganizationsApi.md#orgcustomdomainverifyplatformdns) | **POST** /api/orgs/{orgId}/projects/{projectId}/domains/{hostname}/verify-platform-dns | Custom domain step 3: verify platform DNS (manual TXT or Fly certificate readiness) |
+| [**orgCustomDomainVerifyPlatformDns**](OrganizationsApi.md#orgcustomdomainverifyplatformdns) | **POST** /api/orgs/{orgId}/projects/{projectId}/domains/{hostname}/verify-platform-dns | Custom domain step 3: verify platform DNS (manual TXT or managed certificate readiness) |
 | [**patchOrgCustomDomain**](OrganizationsApi.md#patchorgcustomdomain) | **PATCH** /api/orgs/{orgId}/projects/{projectId}/domains/{hostname} | Update domain status or regenerate verification token |
 | [**removeSubOrganizationMember**](OrganizationsApi.md#removesuborganizationmember) | **DELETE** /api/orgs/{orgId}/suborgs/{suborgId}/members/{userId} | ~~Remove member from sub-organization~~ (deprecated) |
 | [**removeTeamMember**](OrganizationsApi.md#removeteammember) | **DELETE** /api/orgs/{orgId}/members/{userId} | Remove team member from organization |
@@ -49,7 +49,7 @@ All URIs are relative to *https://cloud.mudbase.dev*
 
 Add a custom domain
 
-Creates a pending domain row; the response **`domain`** uses the compact **`OrgDomainEntryOrgConsole`** shape (**`dnsRecords`** includes the Mudbase ownership TXT). **`dnsRecords`** may include Mudbase TXT and routing CNAME only until Mudbase TXT succeeds and Fly ACME (if enabled) provisions a certificate. **`flyCertificateStatus`** is typically omitted until Fly ACME runs after first successful **`verify-dns`**. 
+Creates a pending domain row; the response **`domain`** uses the compact **`OrgDomainEntryOrgConsole`** shape (**`dnsRecords`** includes the Mudbase ownership TXT). **`dnsRecords`** may include the Mudbase TXT and routing CNAME only until the Mudbase TXT succeeds and the managed certificate is provisioned. **`flyCertificateStatus`** is typically omitted until certificate provisioning runs after the first successful **`verify-dns`**. 
 
 ### Example
 
@@ -421,7 +421,7 @@ example().catch(console.error);
 
 Get DNS TXT record instructions for one hostname
 
-Returns the same shape as list/add for one hostname (URL-encode `hostname` in the path), including **`dnsRecords`** and **`flyCertificateStatus`** when applicable. See **`listOrgCustomDomains`** for how Fly ACME and Cloudflare SaaS affect those fields. 
+Returns the same shape as list/add for one hostname (URL-encode `hostname` in the path), including **`dnsRecords`** and **`flyCertificateStatus`** when applicable. See **`listOrgCustomDomains`** for how managed certificate provisioning affects those fields. 
 
 ### Example
 
@@ -1088,7 +1088,7 @@ example().catch(console.error);
 
 Custom domain background sweep status (internal)
 
-Returns the last automated custom-domain sweep (TXT recheck + Fly ACME retry), job env flags, and Fly deploy troubleshooting hints when the proxy reports the app is not listening on 0.0.0.0:PORT. Requires header `X-Internal-Api-Key` (same as other /internal routes).
+Returns the last automated custom-domain sweep (TXT recheck + certificate provisioning retry), job env flags, and deploy troubleshooting hints when the proxy reports the app is not listening on 0.0.0.0:PORT. Requires header `X-Internal-Api-Key` (same as other /internal routes).
 
 ### Example
 
@@ -1446,7 +1446,7 @@ example().catch(console.error);
 
 List custom domains and DNS verification hints
 
-Returns allowed hostnames for **this project**, primary hostname (per project), API base URL, and per-domain DNS guidance.  Each row uses **`dnsRecords`** for the Mudbase ownership TXT (purpose **`mudbase_ownership`**) and routing **CNAME** from Fly **`dns_requirements.cname`** when Fly ACME has provisioned (else fallback **`CUSTOM_DOMAIN_API_CNAME_TARGET`**), and—when Fly ACME is enabled (**`FLY_API_TOKEN`** + **`CUSTOM_DOMAIN_FLY_ACME_ENABLED`**)—Fly rows (`fly_ownership`, `acme_challenge`, etc.) after the org has passed Mudbase TXT at least once. **`flyCertificateStatus`** mirrors Fly’s certificate state when ACME automation is on (e.g. `pending_validation`, `active`).  **`edge`** appears only when edge SSL (SSL-for-SaaS) is configured. Fly ACME and edge SSL are mutually exclusive on the server.  Requires Growth, Scale, or Enterprise plan (custom domains included in plan features). 
+Returns allowed hostnames for **this project**, primary hostname (per project), API base URL, and per-domain DNS guidance.  Each row uses **`dnsRecords`** for the Mudbase ownership TXT (purpose **`mudbase_ownership`**) and the routing **CNAME** target that Mudbase provisions for the hostname (else the platform default target). Once the ownership TXT has passed at least once, Mudbase provisions and manages the TLS certificate for the hostname automatically and may add further checklist rows (for example `acme_challenge`) needed to complete certificate issuance. The certificate status field mirrors the managed certificate’s state during issuance (e.g. `pending_validation`, `active`).  Managed edge TLS details are present only on deployments that serve managed edge certificates.  Requires Growth, Scale, or Enterprise plan (custom domains included in plan features). 
 
 ### Example
 
@@ -1669,7 +1669,7 @@ example().catch(console.error);
 
 Custom domain step 2 (optional): org confirms routing CNAME was added
 
-Usually unnecessary. With Fly ACME default automation, Mudbase TXT verify may already set `cname_approved`. Legacy pipelines may queue `cname_pending_staff` until staff **`approve-cname`**. Use **`routingCnameTarget`** from **`GET .../projects/{projectId}/domains`** (Fly **`dns_requirements.cname`** when provisioned, else **`CUSTOM_DOMAIN_API_CNAME_TARGET`**). 
+Usually unnecessary. With automated certificate provisioning, the Mudbase TXT verify may already set `cname_approved`. Legacy pipelines may queue `cname_pending_staff` until staff **`approve-cname`**. Use **`routingCnameTarget`** from **`GET .../projects/{projectId}/domains`** (the managed routing CNAME target when provisioned, else the platform default target). 
 
 ### Example
 
@@ -1749,7 +1749,7 @@ example().catch(console.error);
 
 Deprecated — use POST .../verify-platform-dns
 
-Deprecated alias of **`orgCustomDomainVerifyPlatformDns`** (same behavior — manual TXT and/or Fly ACME path per server config).
+Deprecated alias of **`orgCustomDomainVerifyPlatformDns`** (same behavior: manual TXT and/or automated certificate provisioning per deployment).
 
 ### Example
 
@@ -1826,9 +1826,9 @@ example().catch(console.error);
 
 > OrgPatchDomainResponse orgCustomDomainVerifyPlatformDns(orgId, projectId, hostname)
 
-Custom domain step 3: verify platform DNS (manual TXT or Fly certificate readiness)
+Custom domain step 3: verify platform DNS (manual TXT or managed certificate readiness)
 
-**Manual path (no Fly ACME):** After staff **`PATCH .../platform-dns-verification`**, the org adds the published TXT and calls this endpoint. The API resolves public TXT at **`platformDnsVerification.recordName`** and matches **`recordValue`**. On success, `status` → **`platform_dns_pending_review`** until staff **`POST .../activate`**.  **Fly ACME path (default):** When Fly ACME is enabled and **`CUSTOM_DOMAIN_FLY_LEGACY_STAFF_PIPELINE`** is **not** set, the org calls this after Mudbase TXT and Fly DNS rows are in place (status typically **`cname_approved`** from automated verify-dns). The API triggers Fly **`POST .../check`** and **`GET`** certificate with bounded retries. On success, `status` → **`active`** and the org may receive the activation email—**no** staff **`approve-cname`** or **`activate`** required.  **Fly legacy:** If **`CUSTOM_DOMAIN_FLY_LEGACY_STAFF_PIPELINE=true`**, behavior matches the older flow: staff **`approve-cname`** may be required first; after a ready Fly cert, **`status`** becomes **`active`** only when **`CUSTOM_DOMAIN_FLY_AUTO_ACTIVATE=true`**, else **`platform_dns_pending_review`** until staff **`activate`**.  **`platform_dns_verification_failed`** may include **`details.flyStatus`** / **`details.flyError`** on the Fly path. 
+**Manual path:** After staff **`PATCH .../platform-dns-verification`**, the org adds the published TXT and calls this endpoint. The API resolves public TXT at **`platformDnsVerification.recordName`** and matches **`recordValue`**. On success, `status` → **`platform_dns_pending_review`** until staff **`POST .../activate`**.  **Automated path (default):** When automated certificate provisioning is in effect, the org calls this after the Mudbase TXT and the certificate DNS rows are in place (status typically **`cname_approved`** from automated verify-dns). The API checks the managed certificate with bounded retries. On success, `status` → **`active`** and the org may receive the activation email, with no staff **`approve-cname`** or **`activate`** required.  **Legacy path:** In the legacy staff pipeline, staff **`approve-cname`** may be required first; after the managed certificate is ready, **`status`** becomes **`active`** on auto-activation, else **`platform_dns_pending_review`** until staff **`activate`**.  **`platform_dns_verification_failed`** may include **`details.flyStatus`** / **`details.flyError`** with provisioning error context. 
 
 ### Example
 
@@ -1894,8 +1894,8 @@ example().catch(console.error);
 ### HTTP response details
 | Status code | Description | Response headers |
 |-------------|-------------|------------------|
-| **200** | Domain row updated (`OrgPatchDomainResponse.domain`). Manual TXT path typically sets `platform_dns_pending_review`. Fly ACME default automation: typically `active` when the certificate is ready. Fly legacy staff pipeline: may set `platform_dns_pending_review` unless `CUSTOM_DOMAIN_FLY_AUTO_ACTIVATE` is enabled. Body may include refreshed `dnsRecords` and `flyCertificateStatus` on the Fly path. |  -  |
-| **400** | custom_domain_invalid_state, platform_dns_verification_failed (manual TXT mismatch or Fly cert not active yet; see response details on Fly path) |  -  |
+| **200** | Domain row updated (`OrgPatchDomainResponse.domain`). Manual TXT path typically sets `platform_dns_pending_review`. Automated provisioning: typically `active` when the certificate is ready. Legacy staff pipeline: may set `platform_dns_pending_review` unless auto-activation is enabled. Body may include refreshed `dnsRecords` and `flyCertificateStatus` when certificate provisioning ran. |  -  |
+| **400** | custom_domain_invalid_state, platform_dns_verification_failed (manual TXT mismatch or managed certificate not active yet; see response details) |  -  |
 | **401** | Unauthorized |  -  |
 | **403** | Forbidden |  -  |
 | **503** | dns_lookup_error |  -  |
@@ -2680,7 +2680,7 @@ example().catch(console.error);
 
 Verify domain ownership via DNS TXT
 
-Looks up TXT at `_mudbase-verify.<hostname>` for value `mudbase-domain-verification=<token>`.  When the server has **`CLOUDFLARE_API_TOKEN`** and **`CLOUDFLARE_ZONE_ID`** configured (and Fly ACME is **not** enabled), a successful verify also creates or refreshes a Cloudflare Custom Hostname (SSL for SaaS) and returns **`cloudflare`** with DCV hints.  When **Fly ACME** is enabled (**`FLY_API_TOKEN`** + **`CUSTOM_DOMAIN_FLY_ACME_ENABLED=true`** + app slug), a successful verify calls Fly’s Certificates API (`POST .../certificates/acme`) and persists DNS requirements. If Fly returns DNS rows and **`CUSTOM_DOMAIN_FLY_LEGACY_STAFF_PIPELINE`** is **not** set, status advances to **`cname_approved`** in the same response (no staff **`approve-cname`**); **`org.domain.cname_staff_queued`** is not logged for that path. Otherwise (legacy Fly or non-Fly), first success from `pending`/`failed` may move to **`cname_pending_staff`** and queue staff as before.  The **200** response may include **`dnsRecords`**, **`flyCertificateStatus`**, and **`routingCnameTarget`** from Fly’s **`dns_requirements.cname`** when provisioned.  Cloudflare SaaS and Fly ACME cannot both be enabled; the API process refuses to start if both are configured. 
+Looks up TXT at `_mudbase-verify.<hostname>` for value `mudbase-domain-verification=<token>`.  On a successful verify, Mudbase begins provisioning and managing the TLS certificate for the hostname automatically. Depending on the deployment, the response may include managed edge TLS details with domain-control validation (DCV) hints for the certificate.  When automated certificate provisioning is in effect, a successful verify records the certificate’s DNS requirements and status may advance to **`cname_approved`** in the same response (no staff **`approve-cname`** step). Otherwise, first success from `pending`/`failed` may move to **`cname_pending_staff`** and queue platform review as before.  The **200** response may include **`dnsRecords`**, certificate status, and **`routingCnameTarget`** for the managed certificate once its requirements are provisioned. 
 
 ### Example
 
@@ -2746,7 +2746,7 @@ example().catch(console.error);
 ### HTTP response details
 | Status code | Description | Response headers |
 |-------------|-------------|------------------|
-| **200** | TXT verified. Fly ACME (default automation): often `cname_approved` when Fly returns DNS requirements; legacy Fly or non-Fly may show `cname_pending_staff` or `dns_verified`. Includes `dnsTxtHost`/`dnsTxtValue`, optional `cloudflare` (Cloudflare SaaS), optional `dnsRecords` + `flyCertificateStatus` when Fly ACME ran after this verify. |  -  |
+| **200** | TXT verified. With automated certificate provisioning, often `cname_approved` once DNS requirements are returned; otherwise may show `cname_pending_staff` or `dns_verified`. Includes `dnsTxtHost`/`dnsTxtValue`, optional managed edge TLS details, optional `dnsRecords` + certificate status when provisioning ran after this verify. |  -  |
 | **400** | dns_verification_failed (TXT missing or wrong); body includes dnsTxtHost, dnsTxtValue, challengeHost, expectedTxt |  -  |
 | **503** | dns_lookup_error |  -  |
 

package/docs/SimulateAppPermissionsRequest.md

@@ -24,7 +24,7 @@ const example = {
   "roleSlug": null,
   "operationId": sendEmail,
   "method": POST,
-  "pathname": /api/messaging/projects/685ad30be129932fbb7a1047/messaging/email,
+  "pathname": /api/messaging/projects/65f1a2b3c4d5e6f7a8b9c0d1/messaging/email,
   "path": null,
 } satisfies SimulateAppPermissionsRequest
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mudbase-sdk",
-  "version": "1.3.12",
+  "version": "1.3.13",
   "description": "Official TypeScript/JavaScript client for the MUDBASE API.",
   "author": "MUDBASE <support@mudbase.dev>",
   "repository": {

package/src/apis/APIKeysApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/AddOnsApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/AuthenticationApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/BackupsApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/BillingApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/BucketsApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/ChatApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/apis/CollectionsApi.ts

@@ -4,7 +4,7 @@
  * MUDBASESDK
  * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`. 
  *
- * The version of the OpenAPI document: 1.3.12
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).