@mastra/core 0.5.0-alpha.9 → 0.5.0

package/dist/utils.cjs

@@ -1,355 +1,46 @@
 'use strict';
 
-var crypto = require('crypto');
-var jsonSchemaToZod = require('json-schema-to-zod');
-var zod = require('zod');
+var chunk43Y7WG5W_cjs = require('./chunk-43Y7WG5W.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var jsonSchemaToZod__default = /*#__PURE__*/_interopDefault(jsonSchemaToZod);
 
-// src/utils.ts
-
-// src/tools/tool.ts
-var Tool = class {
-  id;
-  description;
-  inputSchema;
-  outputSchema;
-  execute;
-  mastra;
-  constructor(opts) {
-    this.id = opts.id;
-    this.description = opts.description;
-    this.inputSchema = opts.inputSchema;
-    this.outputSchema = opts.outputSchema;
-    this.execute = opts.execute;
-    this.mastra = opts.mastra;
-  }
-};
-
-// src/utils.ts
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function jsonSchemaPropertiesToTSTypes(value) {
-  if (!value.type) {
-    return zod.z.object({});
-  }
-  let zodType;
-  switch (value.type) {
-    case "string":
-      zodType = zod.z.string().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "number":
-      zodType = zod.z.number().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "integer":
-      zodType = zod.z.number().int().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "boolean":
-      zodType = zod.z.boolean().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "array":
-      zodType = zod.z.array(jsonSchemaPropertiesToTSTypes(value.items)).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "object":
-      zodType = jsonSchemaToModel(value).describe(
-        (value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : "")
-      );
-      break;
-    case "null":
-      zodType = zod.z.null().describe(value.description || "");
-      break;
-    default:
-      throw new Error(`Unsupported JSON schema type: ${value.type}`);
-  }
-  return zodType;
-}
-function jsonSchemaToModel(jsonSchema) {
-  const properties = jsonSchema.properties;
-  const requiredFields = jsonSchema.required || [];
-  if (!properties) {
-    return zod.z.object({});
-  }
-  const zodSchema = {};
-  for (const [key, _] of Object.entries(properties)) {
-    const value = _;
-    let zodType;
-    if (value.anyOf) {
-      const anyOfTypes = value.anyOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
-      zodType = zod.z.union(anyOfTypes).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-    } else if (value.allOf) {
-      const allOfTypes = value.allOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
-      zodType = zod.z.intersection(
-        allOfTypes[0],
-        allOfTypes.slice(1).reduce((acc, schema) => acc.and(schema), allOfTypes[0])
-      ).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-    } else {
-      if (!value.type) {
-        value.type = "string";
-      }
-      zodType = jsonSchemaPropertiesToTSTypes(value);
-    }
-    if (value.description) {
-      zodType = zodType.describe(value.description);
-    }
-    if (requiredFields.includes(key)) {
-      zodSchema[key] = zodType;
-    } else {
-      zodSchema[key] = zodType.nullable().optional();
-    }
-  }
-  return zod.z.object(zodSchema);
-}
-function deepMerge(target, source) {
-  const output = { ...target };
-  if (!source) return output;
-  Object.keys(source).forEach((key) => {
-    const targetValue = output[key];
-    const sourceValue = source[key];
-    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
-      output[key] = sourceValue;
-    } else if (sourceValue instanceof Object && targetValue instanceof Object && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
-      output[key] = deepMerge(targetValue, sourceValue);
-    } else if (sourceValue !== void 0) {
-      output[key] = sourceValue;
-    }
-  });
-  return output;
-}
-async function* maskStreamTags(stream, tag, options = {}) {
-  const { onStart, onEnd, onMask } = options;
-  const openTag = `<${tag}>`;
-  const closeTag = `</${tag}>`;
-  let buffer = "";
-  let fullContent = "";
-  let isMasking = false;
-  let isBuffering = false;
-  const trimOutsideDelimiter = (text, delimiter, trim) => {
-    if (!text.includes(delimiter)) {
-      return text;
-    }
-    const parts = text.split(delimiter);
-    if (trim === `before-start`) {
-      return `${delimiter}${parts[1]}`;
-    }
-    return `${parts[0]}${delimiter}`;
-  };
-  const startsWith = (text, pattern) => {
-    if (pattern.includes(openTag.substring(0, 3))) {
-      pattern = trimOutsideDelimiter(pattern, `<`, `before-start`);
-    }
-    return text.trim().startsWith(pattern.trim());
-  };
-  for await (const chunk of stream) {
-    fullContent += chunk;
-    if (isBuffering) buffer += chunk;
-    const chunkHasTag = startsWith(chunk, openTag);
-    const bufferHasTag = !chunkHasTag && isBuffering && startsWith(openTag, buffer);
-    let toYieldBeforeMaskedStartTag = ``;
-    if (!isMasking && (chunkHasTag || bufferHasTag)) {
-      isMasking = true;
-      isBuffering = false;
-      const taggedTextToMask = trimOutsideDelimiter(buffer, `<`, `before-start`);
-      if (taggedTextToMask !== buffer.trim()) {
-        toYieldBeforeMaskedStartTag = buffer.replace(taggedTextToMask, ``);
-      }
-      buffer = "";
-      onStart?.();
-    }
-    if (!isMasking && !isBuffering && startsWith(openTag, chunk) && chunk.trim() !== "") {
-      isBuffering = true;
-      buffer += chunk;
-      continue;
-    }
-    if (isBuffering && buffer && !startsWith(openTag, buffer)) {
-      yield buffer;
-      buffer = "";
-      isBuffering = false;
-      continue;
-    }
-    if (isMasking && fullContent.includes(closeTag)) {
-      onMask?.(chunk);
-      onEnd?.();
-      isMasking = false;
-      const lastFullContent = fullContent;
-      fullContent = ``;
-      const textUntilEndTag = trimOutsideDelimiter(lastFullContent, closeTag, "after-end");
-      if (textUntilEndTag !== lastFullContent) {
-        yield lastFullContent.replace(textUntilEndTag, ``);
-      }
-      continue;
-    }
-    if (isMasking) {
-      onMask?.(chunk);
-      if (toYieldBeforeMaskedStartTag) {
-        yield toYieldBeforeMaskedStartTag;
-      }
-      continue;
-    }
-    yield chunk;
-  }
-}
-function resolveSerializedZodOutput(schema) {
-  return Function("z", `"use strict";return (${schema});`)(zod.z);
-}
-function isVercelTool(tool) {
-  return !(tool instanceof Tool);
-}
-function createLogMessageOptions({ agentName, toolName, tool, type }) {
-  if (!agentName) {
-    return {
-      start: `Executing tool ${toolName}`,
-      error: `Failed tool execution`
-    };
-  }
-  const prefix = `[Agent:${agentName}]`;
-  const vercelPrefix = isVercelTool(tool) ? "Vercel " : "";
-  const toolType = type === "toolset" ? "toolset" : "tool";
-  return {
-    start: `${prefix} - Executing ${vercelPrefix}${toolType} ${toolName}`,
-    error: `${prefix} - Failed ${vercelPrefix}${toolType} execution`
-  };
-}
-function createExecute(tool, options, logType) {
-  const { logger, ...rest } = options;
-  const { start, error } = createLogMessageOptions({
-    agentName: options.agentName,
-    toolName: options.name,
-    tool,
-    type: logType
-  });
-  const execFunction = async (args, execOptions) => {
-    if (isVercelTool(tool)) {
-      return tool?.execute?.(args, execOptions) ?? void 0;
-    }
-    return tool?.execute?.(
-      {
-        context: args,
-        threadId: options.threadId,
-        resourceId: options.resourceId,
-        mastra: options.mastra,
-        memory: options.memory,
-        runId: options.runId
-      },
-      execOptions
-    ) ?? void 0;
-  };
-  return async (args, execOptions) => {
-    try {
-      logger.debug(start, { ...rest, args });
-      return await execFunction(args, execOptions);
-    } catch (err) {
-      logger.error(error, { ...rest, error: err, args });
-      throw err;
-    }
-  };
-}
-function isZodType(value) {
-  return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
-}
-function createDeterministicId(input) {
-  return crypto.createHash("sha256").update(input).digest("hex").slice(0, 8);
-}
-function setVercelToolProperties(tool) {
-  const inputSchema = convertVercelToolParameters(tool);
-  const toolId = !("id" in tool) ? tool.description ? `tool-${createDeterministicId(tool.description)}` : `tool-${Math.random().toString(36).substring(2, 9)}` : tool.id;
-  return {
-    ...tool,
-    id: toolId,
-    inputSchema
-  };
-}
-function ensureToolProperties(tools) {
-  const toolsWithProperties = Object.keys(tools).reduce((acc, key) => {
-    const tool = tools?.[key];
-    if (tool) {
-      if (isVercelTool(tool)) {
-        acc[key] = setVercelToolProperties(tool);
-      } else {
-        acc[key] = tool;
-      }
-    }
-    return acc;
-  }, {});
-  return toolsWithProperties;
-}
-function convertVercelToolParameters(tool) {
-  const schema = tool.parameters ?? zod.z.object({});
-  return isZodType(schema) ? schema : resolveSerializedZodOutput(jsonSchemaToZod__default.default(schema));
-}
-function makeCoreTool(tool, options, logType) {
-  const getParameters = () => {
-    if (isVercelTool(tool)) {
-      return convertVercelToolParameters(tool);
-    }
-    return tool.inputSchema ?? zod.z.object({});
-  };
-  return {
-    description: tool.description,
-    parameters: getParameters(),
-    execute: tool.execute ? createExecute(tool, { ...options, description: tool.description }, logType) : void 0
-  };
-}
-function createMastraProxy({ mastra, logger }) {
-  return new Proxy(mastra, {
-    get(target, prop) {
-      const hasProp = Reflect.has(target, prop);
-      if (hasProp) {
-        const value = Reflect.get(target, prop);
-        const isFunction = typeof value === "function";
-        if (isFunction) {
-          return value.bind(target);
-        }
-        return value;
-      }
-      if (prop === "logger") {
-        logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
-        return Reflect.apply(target.getLogger, target, []);
-      }
-      if (prop === "telemetry") {
-        logger.warn(`Please use 'getTelemetry' instead, telemetry is deprecated`);
-        return Reflect.apply(target.getTelemetry, target, []);
-      }
-      if (prop === "storage") {
-        logger.warn(`Please use 'getStorage' instead, storage is deprecated`);
-        return Reflect.get(target, "storage");
-      }
-      if (prop === "agents") {
-        logger.warn(`Please use 'getAgents' instead, agents is deprecated`);
-        return Reflect.apply(target.getAgents, target, []);
-      }
-      if (prop === "tts") {
-        logger.warn(`Please use 'getTTS' instead, tts is deprecated`);
-        return Reflect.apply(target.getTTS, target, []);
-      }
-      if (prop === "vectors") {
-        logger.warn(`Please use 'getVectors' instead, vectors is deprecated`);
-        return Reflect.apply(target.getVectors, target, []);
-      }
-      if (prop === "memory") {
-        logger.warn(`Please use 'getMemory' instead, memory is deprecated`);
-        return Reflect.get(target, "memory");
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-}
-
-exports.createMastraProxy = createMastraProxy;
-exports.deepMerge = deepMerge;
-exports.delay = delay;
-exports.ensureToolProperties = ensureToolProperties;
-exports.isVercelTool = isVercelTool;
-exports.jsonSchemaPropertiesToTSTypes = jsonSchemaPropertiesToTSTypes;
-exports.jsonSchemaToModel = jsonSchemaToModel;
-exports.makeCoreTool = makeCoreTool;
-exports.maskStreamTags = maskStreamTags;
-exports.resolveSerializedZodOutput = resolveSerializedZodOutput;
+Object.defineProperty(exports, "createMastraProxy", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.createMastraProxy; }
+});
+Object.defineProperty(exports, "deepMerge", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.deepMerge; }
+});
+Object.defineProperty(exports, "delay", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.delay; }
+});
+Object.defineProperty(exports, "ensureToolProperties", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.ensureToolProperties; }
+});
+Object.defineProperty(exports, "isVercelTool", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.isVercelTool; }
+});
+Object.defineProperty(exports, "jsonSchemaPropertiesToTSTypes", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.jsonSchemaPropertiesToTSTypes; }
+});
+Object.defineProperty(exports, "jsonSchemaToModel", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.jsonSchemaToModel; }
+});
+Object.defineProperty(exports, "makeCoreTool", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.makeCoreTool; }
+});
+Object.defineProperty(exports, "maskStreamTags", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.maskStreamTags; }
+});
+Object.defineProperty(exports, "resolveSerializedZodOutput", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.resolveSerializedZodOutput; }
+});

