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

package/advanced.js

@@ -0,0 +1,1025 @@
+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,
+  defineRequestSchema: () => defineRequestSchema,
+  distinctBodySchema: () => distinctBodySchema,
+  fromAjv: () => fromAjv,
+  fromArkType: () => fromArkType,
+  fromIoTs: () => fromIoTs,
+  fromJoi: () => fromJoi,
+  fromStandardSchema: () => fromStandardSchema,
+  fromSuperstruct: () => fromSuperstruct,
+  fromValibot: () => fromValibot,
+  fromVine: () => fromVine,
+  fromYup: () => fromYup,
+  fromZod: () => fromZod,
+  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(normalizeIssues(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(normalizeIssues(result.error.issues), void 0, "parameter");
+  }
+  return result.data;
+}
+function parseBody(schema, value) {
+  const result = schema.safeParse(value ?? {});
+  if (!result.success) {
+    throwValidationError(normalizeIssues(result.error.issues), void 0, "pointer");
+  }
+  return result.data;
+}
+function parseBodyWithSchema(schema, value, userSchema) {
+  const body = parseBody(schema, value);
+  return isRequestSchema(userSchema) ? parseUserSchema(userSchema, body) : Promise.resolve(body);
+}
+async function parseNestedBodyWithSchema(schema, value, nestedKey, userSchema) {
+  const body = parseBody(schema, value);
+  if (!isRequestSchema(userSchema)) return body;
+  return {
+    ...body,
+    [nestedKey]: await 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 });
+}
+async function parseUserSchema(schema, value, prefix = []) {
+  const validator = toRequestSchemaValidator(schema);
+  const result = await validator(value);
+  if (!isRequestSchemaFailure(result)) {
+    return result.data;
+  }
+  const issues = result.issues.map((issue) => ({
+    ...issue,
+    path: prefix.concat((issue.path ?? []).map(String))
+  }));
+  throwValidationError(issues, void 0, "pointer");
+}
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function";
+}
+function isRequestSchema(schema) {
+  return isZodSchema(schema) || isStandardSchema(schema) || isRequestSchemaValidator(schema) || isRequestSchemaAdapter(schema);
+}
+function isRequestSchemaValidator(schema) {
+  return typeof schema === "function";
+}
+function isRequestSchemaAdapter(schema) {
+  return typeof schema === "object" && schema !== null && "validate" in schema && typeof schema.validate === "function";
+}
+function isStandardSchema(schema) {
+  return typeof schema === "object" && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "validate" in schema["~standard"] && typeof schema["~standard"].validate === "function";
+}
+function isRequestSchemaFailure(result) {
+  return result.success === false;
+}
+function toRequestSchemaValidator(schema) {
+  if (isZodSchema(schema)) return fromZod(schema);
+  if (isStandardSchema(schema)) return fromStandardSchema(schema);
+  if (isRequestSchemaValidator(schema)) return schema;
+  return schema.validate;
+}
+function defineRequestSchema(validator) {
+  return validator;
+}
+function fromZod(schema) {
+  return (value) => {
+    const result = schema.safeParse(value);
+    if (result.success) {
+      return {
+        success: true,
+        data: result.data
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIssues(result.error.issues)
+    };
+  };
+}
+function fromStandardSchema(schema) {
+  return async (value) => {
+    const result = await schema["~standard"].validate(value);
+    if (!isStandardSchemaFailure(result)) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIssues(result.issues)
+    };
+  };
+}
+function fromYup(schema) {
+  return async (value) => {
+    try {
+      const data = await schema.validate(value, { abortEarly: false });
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeYupIssues(error)
+      };
+    }
+  };
+}
+function fromJoi(schema) {
+  return async (value) => {
+    const result = await schema.validate(value, { abortEarly: false });
+    if (!result.error?.details?.length) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeJoiIssues(result.error.details)
+    };
+  };
+}
+function fromAjv(validator) {
+  return async (value) => {
+    const valid = await validator(value);
+    if (valid) {
+      return {
+        success: true,
+        data: value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeAjvIssues(validator.errors ?? [])
+    };
+  };
+}
+function fromValibot(schema, safeParse) {
+  return async (value) => {
+    const result = await safeParse(schema, value, { abortEarly: false });
+    if (result.success) {
+      return {
+        success: true,
+        data: result.output
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeValibotIssues(result.issues)
+    };
+  };
+}
+function fromArkType(type) {
+  return async (value) => {
+    const result = await type(value);
+    if (!isArkTypeErrors(result)) {
+      return {
+        success: true,
+        data: result
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeArkTypeIssues(result)
+    };
+  };
+}
+function fromIoTs(decoder) {
+  return async (value) => {
+    const result = decoder.decode(value);
+    if (result._tag === "Right") {
+      return {
+        success: true,
+        data: result.right
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIoTsIssues(result.left)
+    };
+  };
+}
+function fromSuperstruct(struct, validate) {
+  return async (value) => {
+    const [failure, output] = await validate(value, struct);
+    if (!failure) {
+      return {
+        success: true,
+        data: output
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeSuperstructFailure(failure)
+    };
+  };
+}
+function fromVine(validator) {
+  return async (value) => {
+    try {
+      const output = await validator.validate(value);
+      return {
+        success: true,
+        data: output
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeVineError(error)
+      };
+    }
+  };
+}
+function isStandardSchemaFailure(result) {
+  return Array.isArray(result.issues);
+}
+function normalizeIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path?.flatMap((segment) => normalizePathSegment(segment))
+  }));
+}
+function normalizePathSegment(segment) {
+  const key = isStandardSchemaPathSegment(segment) ? segment.key : segment;
+  return typeof key === "string" || typeof key === "number" ? [key] : [];
+}
+function isStandardSchemaPathSegment(segment) {
+  return typeof segment === "object" && segment !== null && "key" in segment;
+}
+function normalizeYupIssues(error) {
+  if (!isYupValidationError(error)) {
+    return [{ message: "Validation failed" }];
+  }
+  const issues = error.inner?.length ? error.inner : [error];
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: parsePathString(issue.path)
+  }));
+}
+function normalizeJoiIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path ? [...issue.path] : void 0
+  }));
+}
+function normalizeAjvIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message ?? "Validation failed",
+    path: parseAjvPath(issue)
+  }));
+}
+function normalizeValibotIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path?.flatMap(
+      (item) => typeof item.key === "string" || typeof item.key === "number" ? [item.key] : []
+    )
+  }));
+}
+function normalizeArkTypeIssues(issues) {
+  const normalized = issues.map((issue) => ({
+    message: issue.message ?? issue.problem ?? issues.summary ?? "Validation failed",
+    path: issue.path ? [...issue.path] : void 0
+  }));
+  return normalized.length ? normalized : [{ message: issues.summary ?? "Validation failed" }];
+}
+function normalizeIoTsIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message ?? "Validation failed",
+    path: issue.context.map((entry) => entry.key).filter(Boolean)
+  }));
+}
+function normalizeSuperstructFailure(failure) {
+  const failures = failure.failures?.() ?? [failure];
+  return failures.map((entry) => ({
+    message: entry.message ?? "Validation failed",
+    path: normalizeSuperstructPath(entry)
+  }));
+}
+function normalizeSuperstructPath(failure) {
+  if (failure.path?.length) return [...failure.path];
+  if (typeof failure.key === "string" || typeof failure.key === "number") return [failure.key];
+  return void 0;
+}
+function normalizeVineError(error) {
+  if (!isVineValidationError(error)) {
+    return [{ message: "Validation failed" }];
+  }
+  return error.messages.map((message) => ({
+    message: message.message,
+    path: normalizeVineField(message)
+  }));
+}
+function normalizeVineField(message) {
+  const path = message.field.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+  if (typeof message.index === "number" && path.length === 0) {
+    return [message.index];
+  }
+  return path.length ? path : void 0;
+}
+function parseAjvPath(issue) {
+  const path = issue.instancePath?.split("/").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+  if (issue.params?.missingProperty) {
+    return (path ?? []).concat(issue.params.missingProperty);
+  }
+  return path;
+}
+function parsePathString(path) {
+  if (!path) return void 0;
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+}
+function isYupValidationError(error) {
+  return typeof error === "object" && error !== null && "message" in error;
+}
+function isArkTypeErrors(value) {
+  return Array.isArray(value);
+}
+function isVineValidationError(error) {
+  return typeof error === "object" && error !== null && "messages" in error && Array.isArray(error.messages);
+}
+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,
+  defineRequestSchema,
+  distinctBodySchema,
+  fromAjv,
+  fromArkType,
+  fromIoTs,
+  fromJoi,
+  fromStandardSchema,
+  fromSuperstruct,
+  fromValibot,
+  fromVine,
+  fromYup,
+  fromZod,
+  listBodySchema,
+  listQuerySchema,
+  parseBody,
+  parseBodyWithSchema,
+  parseNestedBodyWithSchema,
+  parsePathParam,
+  parseQuery,
+  readByIdBodySchema,
+  readFilterBodySchema,
+  readQuerySchema,
+  requestSchemas,
+  rootQuerySchema,
+  subListBodySchema,
+  subMutationBodySchema,
+  subReadBodySchema,
+  updateBodySchema,
+  updateQuerySchema,
+  upsertBodySchema,
+  upsertQuerySchema
+});