Method traverse

packages/graph/src/Steps.ts:5813–5965

(
    source: GraphSource<any>,
    input: Iterable<TraversalPath<any, any, any>>,
    context?: QueryContext,
  )

  }

  public *traverse(
    source: GraphSource<any>,
    input: Iterable<TraversalPath<any, any, any>>,
    context?: QueryContext,
  ): IterableIterator<TraversalPath<any, any, any>> {
    const { assignments } = this.config;

    for (const path of input) {
      this.traversed++;

      // Apply each assignment
      for (const assignment of assignments) {
        // Check if this is a map-based assignment (setAllProperties or setAddProperties)
        if ("type" in assignment) {
          const { variable, properties } = assignment;

          // Find the element bound to this variable in the path
          const elementPath = path.get(variable);
          if (!elementPath) {
            throw new Error(
              `SET: Variable '${variable}' not found in path. Available variables: ${Array.from(path.labels).join(", ") || "none"}`,
            );
          }

          let element = elementPath.value;
          // Handle FOREACH element wrappers
          if (element && typeof element === "object" && element.label === "ForeachElement") {
            element = element.value;
          }
          if (!(element instanceof Vertex || element instanceof Edge)) {
            throw new Error(
              `SET: Variable '${variable}' is not a vertex or edge (got ${typeof element})`,
            );
          }

          // Resolve the property map
          let resolvedProps: Record<string, unknown>;
          if (
            typeof properties === "object" &&
            properties !== null &&
            "type" in properties &&
            properties.type === "parameter"
          ) {
            // Parameter reference
            const params = context?.params ?? getQueryParams();
            const paramName = (properties as { type: "parameter"; name: string }).name;
            resolvedProps = params[paramName] as Record<string, unknown>;
            if (
              resolvedProps === undefined ||
              resolvedProps === null ||
              typeof resolvedProps !== "object"
            ) {
              throw new Error(`SET: Parameter '${paramName}' must be an object/map`);
            }
          } else {
            // Direct property map
            resolvedProps = properties as Record<string, unknown>;
          }