@zenstackhq/server 3.4.0-beta.4 → 3.4.0

package/dist/api.d.cts

@@ -147,6 +147,7 @@ declare class RPCApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
     get schema(): Schema;
     get log(): LogConfig | undefined;
     handleRequest({ client, method, path, query, requestBody }: RequestContext<Schema>): Promise<Response>;
+    private handleTransaction;
     private handleProcedureRequest;
     private isValidModel;
     private makeBadInputErrorResponse;

package/dist/api.d.ts

@@ -147,6 +147,7 @@ declare class RPCApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
     get schema(): Schema;
     get log(): LogConfig | undefined;
     handleRequest({ client, method, path, query, requestBody }: RequestContext<Schema>): Promise<Response>;
+    private handleTransaction;
     private handleProcedureRequest;
     private isValidModel;
     private makeBadInputErrorResponse;

package/dist/api.js

@@ -2032,11 +2032,13 @@ ${err.stack}` : "Unknown error");
 
 // src/api/rpc/index.ts
 import { lowerCaseFirst as lowerCaseFirst2, safeJSONStringify } from "@zenstackhq/common-helpers";
-import { ORMError as ORMError3, ORMErrorReason as ORMErrorReason2 } from "@zenstackhq/orm";
+import { CoreCrudOperations, ORMError as ORMError3, ORMErrorReason as ORMErrorReason2 } from "@zenstackhq/orm";
 import SuperJSON4 from "superjson";
 import { match as match3 } from "ts-pattern";
 import z3 from "zod";
 import { fromError as fromError2 } from "zod-validation-error/v4";
+var TRANSACTION_ROUTE_PREFIX = "$transaction";
+var VALID_OPS = new Set(CoreCrudOperations);
 registerCustomSerializers();
 var RPCApiHandler = class {
   static {
@@ -2079,6 +2081,14 @@ var RPCApiHandler = class {
         requestBody
       });
     }
+    if (model === TRANSACTION_ROUTE_PREFIX) {
+      return this.handleTransaction({
+        client,
+        method: method.toUpperCase(),
+        type: op,
+        requestBody
+      });
+    }
     model = lowerCaseFirst2(model);
     method = method.toUpperCase();
     let args;
@@ -2177,6 +2187,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, lowerCaseFirst2(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: lowerCaseFirst2(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 } = SuperJSON4.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: ${safeJSONStringify(response)}`);
+      return response;
+    } catch (err) {
+      log(this.options.log, "error", `error occurred when handling "$transaction" request`, err);
+      if (err instanceof ORMError3) {
+        return this.makeORMErrorResponse(err);
+      }
+      return this.makeGenericErrorResponse(err);
+    }
+  }
   async handleProcedureRequest({ client, method, proc, query, requestBody }) {
     if (!proc) {
       return this.makeBadInputErrorResponse("missing procedure name");