@web-ts-toolkit/access-router 0.38.0 → 0.40.0

package/advanced.js

@@ -128,47 +128,51 @@ var import_express_json_router = __toESM(require("@web-ts-toolkit/express-json-r
 // src/runtime.ts
 var import_mongoose2 = __toESM(require("mongoose"));
 var import_mongoose_schema_jsonschema = __toESM(require("mongoose-schema-jsonschema"));
-var import_utils7 = require("@web-ts-toolkit/utils");
+var import_utils8 = require("@web-ts-toolkit/utils");
+
+// src/helpers/query.ts
+var import_utils = require("@web-ts-toolkit/utils");
+var DEFAULT_LIST_HARD_LIMIT = 1e3;
 
 // src/helpers/index.ts
-var import_utils2 = require("@web-ts-toolkit/utils");
+var import_utils3 = require("@web-ts-toolkit/utils");
 
 // src/lib.ts
 var import_mongoose = require("mongoose");
-var import_utils = require("@web-ts-toolkit/utils");
+var import_utils2 = require("@web-ts-toolkit/utils");
 var isSchema = (val) => val instanceof import_mongoose.Schema;
 var isObjectIdType = (val) => val === "ObjectId" || val === import_mongoose.Schema.Types.ObjectId;
-var isReference = (val) => (0, import_utils.isPlainObject)(val) && !!val.ref && isObjectIdType(val.type);
+var isReference = (val) => (0, import_utils2.isPlainObject)(val) && !!val.ref && isObjectIdType(val.type);
 
 // src/helpers/index.ts
 function recurseObject(obj) {
   if (isSchema(obj)) {
     return buildRefs(obj.tree);
   }
-  if (!(0, import_utils2.isObject)(obj)) return null;
+  if (!(0, import_utils3.isObject)(obj)) return null;
   if (isReference(obj)) {
     return obj.ref;
   }
   let ret = null;
-  (0, import_utils2.forEach)(obj, (val) => {
+  (0, import_utils3.forEach)(obj, (val) => {
     ret = recurseObject(val);
-    if (!(0, import_utils2.isEmpty)(ret)) {
+    if (!(0, import_utils3.isEmpty)(ret)) {
       return false;
     }
   });
   return ret;
 }
 function buildRefs(schema) {
-  if (!(0, import_utils2.isObject)(schema)) return {};
+  if (!(0, import_utils3.isObject)(schema)) return {};
   const references = {};
-  (0, import_utils2.forEach)(schema, (val, key) => {
+  (0, import_utils3.forEach)(schema, (val, key) => {
     const paths = recurseObject(val);
-    if (!(0, import_utils2.isEmpty)(paths)) {
+    if (!(0, import_utils3.isEmpty)(paths)) {
       references[key] = paths;
     }
-    const target = (0, import_utils2.isObject)(val) && "type" in val ? val.type ?? val : val;
-    if ((0, import_utils2.isArray)(target) && target.length > 0) {
-      if (isSchema(target[0]) || (0, import_utils2.isPlainObject)(target[0])) {
+    const target = (0, import_utils3.isObject)(val) && "type" in val ? val.type ?? val : val;
+    if ((0, import_utils3.isArray)(target) && target.length > 0) {
+      if (isSchema(target[0]) || (0, import_utils3.isPlainObject)(target[0])) {
         return;
       }
     }
@@ -176,12 +180,12 @@ function buildRefs(schema) {
   return references;
 }
 function buildSubPaths(schema) {
-  if (!(0, import_utils2.isObject)(schema)) return [];
+  if (!(0, import_utils3.isObject)(schema)) return [];
   const subPaths = [];
-  (0, import_utils2.forEach)(schema, (val, key) => {
-    const target = (0, import_utils2.isObject)(val) && "type" in val ? val.type ?? val : val;
-    if ((0, import_utils2.isArray)(target) && target.length > 0) {
-      if (isSchema(target[0]) || (0, import_utils2.isPlainObject)(target[0]) && !isReference(target[0])) {
+  (0, import_utils3.forEach)(schema, (val, key) => {
+    const target = (0, import_utils3.isObject)(val) && "type" in val ? val.type ?? val : val;
+    if ((0, import_utils3.isArray)(target) && target.length > 0) {
+      if (isSchema(target[0]) || (0, import_utils3.isPlainObject)(target[0]) && !isReference(target[0])) {
         subPaths.push(key);
       }
     }
@@ -190,7 +194,7 @@ function buildSubPaths(schema) {
 }
 
 // src/openapi/build-spec.ts
-var import_utils4 = require("@web-ts-toolkit/utils");
+var import_utils5 = require("@web-ts-toolkit/utils");
 
 // src/openapi/responses.ts
 var json = (schema) => ({
@@ -261,19 +265,19 @@ var openApiResponses = {
 
 // src/openapi/schemas.ts
 var import_zod = require("zod");
-var import_utils3 = require("@web-ts-toolkit/utils");
+var import_utils4 = require("@web-ts-toolkit/utils");
 var fallbackObjectSchema = { type: "object", additionalProperties: true };
 function isOpenApiSchemaPatch(source) {
-  return (0, import_utils3.isPlainObject)(source) && source.kind === "objectProperties";
+  return (0, import_utils4.isPlainObject)(source) && source.kind === "objectProperties";
 }
 function isOpenApiSchemaResolver(source) {
-  return (0, import_utils3.isPlainObject)(source) && source.kind === "schemaResolver" && typeof source.resolve === "function";
+  return (0, import_utils4.isPlainObject)(source) && source.kind === "schemaResolver" && typeof source.resolve === "function";
 }
 function isJsonSchemaLike(source) {
-  return (0, import_utils3.isPlainObject)(source) && ("type" in source || "properties" in source || "$ref" in source || "anyOf" in source);
+  return (0, import_utils4.isPlainObject)(source) && ("type" in source || "properties" in source || "$ref" in source || "anyOf" in source);
 }
 function hasOpenApiSchema(source) {
-  return (0, import_utils3.isPlainObject)(source) && isJsonSchemaLike(source.openapi);
+  return (0, import_utils4.isPlainObject)(source) && isJsonSchemaLike(source.openapi);
 }
 function toOpenApiSchema(source) {
   if (!source) return void 0;
@@ -281,7 +285,7 @@ function toOpenApiSchema(source) {
   if (!resolvedSource) return void 0;
   if (isOpenApiSchemaPatch(resolvedSource)) {
     const schema = toOpenApiSchema(resolvedSource.source) ?? { ...fallbackObjectSchema };
-    const properties = (0, import_utils3.isPlainObject)(schema.properties) ? { ...schema.properties } : {};
+    const properties = (0, import_utils4.isPlainObject)(schema.properties) ? { ...schema.properties } : {};
     for (const [key, value] of Object.entries(resolvedSource.properties)) {
       properties[key] = toOpenApiSchema(value) ?? fallbackObjectSchema;
     }
@@ -314,9 +318,9 @@ var toOpenApiPath = (path) => normalizePath(path).replace(/:([A-Za-z0-9_]+)/g, "
 var schemaToQueryParameters = (schema) => {
   const jsonSchema = toOpenApiSchema(schema);
   if (!jsonSchema || jsonSchema.type !== "object") return [];
-  const properties = (0, import_utils4.isPlainObject)(jsonSchema.properties) ? jsonSchema.properties : {};
+  const properties = (0, import_utils5.isPlainObject)(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = new Set(
-    (0, import_utils4.isArray)(jsonSchema.required) ? jsonSchema.required.filter((item) => typeof item === "string") : []
+    (0, import_utils5.isArray)(jsonSchema.required) ? jsonSchema.required.filter((item) => typeof item === "string") : []
   );
   return Object.entries(properties).map(([name, value]) => ({
     name,
@@ -407,7 +411,7 @@ var OpenApiCollisionError = class extends Error {
 };
 
 // src/openapi/registry.ts
-var isPlainObject5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isPlainObject6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var stableKey = (value) => {
   if (value === null || typeof value === "undefined") return "null";
   if (typeof value === "function") return "[Function]";
@@ -442,7 +446,7 @@ var OpenApiRegistry = class {
       this.routes[existingIndex] = route;
       return;
     }
-    if (descriptorsEqual(existing, route) && (route.idempotent || isPlainObject5(existing) && existing.idempotent)) {
+    if (descriptorsEqual(existing, route) && (route.idempotent || isPlainObject6(existing) && existing.idempotent)) {
       return;
     }
     if (this.options.rejectConflicts) {
@@ -520,7 +524,43 @@ var defaultLogger = (0, import_winston.createLogger)({
 });
 
 // src/options/manager.ts
-var import_utils5 = require("@web-ts-toolkit/utils");
+var import_utils6 = require("@web-ts-toolkit/utils");
+var toPath = (key) => {
+  if (Array.isArray(key)) return key;
+  return typeof key === "string" ? key.split(".") : [key];
+};
+var cloneConfigValue = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneConfigValue(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([entryKey, entryValue]) => [
+      entryKey,
+      cloneConfigValue(entryValue)
+    ])
+  );
+};
+var freezeConfigValue = (value) => {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (Object.isFrozen(value)) {
+    return value;
+  }
+  if (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype) {
+    for (const nestedValue of Object.values(value)) {
+      freezeConfigValue(nestedValue);
+    }
+    return Object.freeze(value);
+  }
+  return value;
+};
 var getNestedOption = (manager, key, defaultValue) => {
   const keys2 = String(key).split(".");
   if (keys2.length === 1) {
@@ -538,8 +578,9 @@ var getNestedOption = (manager, key, defaultValue) => {
   return option;
 };
 var OptionsManager = class {
-  constructor(defaultOptions) {
+  constructor(defaultOptions, options = {}) {
     this.defaultOptions = defaultOptions;
+    this.preserveKeys = new Set(options.preserveKeys ?? []);
     this.listeners = {};
     const _this = this;
     this.currentOptions = new Proxy({}, {
@@ -557,25 +598,46 @@ var OptionsManager = class {
     return this;
   }
   get(key, defaultValue) {
-    return (0, import_utils5.get)(this.currentOptions, key, defaultValue);
+    return (0, import_utils6.get)(this.currentOptions, key, defaultValue);
   }
   set(key, value) {
-    (0, import_utils5.set)(this.currentOptions, key, value);
+    const path = toPath(key);
+    if (path.length <= 1) {
+      (0, import_utils6.set)(this.currentOptions, path, this.preserveKeys.has(String(path[0])) ? value : cloneConfigValue(value));
+      return;
+    }
+    const [rootKey, ...nestedPath] = path;
+    const currentRoot = (0, import_utils6.get)(this.currentOptions, [rootKey], void 0);
+    const nextRoot = cloneConfigValue(currentRoot ?? {});
+    (0, import_utils6.set)(nextRoot, nestedPath, cloneConfigValue(value));
+    (0, import_utils6.set)(this.currentOptions, [rootKey], nextRoot);
   }
   fetch() {
-    return { ...this.currentOptions };
+    const cloned = cloneConfigValue(this.currentOptions);
+    for (const key of this.preserveKeys) {
+      if (key in this.currentOptions) {
+        cloned[key] = this.currentOptions[key];
+      }
+    }
+    return freezeConfigValue(cloned);
   }
   assign(options) {
-    (0, import_utils5.assign)(this.currentOptions, options);
+    const cloned = cloneConfigValue(options);
+    for (const key of this.preserveKeys) {
+      if (key in options) {
+        cloned[key] = options[key];
+      }
+    }
+    (0, import_utils6.assign)(this.currentOptions, cloned);
   }
   onchange(key, func) {
-    (0, import_utils5.set)(this.listeners, key, func);
+    (0, import_utils6.set)(this.listeners, key, func);
     return this;
   }
 };
 
 // src/request-complexity.ts
-var import_utils6 = require("@web-ts-toolkit/utils");
+var import_utils7 = require("@web-ts-toolkit/utils");
 var defaultRequestComplexity = {
   maxDepth: 8,
   maxNodes: 500,
@@ -584,7 +646,8 @@ var defaultRequestComplexity = {
   maxBulkItems: 100,
   maxIncludeCount: 10,
   maxSubQueryCount: 10,
-  maxBulkConcurrency: 10
+  maxBulkConcurrency: 10,
+  maxHookConcurrency: 10
 };
 var normalizePositiveInteger = (value, fallback) => {
   return Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : fallback;
@@ -600,6 +663,10 @@ var resolveRequestComplexity = (options) => ({
   maxBulkConcurrency: normalizePositiveInteger(
     options?.maxBulkConcurrency,
     defaultRequestComplexity.maxBulkConcurrency
+  ),
+  maxHookConcurrency: normalizePositiveInteger(
+    options?.maxHookConcurrency,
+    defaultRequestComplexity.maxHookConcurrency
   )
 });
 function validateRequestComplexity(value, options, scope = "request") {
@@ -626,7 +693,7 @@ function validateRequestComplexity(value, options, scope = "request") {
       pushError(`Request exceeds maximum depth of ${limits.maxDepth}`, path);
       return;
     }
-    if ((0, import_utils6.isArray)(current)) {
+    if ((0, import_utils7.isArray)(current)) {
       if (parentKey === "$and" || parentKey === "$or" || parentKey === "$nor") {
         logicalClauses += current.length;
         if (logicalClauses > limits.maxLogicalClauses) {
@@ -646,14 +713,14 @@ function validateRequestComplexity(value, options, scope = "request") {
       }
       return;
     }
-    if (!(0, import_utils6.isPlainObject)(current)) return;
+    if (!(0, import_utils7.isPlainObject)(current)) return;
     for (const [key, child] of Object.entries(current)) {
       if (key === "__proto__" || key === "prototype" || key === "constructor") {
         pushError(`Unsupported key: ${key}`, path.concat(key));
         return;
       }
       if (scope === "request" && key === "include") {
-        includeCount += (0, import_utils6.isArray)(child) ? child.length : 1;
+        includeCount += (0, import_utils7.isArray)(child) ? child.length : 1;
         if (includeCount > limits.maxIncludeCount) {
           pushError(`Request exceeds maximum include count of ${limits.maxIncludeCount}`, path.concat(key));
           return;
@@ -693,47 +760,48 @@ var defaultModelOptions = {
 var defaultDataOptions = {
   basePath: null,
   parentPath: "/",
-  queryRouteSegment: "__query"
+  queryRouteSegment: "__query",
+  listHardLimit: DEFAULT_LIST_HARD_LIMIT
 };
 var normalizeBasePath = (name, value) => {
-  if ((0, import_utils7.isNil)(value)) {
+  if ((0, import_utils8.isNil)(value)) {
     return `/${pluralize(name)}`;
   }
-  return (0, import_utils7.isString)(value) ? (0, import_utils7.addLeadingSlash)(value) : "";
+  return (0, import_utils8.isString)(value) ? (0, import_utils8.addLeadingSlash)(value) : "";
 };
 var hasModelPermission = (value, modelPermissionPrefix) => {
   if (!modelPermissionPrefix) {
     return true;
   }
-  if ((0, import_utils7.isString)(value)) {
+  if ((0, import_utils8.isString)(value)) {
     return value.trim().split(" ").some((item) => item.startsWith(modelPermissionPrefix));
   }
-  if ((0, import_utils7.isArray)(value)) {
+  if ((0, import_utils8.isArray)(value)) {
     return value.some((item) => {
-      if ((0, import_utils7.isString)(item) || (0, import_utils7.isArray)(item)) {
+      if ((0, import_utils8.isString)(item) || (0, import_utils8.isArray)(item)) {
         return hasModelPermission(item, modelPermissionPrefix);
       }
       return true;
     });
   }
-  return (0, import_utils7.isFunction)(value);
+  return (0, import_utils8.isFunction)(value);
 };
 var classifyPermissionSchema = (permissionSchema, modelPermissionPrefix) => {
   const schemaKeys = Object.keys(permissionSchema);
   const globalPermissionKeys = {};
   const modelPermissionKeys = {};
-  (0, import_utils7.forEach)(schemaKeys, (schemaKey) => {
+  (0, import_utils8.forEach)(schemaKeys, (schemaKey) => {
     const schemaRule = permissionSchema[schemaKey];
-    const ruleEntries = (0, import_utils7.isPlainObject)(schemaRule) ? Object.entries(schemaRule) : FIELD_ACCESS_KEYS.map((accessKey) => [accessKey, schemaRule]);
+    const ruleEntries = (0, import_utils8.isPlainObject)(schemaRule) ? Object.entries(schemaRule) : FIELD_ACCESS_KEYS.map((accessKey) => [accessKey, schemaRule]);
     for (let x = 0; x < ruleEntries.length; x++) {
       const [accessKey, value] = ruleEntries[x];
-      if (!(0, import_utils7.isArray)(globalPermissionKeys[accessKey])) {
+      if (!(0, import_utils8.isArray)(globalPermissionKeys[accessKey])) {
         globalPermissionKeys[accessKey] = [];
       }
-      if (!(0, import_utils7.isArray)(modelPermissionKeys[accessKey])) {
+      if (!(0, import_utils8.isArray)(modelPermissionKeys[accessKey])) {
         modelPermissionKeys[accessKey] = [];
       }
-      if ((0, import_utils7.isBoolean)(value)) {
+      if ((0, import_utils8.isBoolean)(value)) {
         globalPermissionKeys[accessKey].push(schemaKey);
         return;
       }
@@ -750,17 +818,30 @@ var classifyPermissionSchema = (permissionSchema, modelPermissionPrefix) => {
     modelPermissionKeys
   };
 };
+var refreshPermissionMetadata = (target) => {
+  const permissionSchema = target.permissionSchema ?? {};
+  const { schemaKeys, globalPermissionKeys, modelPermissionKeys } = classifyPermissionSchema(
+    permissionSchema,
+    target.modelPermissionPrefix ?? ""
+  );
+  target._permissionSchemaKeys = schemaKeys;
+  target._globalPermissionKeys = globalPermissionKeys;
+  target._modelPermissionKeys = modelPermissionKeys;
+};
 var AccessRuntime = class {
-  constructor() {
-    this.globalOptions = new OptionsManager({
-      requestPermissionField: "_permissions",
-      globalPermissions: () => ({}),
-      requireRegisteredPopulateModels: true,
-      logger: defaultLogger,
-      requestComplexity: defaultRequestComplexity
-    }).build();
+  constructor(options = {}) {
+    this.globalOptions = new OptionsManager(
+      {
+        requestPermissionField: "_permissions",
+        globalPermissions: () => ({}),
+        requireRegisteredPopulateModels: true,
+        logger: defaultLogger,
+        requestComplexity: defaultRequestComplexity
+      },
+      { preserveKeys: ["logger"] }
+    ).build();
     this.defaultModelOptions = new OptionsManager({
-      listHardLimit: 1e3,
+      listHardLimit: DEFAULT_LIST_HARD_LIMIT,
       documentPermissionField: "_permissions",
       idParam: "id",
       idField: "_id",
@@ -778,6 +859,7 @@ var AccessRuntime = class {
     this.modelAtts = {};
     this.modelInstances = {};
     this.openApiRegistry = new OpenApiRegistry();
+    this.allowGlobalModelLookup = options.allowGlobalModelLookup ?? false;
     ensureMongooseJsonSchemaInitialized();
   }
   registerModelInstance(modelName, model) {
@@ -793,13 +875,16 @@ var AccessRuntime = class {
     this.modelInstances[modelName] = model;
   }
   hasModelInstance(modelName) {
-    return modelName in this.modelInstances;
+    return modelName in this.modelInstances || this.allowGlobalModelLookup && modelName in import_mongoose2.default.models;
   }
   getModelInstance(modelName) {
     const registered = this.modelInstances[modelName];
     if (registered) return registered;
+    if (!this.allowGlobalModelLookup) return null;
     const global = import_mongoose2.default.models[modelName];
-    return global ?? null;
+    if (!global) return null;
+    this.registerModelInstance(modelName, global);
+    return global;
   }
   registerOpenApiRoute(route) {
     this.openApiRegistry.register(route);
@@ -848,24 +933,24 @@ var AccessRuntime = class {
     return this.defaultModelOptions.get(key, defaultValue);
   }
   createModelOptions(modelName) {
-    const model = this.getModelInstance(modelName) ?? import_mongoose2.default.model(modelName);
+    const model = this.getModelInstance(modelName);
+    if (!model) {
+      throw new Error(
+        `Runtime model registry missing model "${modelName}". Pass a mongoose.Model instance to createRouter() or register it with registerModelInstance() before using this isolated runtime.`
+      );
+    }
     const manager = new OptionsManager({
       ...defaultModelOptions,
       modelName
     });
-    manager.onchange("permissionSchema", function(newval, key, target) {
-      const permissionSchema = newval ?? {};
-      const { schemaKeys, globalPermissionKeys, modelPermissionKeys } = classifyPermissionSchema(
-        permissionSchema,
-        target.modelPermissionPrefix ?? ""
-      );
-      target._permissionSchemaKeys = schemaKeys;
-      target._globalPermissionKeys = globalPermissionKeys;
-      target._modelPermissionKeys = modelPermissionKeys;
+    manager.onchange("permissionSchema", function(_newval, _key, target) {
+      refreshPermissionMetadata(target);
+    }).onchange("modelPermissionPrefix", function(_newval, _key, target) {
+      refreshPermissionMetadata(target);
     }).onchange("basePath", function(newval, key, target) {
       target[key] = normalizeBasePath(
         modelName,
-        (0, import_utils7.isString)(newval) || (0, import_utils7.isNil)(newval) ? newval : void 0
+        (0, import_utils8.isString)(newval) || (0, import_utils8.isNil)(newval) ? newval : void 0
       );
     }).build();
     this.modelJsonSchemas[modelName] = model.jsonSchema();
@@ -923,7 +1008,7 @@ var AccessRuntime = class {
     manager.onchange("basePath", function(newval, key, target) {
       target[key] = normalizeBasePath(
         dataName,
-        (0, import_utils7.isString)(newval) || (0, import_utils7.isNil)(newval) ? newval : void 0
+        (0, import_utils8.isString)(newval) || (0, import_utils8.isNil)(newval) ? newval : void 0
       );
     }).build();
     return manager;
@@ -974,23 +1059,23 @@ var AccessRuntime = class {
     const schema = model.schema;
     this.modelRefs[modelName] = buildRefs(schema.tree);
     this.modelSubs[modelName] = buildSubPaths(schema.tree);
-    this.modelAtts[modelName] = (0, import_utils7.keys)(schema.obj);
+    this.modelAtts[modelName] = (0, import_utils8.keys)(schema.obj);
   }
   getModelRef(modelName, refPath) {
     this.ensureModelMeta(modelName);
-    const value = (0, import_utils7.get)(this.modelRefs, `${modelName}.${refPath}`, null);
-    return (0, import_utils7.isString)(value) ? value : null;
+    const value = (0, import_utils8.get)(this.modelRefs, `${modelName}.${refPath}`, null);
+    return (0, import_utils8.isString)(value) ? value : null;
   }
   getModelSub(modelName) {
     this.ensureModelMeta(modelName);
-    return (0, import_utils7.get)(this.modelSubs, modelName, []);
+    return (0, import_utils8.get)(this.modelSubs, modelName, []);
   }
   getModelAtt(modelName) {
     this.ensureModelMeta(modelName);
-    return (0, import_utils7.get)(this.modelAtts, modelName, []);
+    return (0, import_utils8.get)(this.modelAtts, modelName, []);
   }
 };
-var defaultRuntime = new AccessRuntime();
+var defaultRuntime = new AccessRuntime({ allowGlobalModelLookup: true });
 
 // src/runtime-context.ts
 var import_node_async_hooks = require("async_hooks");
@@ -1074,7 +1159,7 @@ var includeItemSchema = import_zod2.z.object({
   filter: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
   localField: import_zod2.z.string().min(1),
   foreignField: import_zod2.z.string().min(1),
-  args: import_zod2.z.unknown().optional(),
+  args: import_zod2.z.unknown().optional().describe("Forwarded to list/read includes. Count includes ignore pagination fields so counts remain exact."),
   options: import_zod2.z.unknown().optional()
 }).passthrough();
 var includeSchema = import_zod2.z.union([includeItemSchema, import_zod2.z.array(includeItemSchema)]);
@@ -1611,7 +1696,7 @@ var import_zod4 = require("zod");
 var dataListBodySchema = import_zod4.z.object({
   filter: objectOrArraySchema.optional(),
   select: projectionSchema.optional(),
-  sort: import_zod4.z.string().optional(),
+  sort: sortSchema.optional(),
   skip: import_zod4.z.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),
   limit: import_zod4.z.union([positiveIntegerSchema, positiveIntegerString]).optional(),
   page: import_zod4.z.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),
@@ -1703,7 +1788,7 @@ var rootModelSubReadArgsSchema = import_zod5.z.object({
 var rootModelCountOptionsSchema = import_zod5.z.object({}).strict().optional();
 var rootDataListArgsSchema = import_zod5.z.object({
   select: projectionSchema.optional(),
-  sort: import_zod5.z.string().optional(),
+  sort: sortSchema.optional(),
   skip: import_zod5.z.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),
   limit: import_zod5.z.union([positiveIntegerSchema, positiveIntegerString]).optional(),
   page: import_zod5.z.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),