@zenstackhq/server 3.4.0-beta.4 → 3.4.1

package/dist/api.cjs

@@ -2072,6 +2072,8 @@ var import_superjson4 = __toESM(require("superjson"), 1);
 var import_ts_pattern3 = require("ts-pattern");
 var import_zod3 = __toESM(require("zod"), 1);
 var import_v43 = require("zod-validation-error/v4");
+var TRANSACTION_ROUTE_PREFIX = "$transaction";
+var VALID_OPS = new Set(import_orm3.CoreCrudOperations);
 registerCustomSerializers();
 var RPCApiHandler = class {
   static {
@@ -2114,6 +2116,14 @@ var RPCApiHandler = class {
         requestBody
       });
     }
+    if (model === TRANSACTION_ROUTE_PREFIX) {
+      return this.handleTransaction({
+        client,
+        method: method.toUpperCase(),
+        type: op,
+        requestBody
+      });
+    }
     model = (0, import_common_helpers2.lowerCaseFirst)(model);
     method = method.toUpperCase();
     let args;
@@ -2212,6 +2222,77 @@ var RPCApiHandler = class {
       }
     }
   }
+  async handleTransaction({ client, method, type, requestBody }) {
+    if (method !== "POST") {
+      return this.makeBadInputErrorResponse("invalid request method, only POST is supported");
+    }
+    if (type !== "sequential") {
+      return this.makeBadInputErrorResponse(`unsupported transaction type: ${type}`);
+    }
+    if (!requestBody || !Array.isArray(requestBody) || requestBody.length === 0) {
+      return this.makeBadInputErrorResponse("request body must be a non-empty array of operations");
+    }
+    const processedOps = [];
+    for (let i = 0; i < requestBody.length; i++) {
+      const item = requestBody[i];
+      if (!item || typeof item !== "object") {
+        return this.makeBadInputErrorResponse(`operation at index ${i} must be an object`);
+      }
+      const { model: itemModel, op: itemOp, args: itemArgs } = item;
+      if (!itemModel || typeof itemModel !== "string") {
+        return this.makeBadInputErrorResponse(`operation at index ${i} is missing a valid "model" field`);
+      }
+      if (!itemOp || typeof itemOp !== "string") {
+        return this.makeBadInputErrorResponse(`operation at index ${i} is missing a valid "op" field`);
+      }
+      if (!VALID_OPS.has(itemOp)) {
+        return this.makeBadInputErrorResponse(`operation at index ${i} has invalid op: ${itemOp}`);
+      }
+      if (!this.isValidModel(client, (0, import_common_helpers2.lowerCaseFirst)(itemModel))) {
+        return this.makeBadInputErrorResponse(`operation at index ${i} has unknown model: ${itemModel}`);
+      }
+      if (itemArgs !== void 0 && itemArgs !== null && (typeof itemArgs !== "object" || Array.isArray(itemArgs))) {
+        return this.makeBadInputErrorResponse(`operation at index ${i} has invalid "args" field`);
+      }
+      const { result: processedArgs, error: argsError } = await this.processRequestPayload(itemArgs ?? {});
+      if (argsError) {
+        return this.makeBadInputErrorResponse(`operation at index ${i}: ${argsError}`);
+      }
+      processedOps.push({
+        model: (0, import_common_helpers2.lowerCaseFirst)(itemModel),
+        op: itemOp,
+        args: processedArgs
+      });
+    }
+    try {
+      const promises = processedOps.map(({ model, op, args }) => {
+        return client[model][op](args);
+      });
+      log(this.options.log, "debug", () => `handling "$transaction" request with ${promises.length} operations`);
+      const clientResult = await client.$transaction(promises);
+      const { json, meta } = import_superjson4.default.serialize(clientResult);
+      const responseBody = {
+        data: json
+      };
+      if (meta) {
+        responseBody.meta = {
+          serialization: meta
+        };
+      }
+      const response = {
+        status: 200,
+        body: responseBody
+      };
+      log(this.options.log, "debug", () => `sending response for "$transaction" request: ${(0, import_common_helpers2.safeJSONStringify)(response)}`);
+      return response;
+    } catch (err) {
+      log(this.options.log, "error", `error occurred when handling "$transaction" request`, err);
+      if (err instanceof import_orm3.ORMError) {
+        return this.makeORMErrorResponse(err);
+      }
+      return this.makeGenericErrorResponse(err);
+    }
+  }
   async handleProcedureRequest({ client, method, proc, query, requestBody }) {
     if (!proc) {
       return this.makeBadInputErrorResponse("missing procedure name");