@vibeorm/runtime 2.3.1 → 2.4.1

package/dist/index.js

@@ -12057,32 +12057,63 @@ function isPlainObject9(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function descend(params) {
-  const { ctx, model, key } = params;
-  const field = model.fieldByName.get(key);
-  if (field !== undefined)
-    return field.scalarType === "Json" ? "json" : model;
-  const relation = model.relationByName.get(key);
-  if (relation === undefined)
-    return model;
-  return ctx.meta.modelByName.get(relation.targetModel) ?? model;
-}
+var STRUCTURAL_KEYWORDS = Object.freeze({
+  where: { level: "fields", filter: true },
+  having: { level: "fields", filter: true },
+  some: { level: "fields", filter: true },
+  every: { level: "fields", filter: true },
+  none: { level: "fields", filter: true },
+  is: { level: "fields", filter: true },
+  isNot: { level: "fields", filter: true },
+  deleteMany: { level: "fields", filter: true },
+  data: { level: "fields", filter: false },
+  create: { level: "fields", filter: false },
+  set: { level: "fields", filter: false },
+  connect: { level: "fields", filter: false },
+  disconnect: { level: "fields", filter: false },
+  delete: { level: "fields", filter: false },
+  cursor: { level: "fields", filter: false },
+  select: { level: "fields", filter: "inherit" },
+  include: { level: "fields", filter: "inherit" },
+  omit: { level: "fields", filter: "inherit" },
+  orderBy: { level: "fields", filter: "inherit" },
+  connectOrCreate: { level: "structural", filter: "inherit" },
+  upsert: { level: "structural", filter: "inherit" },
+  createMany: { level: "structural", filter: "inherit" },
+  updateMany: { level: "structural", filter: "inherit" },
+  _count: { level: "structural", filter: "inherit" },
+  update: { level: "structural", filter: false }
+});
+var LOGICAL_KEYS = new Set(["AND", "OR", "NOT"]);
 function walkArray(params) {
-  const { ctx, model, value, path, filter } = params;
+  const { ctx, model, value, path, level, filter } = params;
   let changed = false;
   const out = value.map((item, index) => {
-    const next = walkNode({ ctx, model, value: item, path: `${path}[${index}]`, filter });
+    const next = walkNode({ ctx, model, value: item, path: `${path}[${index}]`, level, filter });
     if (next !== item)
       changed = true;
     return next;
   });
   return changed ? out : value;
 }
+function walkJsonOperators(params) {
+  const { ctx, value, path } = params;
+  let filtered = null;
+  for (const operator of Object.keys(value)) {
+    if (value[operator] === undefined) {
+      throw explicitUndefined({ model: ctx.model, method: ctx.method, path: `${path}.${operator}` });
+    }
+    if (value[operator] === SKIP) {
+      filtered ??= { ...value };
+      delete filtered[operator];
+    }
+  }
+  return filtered ?? value;
+}
 function walkNode(params) {
-  const { ctx, model, value, path } = params;
-  const filter = params.filter === true;
+  const { ctx, model, value, path, level, filter } = params;
   if (Array.isArray(value))
-    return walkArray({ ctx, model, value, path, filter });
+    return walkArray({ ctx, model, value, path, level, filter });
   if (!isPlainObject9(value))
     return value;
   let out = null;
@@ -12097,33 +12128,31 @@ function walkNode(params) {
       delete out[key];
       continue;
     }
-    const target = descend({ ctx, model, key });
-    if (target === "json") {
-      if (filter && isPlainObject9(child)) {
-        let filtered = null;
-        for (const operator of Object.keys(child)) {
-          if (child[operator] === undefined) {
-            throw explicitUndefined({ model: ctx.model, method: ctx.method, path: `${childPath}.${operator}` });
-          }
-          if (child[operator] === SKIP) {
-            filtered ??= { ...child };
-            delete filtered[operator];
-          }
-        }
-        if (filtered !== null) {
-          out ??= { ...value };
-          out[key] = filtered;
-        }
+    let next;
+    const keyword = level === "structural" ? STRUCTURAL_KEYWORDS[key] : undefined;
+    if (keyword !== undefined) {
+      next = walkNode({
+        ctx,
+        model,
+        value: child,
+        path: childPath,
+        level: keyword.level,
+        filter: keyword.filter === "inherit" ? filter : keyword.filter
+      });
+    } else if (LOGICAL_KEYS.has(key)) {
+      next = walkNode({ ctx, model, value: child, path: childPath, level: "fields", filter });
+    } else {
+      const field = model.fieldByName.get(key);
+      if (field !== undefined && field.scalarType === "Json") {
+        next = filter && isPlainObject9(child) ? walkJsonOperators({ ctx, value: child, path: childPath }) : child;
+      } else if (field !== undefined) {
+        next = walkNode({ ctx, model, value: child, path: childPath, level: "fields", filter });
+      } else {
+        const relation = model.relationByName.get(key);
+        const target = relation === undefined ? undefined : ctx.meta.modelByName.get(relation.targetModel);
+        next = target === undefined ? walkNode({ ctx, model, value: child, path: childPath, level: "fields", filter }) : walkNode({ ctx, model: target, value: child, path: childPath, level: "structural", filter });
       }
-      continue;
     }
-    const next = walkNode({
-      ctx,
-      model: target,
-      value: child,
-      path: childPath,
-      filter: key === "where" || key === "having" ? true : key === "data" || key === "create" || key === "update" ? false : filter
-    });
     if (next !== child) {
       out ??= { ...value };
       out[key] = next;
@@ -12136,7 +12165,7 @@ function checkStrictArguments(params) {
   if (args === undefined)
     return;
   const ctx = { meta, model: model.clientName, method };
-  const walked = walkNode({ ctx, model, value: args, path: "args" });
+  const walked = walkNode({ ctx, model, value: args, path: "args", level: "structural", filter: false });
   return walked;
 }
 
@@ -14210,11 +14239,12 @@ function makeMountContext(params) {
           meta: { extension }
         });
       }
+      const checked = engine.options?.strictArguments !== false ? checkStrictArguments({ meta: engine.meta, model: target, method: `${extension}.compileWhere`, args: { where } }) : undefined;
       return compileWhere({
         dialect: engine.dialect,
         meta: engine.meta,
         model: target,
-        where,
+        where: checked === undefined ? where : checked.where,
         ...qualify === undefined ? {} : { qualify }
       });
     }
@@ -14754,4 +14784,4 @@ export {
   validateWriteData
 };
 
-//# debugId=28EC8E14B301CBEB64756E2164756E21
+//# debugId=BC9380E497613E8D64756E2164756E21