@zenstackhq/server 3.1.0 → 3.2.0

package/dist/api.cjs

@@ -38,17 +38,156 @@ module.exports = __toCommonJS(api_exports);
 
 // src/api/rest/index.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
-var import_orm = require("@zenstackhq/orm");
+var import_orm2 = require("@zenstackhq/orm");
 var import_decimal2 = require("decimal.js");
-var import_superjson2 = __toESM(require("superjson"), 1);
+var import_superjson3 = __toESM(require("superjson"), 1);
 var import_ts_japi = __toESM(require("ts-japi"), 1);
 var import_ts_pattern2 = require("ts-pattern");
 var import_url_pattern = __toESM(require("url-pattern"), 1);
+var import_zod2 = __toESM(require("zod"), 1);
+var import_v42 = require("zod-validation-error/v4");
+
+// src/api/common/procedures.ts
+var import_orm = require("@zenstackhq/orm");
+var PROCEDURE_ROUTE_PREFIXES = "$procs";
+function getProcedureDef(schema, proc) {
+  const procs = schema.procedures ?? {};
+  if (!Object.prototype.hasOwnProperty.call(procs, proc)) {
+    return void 0;
+  }
+  return procs[proc];
+}
+__name(getProcedureDef, "getProcedureDef");
+function mapProcedureArgs(procDef, payload) {
+  const params = Object.values(procDef.params ?? {});
+  if (params.length === 0) {
+    if (typeof payload === "undefined") {
+      return void 0;
+    }
+    if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+      const envelope2 = payload;
+      const argsPayload2 = Object.prototype.hasOwnProperty.call(envelope2, "args") ? envelope2.args : void 0;
+      if (typeof argsPayload2 === "undefined") {
+        return payload;
+      }
+      if (argsPayload2 && typeof argsPayload2 === "object" && !Array.isArray(argsPayload2)) {
+        if (Object.keys(argsPayload2).length === 0) {
+          return payload;
+        }
+      }
+    }
+    throw new Error("procedure does not accept arguments");
+  }
+  if (typeof payload === "undefined" && params.every((p) => p.optional)) {
+    return void 0;
+  }
+  if (typeof payload === "undefined") {
+    throw new Error("missing procedure arguments");
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("procedure payload must be an object");
+  }
+  const envelope = payload;
+  const argsPayload = Object.prototype.hasOwnProperty.call(envelope, "args") ? envelope.args : void 0;
+  if (typeof argsPayload === "undefined") {
+    if (params.every((p) => p.optional)) {
+      return payload;
+    }
+    throw new Error("missing procedure arguments");
+  }
+  if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
+    throw new Error("procedure `args` must be an object");
+  }
+  const obj = argsPayload;
+  for (const key of Object.keys(obj)) {
+    if (!params.some((p) => p.name === key)) {
+      throw new Error(`unknown procedure argument: ${key}`);
+    }
+  }
+  for (const p of params) {
+    if (!Object.prototype.hasOwnProperty.call(obj, p.name)) {
+      if (p.optional) {
+        continue;
+      }
+      throw new Error(`missing procedure argument: ${p.name}`);
+    }
+  }
+  return payload;
+}
+__name(mapProcedureArgs, "mapProcedureArgs");
+
+// src/api/common/schemas.ts
 var import_zod = __toESM(require("zod"), 1);
