flowquery 1.0.34 → 1.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.34",
+  "version": "1.0.35",
   "description": "A declarative query language for data processing pipelines.",
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",

package/src/graph/database.ts

@@ -34,20 +34,34 @@ class Database {
         }
         const physical = new PhysicalRelationship(null, relationship.type);
         physical.statement = statement;
+        physical.source = relationship.source;
+        physical.target = relationship.target;
         Database.relationships.set(relationship.type, physical);
     }
     public getRelationship(relationship: Relationship): PhysicalRelationship | null {
         return Database.relationships.get(relationship.type!) || null;
     }
+    public getRelationships(relationship: Relationship): PhysicalRelationship[] {
+        const result: PhysicalRelationship[] = [];
+        for (const type of relationship.types) {
+            const physical = Database.relationships.get(type);
+            if (physical) {
+                result.push(physical);
+            }
+        }
+        return result;
+    }
     public async schema(): Promise<Record<string, any>[]> {
         const result: Record<string, any>[] = [];
 
         for (const [label, physical] of Database.nodes) {
             const records = await physical.data();
-            const entry: Record<string, any> = { kind: "node", label };
+            const entry: Record<string, any> = { kind: "Node", label };
             if (records.length > 0) {
                 const { id, ...sample } = records[0];
-                if (Object.keys(sample).length > 0) {
+                const properties = Object.keys(sample);
+                if (properties.length > 0) {
+                    entry.properties = properties;
                     entry.sample = sample;
                 }
             }
@@ -56,10 +70,17 @@ class Database {
 
         for (const [type, physical] of Database.relationships) {
             const records = await physical.data();
-            const entry: Record<string, any> = { kind: "relationship", type };
+            const entry: Record<string, any> = {
+                kind: "Relationship",
+                type,
+                from_label: physical.source?.label || null,
+                to_label: physical.target?.label || null,
+            };
             if (records.length > 0) {
                 const { left_id, right_id, ...sample } = records[0];
-                if (Object.keys(sample).length > 0) {
+                const properties = Object.keys(sample);
+                if (properties.length > 0) {
+                    entry.properties = properties;
                     entry.sample = sample;
                 }
             }
@@ -78,6 +99,23 @@ class Database {
             const data = await node.data();
             return new NodeData(data as NodeRecord[]);
         } else if (element instanceof Relationship) {
+            if (element.types.length > 1) {
+                const physicals = this.getRelationships(element);
+                if (physicals.length === 0) {
+                    throw new Error(
+                        `No physical relationships found for types ${element.types.join(", ")}`
+                    );
+                }
+                const allRecords: RelationshipRecord[] = [];
+                for (let i = 0; i < physicals.length; i++) {
+                    const records = (await physicals[i].data()) as RelationshipRecord[];
+                    const typeName = element.types[i];
+                    for (const record of records) {
+                        allRecords.push({ ...record, _type: typeName });
+                    }
+                }
+                return new RelationshipData(allRecords);
+            }
             const relationship = this.getRelationship(element);
             if (relationship === null) {
                 throw new Error(`Physical relationship not found for type ${element.type}`);

package/src/graph/relationship.ts

@@ -9,7 +9,7 @@ import RelationshipMatchCollector, {
 
 class Relationship extends ASTNode {
     protected _identifier: string | null = null;
-    protected _type: string | null = null;
+    protected _types: string[] = [];
     protected _properties: Map<string, Expression> = new Map();
     protected _hops: Hops = new Hops();
 
@@ -25,7 +25,9 @@ class Relationship extends ASTNode {
     constructor(identifier: string | null = null, type: string | null = null) {
         super();
         this._identifier = identifier;
-        this._type = type;
+        if (type !== null) {
+            this._types = [type];
+        }
     }
     public set identifier(identifier: string) {
         this._identifier = identifier;
@@ -34,10 +36,16 @@ class Relationship extends ASTNode {
         return this._identifier;
     }
     public set type(type: string) {
-        this._type = type;
+        this._types = [type];
     }
     public get type(): string | null {
-        return this._type;
+        return this._types.length > 0 ? this._types[0] : null;
+    }
+    public set types(types: string[]) {
+        this._types = types;
+    }
+    public get types(): string[] {
+        return this._types;
     }
     public get properties(): Map<string, Expression> {
         return this._properties;

package/src/graph/relationship_data.ts

@@ -18,7 +18,7 @@ class RelationshipData extends Data {
     public properties(): Record<string, any> | null {
         const current = this.current();
         if (current) {
-            const { left_id, right_id, ...props } = current;
+            const { left_id, right_id, _type, ...props } = current;
             return props;
         }
         return null;

package/src/graph/relationship_match_collector.ts

@@ -12,11 +12,15 @@ class RelationshipMatchCollector {
     private _nodeIds: Array<string> = [];
 
     public push(relationship: Relationship, traversalId: string): RelationshipMatchRecord {
+        const data = relationship.getData();
+        const currentRecord = data?.current();
+        const actualType =
+            currentRecord && "_type" in currentRecord ? currentRecord["_type"] : relationship.type!;
         const match: RelationshipMatchRecord = {
-            type: relationship.type!,
+            type: actualType,
             startNode: relationship.source?.value() || {},
             endNode: null,
-            properties: relationship.getData()?.properties() as Record<string, any>,
+            properties: data?.properties() as Record<string, any>,
         };
         this._matches.push(match);
         this._nodeIds.push(traversalId);

package/src/graph/relationship_reference.ts

@@ -6,7 +6,7 @@ class RelationshipReference extends Relationship {
     constructor(base: Relationship, reference: Relationship) {
         super();
         this._identifier = base.identifier;
-        this._type = base.type;
+        this._types = base.types;
         this._hops = base.hops!;
         this._source = base.source;
         this._target = base.target;

package/src/parsing/functions/function_factory.ts

@@ -29,6 +29,7 @@ import "./sum";
 import "./to_json";
 import "./to_lower";
 import "./to_string";
+import "./trim";
 import "./type";
 
 // Re-export AsyncDataProvider for backwards compatibility

package/src/parsing/functions/predicate_sum.ts

@@ -1,17 +1,26 @@
-import PredicateFunction from "./predicate_function";
 import { FunctionDef } from "./function_metadata";
+import PredicateFunction from "./predicate_function";
 
 @FunctionDef({
-    description: "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
+    description:
+        "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
     category: "predicate",
     parameters: [
         { name: "variable", description: "Variable name to bind each element", type: "string" },
         { name: "array", description: "Array to iterate over", type: "array" },
         { name: "expression", description: "Expression to sum for each element", type: "any" },
-        { name: "where", description: "Optional filter condition", type: "boolean", required: false }
+        {
+            name: "where",
+            description: "Optional filter condition",
+            type: "boolean",
+            required: false,
+        },
     ],
     output: { description: "Sum of the evaluated expressions", type: "number", example: 6 },
-    examples: ["WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)", "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)"]
+    examples: [
+        "WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)",
+        "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)",
+    ],
 })
 class PredicateSum extends PredicateFunction {
     constructor() {
@@ -24,19 +33,15 @@ class PredicateSum extends PredicateFunction {
         if (array === null || !Array.isArray(array)) {
             throw new Error("Invalid array for sum function");
         }
-        let _sum: any | null = null;
-        for(let i = 0; i < array.length; i++) {
+        let _sum: number = 0;
+        for (let i = 0; i < array.length; i++) {
             this._valueHolder.holder = array[i];
             if (this.where === null || this.where.value()) {
-                if (_sum === null) {
-                    _sum = this._return.value();
-                } else {
-                    _sum += this._return.value();
-                }
+                _sum += this._return.value();
             }
         }
         return _sum;
     }
 }
 
-export default PredicateSum;
+export default PredicateSum;

package/src/parsing/functions/schema.ts

@@ -5,8 +5,11 @@ import { FunctionDef } from "./function_metadata";
 /**
  * Built-in function that returns the graph schema of the database.
  *
- * Lists all nodes and relationships with their labels/types and a sample
- * of their data (excluding id from nodes, left_id and right_id from relationships).
+ * Lists all nodes and relationships with their labels/types, properties,
+ * and a sample of their data (excluding id from nodes, left_id and right_id from relationships).
+ *
+ * Nodes: {label, properties, sample}
+ * Relationships: {type, from_label, to_label, properties, sample}
  *
  * @example
  * ```
@@ -15,11 +18,11 @@ import { FunctionDef } from "./function_metadata";
  */
 @FunctionDef({
     description:
-        "Returns the graph schema listing all nodes and relationships with a sample of their data.",
+        "Returns the graph schema listing all nodes and relationships with their properties and a sample of their data.",
     category: "async",
     parameters: [],
     output: {
-        description: "Schema entry with kind, label/type, and optional sample data",
+        description: "Schema entry with label/type, properties, and optional sample data",
         type: "object",
     },
     examples: ["LOAD FROM schema() AS s RETURN s"],

package/src/parsing/functions/trim.ts

@@ -0,0 +1,25 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Removes leading and trailing whitespace from a string",
+    category: "scalar",
+    parameters: [{ name: "text", description: "String to trim", type: "string" }],
+    output: { description: "Trimmed string", type: "string", example: "hello" },
+    examples: ["WITH '  hello  ' AS s RETURN trim(s)", "WITH '\\tfoo\\n' AS s RETURN trim(s)"],
+})
+class Trim extends Function {
+    constructor() {
+        super("trim");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (typeof val !== "string") {
+            throw new Error("Invalid argument for trim function: expected a string");
+        }
+        return val.trim();
+    }
+}
+
+export default Trim;

package/src/parsing/operations/group_by.ts

@@ -106,7 +106,10 @@ class GroupBy extends Projection {
                 yield* this.generate_results(mapperIndex + 1, child);
             }
         } else {
-            node.elements?.forEach((element, reducerIndex) => {
+            if (node.elements === null) {
+                node.elements = this.reducers.map((reducer) => reducer.element());
+            }
+            node.elements.forEach((element, reducerIndex) => {
                 this.reducers[reducerIndex].overridden = element.value;
             });
             const record: Record<string, any> = {};

package/src/parsing/parser.ts

@@ -420,6 +420,8 @@ class Parser extends BaseParser {
             }
             relationship = new Relationship();
             relationship.type = type;
+            relationship.source = node;
+            relationship.target = target;
         }
         this.expectAndSkipWhitespaceAndComments();
         if (!this.token.isAs()) {
@@ -673,8 +675,19 @@ class Parser extends BaseParser {
         if (!this.token.isIdentifierOrKeyword()) {
             throw new Error("Expected relationship type identifier");
         }
-        const type: string = this.token.value || "";
+        const types: string[] = [this.token.value || ""];
         this.setNextToken();
+        while (this.token.isPipe()) {
+            this.setNextToken();
+            if (this.token.isColon()) {
+                this.setNextToken();
+            }
+            if (!this.token.isIdentifierOrKeyword()) {
+                throw new Error("Expected relationship type identifier after '|'");
+            }
+            types.push(this.token.value || "");
+            this.setNextToken();
+        }
         const hops: Hops | null = this.parseRelationshipHops();
         const properties: Map<string, Expression> = new Map(this.parseProperties());
         if (!this.token.isClosingBracket()) {
@@ -711,7 +724,7 @@ class Parser extends BaseParser {
         if (hops !== null) {
             relationship.hops = hops;
         }
-        relationship.type = type;
+        relationship.types = types;
         return relationship;
     }
 

package/tests/compute/runner.test.ts

@@ -613,6 +613,38 @@ test("Test toLower function with all uppercase", async () => {
     expect(results[0]).toEqual({ result: "foo bar" });
 });
 
+test("Test trim function", async () => {
+    const runner = new Runner('RETURN trim("  hello  ") as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "hello" });
+});
+
+test("Test trim function with tabs and newlines", async () => {
+    const runner = new Runner('WITH "\tfoo\n" AS s RETURN trim(s) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "foo" });
+});
+
+test("Test trim function with no whitespace", async () => {
+    const runner = new Runner('RETURN trim("hello") as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "hello" });
+});
+
+test("Test trim function with empty string", async () => {
+    const runner = new Runner('RETURN trim("") as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "" });
+});
+
 test("Test associative array with key which is keyword", async () => {
     const runner = new Runner("RETURN {return: 1} as aa");
     await runner.run();
@@ -1964,20 +1996,24 @@ test("Test schema() returns nodes and relationships with sample data", async ()
     `).run();
 
     const runner = new Runner(
-        "CALL schema() YIELD kind, label, type, sample RETURN kind, label, type, sample"
+        "CALL schema() YIELD kind, label, type, from_label, to_label, properties, sample RETURN kind, label, type, from_label, to_label, properties, sample"
     );
     await runner.run();
     const results = runner.results;
 
-    const animal = results.find((r: any) => r.kind === "node" && r.label === "Animal");
+    const animal = results.find((r: any) => r.kind === "Node" && r.label === "Animal");
     expect(animal).toBeDefined();
+    expect(animal.properties).toEqual(["species", "legs"]);
     expect(animal.sample).toBeDefined();
     expect(animal.sample).not.toHaveProperty("id");
     expect(animal.sample).toHaveProperty("species");
     expect(animal.sample).toHaveProperty("legs");
 
-    const chases = results.find((r: any) => r.kind === "relationship" && r.type === "CHASES");
+    const chases = results.find((r: any) => r.kind === "Relationship" && r.type === "CHASES");
     expect(chases).toBeDefined();
+    expect(chases.from_label).toBe("Animal");
+    expect(chases.to_label).toBe("Animal");
+    expect(chases.properties).toEqual(["speed"]);
     expect(chases.sample).toBeDefined();
     expect(chases.sample).not.toHaveProperty("left_id");
     expect(chases.sample).not.toHaveProperty("right_id");
@@ -2690,3 +2726,243 @@ test("Test UNION with empty right side", async () => {
     expect(results.length).toBe(1);
     expect(results).toEqual([{ x: 1 }]);
 });
+
+test("Test language name hits query with virtual graph", async () => {
+    // Create Language nodes
+    await new Runner(`
+        CREATE VIRTUAL (:Language) AS {
+            UNWIND [
+                {id: 1, name: 'Python'},
+                {id: 2, name: 'JavaScript'},
+                {id: 3, name: 'TypeScript'}
+            ] AS record
+            RETURN record.id AS id, record.name AS name
+        }
+    `).run();
+
+    // Create Chat nodes with messages
+    await new Runner(`
+        CREATE VIRTUAL (:Chat) AS {
+            UNWIND [
+                {id: 1, name: 'Dev Discussion', messages: [
+                    {From: 'Alice', SentDateTime: '2025-01-01T10:00:00', Content: 'I love Python and JavaScript'},
+                    {From: 'Bob', SentDateTime: '2025-01-01T10:05:00', Content: 'What languages do you prefer?'}
+                ]},
+                {id: 2, name: 'General', messages: [
+                    {From: 'Charlie', SentDateTime: '2025-01-02T09:00:00', Content: 'The weather is nice today'},
+                    {From: 'Alice', SentDateTime: '2025-01-02T09:05:00', Content: 'TypeScript is great for language tooling'}
+                ]}
+            ] AS record
+            RETURN record.id AS id, record.name AS name, record.messages AS messages
+        }
+    `).run();
+
+    // Create User nodes
+    await new Runner(`
+        CREATE VIRTUAL (:User) AS {
+            UNWIND [
+                {id: 1, displayName: 'Alice'},
+                {id: 2, displayName: 'Bob'},
+                {id: 3, displayName: 'Charlie'}
+            ] AS record
+            RETURN record.id AS id, record.displayName AS displayName
+        }
+    `).run();
+
+    // Create PARTICIPATES_IN relationships
+    await new Runner(`
+        CREATE VIRTUAL (:User)-[:PARTICIPATES_IN]-(:Chat) AS {
+            UNWIND [
+                {left_id: 1, right_id: 1},
+                {left_id: 2, right_id: 1},
+                {left_id: 3, right_id: 2},
+                {left_id: 1, right_id: 2}
+            ] AS record
+            RETURN record.left_id AS left_id, record.right_id AS right_id
+        }
+    `).run();
+
+    // Run the original query (using 'sender' alias since 'from' is a reserved keyword)
+    const runner = new Runner(`
+        MATCH (l:Language)
+        WITH collect(distinct l.name) AS langs
+        MATCH (c:Chat)
+        UNWIND c.messages AS msg
+        WITH c, msg, langs,
+             sum(lang IN langs | 1 where toLower(msg.Content) CONTAINS toLower(lang)) AS langNameHits
+        WHERE toLower(msg.Content) CONTAINS "language"
+           OR toLower(msg.Content) CONTAINS "languages"
+           OR langNameHits > 0
+        OPTIONAL MATCH (u:User)-[:PARTICIPATES_IN]->(c)
+        RETURN
+          c.name AS chat,
+          collect(distinct u.displayName) AS participants,
+          msg.From AS sender,
+          msg.SentDateTime AS sentDateTime,
+          msg.Content AS message
+    `);
+    await runner.run();
+    const results = runner.results;
+
+    // Messages that mention a language name or the word "language(s)":
+    // 1. "I love Python and JavaScript" - langNameHits=2 (matches Python and JavaScript)
+    // 2. "What languages do you prefer?" - contains "languages"
+    // 3. "TypeScript is great for language tooling" - langNameHits=1, also contains "language"
+    expect(results.length).toBe(3);
+    expect(results[0].chat).toBe("Dev Discussion");
+    expect(results[0].message).toBe("I love Python and JavaScript");
+    expect(results[0].sender).toBe("Alice");
+    expect(results[1].chat).toBe("Dev Discussion");
+    expect(results[1].message).toBe("What languages do you prefer?");
+    expect(results[1].sender).toBe("Bob");
+    expect(results[2].chat).toBe("General");
+    expect(results[2].message).toBe("TypeScript is great for language tooling");
+    expect(results[2].sender).toBe("Alice");
+});
+
+test("Test sum with empty collected array", async () => {
+    // Reproduces the original bug: collect on empty input should yield []
+    // and sum over that empty array should return 0, not throw
+    const runner = new Runner(`
+        UNWIND [] AS lang
+        WITH collect(distinct lang) AS langs
+        UNWIND ['hello', 'world'] AS msg
+        WITH msg, langs, sum(l IN langs | 1 where toLower(msg) CONTAINS toLower(l)) AS hits
+        RETURN msg, hits
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ msg: "hello", hits: 0 });
+    expect(results[1]).toEqual({ msg: "world", hits: 0 });
+});
+
+test("Test sum where all elements filtered returns 0", async () => {
+    const runner = new Runner("RETURN sum(n in [1, 2, 3] | n where n > 100) as sum");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ sum: 0 });
+});
+
+test("Test sum over empty array returns 0", async () => {
+    const runner = new Runner("WITH [] AS arr RETURN sum(n in arr | n) as sum");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ sum: 0 });
+});
+
+test("Test match with ORed relationship types", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Alice'},
+                {id: 2, name: 'Bob'},
+                {id: 3, name: 'Charlie'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+            unwind [
+                {left_id: 1, right_id: 2}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:FOLLOWS]-(:Person) AS {
+            unwind [
+                {left_id: 2, right_id: 3}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:Person)-[:KNOWS|FOLLOWS]->(b:Person)
+        RETURN a.name AS name1, b.name AS name2
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ name1: "Alice", name2: "Bob" });
+    expect(results[1]).toEqual({ name1: "Bob", name2: "Charlie" });
+});
+
+test("Test match with ORed relationship types with optional colon syntax", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Animal) AS {
+            unwind [
+                {id: 1, name: 'Cat'},
+                {id: 2, name: 'Dog'},
+                {id: 3, name: 'Fish'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Animal)-[:CHASES]-(:Animal) AS {
+            unwind [
+                {left_id: 1, right_id: 2}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Animal)-[:EATS]-(:Animal) AS {
+            unwind [
+                {left_id: 1, right_id: 3}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:Animal)-[:CHASES|:EATS]->(b:Animal)
+        RETURN a.name AS name1, b.name AS name2
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ name1: "Cat", name2: "Dog" });
+    expect(results[1]).toEqual({ name1: "Cat", name2: "Fish" });
+});
+
+test("Test match with ORed relationship types returns correct type in relationship variable", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:City) AS {
+            unwind [
+                {id: 1, name: 'NYC'},
+                {id: 2, name: 'LA'},
+                {id: 3, name: 'Chicago'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:City)-[:FLIGHT]-(:City) AS {
+            unwind [
+                {left_id: 1, right_id: 2, airline: 'Delta'}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id, record.airline as airline
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:City)-[:TRAIN]-(:City) AS {
+            unwind [
+                {left_id: 1, right_id: 3, line: 'Amtrak'}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id, record.line as line
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:City)-[r:FLIGHT|TRAIN]->(b:City)
+        RETURN a.name AS from, b.name AS to, r.type AS type
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ from: "NYC", to: "LA", type: "FLIGHT" });
+    expect(results[1]).toEqual({ from: "NYC", to: "Chicago", type: "TRAIN" });
+});