@zenstackhq/server 2.20.0 → 3.0.0-beta.12

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022-2025 ZenStack
+Copyright (c) 2025 ZenStack
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/api.cjs

@@ -0,0 +1,299 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  RPCApiHandler: () => RPCApiHandler
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/api/rpc/index.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_runtime2 = require("@zenstackhq/runtime");
+var import_superjson2 = __toESM(require("superjson"), 1);
+
+// src/api/utils.ts
+var import_decimal = require("decimal.js");
+var import_superjson = __toESM(require("superjson"), 1);
+var import_ts_pattern = require("ts-pattern");
+function log(logger, level, message, error) {
+  if (!logger) {
+    return;
+  }
+  const getMessage = typeof message === "function" ? message : () => message;
+  if (typeof logger === "function") {
+    logger(level, getMessage(), error);
+  } else if (logger.includes(level)) {
+    const logFn = (0, import_ts_pattern.match)(level).with("debug", () => console.debug).with("info", () => console.info).with("warn", () => console.warn).with("error", () => console.error).exhaustive();
+    logFn(`@zenstackhq/server: [${level}] ${getMessage()}${error ? `
+${error}` : ""}`);
+  }
+}
+__name(log, "log");
+function registerCustomSerializers() {
+  import_superjson.default.registerCustom({
+    isApplicable: /* @__PURE__ */ __name((v) => import_decimal.Decimal.isDecimal(v), "isApplicable"),
+    serialize: /* @__PURE__ */ __name((v) => v.toJSON(), "serialize"),
+    deserialize: /* @__PURE__ */ __name((v) => new import_decimal.Decimal(v), "deserialize")
+  }, "Decimal");
+  if (globalThis.Buffer) {
+    import_superjson.default.registerCustom({
+      isApplicable: /* @__PURE__ */ __name((v) => Buffer.isBuffer(v), "isApplicable"),
+      serialize: /* @__PURE__ */ __name((v) => v.toString("base64"), "serialize"),
+      deserialize: /* @__PURE__ */ __name((v) => Buffer.from(v, "base64"), "deserialize")
+    }, "Bytes");
+  }
+}
+__name(registerCustomSerializers, "registerCustomSerializers");
+
+// src/api/rpc/index.ts
+registerCustomSerializers();
+var RPCApiHandler = class {
+  static {
+    __name(this, "RPCApiHandler");
+  }
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get schema() {
+    return this.options.schema;
+  }
+  async handleRequest({ client, method, path, query, requestBody }) {
+    const parts = path.split("/").filter((p) => !!p);
+    const op = parts.pop();
+    let model = parts.pop();
+    if (parts.length !== 0 || !op || !model) {
+      return this.makeBadInputErrorResponse("invalid request path");
+    }
+    model = (0, import_common_helpers.lowerCaseFirst)(model);
+    method = method.toUpperCase();
+    let args;
+    let resCode = 200;
+    switch (op) {
+      case "create":
+      case "createMany":
+      case "createManyAndReturn":
+      case "upsert":
+        if (method !== "POST") {
+          return this.makeBadInputErrorResponse("invalid request method, only POST is supported");
+        }
+        if (!requestBody) {
+          return this.makeBadInputErrorResponse("missing request body");
+        }
+        args = requestBody;
+        resCode = 201;
+        break;
+      case "findFirst":
+      case "findUnique":
+      case "findMany":
+      case "aggregate":
+      case "groupBy":
+      case "count":
+        if (method !== "GET") {
+          return this.makeBadInputErrorResponse("invalid request method, only GET is supported");
+        }
+        try {
+          args = query?.["q"] ? this.unmarshalQ(query["q"], query["meta"]) : {};
+        } catch {
+          return this.makeBadInputErrorResponse('invalid "q" query parameter');
+        }
+        break;
+      case "update":
+      case "updateMany":
+      case "updateManyAndReturn":
+        if (method !== "PUT" && method !== "PATCH") {
+          return this.makeBadInputErrorResponse("invalid request method, only PUT or PATCH are supported");
+        }
+        if (!requestBody) {
+          return this.makeBadInputErrorResponse("missing request body");
+        }
+        args = requestBody;
+        break;
+      case "delete":
+      case "deleteMany":
+        if (method !== "DELETE") {
+          return this.makeBadInputErrorResponse("invalid request method, only DELETE is supported");
+        }
+        try {
+          args = query?.["q"] ? this.unmarshalQ(query["q"], query["meta"]) : {};
+        } catch (err) {
+          return this.makeBadInputErrorResponse(err instanceof Error ? err.message : 'invalid "q" query parameter');
+        }
+        break;
+      default:
+        return this.makeBadInputErrorResponse("invalid operation: " + op);
+    }
+    const { result: processedArgs, error } = await this.processRequestPayload(args);
+    if (error) {
+      return this.makeBadInputErrorResponse(error);
+    }
+    try {
+      if (!this.isValidModel(client, model)) {
+        return this.makeBadInputErrorResponse(`unknown model name: ${model}`);
+      }
+      log(this.options.log, "debug", () => `handling "${model}.${op}" request with args: ${(0, import_common_helpers.safeJSONStringify)(processedArgs)}`);
+      const clientResult = await client[model][op](processedArgs);
+      let responseBody = {
+        data: clientResult
+      };
+      if (clientResult) {
+        const { json, meta } = import_superjson2.default.serialize(clientResult);
+        responseBody = {
+          data: json
+        };
+        if (meta) {
+          responseBody.meta = {
+            serialization: meta
+          };
+        }
+      }
+      const response = {
+        status: resCode,
+        body: responseBody
+      };
+      log(this.options.log, "debug", () => `sending response for "${model}.${op}" request: ${(0, import_common_helpers.safeJSONStringify)(response)}`);
+      return response;
+    } catch (err) {
+      log(this.options.log, "error", `error occurred when handling "${model}.${op}" request`, err);
+      if (err instanceof import_runtime2.ZenStackError) {
+        return this.makeZenStackErrorResponse(err);
+      } else {
+        return this.makeGenericErrorResponse(err);
+      }
+    }
+  }
+  isValidModel(client, model) {
+    return Object.keys(client.$schema.models).some((m) => (0, import_common_helpers.lowerCaseFirst)(m) === (0, import_common_helpers.lowerCaseFirst)(model));
+  }
+  makeBadInputErrorResponse(message) {
+    const resp = {
+      status: 400,
+      body: {
+        error: {
+          message
+        }
+      }
+    };
+    log(this.options.log, "debug", () => `sending error response: ${(0, import_common_helpers.safeJSONStringify)(resp)}`);
+    return resp;
+  }
+  makeGenericErrorResponse(err) {
+    const resp = {
+      status: 500,
+      body: {
+        error: {
+          message: err.message || "unknown error"
+        }
+      }
+    };
+    log(this.options.log, "debug", () => `sending error response: ${(0, import_common_helpers.safeJSONStringify)(resp)}`);
+    return resp;
+  }
+  makeZenStackErrorResponse(err) {
+    let status = 400;
+    const error = {
+      message: err.message
+    };
+    if (err.cause && err.cause instanceof Error) {
+      error.cause = err.cause.message;
+    }
+    if (err instanceof import_runtime2.NotFoundError) {
+      status = 404;
+      error.model = err.model;
+    } else if (err instanceof import_runtime2.InputValidationError) {
+      status = 422;
+      error.rejectedByValidation = true;
+      error.model = err.model;
+    } else if (err instanceof import_runtime2.RejectedByPolicyError) {
+      status = 403;
+      error.rejectedByPolicy = true;
+      error.rejectReason = err.reason;
+      error.model = err.model;
+    }
+    const resp = {
+      status,
+      body: {
+        error
+      }
+    };
+    log(this.options.log, "debug", () => `sending error response: ${(0, import_common_helpers.safeJSONStringify)(resp)}`);
+    return resp;
+  }
+  async processRequestPayload(args) {
+    const { meta, ...rest } = args;
+    if (meta?.serialization) {
+      try {
+        args = import_superjson2.default.deserialize({
+          json: rest,
+          meta: meta.serialization
+        });
+      } catch (err) {
+        return {
+          result: void 0,
+          error: `failed to deserialize request payload: ${err.message}`
+        };
+      }
+    }
+    return {
+      result: args,
+      error: void 0
+    };
+  }
+  unmarshalQ(value, meta) {
+    let parsedValue;
+    try {
+      parsedValue = JSON.parse(value);
+    } catch {
+      throw new Error('invalid "q" query parameter');
+    }
+    if (meta) {
+      let parsedMeta;
+      try {
+        parsedMeta = JSON.parse(meta);
+      } catch {
+        throw new Error('invalid "meta" query parameter');
+      }
+      if (parsedMeta.serialization) {
+        return import_superjson2.default.deserialize({
+          json: parsedValue,
+          meta: parsedMeta.serialization
+        });
+      }
+    }
+    return parsedValue;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RPCApiHandler
+});
+//# sourceMappingURL=api.cjs.map

