@zenstackhq/server 3.0.0-beta.12 → 3.0.0-beta.14

package/dist/api.js

@@ -1,15 +1,21 @@
 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";
+// src/api/rest/index.ts
+import { clone, enumerate, lowerCaseFirst, paramCase } from "@zenstackhq/common-helpers";
+import { InputValidationError, NotFoundError, QueryError, RejectedByPolicyError, ZenStackError } from "@zenstackhq/orm";
+import { Decimal as Decimal2 } from "decimal.js";
 import SuperJSON2 from "superjson";
+import { Linker, Paginator, Relator, Serializer } from "ts-japi";
+import UrlPattern from "url-pattern";
+import z from "zod";
 
 // src/api/utils.ts
 import { Decimal } from "decimal.js";
 import SuperJSON from "superjson";
 import { match } from "ts-pattern";
+import { fromError as fromError3 } from "zod-validation-error/v3";
+import { fromError as fromError4 } from "zod-validation-error/v4";
 function log(logger, level, message, error) {
   if (!logger) {
     return;
@@ -39,8 +45,1745 @@ function registerCustomSerializers() {
   }
 }
 __name(registerCustomSerializers, "registerCustomSerializers");
+function getZodErrorMessage(error) {
+  if ("_zod" in error) {
+    return fromError4(error).toString();
+  } else {
+    return fromError3(error).toString();
+  }
+}
+__name(getZodErrorMessage, "getZodErrorMessage");
+
+// src/api/rest/index.ts
+var InvalidValueError = class InvalidValueError2 extends Error {
+  static {
+    __name(this, "InvalidValueError");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+var DEFAULT_PAGE_SIZE = 100;
+var FilterOperations = [
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "contains",
+  "icontains",
+  "search",
+  "startsWith",
+  "endsWith",
+  "has",
+  "hasEvery",
+  "hasSome",
+  "isEmpty"
+];
+var DEFAULT_ID_DIVIDER = "_";
+registerCustomSerializers();
+var RestApiHandler = class {
+  static {
+    __name(this, "RestApiHandler");
+  }
+  options;
+  // resource serializers
+  serializers = /* @__PURE__ */ new Map();
+  // error responses
+  errors = {
+    unsupportedModel: {
+      status: 404,
+      title: "Unsupported model type",
+      detail: "The model type is not supported"
+    },
+    unsupportedRelationship: {
+      status: 400,
+      title: "Unsupported relationship",
+      detail: "The relationship is not supported"
+    },
+    invalidPath: {
+      status: 400,
+      title: "The request path is invalid"
+    },
+    invalidVerb: {
+      status: 400,
+      title: "The HTTP verb is not supported"
+    },
+    notFound: {
+      status: 404,
+      title: "Resource not found"
+    },
+    noId: {
+      status: 400,
+      title: "Model without an ID field is not supported"
+    },
+    invalidId: {
+      status: 400,
+      title: "Resource ID is invalid"
+    },
+    invalidPayload: {
+      status: 400,
+      title: "Invalid payload"
+    },
+    invalidRelationData: {
+      status: 400,
+      title: "Invalid relation data",
+      detail: "Invalid relationship data"
+    },
+    invalidRelation: {
+      status: 400,
+      title: "Invalid relation",
+      detail: "Invalid relationship"
+    },
+    invalidFilter: {
+      status: 400,
+      title: "Invalid filter"
+    },
+    invalidSort: {
+      status: 400,
+      title: "Invalid sort"
+    },
+    invalidValue: {
+      status: 400,
+      title: "Invalid value for type"
+    },
+    duplicatedFieldsParameter: {
+      status: 400,
+      title: "Fields Parameter Duplicated"
+    },
+    forbidden: {
+      status: 403,
+      title: "Operation is forbidden"
+    },
+    validationError: {
+      status: 422,
+      title: "Operation is unprocessable due to validation errors"
+    },
+    queryError: {
+      status: 400,
+      title: "Error occurred while executing the query"
+    },
+    unknownError: {
+      status: 500,
+      title: "Unknown error"
+    }
+  };
+  filterParamPattern = new RegExp(/^filter(?<match>(\[[^[\]]+\])+)$/);
+  // zod schema for payload of creating and updating a resource
+  createUpdatePayloadSchema = z.object({
+    data: z.object({
+      type: z.string(),
+      attributes: z.object({}).passthrough().optional(),
+      relationships: z.record(z.string(), z.object({
+        data: z.union([
+          z.object({
+            type: z.string(),
+            id: z.union([
+              z.string(),
+              z.number()
+            ])
+          }),
+          z.array(z.object({
+            type: z.string(),
+            id: z.union([
+              z.string(),
+              z.number()
+            ])
+          }))
+        ])
+      })).optional()
+    }),
+    meta: z.object({}).passthrough().optional()
+  }).strict();
+  // zod schema for updating a single relationship
+  updateSingleRelationSchema = z.object({
+    data: z.object({
+      type: z.string(),
+      id: z.union([
+        z.string(),
+        z.number()
+      ])
+    }).nullable()
+  });
+  // zod schema for updating collection relationship
+  updateCollectionRelationSchema = z.object({
+    data: z.array(z.object({
+      type: z.string(),
+      id: z.union([
+        z.string(),
+        z.number()
+      ])
+    }))
+  });
+  upsertMetaSchema = z.object({
+    meta: z.object({
+      operation: z.literal("upsert"),
+      matchFields: z.array(z.string()).min(1)
+    })
+  });
+  // all known types and their metadata
+  typeMap = {};
+  // divider used to separate compound ID fields
+  idDivider;
+  urlPatternMap;
+  modelNameMapping;
+  reverseModelNameMapping;
+  externalIdMapping;
+  constructor(options) {
+    this.options = options;
+    this.idDivider = options.idDivider ?? DEFAULT_ID_DIVIDER;
+    const segmentCharset = options.urlSegmentCharset ?? "a-zA-Z0-9-_~ %";
+    this.modelNameMapping = options.modelNameMapping ?? {};
+    this.modelNameMapping = Object.fromEntries(Object.entries(this.modelNameMapping).map(([k, v]) => [
+      lowerCaseFirst(k),
+      v
+    ]));
+    this.reverseModelNameMapping = Object.fromEntries(Object.entries(this.modelNameMapping).map(([k, v]) => [
+      v,
+      k
+    ]));
+    this.externalIdMapping = options.externalIdMapping ?? {};
+    this.externalIdMapping = Object.fromEntries(Object.entries(this.externalIdMapping).map(([k, v]) => [
+      lowerCaseFirst(k),
+      v
+    ]));
+    this.urlPatternMap = this.buildUrlPatternMap(segmentCharset);
+    this.buildTypeMap();
+    this.buildSerializers();
+  }
+  get schema() {
+    return this.options.schema;
+  }
+  get log() {
+    return this.options.log;
+  }
+  buildUrlPatternMap(urlSegmentNameCharset) {
+    const options = {
+      segmentValueCharset: urlSegmentNameCharset
+    };
+    const buildPath = /* @__PURE__ */ __name((segments) => {
+      return "/" + segments.join("/");
+    }, "buildPath");
+    return {
+      ["single"]: new UrlPattern(buildPath([
+        ":type",
+        ":id"
+      ]), options),
+      ["fetchRelationship"]: new UrlPattern(buildPath([
+        ":type",
+        ":id",
+        ":relationship"
+      ]), options),
+      ["relationship"]: new UrlPattern(buildPath([
+        ":type",
+        ":id",
+        "relationships",
+        ":relationship"
+      ]), options),
+      ["collection"]: new UrlPattern(buildPath([
+        ":type"
+      ]), options)
+    };
+  }
+  mapModelName(modelName) {
+    return this.modelNameMapping[modelName] ?? modelName;
+  }
+  matchUrlPattern(path, routeType) {
+    const pattern = this.urlPatternMap[routeType];
+    if (!pattern) {
+      throw new InvalidValueError(`Unknown route type: ${routeType}`);
+    }
+    const match2 = pattern.match(path);
+    if (!match2) {
+      return;
+    }
+    if (match2.type in this.modelNameMapping) {
+      throw new InvalidValueError(`use the mapped model name: ${this.modelNameMapping[match2.type]} and not ${match2.type}`);
+    }
+    if (match2.type in this.reverseModelNameMapping) {
+      match2.type = this.reverseModelNameMapping[match2.type];
+    }
+    return match2;
+  }
+  async handleRequest({ client, method, path, query, requestBody }) {
+    method = method.toUpperCase();
+    if (!path.startsWith("/")) {
+      path = "/" + path;
+    }
+    try {
+      switch (method) {
+        case "GET": {
+          let match2 = this.matchUrlPattern(path, "single");
+          if (match2) {
+            return await this.processSingleRead(client, match2.type, match2.id, query);
+          }
+          match2 = this.matchUrlPattern(path, "fetchRelationship");
+          if (match2) {
+            return await this.processFetchRelated(client, match2.type, match2.id, match2.relationship, query);
+          }
+          match2 = this.matchUrlPattern(path, "relationship");
+          if (match2) {
+            return await this.processReadRelationship(client, match2.type, match2.id, match2.relationship, query);
+          }
+          match2 = this.matchUrlPattern(path, "collection");
+          if (match2) {
+            return await this.processCollectionRead(client, match2.type, query);
+          }
+          return this.makeError("invalidPath");
+        }
+        case "POST": {
+          if (!requestBody) {
+            return this.makeError("invalidPayload");
+          }
+          let match2 = this.matchUrlPattern(path, "collection");
+          if (match2) {
+            const body = requestBody;
+            const upsertMeta = this.upsertMetaSchema.safeParse(body);
+            if (upsertMeta.success) {
+              return await this.processUpsert(client, match2.type, query, requestBody);
+            } else {
+              return await this.processCreate(client, match2.type, query, requestBody);
+            }
+          }
+          match2 = this.matchUrlPattern(path, "relationship");
+          if (match2) {
+            return await this.processRelationshipCRUD(client, "create", match2.type, match2.id, match2.relationship, query, requestBody);
+          }
+          return this.makeError("invalidPath");
+        }
+        // TODO: PUT for full update
+        case "PUT":
+        case "PATCH": {
+          if (!requestBody) {
+            return this.makeError("invalidPayload");
+          }
+          let match2 = this.matchUrlPattern(path, "single");
+          if (match2) {
+            return await this.processUpdate(client, match2.type, match2.id, query, requestBody);
+          }
+          match2 = this.matchUrlPattern(path, "relationship");
+          if (match2) {
+            return await this.processRelationshipCRUD(client, "update", match2.type, match2.id, match2.relationship, query, requestBody);
+          }
+          return this.makeError("invalidPath");
+        }
+        case "DELETE": {
+          let match2 = this.matchUrlPattern(path, "single");
+          if (match2) {
+            return await this.processDelete(client, match2.type, match2.id);
+          }
+          match2 = this.matchUrlPattern(path, "relationship");
+          if (match2) {
+            return await this.processRelationshipCRUD(client, "delete", match2.type, match2.id, match2.relationship, query, requestBody);
+          }
+          return this.makeError("invalidPath");
+        }
+        default:
+          return this.makeError("invalidPath");
+      }
+    } catch (err) {
+      if (err instanceof InvalidValueError) {
+        return this.makeError("invalidValue", err.message);
+      } else if (err instanceof ZenStackError) {
+        return this.handleZenStackError(err);
+      } else {
+        return this.handleGenericError(err);
+      }
+    }
+  }
+  handleGenericError(err) {
+    return this.makeError("unknownError", err instanceof Error ? `${err.message}
+${err.stack}` : "Unknown error");
+  }
+  async processSingleRead(client, type, resourceId, query) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const args = {
+      where: this.makeIdFilter(typeInfo.idFields, resourceId)
+    };
+    this.includeRelationshipIds(type, args, "include");
+    let include;
+    if (query?.["include"]) {
+      const { select: select2, error: error2, allIncludes } = this.buildRelationSelect(type, query["include"], query);
+      if (error2) {
+        return error2;
+      }
+      if (select2) {
+        args.include = {
+          ...args.include,
+          ...select2
+        };
+      }
+      include = allIncludes;
+    }
+    const { select, error } = this.buildPartialSelect(type, query);
+    if (error) return error;
+    if (select) {
+      args.select = {
+        ...select,
+        ...args.select
+      };
+      if (args.include) {
+        args.select = {
+          ...args.select,
+          ...args.include
+        };
+        args.include = void 0;
+      }
+    }
+    const entity = await client[type].findUnique(args);
+    if (entity) {
+      return {
+        status: 200,
+        body: await this.serializeItems(type, entity, {
+          include
+        })
+      };
+    } else {
+      return this.makeError("notFound");
+    }
+  }
+  async processFetchRelated(client, type, resourceId, relationship, query) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const relationInfo = typeInfo.relationships[relationship];
+    if (!relationInfo) {
+      return this.makeUnsupportedRelationshipError(type, relationship, 404);
+    }
+    let select;
+    let include;
+    if (query?.["include"]) {
+      const { select: relationSelect, error, allIncludes } = this.buildRelationSelect(type, query["include"], query);
+      if (error) {
+        return error;
+      }
+      include = allIncludes.filter((i) => i.startsWith(`${relationship}.`)).map((i) => i.substring(`${relationship}.`.length));
+      select = relationSelect;
+    }
+    if (!select) {
+      const { select: partialFields, error } = this.buildPartialSelect(lowerCaseFirst(relationInfo.type), query);
+      if (error) return error;
+      select = partialFields ? {
+        [relationship]: {
+          select: {
+            ...partialFields
+          }
+        }
+      } : {
+        [relationship]: true
+      };
+    }
+    const args = {
+      where: this.makeIdFilter(typeInfo.idFields, resourceId),
+      select
+    };
+    if (relationInfo.isCollection) {
+      const error = this.injectRelationQuery(relationInfo.type, select, relationship, query);
+      if (error) {
+        return error;
+      }
+    }
+    const entity = await client[type].findUnique(args);
+    let paginator;
+    if (entity?._count?.[relationship] !== void 0) {
+      const total = entity?._count?.[relationship];
+      const url = this.makeNormalizedUrl(`/${type}/${resourceId}/${relationship}`, query);
+      const { offset, limit } = this.getPagination(query);
+      paginator = this.makePaginator(url, offset, limit, total);
+    }
+    if (entity?.[relationship]) {
+      const mappedType = this.mapModelName(type);
+      return {
+        status: 200,
+        body: await this.serializeItems(relationInfo.type, entity[relationship], {
+          linkers: {
+            document: new Linker(() => this.makeLinkUrl(`/${mappedType}/${resourceId}/${relationship}`)),
+            paginator
+          },
+          include
+        })
+      };
+    } else {
+      return this.makeError("notFound");
+    }
+  }
+  async processReadRelationship(client, type, resourceId, relationship, query) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const relationInfo = typeInfo.relationships[relationship];
+    if (!relationInfo) {
+      return this.makeUnsupportedRelationshipError(type, relationship, 404);
+    }
+    const args = {
+      where: this.makeIdFilter(typeInfo.idFields, resourceId),
+      select: this.makeIdSelect(typeInfo.idFields)
+    };
+    args.select = {
+      ...args.select,
+      [relationship]: {
+        select: this.makeIdSelect(relationInfo.idFields)
+      }
+    };
+    let paginator;
+    if (relationInfo.isCollection) {
+      const error = this.injectRelationQuery(relationInfo.type, args.select, relationship, query);
+      if (error) {
+        return error;
+      }
+    }
+    const entity = await client[type].findUnique(args);
+    const mappedType = this.mapModelName(type);
+    if (entity?._count?.[relationship] !== void 0) {
+      const total = entity?._count?.[relationship];
+      const url = this.makeNormalizedUrl(`/${mappedType}/${resourceId}/relationships/${relationship}`, query);
+      const { offset, limit } = this.getPagination(query);
+      paginator = this.makePaginator(url, offset, limit, total);
+    }
+    if (entity?.[relationship]) {
+      const serialized = await this.serializeItems(relationInfo.type, entity[relationship], {
+        linkers: {
+          document: new Linker(() => this.makeLinkUrl(`/${mappedType}/${resourceId}/relationships/${relationship}`)),
+          paginator
+        },
+        onlyIdentifier: true
+      });
+      return {
+        status: 200,
+        body: serialized
+      };
+    } else {
+      return this.makeError("notFound");
+    }
+  }
+  async processCollectionRead(client, type, query) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const args = {};
+    const { filter, error: filterError } = this.buildFilter(type, query);
+    if (filterError) {
+      return filterError;
+    }
+    if (filter) {
+      args.where = filter;
+    }
+    const { sort, error: sortError } = this.buildSort(type, query);
+    if (sortError) {
+      return sortError;
+    }
+    if (sort) {
+      args.orderBy = sort;
+    }
+    this.includeRelationshipIds(type, args, "include");
+    let include;
+    if (query?.["include"]) {
+      const { select: select2, error: error2, allIncludes } = this.buildRelationSelect(type, query["include"], query);
+      if (error2) {
+        return error2;
+      }
+      if (select2) {
+        args.include = {
+          ...args.include,
+          ...select2
+        };
+      }
+      include = allIncludes;
+    }
+    const { select, error } = this.buildPartialSelect(type, query);
+    if (error) return error;
+    if (select) {
+      args.select = {
+        ...select,
+        ...args.select
+      };
+      if (args.include) {
+        args.select = {
+          ...args.select,
+          ...args.include
+        };
+        args.include = void 0;
+      }
+    }
+    const { offset, limit } = this.getPagination(query);
+    if (offset > 0) {
+      args.skip = offset;
+    }
+    if (limit === Infinity) {
+      const entities = await client[type].findMany(args);
+      const body = await this.serializeItems(type, entities, {
+        include
+      });
+      const total = entities.length;
+      body.meta = this.addTotalCountToMeta(body.meta, total);
+      return {
+        status: 200,
+        body
+      };
+    } else {
+      args.take = limit;
+      const [entities, count] = await Promise.all([
+        client[type].findMany(args),
+        client[type].count({
+          where: args.where ?? {}
+        })
+      ]);
+      const total = count;
+      const mappedType = this.mapModelName(type);
+      const url = this.makeNormalizedUrl(`/${mappedType}`, query);
+      const options = {
+        include,
+        linkers: {
+          paginator: this.makePaginator(url, offset, limit, total)
+        }
+      };
+      const body = await this.serializeItems(type, entities, options);
+      body.meta = this.addTotalCountToMeta(body.meta, total);
+      return {
+        status: 200,
+        body
+      };
+    }
+  }
+  buildPartialSelect(type, query) {
+    const selectFieldsQuery = query?.[`fields[${type}]`];
+    if (!selectFieldsQuery) {
+      return {
+        select: void 0,
+        error: void 0
+      };
+    }
+    if (Array.isArray(selectFieldsQuery)) {
+      return {
+        select: void 0,
+        error: this.makeError("duplicatedFieldsParameter", `duplicated fields query for type ${type}`)
+      };
+    }
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return {
+        select: void 0,
+        error: this.makeUnsupportedModelError(type)
+      };
+    }
+    const selectFieldNames = selectFieldsQuery.split(",").filter((i) => i);
+    const fields = selectFieldNames.reduce((acc, curr) => ({
+      ...acc,
+      [curr]: true
+    }), {});
+    return {
+      select: {
+        ...this.makeIdSelect(typeInfo.idFields),
+        ...fields
+      }
+    };
+  }
+  addTotalCountToMeta(meta, total) {
+    return meta ? Object.assign(meta, {
+      total
+    }) : Object.assign({}, {
+      total
+    });
+  }
+  makePaginator(baseUrl, offset, limit, total) {
+    if (limit === Infinity) {
+      return void 0;
+    }
+    const totalPages = Math.ceil(total / limit);
+    return new Paginator(() => ({
+      first: this.replaceURLSearchParams(baseUrl, {
+        "page[limit]": limit
+      }),
+      last: this.replaceURLSearchParams(baseUrl, {
+        "page[offset]": (totalPages - 1) * limit
+      }),
+      prev: offset - limit >= 0 && offset - limit <= total - 1 ? this.replaceURLSearchParams(baseUrl, {
+        "page[offset]": offset - limit,
+        "page[limit]": limit
+      }) : null,
+      next: offset + limit <= total - 1 ? this.replaceURLSearchParams(baseUrl, {
+        "page[offset]": offset + limit,
+        "page[limit]": limit
+      }) : null
+    }));
+  }
+  processRequestBody(requestBody) {
+    let body = requestBody;
+    if (body.meta?.serialization) {
+      body = SuperJSON2.deserialize({
+        json: body,
+        meta: body.meta.serialization
+      });
+    }
+    const parseResult = this.createUpdatePayloadSchema.safeParse(body);
+    if (!parseResult.success) {
+      return {
+        attributes: void 0,
+        relationships: void 0,
+        error: this.makeError("invalidPayload", getZodErrorMessage(parseResult.error))
+      };
+    }
+    return {
+      attributes: parseResult.data.data.attributes,
+      relationships: parseResult.data.data.relationships,
+      error: void 0
+    };
+  }
+  async processCreate(client, type, _query, requestBody) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const { attributes, relationships, error } = this.processRequestBody(requestBody);
+    if (error) {
+      return error;
+    }
+    const createPayload = {
+      data: {
+        ...attributes
+      }
+    };
+    if (relationships) {
+      for (const [key, data] of Object.entries(relationships)) {
+        if (!data?.data) {
+          return this.makeError("invalidRelationData");
+        }
+        const relationInfo = typeInfo.relationships[key];
+        if (!relationInfo) {
+          return this.makeUnsupportedRelationshipError(type, key, 400);
+        }
+        if (relationInfo.isCollection) {
+          createPayload.data[key] = {
+            connect: enumerate(data.data).map((item) => this.makeIdConnect(relationInfo.idFields, item.id))
+          };
+        } else {
+          if (typeof data.data !== "object") {
+            return this.makeError("invalidRelationData");
+          }
+          createPayload.data[key] = {
+            connect: this.makeIdConnect(relationInfo.idFields, data.data.id)
+          };
+        }
+        createPayload.include = {
+          ...createPayload.include,
+          [key]: {
+            select: {
+              [this.makeDefaultIdKey(relationInfo.idFields)]: true
+            }
+          }
+        };
+      }
+    }
+    this.includeRelationshipIds(type, createPayload, "include");
+    const entity = await client[type].create(createPayload);
+    return {
+      status: 201,
+      body: await this.serializeItems(type, entity)
+    };
+  }
+  async processUpsert(client, type, _query, requestBody) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const modelName = typeInfo.name;
+    const { attributes, relationships, error } = this.processRequestBody(requestBody);
+    if (error) {
+      return error;
+    }
+    const parseResult = this.upsertMetaSchema.safeParse(requestBody);
+    if (parseResult.error) {
+      return this.makeError("invalidPayload", getZodErrorMessage(parseResult.error));
+    }
+    const matchFields = parseResult.data.meta.matchFields;
+    const uniqueFieldSets = this.getUniqueFieldSets(modelName);
+    if (!uniqueFieldSets.some((set) => set.every((field) => matchFields.includes(field)))) {
+      return this.makeError("invalidPayload", "Match fields must be unique fields", 400);
+    }
+    const upsertPayload = {
+      where: this.makeUpsertWhere(matchFields, attributes, typeInfo),
+      create: {
+        ...attributes
+      },
+      update: {
+        ...Object.fromEntries(Object.entries(attributes ?? {}).filter((e) => !matchFields.includes(e[0])))
+      }
+    };
+    if (relationships) {
+      for (const [key, data] of Object.entries(relationships)) {
+        if (!data?.data) {
+          return this.makeError("invalidRelationData");
+        }
+        const relationInfo = typeInfo.relationships[key];
+        if (!relationInfo) {
+          return this.makeUnsupportedRelationshipError(modelName, key, 400);
+        }
+        if (relationInfo.isCollection) {
+          upsertPayload.create[key] = {
+            connect: enumerate(data.data).map((item) => this.makeIdConnect(relationInfo.idFields, item.id))
+          };
+          upsertPayload.update[key] = {
+            set: enumerate(data.data).map((item) => this.makeIdConnect(relationInfo.idFields, item.id))
+          };
+        } else {
+          if (typeof data.data !== "object") {
+            return this.makeError("invalidRelationData");
+          }
+          upsertPayload.create[key] = {
+            connect: this.makeIdConnect(relationInfo.idFields, data.data.id)
+          };
+          upsertPayload.update[key] = {
+            connect: this.makeIdConnect(relationInfo.idFields, data.data.id)
+          };
+        }
+      }
+    }
+    this.includeRelationshipIds(modelName, upsertPayload, "include");
+    const entity = await client[modelName].upsert(upsertPayload);
+    return {
+      status: 201,
+      body: await this.serializeItems(modelName, entity)
+    };
+  }
+  getUniqueFieldSets(type) {
+    const modelDef = this.requireModel(type);
+    return Object.entries(modelDef.uniqueFields).map(([k, v]) => typeof v.type === "string" ? [
+      k
+    ] : Object.keys(v));
+  }
+  async processRelationshipCRUD(client, mode, type, resourceId, relationship, _query, requestBody) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const relationInfo = typeInfo.relationships[relationship];
+    if (!relationInfo) {
+      return this.makeUnsupportedRelationshipError(type, relationship, 404);
+    }
+    if (!relationInfo.isCollection && mode !== "update") {
+      return this.makeError("invalidVerb");
+    }
+    const updateArgs = {
+      where: this.makeIdFilter(typeInfo.idFields, resourceId),
+      select: {
+        ...typeInfo.idFields.reduce((acc, field) => ({
+          ...acc,
+          [field.name]: true
+        }), {}),
+        [relationship]: {
+          select: this.makeIdSelect(relationInfo.idFields)
+        }
+      }
+    };
+    if (!relationInfo.isCollection) {
+      const parsed = this.updateSingleRelationSchema.safeParse(requestBody);
+      if (!parsed.success) {
+        return this.makeError("invalidPayload", getZodErrorMessage(parsed.error));
+      }
+      if (parsed.data.data === null) {
+        if (!relationInfo.isOptional) {
+          return this.makeError("invalidPayload");
+        }
+        updateArgs.data = {
+          [relationship]: {
+            disconnect: true
+          }
+        };
+      } else {
+        updateArgs.data = {
+          [relationship]: {
+            connect: this.makeIdConnect(relationInfo.idFields, parsed.data.data.id)
+          }
+        };
+      }
+    } else {
+      const parsed = this.updateCollectionRelationSchema.safeParse(requestBody);
+      if (!parsed.success) {
+        return this.makeError("invalidPayload", getZodErrorMessage(parsed.error));
+      }
+      const relationVerb = mode === "create" ? "connect" : mode === "delete" ? "disconnect" : "set";
+      updateArgs.data = {
+        [relationship]: {
+          [relationVerb]: enumerate(parsed.data.data).map((item) => this.makeIdFilter(relationInfo.idFields, item.id))
+        }
+      };
+    }
+    const entity = await client[type].update(updateArgs);
+    const mappedType = this.mapModelName(type);
+    const serialized = await this.serializeItems(relationInfo.type, entity[relationship], {
+      linkers: {
+        document: new Linker(() => this.makeLinkUrl(`/${mappedType}/${resourceId}/relationships/${relationship}`))
+      },
+      onlyIdentifier: true
+    });
+    return {
+      status: 200,
+      body: serialized
+    };
+  }
+  async processUpdate(client, type, resourceId, _query, requestBody) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    const { attributes, relationships, error } = this.processRequestBody(requestBody);
+    if (error) {
+      return error;
+    }
+    const updatePayload = {
+      where: this.makeIdFilter(typeInfo.idFields, resourceId),
+      data: {
+        ...attributes
+      }
+    };
+    if (relationships) {
+      for (const [key, data] of Object.entries(relationships)) {
+        if (!data?.data) {
+          return this.makeError("invalidRelationData");
+        }
+        const relationInfo = typeInfo.relationships[key];
+        if (!relationInfo) {
+          return this.makeUnsupportedRelationshipError(type, key, 400);
+        }
+        if (relationInfo.isCollection) {
+          updatePayload.data[key] = {
+            set: enumerate(data.data).map((item) => ({
+              [this.makeDefaultIdKey(relationInfo.idFields)]: item.id
+            }))
+          };
+        } else {
+          if (typeof data.data !== "object") {
+            return this.makeError("invalidRelationData");
+          }
+          updatePayload.data[key] = {
+            connect: {
+              [this.makeDefaultIdKey(relationInfo.idFields)]: data.data.id
+            }
+          };
+        }
+        updatePayload.include = {
+          ...updatePayload.include,
+          [key]: {
+            select: {
+              [this.makeDefaultIdKey(relationInfo.idFields)]: true
+            }
+          }
+        };
+      }
+    }
+    this.includeRelationshipIds(type, updatePayload, "include");
+    const entity = await client[type].update(updatePayload);
+    return {
+      status: 200,
+      body: await this.serializeItems(type, entity)
+    };
+  }
+  async processDelete(client, type, resourceId) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return this.makeUnsupportedModelError(type);
+    }
+    await client[type].delete({
+      where: this.makeIdFilter(typeInfo.idFields, resourceId)
+    });
+    return {
+      status: 200,
+      body: {
+        meta: {}
+      }
+    };
+  }
+  //#region utilities
+  requireModel(model) {
+    const modelDef = this.schema.models[model];
+    if (!modelDef) {
+      throw new Error(`Model ${model} is not defined in the schema`);
+    }
+    return modelDef;
+  }
+  getIdFields(model) {
+    const modelDef = this.requireModel(model);
+    const modelLower = lowerCaseFirst(model);
+    if (!(modelLower in this.externalIdMapping)) {
+      return Object.values(modelDef.fields).filter((f) => modelDef.idFields.includes(f.name));
+    }
+    const externalIdName = this.externalIdMapping[modelLower];
+    for (const [name, info] of Object.entries(modelDef.uniqueFields)) {
+      if (name === externalIdName) {
+        if (typeof info.type === "string") {
+          return [
+            this.requireField(model, info.type)
+          ];
+        } else {
+          return Object.keys(info).map((f) => this.requireField(model, f));
+        }
+      }
+    }
+    throw new Error(`Model ${model} does not have unique key ${externalIdName}`);
+  }
+  requireField(model, field) {
+    const modelDef = this.requireModel(model);
+    const fieldDef = modelDef.fields[field];
+    if (!fieldDef) {
+      throw new Error(`Field ${field} is not defined in model ${model}`);
+    }
+    return fieldDef;
+  }
+  buildTypeMap() {
+    this.typeMap = {};
+    for (const [model, { fields }] of Object.entries(this.schema.models)) {
+      const idFields = this.getIdFields(model);
+      if (idFields.length === 0) {
+        log(this.options.log, "warn", `Not including model ${model} in the API because it has no ID field`);
+        continue;
+      }
+      const modelInfo = this.typeMap[lowerCaseFirst(model)] = {
+        name: model,
+        idFields,
+        relationships: {},
+        fields
+      };
+      for (const [field, fieldInfo] of Object.entries(fields)) {
+        if (!fieldInfo.relation) {
+          continue;
+        }
+        const fieldTypeIdFields = this.getIdFields(fieldInfo.type);
+        if (fieldTypeIdFields.length === 0) {
+          log(this.options.log, "warn", `Not including relation ${model}.${field} in the API because it has no ID field`);
+          continue;
+        }
+        modelInfo.relationships[field] = {
+          type: fieldInfo.type,
+          idFields: fieldTypeIdFields,
+          isCollection: !!fieldInfo.array,
+          isOptional: !!fieldInfo.optional
+        };
+      }
+    }
+  }
+  getModelInfo(model) {
+    return this.typeMap[lowerCaseFirst(model)];
+  }
+  makeLinkUrl(path) {
+    return `${this.options.endpoint}${path}`;
+  }
+  buildSerializers() {
+    const linkers = {};
+    for (const model of Object.keys(this.schema.models)) {
+      const ids = this.getIdFields(model);
+      const modelLower = lowerCaseFirst(model);
+      const mappedModel = this.mapModelName(modelLower);
+      if (ids.length < 1) {
+        continue;
+      }
+      const linker = new Linker((items) => Array.isArray(items) ? this.makeLinkUrl(`/${mappedModel}`) : this.makeLinkUrl(`/${mappedModel}/${this.getId(model, items)}`));
+      linkers[modelLower] = linker;
+      let projection = {};
+      const modelDef = this.requireModel(model);
+      for (const [field, fieldDef] of Object.entries(modelDef.fields)) {
+        if (fieldDef.relation) {
+          projection[field] = 0;
+        }
+      }
+      if (Object.keys(projection).length === 0) {
+        projection = null;
+      }
+      const serializer = new Serializer(model, {
+        version: "1.1",
+        idKey: this.makeIdKey(ids),
+        linkers: {
+          resource: linker,
+          document: linker
+        },
+        projection
+      });
+      this.serializers.set(modelLower, serializer);
+    }
+    for (const model of Object.keys(this.schema.models)) {
+      const modelLower = lowerCaseFirst(model);
+      const serializer = this.serializers.get(modelLower);
+      if (!serializer) {
+        continue;
+      }
+      const relators = {};
+      const modelDef = this.requireModel(model);
+      for (const [field, fieldDef] of Object.entries(modelDef.fields)) {
+        if (!fieldDef.relation) {
+          continue;
+        }
+        const fieldSerializer = this.serializers.get(lowerCaseFirst(fieldDef.type));
+        if (!fieldSerializer) {
+          continue;
+        }
+        const fieldIds = this.getIdFields(fieldDef.type);
+        if (fieldIds.length > 0) {
+          const mappedModel = this.mapModelName(modelLower);
+          const relator = new Relator(async (data) => {
+            return data[field];
+          }, fieldSerializer, {
+            relatedName: field,
+            linkers: {
+              related: new Linker((primary) => this.makeLinkUrl(`/${mappedModel}/${this.getId(model, primary)}/${field}`)),
+              relationship: new Linker((primary) => this.makeLinkUrl(`/${mappedModel}/${this.getId(model, primary)}/relationships/${field}`))
+            }
+          });
+          relators[field] = relator;
+        }
+      }
+      serializer.setRelators(relators);
+    }
+  }
+  getId(model, data) {
+    if (!data) {
+      return void 0;
+    }
+    const ids = this.getIdFields(model);
+    if (ids.length === 0) {
+      return void 0;
+    } else {
+      return data[this.makeIdKey(ids)];
+    }
+  }
+  async serializeItems(model, items, options) {
+    model = lowerCaseFirst(model);
+    const serializer = this.serializers.get(model);
+    if (!serializer) {
+      throw new Error(`serializer not found for model ${model}`);
+    }
+    const itemsWithId = clone(items);
+    this.injectCompoundId(model, itemsWithId);
+    const serialized = await serializer.serialize(itemsWithId, options);
+    const plainResult = this.toPlainObject(serialized);
+    const { json, meta } = SuperJSON2.serialize(plainResult);
+    const result = json;
+    if (meta) {
+      result.meta = {
+        ...result.meta,
+        serialization: meta
+      };
+    }
+    return result;
+  }
+  injectCompoundId(model, items) {
+    const typeInfo = this.getModelInfo(model);
+    if (!typeInfo) {
+      return;
+    }
+    enumerate(items).forEach((item) => {
+      if (!item) {
+        return;
+      }
+      if (typeInfo.idFields.length > 1) {
+        item[this.makeIdKey(typeInfo.idFields)] = this.makeCompoundId(typeInfo.idFields, item);
+      }
+      for (const [key, value] of Object.entries(item)) {
+        if (typeInfo.relationships[key]) {
+          this.injectCompoundId(typeInfo.relationships[key].type, value);
+        }
+      }
+    });
+  }
+  toPlainObject(data) {
+    if (data === void 0 || data === null) {
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return data.map((item) => this.toPlainObject(item));
+    }
+    if (typeof data === "object") {
+      if (typeof data.toJSON === "function") {
+        return data.toJSON();
+      }
+      const result = {};
+      for (const [field, value] of Object.entries(data)) {
+        if (value === void 0 || typeof value === "function") {
+          continue;
+        } else if (field === "attributes") {
+          result[field] = value;
+        } else {
+          result[field] = this.toPlainObject(value);
+        }
+      }
+      return result;
+    }
+    return data;
+  }
+  replaceURLSearchParams(url, params) {
+    const r = new URL(url);
+    for (const [key, value] of Object.entries(params)) {
+      r.searchParams.set(key, value.toString());
+    }
+    return r.toString();
+  }
+  makeIdFilter(idFields, resourceId, nested = true) {
+    const decodedId = decodeURIComponent(resourceId);
+    if (idFields.length === 1) {
+      return {
+        [idFields[0].name]: this.coerce(idFields[0], decodedId)
+      };
+    } else if (nested) {
+      return {
+        // TODO: support `@@id` with custom name
+        [idFields.map((idf) => idf.name).join(DEFAULT_ID_DIVIDER)]: idFields.reduce((acc, curr, idx) => ({
+          ...acc,
+          [curr.name]: this.coerce(curr, decodedId.split(this.idDivider)[idx])
+        }), {})
+      };
+    } else {
+      return idFields.reduce((acc, curr, idx) => ({
+        ...acc,
+        [curr.name]: this.coerce(curr, decodedId.split(this.idDivider)[idx])
+      }), {});
+    }
+  }
+  makeIdSelect(idFields) {
+    if (idFields.length === 0) {
+      throw this.errors["noId"];
+    }
+    return idFields.reduce((acc, curr) => ({
+      ...acc,
+      [curr.name]: true
+    }), {});
+  }
+  makeIdConnect(idFields, id) {
+    if (idFields.length === 1) {
+      return {
+        [idFields[0].name]: this.coerce(idFields[0], id)
+      };
+    } else {
+      return {
+        [this.makeDefaultIdKey(idFields)]: idFields.reduce((acc, curr, idx) => ({
+          ...acc,
+          [curr.name]: this.coerce(curr, `${id}`.split(this.idDivider)[idx])
+        }), {})
+      };
+    }
+  }
+  makeIdKey(idFields) {
+    return idFields.map((idf) => idf.name).join(this.idDivider);
+  }
+  makeDefaultIdKey(idFields) {
+    return idFields.map((idf) => idf.name).join(DEFAULT_ID_DIVIDER);
+  }
+  makeCompoundId(idFields, item) {
+    return idFields.map((idf) => item[idf.name]).join(this.idDivider);
+  }
+  makeUpsertWhere(matchFields, attributes, typeInfo) {
+    const where = matchFields.reduce((acc, field) => {
+      acc[field] = attributes[field] ?? null;
+      return acc;
+    }, {});
+    if (typeInfo.idFields.length > 1 && matchFields.some((mf) => typeInfo.idFields.map((idf) => idf.name).includes(mf))) {
+      return {
+        [this.makeDefaultIdKey(typeInfo.idFields)]: where
+      };
+    }
+    return where;
+  }
+  includeRelationshipIds(model, args, mode) {
+    const typeInfo = this.getModelInfo(model);
+    if (!typeInfo) {
+      return;
+    }
+    for (const [relation, relationInfo] of Object.entries(typeInfo.relationships)) {
+      args[mode] = {
+        ...args[mode],
+        [relation]: {
+          select: this.makeIdSelect(relationInfo.idFields)
+        }
+      };
+    }
+  }
+  coerce(fieldDef, value) {
+    if (typeof value === "string") {
+      if (fieldDef.attributes?.some((attr) => attr.name === "@json")) {
+        try {
+          return JSON.parse(value);
+        } catch {
+          throw new InvalidValueError(`invalid JSON value: ${value}`);
+        }
+      }
+      const type = fieldDef.type;
+      if (type === "Int") {
+        const parsed = parseInt(value);
+        if (isNaN(parsed)) {
+          throw new InvalidValueError(`invalid ${type} value: ${value}`);
+        }
+        return parsed;
+      } else if (type === "BigInt") {
+        try {
+          return BigInt(value);
+        } catch {
+          throw new InvalidValueError(`invalid ${type} value: ${value}`);
+        }
+      } else if (type === "Float") {
+        const parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+          throw new InvalidValueError(`invalid ${type} value: ${value}`);
+        }
+        return parsed;
+      } else if (type === "Decimal") {
+        try {
+          return new Decimal2(value);
+        } catch {
+          throw new InvalidValueError(`invalid ${type} value: ${value}`);
+        }
+      } else if (type === "Boolean") {
+        if (value === "true") {
+          return true;
+        } else if (value === "false") {
+          return false;
+        } else {
+          throw new InvalidValueError(`invalid ${type} value: ${value}`);
+        }
+      }
+    }
+    return value;
+  }
+  makeNormalizedUrl(path, query) {
+    const url = new URL(this.makeLinkUrl(path));
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (key.startsWith("filter[") || key.startsWith("sort[") || key === "include" || key.startsWith("include[") || key.startsWith("fields[")) {
+        for (const v of enumerate(value)) {
+          url.searchParams.append(key, v);
+        }
+      }
+    }
+    return url.toString();
+  }
+  getPagination(query) {
+    if (!query) {
+      return {
+        offset: 0,
+        limit: this.options.pageSize ?? DEFAULT_PAGE_SIZE
+      };
+    }
+    let offset = 0;
+    if (query["page[offset]"]) {
+      const value = query["page[offset]"];
+      const offsetText = Array.isArray(value) ? value[value.length - 1] : value;
+      offset = parseInt(offsetText);
+      if (isNaN(offset) || offset < 0) {
+        offset = 0;
+      }
+    }
+    let pageSizeOption = this.options.pageSize ?? DEFAULT_PAGE_SIZE;
+    if (pageSizeOption <= 0) {
+      pageSizeOption = DEFAULT_PAGE_SIZE;
+    }
+    let limit = pageSizeOption;
+    if (query["page[limit]"]) {
+      const value = query["page[limit]"];
+      const limitText = Array.isArray(value) ? value[value.length - 1] : value;
+      limit = parseInt(limitText);
+      if (isNaN(limit) || limit <= 0) {
+        limit = pageSizeOption;
+      }
+      limit = Math.min(pageSizeOption, limit);
+    }
+    return {
+      offset,
+      limit
+    };
+  }
+  buildFilter(type, query) {
+    if (!query) {
+      return {
+        filter: void 0,
+        error: void 0
+      };
+    }
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return {
+        filter: void 0,
+        error: this.makeUnsupportedModelError(type)
+      };
+    }
+    const items = [];
+    for (const [key, value] of Object.entries(query)) {
+      if (!value) {
+        continue;
+      }
+      const match2 = key.match(this.filterParamPattern);
+      if (!match2 || !match2.groups || !match2.groups["match"]) {
+        continue;
+      }
+      const filterKeys = match2.groups["match"].replaceAll(/[[\]]/g, " ").split(" ").filter((i) => i);
+      if (!filterKeys.length) {
+        continue;
+      }
+      const item = {};
+      let curr = item;
+      let currType = typeInfo;
+      for (const filterValue of enumerate(value)) {
+        for (let i = 0; i < filterKeys.length; i++) {
+          let filterKey = filterKeys[i];
+          let filterOp;
+          const pos = filterKey.indexOf("$");
+          if (pos > 0) {
+            filterOp = filterKey.substring(pos + 1);
+            filterKey = filterKey.substring(0, pos);
+          }
+          if (!!filterOp && !FilterOperations.includes(filterOp)) {
+            return {
+              filter: void 0,
+              error: this.makeError("invalidFilter", `invalid filter operation: ${filterOp}`)
+            };
+          }
+          const idFields = this.getIdFields(currType.name);
+          const fieldDef = filterKey === "id" ? Object.values(currType.fields).find((f) => idFields.some((idf) => idf.name === f.name)) : currType.fields[filterKey];
+          if (!fieldDef) {
+            return {
+              filter: void 0,
+              error: this.makeError("invalidFilter")
+            };
+          }
+          if (!fieldDef.relation) {
+            if (i !== filterKeys.length - 1) {
+              return {
+                filter: void 0,
+                error: this.makeError("invalidFilter")
+              };
+            }
+            curr[fieldDef.name] = this.makeFilterValue(fieldDef, filterValue, filterOp);
+          } else {
+            if (i === filterKeys.length - 1) {
+              curr[fieldDef.name] = this.makeFilterValue(fieldDef, filterValue, filterOp);
+            } else {
+              if (fieldDef.array) {
+                curr[fieldDef.name] = {
+                  some: {}
+                };
+                curr = curr[fieldDef.name].some;
+              } else {
+                curr = curr[fieldDef.name] = {};
+              }
+              currType = this.getModelInfo(fieldDef.type);
+            }
+          }
+        }
+        items.push(item);
+      }
+    }
+    if (items.length === 0) {
+      return {
+        filter: void 0,
+        error: void 0
+      };
+    } else {
+      return {
+        filter: items.length === 1 ? items[0] : {
+          AND: items
+        },
+        error: void 0
+      };
+    }
+  }
+  buildSort(type, query) {
+    if (!query?.["sort"]) {
+      return {
+        sort: void 0,
+        error: void 0
+      };
+    }
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return {
+        sort: void 0,
+        error: this.makeUnsupportedModelError(type)
+      };
+    }
+    const result = [];
+    for (const sortSpec of enumerate(query["sort"])) {
+      const sortFields = sortSpec.split(",").filter((i) => i);
+      for (const sortField of sortFields) {
+        const dir = sortField.startsWith("-") ? "desc" : "asc";
+        const cleanedSortField = sortField.startsWith("-") ? sortField.substring(1) : sortField;
+        const parts = cleanedSortField.split(".").filter((i) => i);
+        const sortItem = {};
+        let curr = sortItem;
+        let currType = typeInfo;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          const fieldInfo = currType.fields[part];
+          if (!fieldInfo || fieldInfo.array) {
+            return {
+              sort: void 0,
+              error: this.makeError("invalidSort", "sorting by array field is not supported")
+            };
+          }
+          if (i === parts.length - 1) {
+            if (fieldInfo.relation) {
+              const relationType = this.getModelInfo(fieldInfo.type);
+              if (!relationType) {
+                return {
+                  sort: void 0,
+                  error: this.makeUnsupportedModelError(fieldInfo.type)
+                };
+              }
+              curr[fieldInfo.name] = relationType.idFields.reduce((acc, idField) => {
+                acc[idField.name] = dir;
+                return acc;
+              }, {});
+            } else {
+              curr[fieldInfo.name] = dir;
+            }
+          } else {
+            if (!fieldInfo.relation) {
+              return {
+                sort: void 0,
+                error: this.makeError("invalidSort", "intermediate sort segments must be relationships")
+              };
+            }
+            curr = curr[fieldInfo.name] = {};
+            currType = this.getModelInfo(fieldInfo.type);
+            if (!currType) {
+              return {
+                sort: void 0,
+                error: this.makeUnsupportedModelError(fieldInfo.type)
+              };
+            }
+          }
+        }
+        result.push(sortItem);
+      }
+    }
+    return {
+      sort: result,
+      error: void 0
+    };
+  }
+  buildRelationSelect(type, include, query) {
+    const typeInfo = this.getModelInfo(type);
+    if (!typeInfo) {
+      return {
+        select: void 0,
+        error: this.makeUnsupportedModelError(type)
+      };
+    }
+    const result = {};
+    const allIncludes = [];
+    for (const includeItem of enumerate(include)) {
+      const inclusions = includeItem.split(",").filter((i) => i);
+      for (const inclusion of inclusions) {
+        allIncludes.push(inclusion);
+        const parts = inclusion.split(".");
+        let currPayload = result;
+        let currType = typeInfo;
+        for (let i = 0; i < parts.length; i++) {
+          const relation = parts[i];
+          const relationInfo = currType.relationships[relation];
+          if (!relationInfo) {
+            return {
+              select: void 0,
+              error: this.makeUnsupportedRelationshipError(type, relation, 400)
+            };
+          }
+          currType = this.getModelInfo(relationInfo.type);
+          if (!currType) {
+            return {
+              select: void 0,
+              error: this.makeUnsupportedModelError(relationInfo.type)
+            };
+          }
+          const { select, error } = this.buildPartialSelect(lowerCaseFirst(relationInfo.type), query);
+          if (error) return {
+            select: void 0,
+            error
+          };
+          if (i !== parts.length - 1) {
+            if (select) {
+              currPayload[relation] = {
+                select: {
+                  ...select
+                }
+              };
+              currPayload = currPayload[relation].select;
+            } else {
+              currPayload[relation] = {
+                include: {
+                  ...currPayload[relation]?.include
+                }
+              };
+              currPayload = currPayload[relation].include;
+            }
+          } else {
+            currPayload[relation] = select ? {
+              select: {
+                ...select
+              }
+            } : true;
+          }
+        }
+      }
+    }
+    return {
+      select: result,
+      error: void 0,
+      allIncludes
+    };
+  }
+  makeFilterValue(fieldDef, value, op) {
+    if (fieldDef.relation) {
+      const info = this.getModelInfo(fieldDef.type);
+      if (fieldDef.array) {
+        const values = value.split(",").filter((i) => i);
+        const filterValue = values.length > 1 ? {
+          OR: values.map((v) => this.makeIdFilter(info.idFields, v, false))
+        } : this.makeIdFilter(info.idFields, value, false);
+        return {
+          some: filterValue
+        };
+      } else {
+        const values = value.split(",").filter((i) => i);
+        if (values.length > 1) {
+          return {
+            OR: values.map((v) => this.makeIdFilter(info.idFields, v, false))
+          };
+        } else {
+          return {
+            is: this.makeIdFilter(info.idFields, value, false)
+          };
+        }
+      }
+    } else {
+      const coerced = this.coerce(fieldDef, value);
+      switch (op) {
+        case "icontains":
+          return {
+            contains: coerced,
+            mode: "insensitive"
+          };
+        case "hasSome":
+        case "hasEvery": {
+          const values = value.split(",").filter((i) => i).map((v) => this.coerce(fieldDef, v));
+          return {
+            [op]: values
+          };
+        }
+        case "isEmpty":
+          if (value !== "true" && value !== "false") {
+            throw new InvalidValueError(`Not a boolean: ${value}`);
+          }
+          return {
+            isEmpty: value === "true" ? true : false
+          };
+        default:
+          if (op === void 0) {
+            if (fieldDef.attributes?.some((attr) => attr.name === "@json")) {
+              return {
+                equals: coerced
+              };
+            }
+            const values = value.split(",").filter((i) => i).map((v) => this.coerce(fieldDef, v));
+            return values.length > 1 ? {
+              in: values
+            } : {
+              equals: values[0]
+            };
+          } else {
+            return {
+              [op]: coerced
+            };
+          }
+      }
+    }
+  }
+  injectRelationQuery(type, injectTarget, injectKey, query) {
+    const { filter, error: filterError } = this.buildFilter(type, query);
+    if (filterError) {
+      return filterError;
+    }
+    if (filter) {
+      injectTarget[injectKey] = {
+        ...injectTarget[injectKey],
+        where: filter
+      };
+    }
+    const { sort, error: sortError } = this.buildSort(type, query);
+    if (sortError) {
+      return sortError;
+    }
+    if (sort) {
+      injectTarget[injectKey] = {
+        ...injectTarget[injectKey],
+        orderBy: sort
+      };
+    }
+    const pagination = this.getPagination(query);
+    const offset = pagination.offset;
+    if (offset > 0) {
+      injectTarget[injectKey] = {
+        ...injectTarget[injectKey],
+        skip: offset
+      };
+    }
+    const limit = pagination.limit;
+    if (limit !== Infinity) {
+      injectTarget[injectKey] = {
+        ...injectTarget[injectKey],
+        take: limit
+      };
+      injectTarget._count = {
+        select: {
+          [injectKey]: true
+        }
+      };
+    }
+  }
+  handleZenStackError(err) {
+    if (err instanceof InputValidationError) {
+      return this.makeError("validationError", err.message, 422, err.cause instanceof Error ? err.cause.message : void 0);
+    } else if (err instanceof RejectedByPolicyError) {
+      return this.makeError("forbidden", err.message, 403, err.reason);
+    } else if (err instanceof NotFoundError) {
+      return this.makeError("notFound", err.message);
+    } else if (err instanceof QueryError) {
+      return this.makeError("queryError", err.message, 400, err.cause instanceof Error ? err.cause.message : void 0);
+    } else {
+      return this.makeError("unknownError", err.message);
+    }
+  }
+  makeError(code, detail, status, reason) {
+    status = status ?? this.errors[code]?.status ?? 500;
+    const error = {
+      status,
+      code: paramCase(code),
+      title: this.errors[code]?.title
+    };
+    if (detail) {
+      error.detail = detail;
+    }
+    if (reason) {
+      error.reason = reason;
+    }
+    return {
+      status,
+      body: {
+        errors: [
+          error
+        ]
+      }
+    };
+  }
+  makeUnsupportedModelError(model) {
+    return this.makeError("unsupportedModel", `Model ${model} doesn't exist`);
+  }
+  makeUnsupportedRelationshipError(model, relationship, status) {
+    return this.makeError("unsupportedRelationship", `Relationship ${model}.${relationship} doesn't exist`, status);
+  }
+};
 
 // src/api/rpc/index.ts