+var loggerSchema = import_zod.default.union([
+  import_zod.default.enum([
+    "debug",
+    "info",
+    "warn",
+    "error"
+  ]).array(),
+  import_zod.default.function()
+]);
+
+// src/api/common/utils.ts
+var import_superjson = __toESM(require("superjson"), 1);
+async function processSuperJsonRequestPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload) || !("meta" in payload)) {
+    return {
+      result: payload,
+      error: void 0
+    };
+  }
+  const { meta, ...rest } = payload;
+  if (meta?.serialization) {
+    try {
+      return {
+        result: import_superjson.default.deserialize({
+          json: rest,
+          meta: meta.serialization
+        }),
+        error: void 0
+      };
+    } catch (err) {
+      return {
+        result: void 0,
+        error: `failed to deserialize request payload: ${err.message}`
+      };
+    }
+  }
+  return {
+    result: rest,
+    error: void 0
+  };
+}
+__name(processSuperJsonRequestPayload, "processSuperJsonRequestPayload");
+function 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_superjson.default.deserialize({
+        json: parsedValue,
+        meta: parsedMeta.serialization
+      });
+    }
+  }
+  return parsedValue;
+}
+__name(unmarshalQ, "unmarshalQ");
 
 // src/api/utils.ts
 var import_decimal = require("decimal.js");
-var import_superjson = __toESM(require("superjson"), 1);
+var import_superjson2 = __toESM(require("superjson"), 1);
 var import_ts_pattern = require("ts-pattern");
 var import_v3 = require("zod-validation-error/v3");
 var import_v4 = require("zod-validation-error/v4");
