@xano/xanoscript-language-server 11.0.3

package/parser/functions/db/dbEditFn.spec.js

@@ -0,0 +1,122 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.dbEditFn();
+  return parser;
+}
+
+describe("dbEditFn", () => {
+  it("dbEditFn accepts data, field_name and field_value", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbEditFn accepts a multiline data object", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      data = { 
+        name: $input.name
+        age: $input.age
+      }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbEditFn accepts an output", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      data = { 
+        name: $input.name
+        age: $input.age
+      }
+      output = ["id", "name", "email"]
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbEditFn rejects a variable as data", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      data = $input.data
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbEditFn rejects data with a badly formed object", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      data = { 
+        name: $input.name,
+        someError
+      }
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbEditFn accepts a string literal for table", () => {
+    const parser = parse(`edit "my users" {
+      field_name = "email"
+      field_value = $input.email
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbEditFn can be disabled", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      data = { name: $input.name }
+      disabled = true
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbEditFn accepts a description", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+      description = "check if a user exists"
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbEditFn requires a field_name", () => {
+    const parser = parse(`edit user {
+      field_value = $input.email
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbEditFn requires a field_value", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbEditFn requires a data field", () => {
+    const parser = parse(`edit user {
+      field_name = "email"
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/db/dbExternalDirectQueryFn.js

@@ -0,0 +1,29 @@
+import { DirectQueryToken } from "../../../lexer/db.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function dbExternalDirectQueryFn($) {
+  return () => {
+    $.sectionStack.push("dbExternalDirectQueryFn");
+    const fnToken = $.CONSUME(DirectQueryToken); // "direct_query"
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          sql: "[expression]",
+          response_type: ["list", "single"],
+          connection_string: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "arg*": "[expression]",
+          "mock?": { "![string]": "[expression]" },
+        },
+      ],
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/db/dbExternalDirectQueryFn.spec.js

@@ -0,0 +1,103 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.dbExternalDirectQueryFn();
+  return parser;
+}
+
+describe("dbExternalDirectQueryFn", () => {
+  it("dbExternalDirectQueryFn accepts a code, response_type and connection_string", () => {
+    const parser = parse(`direct_query {
+      sql = "SELECT * FROM USERS"
+      response_type = "list"
+      connection_string = ""
+    } as $x3`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn can be disabled", () => {
+    const parser = parse(`direct_query {
+      sql = "SELECT * FROM USERS"
+      response_type = "list"
+      connection_string = ""
+      disabled = true
+    } as $x3`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn accepts a description", () => {
+    const parser = parse(`direct_query {
+      sql = "SELECT * FROM USERS"
+      response_type = "list"
+      connection_string = ""
+      description = "external query"
+    } as $x3`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn accepts multiple args", () => {
+    const parser = parse(`direct_query {
+      sql = "SELECT * FROM USERS"
+      response_type = "list"
+      connection_string = ""
+      arg = $input.name
+      arg = $input.category
+    } as $x3`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn accepts multiline", () => {
+    const parser = parse(`direct_query {
+      sql = """
+        SELECT * 
+        FROM USERS
+        WHERE name = $input.name
+        """
+      response_type = "list"
+      connection_string = ""
+      arg = $input.name
+      arg = $input.category
+    } as $x3`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn requires code", () => {
+    const parser = parse(`direct_query {
+      response_type = "list"
+      connection_string = ""
+      arg = $input.name
+      arg = $input.category
+    } as $x3`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn requires connection_string", () => {
+    const parser = parse(`direct_query {
+      sql = "SELECT * FROM USERS"
+      response_type = "list"
+      arg = $input.name
+      arg = $input.category
+    } as $x3`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbExternalDirectQueryFn requires response_type", () => {
+    const parser = parse(`direct_query {
+      sql = """
+        SELECT * 
+        FROM USERS
+        WHERE name = $input.name
+        """
+      connection_string = ""
+      arg = $input.name
+      arg = $input.category
+    } as $x3`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/db/dbExternalFn.js

@@ -0,0 +1,29 @@
+import {
+  ExternalToken,
+  MssqlToken,
+  MysqlToken,
+  OracleToken,
+  PostgresToken,
+} from "../../../lexer/db.js";
+import { DotToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function dbExternalFn($) {
+  return () => {
+    $.sectionStack.push("dbExternalFn");
+    $.CONSUME(ExternalToken); // "external"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.CONSUME(MssqlToken) }, // "external.mssql"
+      { ALT: () => $.CONSUME(MysqlToken) }, // "external.mysql"
+      { ALT: () => $.CONSUME(OracleToken) }, // "external.oracle"
+      { ALT: () => $.CONSUME(PostgresToken) }, // "external.postgres"
+    ]);
+    $.CONSUME1(DotToken); // "."
+    $.SUBRULE($.dbExternalDirectQueryFn); // "external.direct_query"
+
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/db/dbGetFn.js

@@ -0,0 +1,40 @@
+import { GetToken } from "../../../lexer/db.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { Identifier } from "../../../lexer/tokens.js";
+import { addonSchema } from "./schema.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function dbGetFn($) {
+  return () => {
+    $.sectionStack.push("dbGetFn");
+    const fnToken = $.CONSUME(GetToken); // "get"
+    $.OR({
+      DEF: [
+        { ALT: () => $.CONSUME(Identifier) }, // user
+        { ALT: () => $.CONSUME1(StringLiteral) }, // "user table"
+      ],
+      ERR_MSG: "Expected a table name",
+    });
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          field_name: "[expression]",
+          field_value: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "output?": ["[string]"],
+          "lock?": "[boolean]",
+          "addon?": [addonSchema],
+          "mock?": { "![string]": "[expression]" },
+        },
+      ],
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/db/dbGetFn.spec.js

@@ -0,0 +1,117 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.dbGetFn();
+  return parser;
+}
+
+describe("dbGetFn", () => {
+  it("dbGetFn accepts a field_name and field_value", () => {
+    const parser = parse(`get user {
+      field_name = "email"
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn accepts a string literal for table", () => {
+    const parser = parse(`get "my users" {
+      field_name = "email"
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn can be disabled", () => {
+    const parser = parse(`get user {
+      field_name = "email"
+      field_value = $input.email
+      disabled = true
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn accepts a lock field", () => {
+    const parser = parse(`get user {
+      field_name = "id"
+      field_value = ""
+      lock = true
+    } as $user1`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn accepts output fields", () => {
+    const parser = parse(`get user {
+      field_name = "email"
+      field_value = $input.email
+      output = ["id", "email", "created_at"]
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn accepts a description", () => {
+    const parser = parse(`get user {
+      field_name = "email"
+      field_value = $input.email
+      description = "query to get user by email"
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn requires a field_name", () => {
+    const parser = parse(`get user {
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbGetFn accepts an addon", () => {
+    const parser = parse(`get user {
+      field_value = $input.email
+      field_name = "email"
+      addon = [
+        {name: "client", input: {client_id: ""}, as: "_client"}
+      ]
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn accepts sub addon", () => {
+    const parser = parse(`get user {
+      field_value = $input.email
+      field_name = "email"
+      addon = [
+       {
+          as: "client1"
+          name: "client",
+          input: {client_id: ""}
+          addon: [
+            {
+              name: "client"
+              input: {client_id: $output.id}
+              as: "client2"
+            }
+            {
+              name: "bar"
+              as: "foo"
+            }
+          ]
+        }
+      ]
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbGetFn requires a field_value", () => {
+    const parser = parse(`get user {
+      field_name = "email"
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/db/dbHasFn.js

@@ -0,0 +1,34 @@
+import { HasToken } from "../../../lexer/db.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { Identifier } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function dbHasFn($) {
+  return () => {
+    $.sectionStack.push("dbHasFn");
+    const fnToken = $.CONSUME(HasToken); // "has"
+    $.OR({
+      DEF: [
+        { ALT: () => $.CONSUME(Identifier) }, // user
+        { ALT: () => $.CONSUME1(StringLiteral) }, // "user table"
+      ],
+      ERR_MSG: "Expected a table name",
+    });
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          field_name: "[expression]",
+          field_value: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "mock?": { "![string]": "[expression]" },
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/db/dbHasFn.spec.js

@@ -0,0 +1,62 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.dbHasFn();
+  return parser;
+}
+
+describe("dbHasFn", () => {
+  it("dbHasFn accepts a field_name and field_value", () => {
+    const parser = parse(`has user {
+      field_name = "email"
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbHasFn accepts a string literal for table", () => {
+    const parser = parse(`has "my users" {
+      field_name = "email"
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbHasFn can be disabled", () => {
+    const parser = parse(`has user {
+      field_name = "email"
+      field_value = $input.email
+      disabled = true
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbHasFn accepts a description", () => {
+    const parser = parse(`has user {
+      field_name = "email"
+      field_value = $input.email
+      description = "check if a user exists"
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbHasFn requires a field_name", () => {
+    const parser = parse(`has user {
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbHasFn requires a field_value", () => {
+    const parser = parse(`has user {
+      field_name = "email"
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/db/dbPatchFn.js

@@ -0,0 +1,39 @@
+import { PatchToken } from "../../../lexer/db.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { Identifier } from "../../../lexer/tokens.js";
+import { addonSchema } from "./schema.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function dbPatchFn($) {
+  return () => {
+    $.sectionStack.push("dbPatchFn");
+    const fnToken = $.CONSUME(PatchToken); // "patch"
+    $.OR({
+      DEF: [
+        { ALT: () => $.CONSUME(Identifier) }, // user
+        { ALT: () => $.CONSUME1(StringLiteral) }, // "user table"
+      ],
+      ERR_MSG: "Expected a table name",
+    });
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          field_name: "[expression]",
+          field_value: "[expression]",
+          data: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "addon?": [addonSchema],
+          "mock?": { "![string]": "[expression]" },
+        },
+      ],
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/db/dbPatchFn.spec.js

@@ -0,0 +1,88 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.dbPatchFn();
+  return parser;
+}
+
+describe("dbPatchFn", () => {
+  it("dbPatchFn accepts data, field_name and field_value", () => {
+    const parser = parse(`patch user {
+      field_name = "email"
+      field_value = $input.email
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbPatchFn accepts a multiline data object", () => {
+    const parser = parse(`patch user {
+      field_name = "email"
+      field_value = $input.email
+      data = { 
+        name: $input.name
+        age: $input.age
+      }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbPatchFn accepts a string literal for table", () => {
+    const parser = parse(`patch "my users" {
+      field_name = "email"
+      field_value = $input.email
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbPatchFn can be disabled", () => {
+    const parser = parse(`patch user {
+      field_name = "email"
+      field_value = $input.email
+      data = { name: $input.name }
+      disabled = true
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbPatchFn accepts a description", () => {
+    const parser = parse(`patch user {
+      field_name = "email"
+      field_value = $input.email
+      description = "check if a user exists"
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbPatchFn requires a field_name", () => {
+    const parser = parse(`patch user {
+      field_value = $input.email
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbPatchFn requires a field_value", () => {
+    const parser = parse(`patch user {
+      field_name = "email"
+      data = { name: $input.name }
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbPatchFn requires a data field", () => {
+    const parser = parse(`patch user {
+      field_name = "email"
+      field_value = $input.email
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});