@objectstack/rest 9.8.0 → 9.9.0

package/dist/index.d.cts

@@ -451,11 +451,13 @@ declare class RestServer {
     private registerCrudEndpoints;
     /**
      * Register object-specific action endpoints that don't fit the
-     * generic CRUD shape. These are domain operations (Salesforce
-     * convertLead, etc.) where the protocol implementation does its own
-     * multi-record orchestration and we just need a thin HTTP route.
+     * generic CRUD shape — domain operations where the protocol does its
+     * own orchestration and we just need a thin HTTP route.
      *
-     * POST {basePath}/data/lead/:id/convert — M10.6 lead conversion.
+     * POST {basePath}/data/:object/:id/clone — record clone (gated by
+     * `enable.clone`). This is object-agnostic by design: it works for any
+     * authored object regardless of namespace, unlike a hardcoded
+     * per-object route would.
      */
     private registerDataActionEndpoints;
     /**

package/dist/index.d.ts

@@ -451,11 +451,13 @@ declare class RestServer {
     private registerCrudEndpoints;
     /**
      * Register object-specific action endpoints that don't fit the
-     * generic CRUD shape. These are domain operations (Salesforce
-     * convertLead, etc.) where the protocol implementation does its own
-     * multi-record orchestration and we just need a thin HTTP route.
+     * generic CRUD shape — domain operations where the protocol does its
+     * own orchestration and we just need a thin HTTP route.
      *
-     * POST {basePath}/data/lead/:id/convert — M10.6 lead conversion.
+     * POST {basePath}/data/:object/:id/clone — record clone (gated by
+     * `enable.clone`). This is object-agnostic by design: it works for any
+     * authored object regardless of namespace, unlike a hardcoded
+     * per-object route would.
      */
     private registerDataActionEndpoints;
     /**

package/dist/index.js

@@ -218,6 +218,18 @@ function isMetaEnvelope(value) {
   return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.name === "string" && value.item != null && typeof value.item === "object" && !Array.isArray(value.item);
 }
 function mapDataError(error, object) {
+  if (error?.code === "DELETE_RESTRICTED") {
+    return {
+      status: 409,
+      body: {
+        error: error?.message ?? "Cannot delete: dependent records exist",
+        code: "DELETE_RESTRICTED",
+        ...error?.dependentObject ? { dependentObject: error.dependentObject } : {},
+        ...typeof error?.dependentCount === "number" ? { dependentCount: error.dependentCount } : {},
+        ...object ? { object } : {}
+      }
+    };
+  }
   if (error?.code === "CONCURRENT_UPDATE" || error?.name === "ConcurrentUpdateError") {
     return {
       status: 409,
@@ -2326,51 +2338,18 @@ var RestServer = class {
   }
   /**
    * Register object-specific action endpoints that don't fit the
-   * generic CRUD shape. These are domain operations (Salesforce
-   * convertLead, etc.) where the protocol implementation does its own
-   * multi-record orchestration and we just need a thin HTTP route.
+   * generic CRUD shape — domain operations where the protocol does its
+   * own orchestration and we just need a thin HTTP route.
    *
-   * POST {basePath}/data/lead/:id/convert — M10.6 lead conversion.
+   * POST {basePath}/data/:object/:id/clone — record clone (gated by
+   * `enable.clone`). This is object-agnostic by design: it works for any
+   * authored object regardless of namespace, unlike a hardcoded
+   * per-object route would.
    */
   registerDataActionEndpoints(basePath) {
     const isScoped = basePath.includes("/environments/:environmentId");
     const { crud } = this.config;
     const dataPath = `${basePath}${crud.dataPrefix}`;
-    this.routeManager.register({
-      method: "POST",
-      path: `${dataPath}/lead/:id/convert`,
-      handler: async (req, res) => {
-        try {
-          const environmentId = isScoped ? req.params?.environmentId : void 0;
-          const p = await this.resolveProtocol(environmentId, req);
-          const context = await this.resolveExecCtx(environmentId, req);
-          if (this.enforceAuth(req, res, context)) return;
-          const convertLead = p.convertLead;
-          if (typeof convertLead !== "function") {
-            res.status(501).json({ code: "NOT_IMPLEMENTED", error: "Lead convert not supported by this protocol" });
-            return;
-          }
-          const body = req.body ?? {};
-          const result = await convertLead.call(p, {
-            leadId: req.params.id,
-            accountId: body.accountId,
-            contactId: body.contactId,
-            createOpportunity: body.createOpportunity,
-            opportunity: body.opportunity,
-            convertedStatus: body.convertedStatus,
-            ...context ? { context } : {}
-          });
-          res.json(result);
-        } catch (error) {
-          logError("[REST] Unhandled error:", error);
-          sendError(res, error, "lead");
-        }
-      },
-      metadata: {
-        summary: "Convert a Lead into Account + Contact (+ optional Opportunity)",
-        tags: ["data", "lead"]
-      }
-    });
     this.routeManager.register({
       method: "POST",
       path: `${dataPath}/:object/:id/clone`,
@@ -2804,6 +2783,9 @@ var RestServer = class {
             }
           }
         }
+        if (view.viewKind === "form" && view.config && typeof view.config === "object" && view.config.sharing) {
+          candidates.push({ form: view.config, key: view.name });
+        }
         for (const c of candidates) {
           const sharing = c.form?.sharing;
           if (!sharing || sharing.allowAnonymous !== true) continue;