@@ -67,13 +206,13 @@ ${error}` : ""}`);
 }
 __name(log, "log");
 function registerCustomSerializers() {
-  import_superjson.default.registerCustom({
+  import_superjson2.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({
+    import_superjson2.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")
@@ -205,55 +344,55 @@ var RestApiHandler = class {
   };
   filterParamPattern = new RegExp(/^filter(?<match>(\[[^[\]]+\])+)$/);
   // zod schema for payload of creating and updating a resource
-  createUpdatePayloadSchema = import_zod.default.object({
-    data: import_zod.default.object({
-      type: import_zod.default.string(),
-      attributes: import_zod.default.object({}).passthrough().optional(),
-      relationships: import_zod.default.record(import_zod.default.string(), import_zod.default.object({
-        data: import_zod.default.union([
-          import_zod.default.object({
-            type: import_zod.default.string(),
-            id: import_zod.default.union([
-              import_zod.default.string(),
-              import_zod.default.number()
+  createUpdatePayloadSchema = import_zod2.default.object({
+    data: import_zod2.default.object({
+      type: import_zod2.default.string(),
+      attributes: import_zod2.default.object({}).passthrough().optional(),
+      relationships: import_zod2.default.record(import_zod2.default.string(), import_zod2.default.object({
+        data: import_zod2.default.union([
+          import_zod2.default.object({
+            type: import_zod2.default.string(),
+            id: import_zod2.default.union([
+              import_zod2.default.string(),
+              import_zod2.default.number()
             ])
           }),
-          import_zod.default.array(import_zod.default.object({
-            type: import_zod.default.string(),
-            id: import_zod.default.union([
-              import_zod.default.string(),
-              import_zod.default.number()
+          import_zod2.default.array(import_zod2.default.object({
+            type: import_zod2.default.string(),
+            id: import_zod2.default.union([
+              import_zod2.default.string(),
+              import_zod2.default.number()
             ])
           }))
         ])
       })).optional()
     }),
-    meta: import_zod.default.object({}).passthrough().optional()
+    meta: import_zod2.default.object({}).passthrough().optional()
   }).strict();
   // zod schema for updating a single relationship
-  updateSingleRelationSchema = import_zod.default.object({
-    data: import_zod.default.object({
-      type: import_zod.default.string(),
-      id: import_zod.default.union([
-        import_zod.default.string(),
-        import_zod.default.number()
+  updateSingleRelationSchema = import_zod2.default.object({
+    data: import_zod2.default.object({
+      type: import_zod2.default.string(),
+      id: import_zod2.default.union([
+        import_zod2.default.string(),
+        import_zod2.default.number()
       ])
     }).nullable()
   });
   // zod schema for updating collection relationship
-  updateCollectionRelationSchema = import_zod.default.object({
-    data: import_zod.default.array(import_zod.default.object({
-      type: import_zod.default.string(),
-      id: import_zod.default.union([
-        import_zod.default.string(),
-        import_zod.default.number()
+  updateCollectionRelationSchema = import_zod2.default.object({
+    data: import_zod2.default.array(import_zod2.default.object({
+      type: import_zod2.default.string(),
+      id: import_zod2.default.union([
+        import_zod2.default.string(),
+        import_zod2.default.number()
       ])
     }))
   });
-  upsertMetaSchema = import_zod.default.object({
-    meta: import_zod.default.object({
-      operation: import_zod.default.literal("upsert"),
-      matchFields: import_zod.default.array(import_zod.default.string()).min(1)
+  upsertMetaSchema = import_zod2.default.object({
+    meta: import_zod2.default.object({
+      operation: import_zod2.default.literal("upsert"),
+      matchFields: import_zod2.default.array(import_zod2.default.string()).min(1)
     })
   });
   // all known types and their metadata
@@ -266,6 +405,7 @@ var RestApiHandler = class {
   externalIdMapping;
   constructor(options) {
     this.options = options;
+    this.validateOptions(options);
     this.idDivider = options.idDivider ?? DEFAULT_ID_DIVIDER;
     const segmentCharset = options.urlSegmentCharset ?? "a-zA-Z0-9-_~ %";
     this.modelNameMapping = options.modelNameMapping ?? {};
@@ -286,6 +426,25 @@ var RestApiHandler = class {
     this.buildTypeMap();
     this.buildSerializers();
   }
+  validateOptions(options) {
+    const schema = import_zod2.default.strictObject({
+      schema: import_zod2.default.object(),
+      log: loggerSchema.optional(),
+      endpoint: import_zod2.default.string().min(1),
+      pageSize: import_zod2.default.union([
+        import_zod2.default.number().int().positive(),
+        import_zod2.default.literal(Infinity)
+      ]).optional(),
+      idDivider: import_zod2.default.string().min(1).optional(),
+      urlSegmentCharset: import_zod2.default.string().min(1).optional(),
+      modelNameMapping: import_zod2.default.record(import_zod2.default.string(), import_zod2.default.string()).optional(),
+      externalIdMapping: import_zod2.default.record(import_zod2.default.string(), import_zod2.default.string()).optional()
+    });
+    const parseResult = schema.safeParse(options);
+    if (!parseResult.success) {
+      throw new Error(`Invalid options: ${(0, import_v42.fromError)(parseResult.error)}`);
+    }
+  }
   get schema() {
     return this.options.schema;
   }
@@ -346,6 +505,16 @@ var RestApiHandler = class {
       path = "/" + path;
     }
     try {
+      if (path.startsWith("/$procs/")) {
+        const proc = path.split("/")[2];
+        return await this.processProcedureRequest({
+          client,
+          method,
+          proc,
+          query,
+          requestBody
+        });
+      }
       switch (method) {
         case "GET": {
           let match4 = this.matchUrlPattern(path, "single");
@@ -419,7 +588,7 @@ var RestApiHandler = class {
     } catch (err) {
       if (err instanceof InvalidValueError) {
         return this.makeError("invalidValue", err.message);
-      } else if (err instanceof import_orm.ORMError) {
+      } else if (err instanceof import_orm2.ORMError) {
         return this.handleORMError(err);
       } else {
         return this.handleGenericError(err);
@@ -430,6 +599,71 @@ var RestApiHandler = class {
     return this.makeError("unknownError", err instanceof Error ? `${err.message}
 ${err.stack}` : "Unknown error");
   }
+  async processProcedureRequest({ client, method, proc, query, requestBody }) {
+    if (!proc) {
+      return this.makeProcBadInputErrorResponse("missing procedure name");
+    }
+    const procDef = getProcedureDef(this.schema, proc);
+    if (!procDef) {
+      return this.makeProcBadInputErrorResponse(`unknown procedure: ${proc}`);
+    }
+    const isMutation = !!procDef.mutation;
+    if (isMutation) {
+      if (method !== "POST") {
+        return this.makeProcBadInputErrorResponse("invalid request method, only POST is supported");
+      }
+    } else {
+      if (method !== "GET") {
+        return this.makeProcBadInputErrorResponse("invalid request method, only GET is supported");
+      }
+    }
+    const argsPayload = method === "POST" ? requestBody : query;
+    const { result: processedArgsPayload, error } = await processSuperJsonRequestPayload(argsPayload);
+    if (error) {
+      return this.makeProcBadInputErrorResponse(error);
+    }
+    let procInput;
+    try {
+      procInput = mapProcedureArgs(procDef, processedArgsPayload);
+    } catch (err) {
+      return this.makeProcBadInputErrorResponse(err instanceof Error ? err.message : "invalid procedure arguments");
+    }
+    try {
+      log(this.log, "debug", () => `handling "$procs.${proc}" request`);
+      const clientResult = await client.$procs?.[proc](procInput);
+      const toSerialize = this.toPlainObject(clientResult);
+      const { json, meta } = import_superjson3.default.serialize(toSerialize);
+      const responseBody = {
+        data: json
+      };
+      if (meta) {
+        responseBody.meta = {
+          serialization: meta
+        };
+      }
+      return {
+        status: 200,
+        body: responseBody
+      };
+    } catch (err) {
+      log(this.log, "error", `error occurred when handling "$procs.${proc}" request`, err);
+      if (err instanceof import_orm2.ORMError) {
+        throw err;
+      }
+      return this.makeProcGenericErrorResponse(err);
+    }
+  }
+  makeProcBadInputErrorResponse(message) {
+    const resp = this.makeError("invalidPayload", message, 400);
+    log(this.log, "debug", () => `sending error response: ${JSON.stringify(resp)}`);
+    return resp;
+  }
+  makeProcGenericErrorResponse(err) {
+    const message = err instanceof Error ? err.message : "unknown error";
+    const resp = this.makeError("unknownError", message, 500);
+    log(this.log, "debug", () => `sending error response: ${JSON.stringify(resp)}`);
+    return resp;
+  }
   async processSingleRead(client, type, resourceId, query) {
     const typeInfo = this.getModelInfo(type);
     if (!typeInfo) {
@@ -751,7 +985,7 @@ ${err.stack}` : "Unknown error");
   processRequestBody(requestBody) {
     let body = requestBody;
     if (body.meta?.serialization) {
-      body = import_superjson2.default.deserialize({
+      body = import_superjson3.default.deserialize({
         json: body,
         meta: body.meta.serialization
       });
@@ -1195,7 +1429,7 @@ ${err.stack}` : "Unknown error");
     this.injectCompoundId(model, itemsWithId);
     const serialized = await serializer.serialize(itemsWithId, options);
     const plainResult = this.toPlainObject(serialized);
-    const { json, meta } = import_superjson2.default.serialize(plainResult);
+    const { json, meta } = import_superjson3.default.serialize(plainResult);
     const result = json;
     if (meta) {
       result.meta = {
@@ -1774,15 +2008,15 @@ ${err.stack}` : "Unknown error");
     }
   }
   handleORMError(err) {
-    return (0, import_ts_pattern2.match)(err.reason).with(import_orm.ORMErrorReason.INVALID_INPUT, () => {
+    return (0, import_ts_pattern2.match)(err.reason).with(import_orm2.ORMErrorReason.INVALID_INPUT, () => {
       return this.makeError("validationError", err.message, 422);
-    }).with(import_orm.ORMErrorReason.REJECTED_BY_POLICY, () => {
+    }).with(import_orm2.ORMErrorReason.REJECTED_BY_POLICY, () => {
       return this.makeError("forbidden", err.message, 403, {
         reason: err.rejectedByPolicyReason
       });
-    }).with(import_orm.ORMErrorReason.NOT_FOUND, () => {
+    }).with(import_orm2.ORMErrorReason.NOT_FOUND, () => {
       return this.makeError("notFound", err.message, 404);
-    }).with(import_orm.ORMErrorReason.DB_QUERY_ERROR, () => {
+    }).with(import_orm2.ORMErrorReason.DB_QUERY_ERROR, () => {
       return this.makeError("queryError", err.message, 400, {
         dbErrorCode: err.dbErrorCode
       });
@@ -1820,9 +2054,11 @@ ${err.stack}` : "Unknown error");
 
 // src/api/rpc/index.ts
 var import_common_helpers2 = require("@zenstackhq/common-helpers");
-var import_orm2 = require("@zenstackhq/orm");
-var import_superjson3 = __toESM(require("superjson"), 1);
+var import_orm3 = require("@zenstackhq/orm");
+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");
 registerCustomSerializers();
 var RPCApiHandler = class {
   static {
@@ -1831,6 +2067,17 @@ var RPCApiHandler = class {
   options;
   constructor(options) {
     this.options = options;
+    this.validateOptions(options);
+  }
+  validateOptions(options) {
+    const schema = import_zod3.default.strictObject({
+      schema: import_zod3.default.object(),
+      log: loggerSchema.optional()
+    });
+    const parseResult = schema.safeParse(options);
+    if (!parseResult.success) {
+      throw new Error(`Invalid options: ${(0, import_v43.fromError)(parseResult.error)}`);
+    }
   }
   get schema() {
     return this.options.schema;
@@ -1845,6 +2092,15 @@ var RPCApiHandler = class {
     if (parts.length !== 0 || !op || !model) {
       return this.makeBadInputErrorResponse("invalid request path");
     }
+    if (model === PROCEDURE_ROUTE_PREFIXES) {
+      return this.handleProcedureRequest({
+        client,
+        method: method.toUpperCase(),
+        proc: op,
+        query,
+        requestBody
+      });
+    }
     model = (0, import_common_helpers2.lowerCaseFirst)(model);
     method = method.toUpperCase();
     let args;
@@ -1869,11 +2125,12 @@ var RPCApiHandler = class {
       case "aggregate":
       case "groupBy":
       case "count":
+      case "exists":
         if (method !== "GET") {
           return this.makeBadInputErrorResponse("invalid request method, only GET is supported");
         }
         try {
-          args = query?.["q"] ? this.unmarshalQ(query["q"], query["meta"]) : {};
+          args = query?.["q"] ? unmarshalQ(query["q"], query["meta"]) : {};
         } catch {
           return this.makeBadInputErrorResponse('invalid "q" query parameter');
         }
@@ -1895,7 +2152,7 @@ var RPCApiHandler = class {
           return this.makeBadInputErrorResponse("invalid request method, only DELETE is supported");
         }
         try {
-          args = query?.["q"] ? this.unmarshalQ(query["q"], query["meta"]) : {};
+          args = query?.["q"] ? unmarshalQ(query["q"], query["meta"]) : {};
         } catch (err) {
           return this.makeBadInputErrorResponse(err instanceof Error ? err.message : 'invalid "q" query parameter');
         }
@@ -1917,7 +2174,7 @@ var RPCApiHandler = class {
         data: clientResult
       };
       if (clientResult) {
-        const { json, meta } = import_superjson3.default.serialize(clientResult);
+        const { json, meta } = import_superjson4.default.serialize(clientResult);
         responseBody = {
           data: json
         };
@@ -1935,13 +2192,75 @@ var RPCApiHandler = class {
       return response;
     } catch (err) {
       log(this.options.log, "error", `error occurred when handling "${model}.${op}" request`, err);
-      if (err instanceof import_orm2.ORMError) {
+      if (err instanceof import_orm3.ORMError) {
         return this.makeORMErrorResponse(err);
       } else {
         return this.makeGenericErrorResponse(err);
       }
     }
   }
+  async handleProcedureRequest({ client, method, proc, query, requestBody }) {
+    if (!proc) {
+      return this.makeBadInputErrorResponse("missing procedure name");
+    }
+    const procDef = getProcedureDef(this.options.schema, proc);
+    if (!procDef) {
+      return this.makeBadInputErrorResponse(`unknown procedure: ${proc}`);
+    }
+    const isMutation = !!procDef.mutation;
+    if (isMutation) {
+      if (method !== "POST") {
+        return this.makeBadInputErrorResponse("invalid request method, only POST is supported");
+      }
+    } else {
+      if (method !== "GET") {
+        return this.makeBadInputErrorResponse("invalid request method, only GET is supported");
+      }
+    }
+    let argsPayload = method === "POST" ? requestBody : void 0;
+    if (method === "GET") {
+      try {
+        argsPayload = query?.["q"] ? unmarshalQ(query["q"], query["meta"]) : void 0;
+      } catch (err) {
+        return this.makeBadInputErrorResponse(err instanceof Error ? err.message : 'invalid "q" query parameter');
+      }
+    }
+    const { result: processedArgsPayload, error } = await processSuperJsonRequestPayload(argsPayload);
+    if (error) {
+      return this.makeBadInputErrorResponse(error);
+    }
+    let procInput;
+    try {
+      procInput = mapProcedureArgs(procDef, processedArgsPayload);
+    } catch (err) {
+      return this.makeBadInputErrorResponse(err instanceof Error ? err.message : "invalid procedure arguments");
+    }
+    try {
+      log(this.options.log, "debug", () => `handling "$procs.${proc}" request`);
+      const clientResult = await client.$procs?.[proc](procInput);
+      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 "$procs.${proc}" request: ${(0, import_common_helpers2.safeJSONStringify)(response)}`);
+      return response;
+    } catch (err) {
+      log(this.options.log, "error", `error occurred when handling "$procs.${proc}" request`, err);
+      if (err instanceof import_orm3.ORMError) {
+        return this.makeORMErrorResponse(err);
+      }
+      return this.makeGenericErrorResponse(err);
+    }
+  }
   isValidModel(client, model) {
     return Object.keys(client.$schema.models).some((m) => (0, import_common_helpers2.lowerCaseFirst)(m) === (0, import_common_helpers2.lowerCaseFirst)(model));
   }
@@ -1975,19 +2294,19 @@ var RPCApiHandler = class {
       message: err.message,
       reason: err.reason
     };
-    (0, import_ts_pattern3.match)(err.reason).with(import_orm2.ORMErrorReason.NOT_FOUND, () => {
+    (0, import_ts_pattern3.match)(err.reason).with(import_orm3.ORMErrorReason.NOT_FOUND, () => {
       status = 404;
       error.model = err.model;
-    }).with(import_orm2.ORMErrorReason.INVALID_INPUT, () => {
+    }).with(import_orm3.ORMErrorReason.INVALID_INPUT, () => {
       status = 422;
       error.rejectedByValidation = true;
       error.model = err.model;
-    }).with(import_orm2.ORMErrorReason.REJECTED_BY_POLICY, () => {
+    }).with(import_orm3.ORMErrorReason.REJECTED_BY_POLICY, () => {
       status = 403;
       error.rejectedByPolicy = true;
-      error.rejectReason = err.rejectedByPolicyReason;
       error.model = err.model;
-    }).with(import_orm2.ORMErrorReason.DB_QUERY_ERROR, () => {
+      error.rejectReason = err.rejectedByPolicyReason;
+    }).with(import_orm3.ORMErrorReason.DB_QUERY_ERROR, () => {
       status = 400;
       error.dbErrorCode = err.dbErrorCode;
     }).otherwise(() => {
@@ -2005,7 +2324,7 @@ var RPCApiHandler = class {
     const { meta, ...rest } = args ?? {};
     if (meta?.serialization) {
       try {
-        args = import_superjson3.default.deserialize({
+        args = import_superjson4.default.deserialize({
           json: rest,
           meta: meta.serialization
         });
@@ -2023,29 +2342,6 @@ var RPCApiHandler = class {
       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_superjson3.default.deserialize({
-          json: parsedValue,
-          meta: parsedMeta.serialization
-        });
-      }
-    }
-    return parsedValue;
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {