@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/parser/clauses/schemaClause.spec.js

@@ -1,102 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText, context = null) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-
-  if (context) {
-    parser.sectionStack.push(context);
-    parser.schemaClause();
-    parser.sectionStack.pop();
-  } else {
-    parser.schemaClause();
-  }
-
-  return parser;
-}
-
-describe("schemaClause", () => {
-  it("schemaClause accepts a field", () => {
-    const parser = parse(`schema {
-        int rank
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause accepts a comment above a field", () => {
-    const parser = parse(`schema {
-        // some comment
-        int rank
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause accepts multiple fields", () => {
-    const parser = parse(`schema {
-        int rank
-        text label
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause does not require curlies", () => {
-    const parser = parse(`schema`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause accepts a visibility when in a table definition", () => {
-    const parser = parse(
-      `schema {
-      int rank {
-        visibility = "private"
-      }
-      text label {
-        visibility = "internal"
-      }
-    }`,
-      "tableDeclaration",
-    );
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause rejects a visibility when not in a table definition", () => {
-    const parser = parse(`schema {
-      int rank {
-        visibility = "private"
-      }
-      text label {
-        visibility = "internal"
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("schemaClause accepts a description", () => {
-    const parser = parse(`schema {
-      text label {
-        description = "This is a description"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause field accepts a file type", () => {
-    const parser = parse(`schema {
-        file my_file?
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaClause field accepts a sensitivity marker", () => {
-    const parser = parse(`schema {
-      decimal value {
-        sensitive = true
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/testClause.spec.js

@@ -1,69 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.testClause();
-  return parser;
-}
-
-describe("testClause", () => {
-  it("testClause defines a named test", () => {
-    const parser = parse(`test "should add numbers" {
-      expect.to_equal ($response) {
-        value = 5
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("testClause requires accepts an optional datasource", () => {
-    const parser = parse(`test "should add numbers" {
-      datasource = "live"
-
-      expect.to_equal ($response) {
-        value = 5
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("testClause can have many expects", () => {
-    const parser = parse(`test "should add numbers" {
-      expect.to_equal ($response) {
-        value = 5
-      }
-
-      expect.to_be_defined ($response)
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("testClause accepts inputs", () => {
-    const parser = parse(`test "should add numbers" {
-      input = {
-        a: 2
-        b: 3
-      }
-
-      expect.to_equal ($response) {
-        value = 5
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("testClause accepts a one liner input", () => {
-    const parser = parse(`test "should add numbers" {
-      input = { a: 2, b: 3 }
-
-      expect.to_be_greater_than ($response) {
-        value = 4
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/viewClause.spec.js

@@ -1,163 +0,0 @@
-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.viewClause();
-  return parser;
-}
-
-describe("viewClause", () => {
-  it("viewClause accepts a basic view with search, sort and id", () => {
-    const parser = parse(`view = {
-      "pending applications": {
-        search: $db.status == "pending"
-        sort  : {id: "rand"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts a hide attribute", () => {
-    const parser = parse(`view = {
-      "pending applications": {
-        hide: ["created_at"];
-        sort  : {id: "rand"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts multiple views in an object", () => {
-    const parser = parse(`view = {
-      "pending applications": {
-        search: $db.status == "pending"
-        sort  : {id: "rand"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-      "what is that?": {
-        alias : "that_alias"
-        search: $db.status == "pending"
-        sort  : {id: "asc"}
-        id    : "07a2ebcd-3361-425c-8f7f-ed8981dca0d1"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts different sort directions", () => {
-    const parser = parse(`view = {
-      "ascending": {
-        search: $db.status == "pending"
-        sort  : {id: "asc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-      "descending": {
-        search: $db.status == "pending"
-        sort  : {id: "desc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-      "random": {
-        search: $db.status == "pending"
-        sort  : {id: "rand"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts an alias property", () => {
-    const parser = parse(`view = {
-      "aliased view": {
-        alias : "that_alias"
-        search: $db.status == "pending"
-        sort  : {id: "asc"}
-        id    : "07a2ebcd-3361-425c-8f7f-ed8981dca0d1"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts complex search expressions", () => {
-    const parser = parse(`view = {
-      "complex search": {
-        search: $db.status == "pending" && $db.created_at > "2023-01-01"
-        sort  : {id: "asc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts multiple sort fields", () => {
-    const parser = parse(`view = {
-      "multiple sorts": {
-        search: $db.status == "pending"
-        sort  : {
-          created_at: "desc"
-          name: "asc"
-        }
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accept either a sort criteria", () => {
-    const parser = parse(`view = {
-      "no search criteria": {
-        sort  : {id: "asc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause requires either a search, sort or hide criteria", () => {
-    const parser = parse(`view = {
-      "no criteria": {
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("viewClause accepts a view with numeric keys in search criteria", () => {
-    const parser = parse(`view = {
-      "numeric search": {
-        search: $db.count > 5
-        sort  : {id: "asc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts a view with complex boolean logic", () => {
-    const parser = parse(`view = {
-      "complex logic": {
-        search: ($db.status == "pending" || $db.status == "active") && $db.created_at > "2023-01-01"
-        sort  : {id: "asc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("viewClause accepts a view with special characters in name", () => {
-    const parser = parse(`view = {
-      "view-with_special.chars!": {
-        search: $db.status == "pending"
-        sort  : {id: "asc"}
-        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/definitions/arraySlice.spec.js

@@ -1,49 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.arraySlice();
-  return parser;
-}
-
-describe("arraySlice", () => {
-  // []
-  it("arraySlice can define an array slice", () => {
-    const parser = parse(`[]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // [1:]
-  it("arraySlice can define an array slice with start index", () => {
-    const parser = parse(`[1:]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // [:3]
-  it("arraySlice can define an array slice with end index", () => {
-    const parser = parse(`[:3]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // [1:3]
-  it("arraySlice can define an array slice with start and end index", () => {
-    const parser = parse(`[1:3]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // cannot be negative
-  it("arraySlice cannot define an array slice with negative index", () => {
-    const parser = parse(`[-1:]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  // cannot have end < start
-  it("arraySlice cannot define an array slice with end index < start index", () => {
-    const parser = parse(`[3:1]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/definitions/columnDefinition.spec.js

@@ -1,199 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.columnDefinition();
-  return parser;
-}
-
-describe("columnDefinition", () => {
-  it("columnDefinition can define an int", () => {
-    const parser = parse(`int anIntegerVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition capture the input in the registry", () => {
-    const parser = parse(`int anIntegerVar`);
-    expect(parser.__symbolTable.input).to.deep.equal({
-      anIntegerVar: {
-        type: "int",
-        iterable: false,
-        nullable: false,
-        optional: false,
-      },
-    });
-  });
-
-  it("columnDefinition can define a text", () => {
-    const parser = parse(`text aTextVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a uuid", () => {
-    const parser = parse(`uuid aTextVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a decimal", () => {
-    const parser = parse(`decimal aDecimalVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a boolean", () => {
-    const parser = parse(`bool aBooleanVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a date", () => {
-    const parser = parse(`date aDateVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a timestamp", () => {
-    const parser = parse(`timestamp aDateTimeVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a vector", () => {
-    const parser = parse(`vector aVectorVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a json", () => {
-    const parser = parse(`json aJsonVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a email", () => {
-    const parser = parse(`email anEmailVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can define a password", () => {
-    const parser = parse(`password aPasswordVar`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition accepts a sensitive marker", () => {
-    const parser = parse(`password aPasswordVar {
-      sensitive = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition accepts a vector size", () => {
-    const parser = parse(`vector vec {
-      size = 1536
-    }`);
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).to.be.empty;
-  });
-
-  it("columnDefinition warns of a missing vector size", () => {
-    const parser = parse(`vector vec`);
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).to.not.be.empty;
-  });
-
-  it("columnDefinition accepts a description", () => {
-    const parser = parse(`text label {
-      description = "the display name of the product"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition does not accepts non-registered filter", () => {
-    const parser = parse("int age filters=whatTheHeck");
-    expect(parser.errors).not.to.be.empty;
-  });
-
-  it("columnDefinition can be defined as an array", () => {
-    const parser = parse(`int[] variableArray`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition captures the array input", () => {
-    const parser = parse(`int[] variableArray`);
-    expect(parser.__symbolTable.input).to.deep.equal({
-      variableArray: {
-        type: "int",
-        iterable: true,
-        nullable: false,
-        optional: false,
-      },
-    });
-  });
-
-  it("columnDefinition captures optional values", () => {
-    const parser = parse(`email[] variableArray?`);
-    expect(parser.__symbolTable.input).to.deep.equal({
-      variableArray: {
-        type: "email",
-        iterable: true,
-        nullable: false,
-        optional: true,
-      },
-    });
-  });
-
-  it("columnDefinition captures nullable values", () => {
-    const parser = parse(`timestamp[]? variableArray`);
-    expect(parser.__symbolTable.input).to.deep.equal({
-      variableArray: {
-        type: "timestamp",
-        iterable: true,
-        nullable: true,
-        optional: false,
-      },
-    });
-  });
-
-  it("columnDefinition can reuse type as variable name", () => {
-    const parser = parse(`email email`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition can be optional", () => {
-    const parser = parse(`decimal variable?`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition cannot start with a number", () => {
-    const parser = parse(`uuid 12variable`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("columnDefinition can be marked nullable", () => {
-    const parser = parse(`text? variable`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition accepts a default value", () => {
-    const parser = parse(`timestamp when=now`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition accepts a filter", () => {
-    const parser = parse("text isbn? filters=trim");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition accepts multiple filters", () => {
-    const parser = parse("email email_input? filters=trim|lower");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("columnDefinition rejects mismatched filters", () => {
-    const parser = parse("decimal height filters=startsWith:12|max:200");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("columnDefinition rejects non-existing filters", () => {
-    const parser = parse("decimal height filters=nonExistingFilter");
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/definitions/dbLinkColumnDefinition.spec.js

@@ -1,45 +0,0 @@
-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.dbLinkColumnDefinition();
-  return parser;
-}
-
-describe("dbLinkColumnDefinition", () => {
-  it("dbLinkColumnDefinition accepts a string for table value", () => {
-    const parser = parse(`dblink {
-      table = "book_club_meeting_registration"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("dbLinkColumnDefinition requires a string for table value", () => {
-    const parser = parse(`dblink {
-      table = 123
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("dbLinkColumnDefinition allows an override", () => {
-    const parser = parse(`dblink {
-      table = "user"
-      override = {
-        created_at: {hidden: true}
-        email     : {hidden: true}
-        password  : {hidden: true}
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("dbLinkColumnDefinition cannot be empty", () => {
-    const parser = parse(`dblink {}`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});