@web-ts-toolkit/access-router 0.2.0 → 0.3.0

package/advanced.js

@@ -0,0 +1,719 @@
+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 __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/advanced.ts
+var advanced_exports = {};
+__export(advanced_exports, {
+  CORE: () => CORE,
+  Codes: () => Codes,
+  CustomHeaders: () => CustomHeaders,
+  DATA_MIDDLEWARE: () => DATA_MIDDLEWARE,
+  FilterOperator: () => FilterOperator,
+  MIDDLEWARE: () => MIDDLEWARE,
+  PERMISSIONS: () => PERMISSIONS,
+  PERMISSION_KEYS: () => PERMISSION_KEYS,
+  StatusCodes: () => StatusCodes,
+  advancedCreateBodySchema: () => advancedCreateBodySchema,
+  advancedUpdateBodySchema: () => advancedUpdateBodySchema,
+  advancedUpsertBodySchema: () => advancedUpsertBodySchema,
+  countBodySchema: () => countBodySchema,
+  createBodySchema: () => createBodySchema,
+  createQuerySchema: () => createQuerySchema,
+  dataListBodySchema: () => dataListBodySchema,
+  dataReadByIdBodySchema: () => dataReadByIdBodySchema,
+  dataReadFilterBodySchema: () => dataReadFilterBodySchema,
+  distinctBodySchema: () => distinctBodySchema,
+  listBodySchema: () => listBodySchema,
+  listQuerySchema: () => listQuerySchema,
+  parseBody: () => parseBody,
+  parseBodyWithSchema: () => parseBodyWithSchema,
+  parseNestedBodyWithSchema: () => parseNestedBodyWithSchema,
+  parsePathParam: () => parsePathParam,
+  parseQuery: () => parseQuery,
+  readByIdBodySchema: () => readByIdBodySchema,
+  readFilterBodySchema: () => readFilterBodySchema,
+  readQuerySchema: () => readQuerySchema,
+  requestSchemas: () => requestSchemas,
+  rootQuerySchema: () => rootQuerySchema,
+  subListBodySchema: () => subListBodySchema,
+  subMutationBodySchema: () => subMutationBodySchema,
+  subReadBodySchema: () => subReadBodySchema,
+  updateBodySchema: () => updateBodySchema,
+  updateQuerySchema: () => updateQuerySchema,
+  upsertBodySchema: () => upsertBodySchema,
+  upsertQuerySchema: () => upsertQuerySchema
+});
+module.exports = __toCommonJS(advanced_exports);
+
+// src/symbols.ts
+var MIDDLEWARE = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/middleware");
+var DATA_MIDDLEWARE = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/data-middleware");
+var CORE = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/core");
+var PERMISSIONS = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/permissions");
+var PERMISSION_KEYS = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/permission-keys");
+
+// src/enums.ts
+var StatusCodes = /* @__PURE__ */ ((StatusCodes2) => {
+  StatusCodes2[StatusCodes2["OK"] = 200] = "OK";
+  StatusCodes2[StatusCodes2["Created"] = 201] = "Created";
+  StatusCodes2[StatusCodes2["BadRequest"] = 400] = "BadRequest";
+  StatusCodes2[StatusCodes2["Unauthorized"] = 401] = "Unauthorized";
+  StatusCodes2[StatusCodes2["Forbidden"] = 403] = "Forbidden";
+  StatusCodes2[StatusCodes2["NotFound"] = 404] = "NotFound";
+  StatusCodes2[StatusCodes2["UnprocessableContent"] = 422] = "UnprocessableContent";
+  return StatusCodes2;
+})(StatusCodes || {});
+var Codes = /* @__PURE__ */ ((Codes2) => {
+  Codes2["Success"] = "success";
+  Codes2["Created"] = "created";
+  Codes2["BadRequest"] = "bad_request";
+  Codes2["Unauthorized"] = "unauthorized";
+  Codes2["Forbidden"] = "forbidden";
+  Codes2["NotFound"] = "not_found";
+  return Codes2;
+})(Codes || {});
+var CustomHeaders = /* @__PURE__ */ ((CustomHeaders2) => {
+  CustomHeaders2["TotalCount"] = "wtt-total-count";
+  CustomHeaders2["ReturnedCount"] = "wtt-returned-count";
+  CustomHeaders2["Page"] = "wtt-page";
+  CustomHeaders2["PageSize"] = "wtt-page-size";
+  CustomHeaders2["TotalPages"] = "wtt-total-pages";
+  CustomHeaders2["HasNextPage"] = "wtt-has-next-page";
+  CustomHeaders2["HasPreviousPage"] = "wtt-has-previous-page";
+  return CustomHeaders2;
+})(CustomHeaders || {});
+var FilterOperator = /* @__PURE__ */ ((FilterOperator2) => {
+  FilterOperator2[FilterOperator2["SubQuery"] = 0] = "SubQuery";
+  FilterOperator2[FilterOperator2["Date"] = 1] = "Date";
+  return FilterOperator2;
+})(FilterOperator || {});
+
+// src/validation/parsers.ts
+var import_express_json_router = __toESM(require("@web-ts-toolkit/express-json-router"));
+
+// src/validation/common.ts
+var import_zod = require("zod");
+var stringOrStringArray = import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]);
+var queryBooleanString = import_zod.z.enum(["true", "false"]);
+var positiveIntegerString = import_zod.z.string().regex(/^\d+$/, "Expected a non-negative integer");
+var nonNegativeIntegerSchema = import_zod.z.number().int().min(0);
+var unknownRecord = import_zod.z.record(import_zod.z.string(), import_zod.z.unknown());
+var projectionObjectSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(-1)]));
+var projectionSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string()), projectionObjectSchema]);
+var sortOrderSchema = import_zod.z.union([
+  import_zod.z.literal(-1),
+  import_zod.z.literal(1),
+  import_zod.z.literal("asc"),
+  import_zod.z.literal("ascending"),
+  import_zod.z.literal("desc"),
+  import_zod.z.literal("descending")
+]);
+var sortSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.record(import_zod.z.string(), sortOrderSchema),
+  import_zod.z.array(import_zod.z.tuple([import_zod.z.string(), sortOrderSchema])),
+  import_zod.z.null()
+]);
+var populateSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.array(
+    import_zod.z.union([
+      import_zod.z.string(),
+      import_zod.z.object({
+        path: import_zod.z.string().min(1),
+        select: projectionSchema.optional(),
+        match: import_zod.z.unknown().optional(),
+        access: import_zod.z.enum(["list", "read"]).optional()
+      }).passthrough()
+    ])
+  ),
+  import_zod.z.object({
+    path: import_zod.z.string().min(1),
+    select: projectionSchema.optional(),
+    match: import_zod.z.unknown().optional(),
+    access: import_zod.z.enum(["list", "read"]).optional()
+  }).passthrough()
+]);
+var subPopulateSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.array(
+    import_zod.z.union([
+      import_zod.z.string(),
+      import_zod.z.object({
+        path: import_zod.z.string().min(1),
+        select: projectionSchema.optional()
+      }).passthrough()
+    ])
+  ),
+  import_zod.z.object({
+    path: import_zod.z.string().min(1),
+    select: projectionSchema.optional()
+  }).passthrough()
+]);
+var includeItemSchema = import_zod.z.object({
+  model: import_zod.z.string().min(1),
+  op: import_zod.z.enum(["list", "read", "count"]),
+  path: import_zod.z.string().min(1),
+  filter: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  localField: import_zod.z.string().min(1),
+  foreignField: import_zod.z.string().min(1),
+  args: import_zod.z.unknown().optional(),
+  options: import_zod.z.unknown().optional()
+}).passthrough();
+var includeSchema = import_zod.z.union([includeItemSchema, import_zod.z.array(includeItemSchema)]);
+var fieldsSchema = import_zod.z.array(import_zod.z.string().min(1));
+var taskSchema = import_zod.z.object({
+  type: import_zod.z.string().min(1),
+  args: import_zod.z.unknown(),
+  options: unknownRecord.optional()
+});
+var tasksSchema = import_zod.z.union([taskSchema, import_zod.z.array(taskSchema)]);
+var objectOrArraySchema = import_zod.z.union([import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()), import_zod.z.array(import_zod.z.unknown())]);
+function rejectKeys(body, ctx, keys) {
+  for (const key of keys) {
+    if (key in body) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: `Unsupported field: ${key}`,
+        path: [key]
+      });
+    }
+  }
+}
+
+// src/validation/parsers.ts
+var clientErrors = import_express_json_router.default.clientErrors;
+function parsePathParam(value, parameter) {
+  const result = stringOrStringArray.safeParse(value);
+  if (!result.success) {
+    throwValidationError(result.error.issues, parameter, "parameter");
+  }
+  const param = Array.isArray(result.data) ? result.data[0] : result.data;
+  if (!param) {
+    throw new clientErrors.BadRequestError("Bad Request", {
+      errors: [{ detail: "Required", parameter }]
+    });
+  }
+  return param;
+}
+function parseQuery(schema, value) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    throwValidationError(result.error.issues, void 0, "parameter");
+  }
+  return result.data;
+}
+function parseBody(schema, value) {
+  const result = schema.safeParse(value ?? {});
+  if (!result.success) {
+    throwValidationError(result.error.issues, void 0, "pointer");
+  }
+  return result.data;
+}
+function parseBodyWithSchema(schema, value, userSchema) {
+  const body = parseBody(schema, value);
+  return isZodSchema(userSchema) ? parseUserSchema(userSchema, body) : body;
+}
+function parseNestedBodyWithSchema(schema, value, nestedKey, userSchema) {
+  const body = parseBody(schema, value);
+  if (!isZodSchema(userSchema)) return body;
+  return {
+    ...body,
+    [nestedKey]: parseUserSchema(userSchema, body?.[nestedKey], [nestedKey])
+  };
+}
+function throwValidationError(issues, key, location = "pointer") {
+  const errors = issues.map((issue) => formatIssue(issue, key, location));
+  throw new clientErrors.BadRequestError("Bad Request", { errors });
+}
+function parseUserSchema(schema, value, prefix = []) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => ({
+      ...issue,
+      path: prefix.concat(issue.path.map(String))
+    }));
+    throwValidationError(issues, void 0, "pointer");
+  }
+  return result.data;
+}
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function";
+}
+function formatIssue(issue, key, location = "pointer") {
+  const path = issue.path.map(String);
+  const joinedPath = path.join(".");
+  if (location === "parameter") {
+    return {
+      detail: issue.message,
+      parameter: (key ?? joinedPath) || void 0
+    };
+  }
+  return {
+    detail: issue.message,
+    pointer: buildPointer(path)
+  };
+}
+function buildPointer(path) {
+  return path.length === 0 ? "#" : `#/${path.join("/")}`;
+}
+
+// src/validation/model-router.ts
+var import_zod2 = require("zod");
+var listQuerySchema = import_zod2.z.object({
+  skip: positiveIntegerString.optional(),
+  limit: positiveIntegerString.optional(),
+  page: positiveIntegerString.optional(),
+  page_size: positiveIntegerString.optional(),
+  skim: queryBooleanString.optional(),
+  include_permissions: queryBooleanString.optional(),
+  include_count: queryBooleanString.optional(),
+  include_extra_headers: queryBooleanString.optional()
+}).passthrough();
+var createQuerySchema = import_zod2.z.object({
+  include_permissions: queryBooleanString.optional()
+}).passthrough();
+var readQuerySchema = import_zod2.z.object({
+  include_permissions: queryBooleanString.optional(),
+  try_list: queryBooleanString.optional()
+}).passthrough();
+var updateQuerySchema = import_zod2.z.object({
+  returning_all: queryBooleanString.optional(),
+  include_permissions: queryBooleanString.optional()
+}).passthrough();
+var upsertQuerySchema = import_zod2.z.object({
+  returning_all: queryBooleanString.optional(),
+  include_permissions: queryBooleanString.optional()
+}).passthrough();
+var listBodySchema = import_zod2.z.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional(),
+  sort: sortSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional(),
+  skip: import_zod2.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: import_zod2.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: import_zod2.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: import_zod2.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  options: import_zod2.z.object({
+    skim: import_zod2.z.boolean().optional(),
+    includePermissions: import_zod2.z.boolean().optional(),
+    includeCount: import_zod2.z.boolean().optional(),
+    includeExtraHeaders: import_zod2.z.boolean().optional(),
+    populateAccess: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["query"]));
+var countBodySchema = import_zod2.z.object({
+  filter: objectOrArraySchema.optional(),
+  options: import_zod2.z.object({
+    access: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["query", "access"]));
+var readFilterBodySchema = import_zod2.z.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional(),
+  sort: sortSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: import_zod2.z.object({
+    skim: import_zod2.z.boolean().optional(),
+    includePermissions: import_zod2.z.boolean().optional(),
+    tryList: import_zod2.z.boolean().optional(),
+    populateAccess: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var readByIdBodySchema = import_zod2.z.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: import_zod2.z.object({
+    skim: import_zod2.z.boolean().optional(),
+    includePermissions: import_zod2.z.boolean().optional(),
+    tryList: import_zod2.z.boolean().optional(),
+    populateAccess: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var advancedCreateBodySchema = import_zod2.z.object({
+  data: import_zod2.z.unknown(),
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: import_zod2.z.object({
+    includePermissions: import_zod2.z.boolean().optional(),
+    populateAccess: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var createBodySchema = import_zod2.z.union([
+  import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
+  import_zod2.z.array(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()))
+]);
+var updateBodySchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown());
+var advancedUpdateBodySchema = import_zod2.z.object({
+  data: import_zod2.z.unknown(),
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: import_zod2.z.object({
+    returningAll: import_zod2.z.boolean().optional(),
+    includePermissions: import_zod2.z.boolean().optional(),
+    populateAccess: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var upsertBodySchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown());
+var advancedUpsertBodySchema = import_zod2.z.object({
+  data: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: import_zod2.z.object({
+    returningAll: import_zod2.z.boolean().optional(),
+    includePermissions: import_zod2.z.boolean().optional(),
+    populateAccess: import_zod2.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var distinctBodySchema = import_zod2.z.object({
+  filter: objectOrArraySchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["query"]));
+var subListBodySchema = import_zod2.z.object({
+  filter: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  select: fieldsSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["fields"]));
+var subMutationBodySchema = import_zod2.z.union([
+  import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
+  import_zod2.z.array(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()))
+]);
+var subReadBodySchema = import_zod2.z.object({
+  select: fieldsSchema.optional(),
+  populate: subPopulateSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["fields"]));
+var requestSchemas = {
+  listQuery: listQuerySchema,
+  createQuery: createQuerySchema,
+  readQuery: readQuerySchema,
+  updateQuery: updateQuerySchema,
+  upsertQuery: upsertQuerySchema
+};
+
+// src/validation/data-router.ts
+var import_zod3 = require("zod");
+var dataListBodySchema = import_zod3.z.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional(),
+  sort: import_zod3.z.string().optional(),
+  skip: import_zod3.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: import_zod3.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: import_zod3.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: import_zod3.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  options: import_zod3.z.object({
+    includeCount: import_zod3.z.boolean().optional(),
+    includeExtraHeaders: import_zod3.z.boolean().optional()
+  }).passthrough().optional()
+}).passthrough();
+var dataReadFilterBodySchema = import_zod3.z.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["options"]));
+var dataReadByIdBodySchema = import_zod3.z.object({
+  select: projectionSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["options"]));
+
+// src/validation/root-router.ts
+var import_zod4 = require("zod");
+var rootEntryBaseSchema = {
+  target: import_zod4.z.enum(["model", "data"]),
+  name: import_zod4.z.string().min(1),
+  order: import_zod4.z.number().int().optional()
+};
+var rootModelListArgsSchema = import_zod4.z.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  sort: sortSchema.optional(),
+  skip: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelListOptionsSchema = import_zod4.z.object({
+  skim: import_zod4.z.boolean().optional(),
+  includePermissions: import_zod4.z.boolean().optional(),
+  includeCount: import_zod4.z.boolean().optional(),
+  populateAccess: import_zod4.z.unknown().optional(),
+  lean: import_zod4.z.boolean().optional()
+}).passthrough();
+var rootModelReadArgsSchema = import_zod4.z.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelReadFilterArgsSchema = rootModelReadArgsSchema.extend({
+  sort: sortSchema.optional()
+});
+var rootModelReadOptionsSchema = import_zod4.z.object({
+  skim: import_zod4.z.boolean().optional(),
+  includePermissions: import_zod4.z.boolean().optional(),
+  tryList: import_zod4.z.boolean().optional(),
+  populateAccess: import_zod4.z.unknown().optional(),
+  lean: import_zod4.z.boolean().optional()
+}).passthrough();
+var rootModelCreateArgsSchema = import_zod4.z.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelCreateOptionsSchema = import_zod4.z.object({
+  skim: import_zod4.z.boolean().optional(),
+  includePermissions: import_zod4.z.boolean().optional(),
+  populateAccess: import_zod4.z.unknown().optional()
+}).passthrough();
+var rootModelUpdateArgsSchema = import_zod4.z.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelUpdateOptionsSchema = import_zod4.z.object({
+  skim: import_zod4.z.boolean().optional(),
+  returningAll: import_zod4.z.boolean().optional(),
+  includePermissions: import_zod4.z.boolean().optional(),
+  populateAccess: import_zod4.z.unknown().optional()
+}).passthrough();
+var rootModelUpsertArgsSchema = rootModelUpdateArgsSchema;
+var rootModelUpsertOptionsSchema = rootModelUpdateOptionsSchema;
+var rootModelSubListArgsSchema = import_zod4.z.object({
+  select: fieldsSchema.optional()
+}).passthrough();
+var rootModelSubReadArgsSchema = import_zod4.z.object({
+  select: fieldsSchema.optional(),
+  populate: subPopulateSchema.optional()
+}).passthrough();
+var rootModelCountOptionsSchema = import_zod4.z.object({
+  access: import_zod4.z.unknown().optional()
+}).passthrough();
+var rootDataListArgsSchema = import_zod4.z.object({
+  select: projectionSchema.optional(),
+  sort: import_zod4.z.string().optional(),
+  skip: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: import_zod4.z.union([nonNegativeIntegerSchema, positiveIntegerString]).optional()
+}).passthrough();
+var rootDataListOptionsSchema = import_zod4.z.object({
+  includeCount: import_zod4.z.boolean().optional()
+}).passthrough();
+var rootDataReadArgsSchema = import_zod4.z.object({
+  select: projectionSchema.optional()
+}).passthrough();
+var rootModelQueryEntrySchema = import_zod4.z.union([
+  import_zod4.z.object({ ...rootEntryBaseSchema, target: import_zod4.z.literal("model"), op: import_zod4.z.literal("new") }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("list"),
+    filter: objectOrArraySchema.optional(),
+    args: rootModelListArgsSchema.optional(),
+    options: rootModelListOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("read"),
+    id: import_zod4.z.string().min(1),
+    args: rootModelReadArgsSchema.optional(),
+    options: rootModelReadOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("read"),
+    filter: objectOrArraySchema,
+    args: rootModelReadFilterArgsSchema.optional(),
+    options: rootModelReadOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("create"),
+    data: import_zod4.z.unknown(),
+    args: rootModelCreateArgsSchema.optional(),
+    options: rootModelCreateOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("update"),
+    id: import_zod4.z.string().min(1),
+    data: import_zod4.z.unknown(),
+    args: rootModelUpdateArgsSchema.optional(),
+    options: rootModelUpdateOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("upsert"),
+    data: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()),
+    args: rootModelUpsertArgsSchema.optional(),
+    options: rootModelUpsertOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({ ...rootEntryBaseSchema, target: import_zod4.z.literal("model"), op: import_zod4.z.literal("delete"), id: import_zod4.z.string().min(1) }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("subList"),
+    id: import_zod4.z.string().min(1),
+    sub: import_zod4.z.string().min(1),
+    filter: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
+    args: rootModelSubListArgsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("subRead"),
+    id: import_zod4.z.string().min(1),
+    sub: import_zod4.z.string().min(1),
+    subId: import_zod4.z.string().min(1),
+    args: rootModelSubReadArgsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("subCreate"),
+    id: import_zod4.z.string().min(1),
+    sub: import_zod4.z.string().min(1),
+    data: import_zod4.z.union([import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()), import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()))])
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("subUpdate"),
+    id: import_zod4.z.string().min(1),
+    sub: import_zod4.z.string().min(1),
+    subId: import_zod4.z.string().min(1),
+    data: import_zod4.z.union([import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()), import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()))])
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("subBulkUpdate"),
+    id: import_zod4.z.string().min(1),
+    sub: import_zod4.z.string().min(1),
+    data: import_zod4.z.union([import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()), import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()))])
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("subDelete"),
+    id: import_zod4.z.string().min(1),
+    sub: import_zod4.z.string().min(1),
+    subId: import_zod4.z.string().min(1)
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("distinct"),
+    field: import_zod4.z.string().min(1),
+    filter: objectOrArraySchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("model"),
+    op: import_zod4.z.literal("count"),
+    filter: objectOrArraySchema.optional(),
+    options: rootModelCountOptionsSchema.optional()
+  }).passthrough()
+]);
+var rootDataQueryEntrySchema = import_zod4.z.union([
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("data"),
+    op: import_zod4.z.literal("list"),
+    filter: objectOrArraySchema.optional(),
+    args: rootDataListArgsSchema.optional(),
+    options: rootDataListOptionsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("data"),
+    op: import_zod4.z.literal("read"),
+    id: import_zod4.z.string().min(1),
+    args: rootDataReadArgsSchema.optional()
+  }).passthrough(),
+  import_zod4.z.object({
+    ...rootEntryBaseSchema,
+    target: import_zod4.z.literal("data"),
+    op: import_zod4.z.literal("read"),
+    filter: objectOrArraySchema,
+    args: rootDataReadArgsSchema.optional()
+  }).passthrough()
+]);
+var rootQuerySchema = import_zod4.z.array(import_zod4.z.union([rootModelQueryEntrySchema, rootDataQueryEntrySchema]));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CORE,
+  Codes,
+  CustomHeaders,
+  DATA_MIDDLEWARE,
+  FilterOperator,
+  MIDDLEWARE,
+  PERMISSIONS,
+  PERMISSION_KEYS,
+  StatusCodes,
+  advancedCreateBodySchema,
+  advancedUpdateBodySchema,
+  advancedUpsertBodySchema,
+  countBodySchema,
+  createBodySchema,
+  createQuerySchema,
+  dataListBodySchema,
+  dataReadByIdBodySchema,
+  dataReadFilterBodySchema,
+  distinctBodySchema,
+  listBodySchema,
+  listQuerySchema,
+  parseBody,
+  parseBodyWithSchema,
+  parseNestedBodyWithSchema,
+  parsePathParam,
+  parseQuery,
+  readByIdBodySchema,
+  readFilterBodySchema,
+  readQuerySchema,
+  requestSchemas,
+  rootQuerySchema,
+  subListBodySchema,
+  subMutationBodySchema,
+  subReadBodySchema,
+  updateBodySchema,
+  updateQuerySchema,
+  upsertBodySchema,
+  upsertQuerySchema
+});