+import { lowerCaseFirst as lowerCaseFirst2, safeJSONStringify } from "@zenstackhq/common-helpers";
+import { InputValidationError as InputValidationError2, NotFoundError as NotFoundError2, RejectedByPolicyError as RejectedByPolicyError2, ZenStackError as ZenStackError2 } from "@zenstackhq/orm";
+import SuperJSON3 from "superjson";
 registerCustomSerializers();
 var RPCApiHandler = class {
   static {
@@ -53,6 +1796,9 @@ var RPCApiHandler = class {
   get schema() {
     return this.options.schema;
   }
+  get log() {
+    return this.options.log;
+  }
   async handleRequest({ client, method, path, query, requestBody }) {
     const parts = path.split("/").filter((p) => !!p);
     const op = parts.pop();
@@ -60,7 +1806,7 @@ var RPCApiHandler = class {
     if (parts.length !== 0 || !op || !model) {
       return this.makeBadInputErrorResponse("invalid request path");
     }
-    model = lowerCaseFirst(model);
+    model = lowerCaseFirst2(model);
     method = method.toUpperCase();
     let args;
     let resCode = 200;
@@ -132,7 +1878,7 @@ var RPCApiHandler = class {
         data: clientResult
       };
       if (clientResult) {
-        const { json, meta } = SuperJSON2.serialize(clientResult);
+        const { json, meta } = SuperJSON3.serialize(clientResult);
         responseBody = {
           data: json
         };
@@ -150,7 +1896,7 @@ var RPCApiHandler = class {
       return response;
     } catch (err) {
       log(this.options.log, "error", `error occurred when handling "${model}.${op}" request`, err);
-      if (err instanceof ZenStackError) {
+      if (err instanceof ZenStackError2) {
         return this.makeZenStackErrorResponse(err);
       } else {
         return this.makeGenericErrorResponse(err);
@@ -158,7 +1904,7 @@ var RPCApiHandler = class {
     }
   }
   isValidModel(client, model) {
-    return Object.keys(client.$schema.models).some((m) => lowerCaseFirst(m) === lowerCaseFirst(model));
+    return Object.keys(client.$schema.models).some((m) => lowerCaseFirst2(m) === lowerCaseFirst2(model));
   }
   makeBadInputErrorResponse(message) {
     const resp = {
@@ -177,11 +1923,11 @@ var RPCApiHandler = class {
       status: 500,
       body: {
         error: {
-          message: err.message || "unknown error"
+          message: err instanceof Error ? err.message : "unknown error"
         }
       }
     };
-    log(this.options.log, "debug", () => `sending error response: ${safeJSONStringify(resp)}`);
+    log(this.options.log, "debug", () => `sending error response: ${safeJSONStringify(resp)}${err instanceof Error ? "\n" + err.stack : ""}`);
     return resp;
   }
   makeZenStackErrorResponse(err) {
@@ -192,14 +1938,14 @@ var RPCApiHandler = class {
     if (err.cause && err.cause instanceof Error) {
       error.cause = err.cause.message;
     }
-    if (err instanceof NotFoundError) {
+    if (err instanceof NotFoundError2) {
       status = 404;
       error.model = err.model;
-    } else if (err instanceof InputValidationError) {
+    } else if (err instanceof InputValidationError2) {
       status = 422;
       error.rejectedByValidation = true;
       error.model = err.model;
-    } else if (err instanceof RejectedByPolicyError) {
+    } else if (err instanceof RejectedByPolicyError2) {
       status = 403;
       error.rejectedByPolicy = true;
       error.rejectReason = err.reason;
@@ -218,7 +1964,7 @@ var RPCApiHandler = class {
     const { meta, ...rest } = args;
     if (meta?.serialization) {
       try {
-        args = SuperJSON2.deserialize({
+        args = SuperJSON3.deserialize({
           json: rest,
           meta: meta.serialization
         });
@@ -249,7 +1995,7 @@ var RPCApiHandler = class {
         throw new Error('invalid "meta" query parameter');
       }
       if (parsedMeta.serialization) {
-        return SuperJSON2.deserialize({
+        return SuperJSON3.deserialize({
           json: parsedValue,
           meta: parsedMeta.serialization
         });
@@ -259,6 +2005,7 @@ var RPCApiHandler = class {
   }
 };
 export {
-  RPCApiHandler
+  RPCApiHandler,
+  RestApiHandler
 };
 //# sourceMappingURL=api.js.map