package/dist/utils.d.cts

@@ -1,9 +1,9 @@
 import { MastraTTS } from './tts/index.cjs';
 import { MastraVector } from './vector/index.cjs';
-import { V as VercelTool, T as ToolAction, a as ToolsInput, M as Mastra, b as MastraPrimitives, c as MastraMemory, C as CoreTool, A as Agent, W as Workflow } from './base-CMEKtEnE.cjs';
+import { V as VercelTool, T as ToolAction, a as ToolsInput, M as Mastra, b as MastraPrimitives, c as MastraMemory, C as CoreTool, A as Agent, W as Workflow, S as Step, d as StepExecutionContext, e as WorkflowContext } from './base-CIPKleAU.cjs';
+import { M as Metric } from './types-CwTG2XyQ.cjs';
 import { z, ZodObject } from 'zod';
 import { L as Logger } from './index-mKY1XrpK.cjs';
-import { M as Metric } from './types-CwTG2XyQ.cjs';
 import './base-DboIg_Cd.cjs';
 import './vector/filter/index.cjs';
 import 'ai';
@@ -88,6 +88,6 @@ declare function makeCoreTool(tool: ToolToConvert, options: ToolOptions, logType
 declare function createMastraProxy({ mastra, logger }: {
     mastra: Mastra;
     logger: Logger;
-}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<any, any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
+}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<Step<string, any, any, StepExecutionContext<any, WorkflowContext<any, Step<string, any, any, any>[]>>>[], any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
 
 export { type TagMaskOptions, createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };

package/dist/utils.d.ts

@@ -1,9 +1,9 @@
 import { MastraTTS } from './tts/index.js';
 import { MastraVector } from './vector/index.js';
-import { V as VercelTool, T as ToolAction, a as ToolsInput, M as Mastra, b as MastraPrimitives, c as MastraMemory, C as CoreTool, A as Agent, W as Workflow } from './base-B78F6w8S.js';
+import { V as VercelTool, T as ToolAction, a as ToolsInput, M as Mastra, b as MastraPrimitives, c as MastraMemory, C as CoreTool, A as Agent, W as Workflow, S as Step, d as StepExecutionContext, e as WorkflowContext } from './base-C_Oq53qk.js';
+import { M as Metric } from './types-CwTG2XyQ.js';
 import { z, ZodObject } from 'zod';
 import { L as Logger } from './index-mKY1XrpK.js';
-import { M as Metric } from './types-CwTG2XyQ.js';
 import './base-BZViaFTt.js';
 import './vector/filter/index.js';
 import 'ai';
@@ -88,6 +88,6 @@ declare function makeCoreTool(tool: ToolToConvert, options: ToolOptions, logType
 declare function createMastraProxy({ mastra, logger }: {
     mastra: Mastra;
     logger: Logger;
-}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<any, any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
+}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<Step<string, any, any, StepExecutionContext<any, WorkflowContext<any, Step<string, any, any, any>[]>>>[], any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
 
 export { type TagMaskOptions, createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };

package/dist/utils.js

@@ -1 +1 @@
-export { createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput } from './chunk-IM7CM3DU.js';
+export { createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput } from './chunk-4Y74D74B.js';

package/dist/vector/filter/index.cjs

@@ -1,192 +1,10 @@
 'use strict';
 
-// src/vector/filter/base.ts
-var BaseFilterTranslator = class _BaseFilterTranslator {
-  /**
-   * Operator type checks
-   */
-  isOperator(key) {
-    return key.startsWith("$");
-  }
-  static BASIC_OPERATORS = ["$eq", "$ne"];
-  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
-  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
-  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
-  static ELEMENT_OPERATORS = ["$exists"];
-  static REGEX_OPERATORS = ["$regex", "$options"];
-  static DEFAULT_OPERATORS = {
-    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
-    basic: _BaseFilterTranslator.BASIC_OPERATORS,
-    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
-    array: _BaseFilterTranslator.ARRAY_OPERATORS,
-    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
-    regex: _BaseFilterTranslator.REGEX_OPERATORS
-  };
-  isLogicalOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
-  }
-  isBasicOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
-  }
-  isNumericOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
-  }
-  isArrayOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
-  }
-  isElementOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
-  }
-  isRegexOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
-  }
-  isFieldOperator(key) {
-    return this.isOperator(key) && !this.isLogicalOperator(key);
-  }
-  isCustomOperator(key) {
-    const support = this.getSupportedOperators();
-    return support.custom?.includes(key) ?? false;
-  }
-  getSupportedOperators() {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS;
-  }
-  isValidOperator(key) {
-    const support = this.getSupportedOperators();
-    const allSupported = Object.values(support).flat();
-    return allSupported.includes(key);
-  }
-  /**
-   * Value normalization for comparison operators
-   */
-  normalizeComparisonValue(value) {
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "number" && Object.is(value, -0)) {
-      return 0;
-    }
-    return value;
-  }
-  /**
-   * Helper method to simulate $all operator using $and + $eq when needed.
-   * Some vector stores don't support $all natively.
-   */
-  simulateAllOperator(field, values) {
-    return {
-      $and: values.map((value) => ({
-        [field]: { $in: [this.normalizeComparisonValue(value)] }
-      }))
-    };
-  }
-  /**
-   * Utility functions for type checking
-   */
-  isPrimitive(value) {
-    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-  }
-  isRegex(value) {
-    return value instanceof RegExp;
-  }
-  isEmpty(obj) {
-    return obj === null || obj === void 0 || typeof obj === "object" && Object.keys(obj).length === 0;
-  }
-  static ErrorMessages = {
-    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
-    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path) => `Logical operator ${op} cannot be used at field level: ${path}`,
-    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
-    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
-    INVALID_LOGICAL_OPERATOR_CONTENT: (path) => `Logical operators must contain field conditions, not direct operators: ${path}`,
-    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
-    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
-  };
-  /**
-   * Helper to handle array value normalization consistently
-   */
-  normalizeArrayValues(values) {
-    return values.map((value) => this.normalizeComparisonValue(value));
-  }
-  validateFilter(filter) {
-    const validation = this.validateFilterSupport(filter);
-    if (!validation.supported) {
-      throw new Error(validation.messages.join(", "));
-    }
-  }
-  /**
-   * Validates if a filter structure is supported by the specific vector DB
-   * and returns detailed validation information.
-   */
-  validateFilterSupport(node, path = "") {
-    const messages = [];
-    if (this.isPrimitive(node) || this.isEmpty(node)) {
-      return { supported: true, messages: [] };
-    }
-    if (Array.isArray(node)) {
-      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
-      const arrayMessages = arrayResults.flatMap((r) => r.messages);
-      return {
-        supported: arrayResults.every((r) => r.supported),
-        messages: arrayMessages
-      };
-    }
-    const nodeObj = node;
-    let isSupported = true;
-    for (const [key, value] of Object.entries(nodeObj)) {
-      const newPath = path ? `${path}.${key}` : key;
-      if (this.isOperator(key)) {
-        if (!this.isValidOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
-          continue;
-        }
-        if (!path && !this.isLogicalOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
-          continue;
-        }
-        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
-          continue;
-        }
-        if (this.isLogicalOperator(key)) {
-          if (key === "$not") {
-            if (Array.isArray(value) || typeof value !== "object") {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
-              continue;
-            }
-            if (this.isEmpty(value)) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
-              continue;
-            }
-            continue;
-          }
-          if (path && !this.isLogicalOperator(path.split(".").pop())) {
-            isSupported = false;
-            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
-            continue;
-          }
-          if (Array.isArray(value)) {
-            const hasDirectOperators = value.some(
-              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
-            );
-            if (hasDirectOperators) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
-              continue;
-            }
-          }
-        }
-      }
-      const nestedValidation = this.validateFilterSupport(value, newPath);
-      if (!nestedValidation.supported) {
-        isSupported = false;
-        messages.push(...nestedValidation.messages);
-      }
-    }
-    return { supported: isSupported, messages };
-  }
-};
+var chunkYK3XJ52U_cjs = require('../../chunk-YK3XJ52U.cjs');
 
-exports.BaseFilterTranslator = BaseFilterTranslator;
+
+
+Object.defineProperty(exports, "BaseFilterTranslator", {
+  enumerable: true,
+  get: function () { return chunkYK3XJ52U_cjs.BaseFilterTranslator; }
+});