Support users embedding fql snippets in objects and arrays

__tests__/integration/query-limits.test.ts

@@ -1,5 +1,5 @@
-import { Client, fql, Module } from "../../src";
-import { getClient, getDefaultSecretAndEndpoint } from "../client";
+import { Client, fql } from "../../src";
+import { getClient } from "../client";
 
 const rootClient = getClient();
 const clients = new Array<Client>();

__tests__/integration/query.test.ts

@@ -518,7 +518,73 @@ describe("query can encode / decode QueryValue correctly", () => {
  if (e instanceof TypeError) {
  expect(e.name).toBe("TypeError");
  expect(e.message).toBe(
- "Passing undefined as a QueryValue is not supported",
+ "Passing undefined as a QueryArgument is not supported",
+ );
+ }
+ }
+ });
+
+ it("symbol arguments throw a TypeError", async () => {
+ expect.assertions(2);
+ // whack in a symbol
+ // @ts-expect-error Type 'symbol' is not assignable to type 'QueryValue'
+ let symbolValue: QueryValue = Symbol("foo");
+ try {
+ await client.query(fql`{ foo: ${symbolValue} }`);
+ } catch (e) {
+ if (e instanceof TypeError) {
+ expect(e.name).toBe("TypeError");
+ expect(e.message).toBe(
+ "Passing symbol as a QueryArgument is not supported",
+ );
+ }
+ }
+ });
+
+ it("function arguments throw a TypeError", async () => {
+ expect.assertions(2);
+ // whack in a function
+ let fnValue: QueryValue = () => {};
+ try {
+ await client.query(fql`{ foo: ${fnValue} }`);
+ } catch (e) {
+ if (e instanceof TypeError) {
+ expect(e.name).toBe("TypeError");
+ expect(e.message).toBe(
+ "Passing function as a QueryArgument is not supported",
+ );
+ }
+ }
+ });
+
+ it("symbol arguments throw a TypeError in arguments", async () => {
+ expect.assertions(2);
+ // whack in a symbol
+ // @ts-expect-error Type 'symbol' is not assignable to type 'QueryValue'
+ let symbolValue: QueryValue = Symbol("foo");
+ try {
+ await client.query(fql`foo`, { arguments: { foo: symbolValue } });
+ } catch (e) {
+ if (e instanceof TypeError) {
+ expect(e.name).toBe("TypeError");
+ expect(e.message).toBe(
+ "Passing symbol as a QueryArgument is not supported",
+ );
+ }
+ }
+ });
+
+ it("function arguments throw a TypeError in arguments", async () => {
+ expect.assertions(2);
+ // whack in a function
+ let fnValue: QueryValue = () => {};
+ try {
+ await client.query(fql`foo`, { arguments: { foo: fnValue } });
+ } catch (e) {
+ if (e instanceof TypeError) {
+ expect(e.name).toBe("TypeError");
+ expect(e.message).toBe(
+ "Passing function as a QueryArgument is not supported",
  );
  }
  }

__tests__/integration/template-format.test.ts

@@ -109,6 +109,64 @@ describe("query using template format", () => {
  expect(response.data).toBe(true);
  });
 
+ it("succeeds with deep nested expressions - example 2", async () => {
+ const str = "foo";
+ const otherStr = "bar";
+ const num = 6;
+ const otherNum = 3;
+ const deepFirst = fql`(${str} + ${otherStr})`;
+ const deeperBuilder = fql`(${num} + 3)`;
+ const innerQuery = fql`(${deeperBuilder} + ${otherNum})`;
+ const queryBuilder = fql`${deepFirst}.length + ${innerQuery}`;
+ const response = await client.query(queryBuilder);
+ expect(response.data).toBe(18);
+ });
+
+ it("succeeds with expressions nested within objects", async () => {
+ const arg = {
+ a: fql`1`,
+ b: fql`2`,
+ };
+ const queryBuilder = fql`${arg}`;
+ const response = await client.query(queryBuilder);
+ expect(response.data).toStrictEqual({ a: 1, b: 2 });
+ });
+
+ it("succeeds with expressions nested within arrays", async () => {
+ const arg = [fql`1`, fql`2`];
+ const queryBuilder = fql`${arg}`;
+ const response = await client.query(queryBuilder);
+ expect(response.data).toEqual([1, 2]);
+ });
+
+ it("succeeds with expressions nested within arrays and objects combined", async () => {
+ const arg = [
+ [fql`1`],
+ {
+ a: fql`1`,
+ b: fql`2`,
+ },
+ ];
+ const queryBuilder = fql`${arg}`;
+ const response = await client.query(queryBuilder);
+ expect(response.data).toEqual([[1], { a: 1, b: 2 }]);
+ });
+
+ it("succeeds with multiple layers of nesting of arrays and objects", async () => {
+ const other = { a: fql`3`, b: fql`4` };
+ const arg = [
+ [fql`1 + ${fql`2`}`],
+ {
+ a: fql`1`,
+ b: fql`2`,
+ c: other,
+ },
+ ];
+ const queryBuilder = fql`${arg}`;
+ const response = await client.query(queryBuilder);
+ expect(response.data).toEqual([[3], { a: 1, b: 2, c: { a: 3, b: 4 } }]);
+ });
+
  it("succeeds with FQL string interpolation", async () => {
  const codeName = "Alice";
  const queryBuilder = fql`

__tests__/unit/query-builder.test.ts

@@ -3,108 +3,117 @@ import { fql } from "../../src";
 describe("fql method producing Querys", () => {
  it("parses with no variables", () => {
  const queryBuilder = fql`'foo'.length`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({ fql: ["'foo'.length"] });
- expect(queryRequest.arguments).toStrictEqual({});
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({ fql: ["'foo'.length"] });
  });
 
  it("parses with a string variable", () => {
  const str = "foo";
  const queryBuilder = fql`${str}.length`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: [{ value: "foo" }, ".length"],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with a number variable", () => {
  const num = 8;
  const queryBuilder = fql`'foo'.length == ${num}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: ["'foo'.length == ", { value: { "@int": "8" } }],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with a boolean variable", () => {
  const bool = true;
  const queryBuilder = fql`val.enabled == ${bool}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: ["val.enabled == ", { value: true }],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with a null variable", () => {
  const queryBuilder = fql`value: ${null}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: ["value: ", { value: null }],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with an object variable", () => {
  const obj = { foo: "bar", bar: "baz" };
  const queryBuilder = fql`value: ${obj}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
- fql: ["value: ", { value: { bar: "baz", foo: "bar" } }],
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
+ fql: [
+ "value: ",
+ { object: { bar: { value: "baz" }, foo: { value: "bar" } } },
+ ],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with an object variable having a toQuery property", () => {
  const obj = { foo: "bar", bar: "baz", toQuery: "hehe" };
  const queryBuilder = fql`value: ${obj}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
- fql: ["value: ", { value: { bar: "baz", foo: "bar", toQuery: "hehe" } }],
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
+ fql: [
+ "value: ",
+ {
+ object: {
+ bar: { value: "baz" },
+ foo: { value: "bar" },
+ toQuery: { value: "hehe" },
+ },
+ },
+ ],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with an array variable", () => {
  const arr = [1, 2, 3];
  const queryBuilder = fql`value: ${arr}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: [
  "value: ",
- { value: [{ "@int": "1" }, { "@int": "2" }, { "@int": "3" }] },
+ {
+ array: [
+ { value: { "@int": "1" } },
+ { value: { "@int": "2" } },
+ { value: { "@int": "3" } },
+ ],
+ },
+ ,
  ],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with multiple variables", () => {
  const str = "bar";
  const num = 17;
  const queryBuilder = fql`${str}.length == ${num + 3}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: [{ value: "bar" }, ".length == ", { value: { "@int": "20" } }],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses nested expressions", () => {
  const str = "baz";
  const num = 17;
  const innerQuery = fql`Math.add(${num}, 3)`;
  const queryBuilder = fql`${str}.length == ${innerQuery}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: [
  { value: "baz" },
  ".length == ",
  { fql: ["Math.add(", { value: { "@int": "17" } }, ", 3)"] },
  ],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses deep nested expressions", () => {
@@ -116,8 +125,8 @@ describe("fql method producing Querys", () => {
  const deeperBuilder = fql`Math.add(${num}, 3)`;
  const innerQuery = fql`Math.add(${deeperBuilder}, ${otherNum})`;
  const queryBuilder = fql`${deepFirst}.length == ${innerQuery}`;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: [
  { fql: ["(", { value: "baz" }, " + ", { value: "bar" }, ")"] },
  ".length == ",
@@ -132,38 +141,6 @@ describe("fql method producing Querys", () => {
  },
  ],
  });
- expect(queryRequest.arguments).toStrictEqual({});
- });
-
- it("adds headers if passed in", () => {
- const str = "baz";
- const num = 17;
- const innerQuery = fql`Math.add(${num}, 3)`;
- const queryBuilder = fql`${str}.length == ${innerQuery}`;
- const queryRequest = queryBuilder.toQuery({
- linearized: true,
- query_timeout_ms: 600,
- max_contention_retries: 4,
- query_tags: { a: "tag" },
- traceparent: "00-750efa5fb6a131eb2cf4db39f28366cb-5669e71839eca76b-00",
- typecheck: false,
- });
- expect(queryRequest).toMatchObject({
- linearized: true,
- query_timeout_ms: 600,
- max_contention_retries: 4,
- query_tags: { a: "tag" },
- traceparent: "00-750efa5fb6a131eb2cf4db39f28366cb-5669e71839eca76b-00",
- typecheck: false,
- });
- expect(queryRequest.query).toEqual({
- fql: [
- { value: "baz" },
- ".length == ",
- { fql: ["Math.add(", { value: { "@int": "17" } }, ", 3)"] },
- ],
- });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 
  it("parses with FQL string interpolation", async () => {
@@ -172,14 +149,13 @@ describe("fql method producing Querys", () => {
  let name = ${codeName}
  "Hello, #{name}"
  `;
- const queryRequest = queryBuilder.toQuery();
- expect(queryRequest.query).toEqual({
+ const fragment = queryBuilder.encode();
+ expect(fragment).toEqual({
  fql: [
  "\n let name = ",
  { value: "Alice" },
  '\n "Hello, #{name}"\n ',
  ],
  });
- expect(queryRequest.arguments).toStrictEqual({});
  });
 });