package/dist/api.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api/index.ts","../src/api/rpc/index.ts","../src/api/utils.ts"],"sourcesContent":["export { RPCApiHandler } from './rpc';\n","import { lowerCaseFirst, safeJSONStringify } from '@zenstackhq/common-helpers';\nimport {\n    InputValidationError,\n    NotFoundError,\n    RejectedByPolicyError,\n    ZenStackError,\n    type ClientContract,\n} from '@zenstackhq/runtime';\nimport type { SchemaDef } from '@zenstackhq/runtime/schema';\nimport SuperJSON from 'superjson';\nimport type { ApiHandler, LogConfig, RequestContext, Response } from '../../types';\nimport { log, registerCustomSerializers } from '../utils';\n\nregisterCustomSerializers();\n\n/**\n * Options for {@link RPCApiHandler}\n */\nexport type RPCApiHandlerOptions<Schema extends SchemaDef> = {\n    schema: Schema;\n    log?: LogConfig;\n};\n\n/**\n * RPC style API request handler that mirrors the ZenStackClient API\n */\nexport class RPCApiHandler<Schema extends SchemaDef> implements ApiHandler<Schema> {\n    constructor(private readonly options: RPCApiHandlerOptions<Schema>) {}\n\n    get schema(): Schema {\n        return this.options.schema;\n    }\n\n    async handleRequest({ client, method, path, query, requestBody }: RequestContext<Schema>): Promise<Response> {\n        const parts = path.split('/').filter((p) => !!p);\n        const op = parts.pop();\n        let model = parts.pop();\n\n        if (parts.length !== 0 || !op || !model) {\n            return this.makeBadInputErrorResponse('invalid request path');\n        }\n\n        model = lowerCaseFirst(model);\n        method = method.toUpperCase();\n        let args: unknown;\n        let resCode = 200;\n\n        switch (op) {\n            case 'create':\n            case 'createMany':\n            case 'createManyAndReturn':\n            case 'upsert':\n                if (method !== 'POST') {\n                    return this.makeBadInputErrorResponse('invalid request method, only POST is supported');\n                }\n                if (!requestBody) {\n                    return this.makeBadInputErrorResponse('missing request body');\n                }\n\n                args = requestBody;\n                resCode = 201;\n                break;\n\n            case 'findFirst':\n            case 'findUnique':\n            case 'findMany':\n            case 'aggregate':\n            case 'groupBy':\n            case 'count':\n                if (method !== 'GET') {\n                    return this.makeBadInputErrorResponse('invalid request method, only GET is supported');\n                }\n                try {\n                    args = query?.['q']\n                        ? this.unmarshalQ(query['q'] as string, query['meta'] as string | undefined)\n                        : {};\n                } catch {\n                    return this.makeBadInputErrorResponse('invalid \"q\" query parameter');\n                }\n                break;\n\n            case 'update':\n            case 'updateMany':\n            case 'updateManyAndReturn':\n                if (method !== 'PUT' && method !== 'PATCH') {\n                    return this.makeBadInputErrorResponse('invalid request method, only PUT or PATCH are supported');\n                }\n                if (!requestBody) {\n                    return this.makeBadInputErrorResponse('missing request body');\n                }\n\n                args = requestBody;\n                break;\n\n            case 'delete':\n            case 'deleteMany':\n                if (method !== 'DELETE') {\n                    return this.makeBadInputErrorResponse('invalid request method, only DELETE is supported');\n                }\n                try {\n                    args = query?.['q']\n                        ? this.unmarshalQ(query['q'] as string, query['meta'] as string | undefined)\n                        : {};\n                } catch (err) {\n                    return this.makeBadInputErrorResponse(\n                        err instanceof Error ? err.message : 'invalid \"q\" query parameter',\n                    );\n                }\n                break;\n\n            default:\n                return this.makeBadInputErrorResponse('invalid operation: ' + op);\n        }\n\n        const { result: processedArgs, error } = await this.processRequestPayload(args);\n        if (error) {\n            return this.makeBadInputErrorResponse(error);\n        }\n\n        try {\n            if (!this.isValidModel(client, model)) {\n                return this.makeBadInputErrorResponse(`unknown model name: ${model}`);\n            }\n\n            log(\n                this.options.log,\n                'debug',\n                () => `handling \"${model}.${op}\" request with args: ${safeJSONStringify(processedArgs)}`,\n            );\n\n            const clientResult = await (client as any)[model][op](processedArgs);\n            let responseBody: any = { data: clientResult };\n\n            // superjson serialize response\n            if (clientResult) {\n                const { json, meta } = SuperJSON.serialize(clientResult);\n                responseBody = { data: json };\n                if (meta) {\n                    responseBody.meta = { serialization: meta };\n                }\n            }\n\n            const response = { status: resCode, body: responseBody };\n            log(\n                this.options.log,\n                'debug',\n                () => `sending response for \"${model}.${op}\" request: ${safeJSONStringify(response)}`,\n            );\n            return response;\n        } catch (err) {\n            log(this.options.log, 'error', `error occurred when handling \"${model}.${op}\" request`, err);\n            if (err instanceof ZenStackError) {\n                return this.makeZenStackErrorResponse(err);\n            } else {\n                return this.makeGenericErrorResponse(err);\n            }\n        }\n    }\n\n    private isValidModel(client: ClientContract<Schema>, model: string) {\n        return Object.keys(client.$schema.models).some((m) => lowerCaseFirst(m) === lowerCaseFirst(model));\n    }\n\n    private makeBadInputErrorResponse(message: string) {\n        const resp = {\n            status: 400,\n            body: { error: { message } },\n        };\n        log(this.options.log, 'debug', () => `sending error response: ${safeJSONStringify(resp)}`);\n        return resp;\n    }\n\n    private makeGenericErrorResponse(err: unknown) {\n        const resp = {\n            status: 500,\n            body: { error: { message: (err as Error).message || 'unknown error' } },\n        };\n        log(this.options.log, 'debug', () => `sending error response: ${safeJSONStringify(resp)}`);\n        return resp;\n    }\n\n    private makeZenStackErrorResponse(err: ZenStackError) {\n        let status = 400;\n        const error: any = { message: err.message };\n        if (err.cause && err.cause instanceof Error) {\n            error.cause = err.cause.message;\n        }\n\n        if (err instanceof NotFoundError) {\n            status = 404;\n            error.model = err.model;\n        } else if (err instanceof InputValidationError) {\n            status = 422;\n            error.rejectedByValidation = true;\n            error.model = err.model;\n        } else if (err instanceof RejectedByPolicyError) {\n            status = 403;\n            error.rejectedByPolicy = true;\n            error.rejectReason = err.reason;\n            error.model = err.model;\n        }\n\n        const resp = { status, body: { error } };\n        log(this.options.log, 'debug', () => `sending error response: ${safeJSONStringify(resp)}`);\n        return resp;\n    }\n\n    private async processRequestPayload(args: any) {\n        const { meta, ...rest } = args;\n        if (meta?.serialization) {\n            try {\n                // superjson deserialization\n                args = SuperJSON.deserialize({ json: rest, meta: meta.serialization });\n            } catch (err) {\n                return { result: undefined, error: `failed to deserialize request payload: ${(err as Error).message}` };\n            }\n        }\n        return { result: args, error: undefined };\n    }\n\n    private unmarshalQ(value: string, meta: string | undefined) {\n        let parsedValue: any;\n        try {\n            parsedValue = JSON.parse(value);\n        } catch {\n            throw new Error('invalid \"q\" query parameter');\n        }\n\n        if (meta) {\n            let parsedMeta: any;\n            try {\n                parsedMeta = JSON.parse(meta);\n            } catch {\n                throw new Error('invalid \"meta\" query parameter');\n            }\n\n            if (parsedMeta.serialization) {\n                return SuperJSON.deserialize({ json: parsedValue, meta: parsedMeta.serialization });\n            }\n        }\n\n        return parsedValue;\n    }\n}\n","import { Decimal } from 'decimal.js';\nimport SuperJSON from 'superjson';\nimport { match } from 'ts-pattern';\nimport type { LogConfig, LogLevel } from '../types';\n\nexport function log(logger: LogConfig | undefined, level: LogLevel, message: string | (() => string), error?: unknown) {\n    if (!logger) {\n        return;\n    }\n\n    const getMessage = typeof message === 'function' ? message : () => message;\n\n    if (typeof logger === 'function') {\n        logger(level, getMessage(), error);\n    } else if (logger.includes(level)) {\n        const logFn = match(level)\n            .with('debug', () => console.debug)\n            .with('info', () => console.info)\n            .with('warn', () => console.warn)\n            .with('error', () => console.error)\n            .exhaustive();\n        logFn(`@zenstackhq/server: [${level}] ${getMessage()}${error ? `\\n${error}` : ''}`);\n    }\n}\n\n/**\n * Registers custom superjson serializers.\n */\nexport function registerCustomSerializers() {\n    SuperJSON.registerCustom<Decimal, string>(\n        {\n            isApplicable: (v): v is Decimal => Decimal.isDecimal(v),\n            serialize: (v) => v.toJSON(),\n            deserialize: (v) => new Decimal(v),\n        },\n        'Decimal',\n    );\n\n    // `Buffer` is not available in edge runtime\n    if (globalThis.Buffer) {\n        SuperJSON.registerCustom<Buffer, string>(\n            {\n                isApplicable: (v): v is Buffer => Buffer.isBuffer(v),\n                serialize: (v) => v.toString('base64'),\n                deserialize: (v) => Buffer.from(v, 'base64'),\n            },\n            'Bytes',\n        );\n    }\n}\n"],"mappings":"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","names":["import_runtime","import_superjson","log","logger","level","message","error","getMessage","includes","logFn","match","with","console","debug","info","warn","exhaustive","registerCustomSerializers","SuperJSON","registerCustom","isApplicable","v","Decimal","isDecimal","serialize","toJSON","deserialize","globalThis","Buffer","isBuffer","toString","from","registerCustomSerializers","RPCApiHandler","options","schema","handleRequest","client","method","path","query","requestBody","parts","split","filter","p","op","pop","model","length","makeBadInputErrorResponse","lowerCaseFirst","toUpperCase","args","resCode","unmarshalQ","err","Error","message","result","processedArgs","error","processRequestPayload","isValidModel","log","safeJSONStringify","clientResult","responseBody","data","json","meta","SuperJSON","serialize","serialization","response","status","body","ZenStackError","makeZenStackErrorResponse","makeGenericErrorResponse","Object","keys","$schema","models","some","m","resp","cause","NotFoundError","InputValidationError","rejectedByValidation","RejectedByPolicyError","rejectedByPolicy","rejectReason","reason","rest","deserialize","undefined","value","parsedValue","JSON","parse","parsedMeta"]}

package/dist/api.d.cts

@@ -0,0 +1,28 @@
+import { SchemaDef } from '@zenstackhq/runtime/schema';
+import { A as ApiHandler, L as LogConfig, R as RequestContext, a as Response } from './types-BH-88xJo.cjs';
+import '@zenstackhq/runtime';
+
+/**
+ * Options for {@link RPCApiHandler}
+ */
+type RPCApiHandlerOptions<Schema extends SchemaDef> = {
+    schema: Schema;
+    log?: LogConfig;
+};
+/**
+ * RPC style API request handler that mirrors the ZenStackClient API
+ */
+declare class RPCApiHandler<Schema extends SchemaDef> implements ApiHandler<Schema> {
+    private readonly options;
+    constructor(options: RPCApiHandlerOptions<Schema>);
+    get schema(): Schema;
+    handleRequest({ client, method, path, query, requestBody }: RequestContext<Schema>): Promise<Response>;
+    private isValidModel;
+    private makeBadInputErrorResponse;
+    private makeGenericErrorResponse;
+    private makeZenStackErrorResponse;
+    private processRequestPayload;
+    private unmarshalQ;
+}
+
+export { RPCApiHandler };

package/dist/api.d.ts

@@ -0,0 +1,28 @@
+import { SchemaDef } from '@zenstackhq/runtime/schema';
+import { A as ApiHandler, L as LogConfig, R as RequestContext, a as Response } from './types-BH-88xJo.js';
+import '@zenstackhq/runtime';
+
+/**
+ * Options for {@link RPCApiHandler}
+ */
+type RPCApiHandlerOptions<Schema extends SchemaDef> = {
+    schema: Schema;
+    log?: LogConfig;
+};
+/**
+ * RPC style API request handler that mirrors the ZenStackClient API
+ */
+declare class RPCApiHandler<Schema extends SchemaDef> implements ApiHandler<Schema> {
+    private readonly options;
+    constructor(options: RPCApiHandlerOptions<Schema>);
+    get schema(): Schema;
+    handleRequest({ client, method, path, query, requestBody }: RequestContext<Schema>): Promise<Response>;
+    private isValidModel;
+    private makeBadInputErrorResponse;
+    private makeGenericErrorResponse;
+    private makeZenStackErrorResponse;
+    private processRequestPayload;
+    private unmarshalQ;
+}
+
+export { RPCApiHandler };

package/dist/api.js

@@ -0,0 +1,264 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/api/rpc/index.ts
+import { lowerCaseFirst, safeJSONStringify } from "@zenstackhq/common-helpers";
+import { InputValidationError, NotFoundError, RejectedByPolicyError, ZenStackError } from "@zenstackhq/runtime";
+import SuperJSON2 from "superjson";
+
+// src/api/utils.ts
+import { Decimal } from "decimal.js";
+import SuperJSON from "superjson";
+import { match } from "ts-pattern";
+function log(logger, level, message, error) {
+  if (!logger) {
+    return;
+  }
+  const getMessage = typeof message === "function" ? message : () => message;
+  if (typeof logger === "function") {
+    logger(level, getMessage(), error);
+  } else if (logger.includes(level)) {
+    const logFn = match(level).with("debug", () => console.debug).with("info", () => console.info).with("warn", () => console.warn).with("error", () => console.error).exhaustive();
+    logFn(`@zenstackhq/server: [${level}] ${getMessage()}${error ? `
+${error}` : ""}`);
+  }
+}
+__name(log, "log");
+function registerCustomSerializers() {
+  SuperJSON.registerCustom({
+    isApplicable: /* @__PURE__ */ __name((v) => Decimal.isDecimal(v), "isApplicable"),
+    serialize: /* @__PURE__ */ __name((v) => v.toJSON(), "serialize"),
+    deserialize: /* @__PURE__ */ __name((v) => new Decimal(v), "deserialize")
+  }, "Decimal");
+  if (globalThis.Buffer) {
+    SuperJSON.registerCustom({
+      isApplicable: /* @__PURE__ */ __name((v) => Buffer.isBuffer(v), "isApplicable"),
+      serialize: /* @__PURE__ */ __name((v) => v.toString("base64"), "serialize"),
+      deserialize: /* @__PURE__ */ __name((v) => Buffer.from(v, "base64"), "deserialize")
+    }, "Bytes");
+  }
+}
+__name(registerCustomSerializers, "registerCustomSerializers");
+
+// src/api/rpc/index.ts
+registerCustomSerializers();
+var RPCApiHandler = class {
+  static {
+    __name(this, "RPCApiHandler");
+  }
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get schema() {
+    return this.options.schema;
+  }
+  async handleRequest({ client, method, path, query, requestBody }) {
+    const parts = path.split("/").filter((p) => !!p);
+    const op = parts.pop();
+    let model = parts.pop();
+    if (parts.length !== 0 || !op || !model) {
+      return this.makeBadInputErrorResponse("invalid request path");
+    }
+    model = lowerCaseFirst(model);
+    method = method.toUpperCase();
+    let args;
+    let resCode = 200;
+    switch (op) {
+      case "create":
+      case "createMany":
+      case "createManyAndReturn":
+      case "upsert":
+        if (method !== "POST") {
+          return this.makeBadInputErrorResponse("invalid request method, only POST is supported");
+        }
+        if (!requestBody) {
+          return this.makeBadInputErrorResponse("missing request body");
+        }
+        args = requestBody;
+        resCode = 201;
+        break;
+      case "findFirst":
+      case "findUnique":
+      case "findMany":
+      case "aggregate":
+      case "groupBy":
+      case "count":
+        if (method !== "GET") {
+          return this.makeBadInputErrorResponse("invalid request method, only GET is supported");
+        }
+        try {
+          args = query?.["q"] ? this.unmarshalQ(query["q"], query["meta"]) : {};
+        } catch {
+          return this.makeBadInputErrorResponse('invalid "q" query parameter');
+        }
+        break;
+      case "update":
+      case "updateMany":
+      case "updateManyAndReturn":
+        if (method !== "PUT" && method !== "PATCH") {
+          return this.makeBadInputErrorResponse("invalid request method, only PUT or PATCH are supported");
+        }
+        if (!requestBody) {
+          return this.makeBadInputErrorResponse("missing request body");
+        }
+        args = requestBody;
+        break;
+      case "delete":
+      case "deleteMany":
+        if (method !== "DELETE") {
+          return this.makeBadInputErrorResponse("invalid request method, only DELETE is supported");
+        }
+        try {
+          args = query?.["q"] ? this.unmarshalQ(query["q"], query["meta"]) : {};
+        } catch (err) {
+          return this.makeBadInputErrorResponse(err instanceof Error ? err.message : 'invalid "q" query parameter');
+        }
+        break;
+      default:
+        return this.makeBadInputErrorResponse("invalid operation: " + op);
+    }
+    const { result: processedArgs, error } = await this.processRequestPayload(args);
+    if (error) {
+      return this.makeBadInputErrorResponse(error);
+    }
+    try {
+      if (!this.isValidModel(client, model)) {
+        return this.makeBadInputErrorResponse(`unknown model name: ${model}`);
+      }
+      log(this.options.log, "debug", () => `handling "${model}.${op}" request with args: ${safeJSONStringify(processedArgs)}`);
+      const clientResult = await client[model][op](processedArgs);
+      let responseBody = {
+        data: clientResult
+      };
+      if (clientResult) {
+        const { json, meta } = SuperJSON2.serialize(clientResult);
+        responseBody = {
+          data: json
+        };
+        if (meta) {
+          responseBody.meta = {
+            serialization: meta
+          };
+        }
+      }
+      const response = {
+        status: resCode,
+        body: responseBody
+      };
+      log(this.options.log, "debug", () => `sending response for "${model}.${op}" request: ${safeJSONStringify(response)}`);
+      return response;
+    } catch (err) {
+      log(this.options.log, "error", `error occurred when handling "${model}.${op}" request`, err);
+      if (err instanceof ZenStackError) {
+        return this.makeZenStackErrorResponse(err);
+      } else {
+        return this.makeGenericErrorResponse(err);
+      }
+    }
+  }
+  isValidModel(client, model) {
+    return Object.keys(client.$schema.models).some((m) => lowerCaseFirst(m) === lowerCaseFirst(model));
+  }
+  makeBadInputErrorResponse(message) {
+    const resp = {
+      status: 400,
+      body: {
+        error: {
+          message
+        }
+      }
+    };
+    log(this.options.log, "debug", () => `sending error response: ${safeJSONStringify(resp)}`);
+    return resp;
+  }
+  makeGenericErrorResponse(err) {
+    const resp = {
+      status: 500,
+      body: {
+        error: {
+          message: err.message || "unknown error"
+        }
+      }
+    };
+    log(this.options.log, "debug", () => `sending error response: ${safeJSONStringify(resp)}`);
+    return resp;
+  }
+  makeZenStackErrorResponse(err) {
+    let status = 400;
+    const error = {
+      message: err.message
+    };
+    if (err.cause && err.cause instanceof Error) {
+      error.cause = err.cause.message;
+    }
+    if (err instanceof NotFoundError) {
+      status = 404;
+      error.model = err.model;
+    } else if (err instanceof InputValidationError) {
+      status = 422;
+      error.rejectedByValidation = true;
+      error.model = err.model;
+    } else if (err instanceof RejectedByPolicyError) {
+      status = 403;
+      error.rejectedByPolicy = true;
+      error.rejectReason = err.reason;
+      error.model = err.model;
+    }
+    const resp = {
+      status,
+      body: {
+        error
+      }
+    };
+    log(this.options.log, "debug", () => `sending error response: ${safeJSONStringify(resp)}`);
+    return resp;
+  }
+  async processRequestPayload(args) {
+    const { meta, ...rest } = args;
+    if (meta?.serialization) {
+      try {
+        args = SuperJSON2.deserialize({
+          json: rest,
+          meta: meta.serialization
+        });
+      } catch (err) {
+        return {
+          result: void 0,
+          error: `failed to deserialize request payload: ${err.message}`
+        };
+      }
+    }
+    return {
+      result: args,
+      error: void 0
+    };
+  }
+  unmarshalQ(value, meta) {
+    let parsedValue;
+    try {
+      parsedValue = JSON.parse(value);
+    } catch {
+      throw new Error('invalid "q" query parameter');
+    }
+    if (meta) {
+      let parsedMeta;
+      try {
+        parsedMeta = JSON.parse(meta);
+      } catch {
+        throw new Error('invalid "meta" query parameter');
+      }
+      if (parsedMeta.serialization) {
+        return SuperJSON2.deserialize({
+          json: parsedValue,
+          meta: parsedMeta.serialization
+        });
+      }
+    }
+    return parsedValue;
+  }
+};
+export {
+  RPCApiHandler
+};
+//# sourceMappingURL=api.js.map