@xano/xanoscript-language-server 11.0.3

package/parser/clauses/schemaClause.spec.js

@@ -0,0 +1,66 @@
+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.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 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/stackClause.js

@@ -0,0 +1,16 @@
+import { StackToken } from "../../lexer/tokens.js";
+import { DEFAULT_OPTIONS } from "./nakedStackFn.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function stackClause($) {
+  return (options = {}) => {
+    options = { ...DEFAULT_OPTIONS, ...options };
+
+    $.sectionStack.push("stackClause");
+    $.CONSUME(StackToken);
+    $.OPTION(() => $.SUBRULE($.nakedStackFn, { ARGS: [options] }));
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/testClause.js

@@ -0,0 +1,73 @@
+import { EqualToken, LCurly, RCurly } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import {
+  Identifier,
+  InputToken,
+  NewlineToken,
+  TestToken,
+} from "../../lexer/tokens.js";
+import { DatasourceToken } from "../../lexer/workflow_test.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function testClause($) {
+  return (testNames) => {
+    let hasInput = false;
+    let hasDatasource = false;
+
+    // during parser initialization, testNames is undefined
+    testNames = testNames || [];
+
+    $.sectionStack.push("testClause");
+
+    $.CONSUME(TestToken); // test
+    const testNameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) }, // "foo"
+      { ALT: () => $.CONSUME(Identifier) }, // foo
+    ]);
+
+    if (testNameToken && testNameToken.image) {
+      const cleanedName = testNameToken.image.replaceAll('"', "");
+
+      if (testNames.includes(cleanedName)) {
+        $.addDuplicateNameError(testNameToken, "test");
+      }
+
+      testNames.push(testNameToken.image.replaceAll('"', "")); // "test_one" and test_one
+    }
+
+    $.CONSUME(LCurly); // "{"
+    $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+
+    $.MANY(() => {
+      $.OR1([
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.CONSUME(InputToken);
+            $.CONSUME(EqualToken); // "="
+            $.SUBRULE($.objectWithAttributes);
+          },
+        },
+        {
+          GATE: () => !hasDatasource,
+          ALT: () => {
+            hasDatasource = true;
+            $.CONSUME(DatasourceToken);
+            $.CONSUME1(EqualToken); // "="
+            $.CONSUME1(StringLiteral); // "live"
+          },
+        },
+        {
+          ALT: () => $.SUBRULE($.unitExpectFn),
+        },
+      ]);
+      $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // at least one new line
+    });
+
+    $.CONSUME(RCurly); // "}"
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/testClause.spec.js

@@ -0,0 +1,78 @@
+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 accepts a comment", () => {
+    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.js

@@ -0,0 +1,49 @@
+import { EqualToken } from "../../lexer/control.js";
+import { ViewToken } from "../../lexer/tokens.js";
+
+/**
+ * view = {
+ *   "pending applications": {
+ *     search: $db.status == "pending"
+ *     sort  : {id: "asc"}
+ *     id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
+ *   }
+ * }
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function viewClause($) {
+  return () => {
+    $.sectionStack.push("viewClause");
+    const parent = $.CONSUME(ViewToken); // "view"
+    $.CONSUME(EqualToken); // "="
+    const captured = {};
+    $.SUBRULE($.schemaParseObjectFn, {
+      ARGS: [
+        parent,
+        {
+          "[string]": {
+            "search?": "[query]",
+            "hide?": ["[string]"],
+            sort: { "[string]": ["asc", "desc", "rand"] },
+            id: "[string]",
+            "alias?": "[string]",
+          },
+        },
+        captured,
+      ],
+    });
+
+    // each key is the view name, ensure either search or hide is present
+    for (const viewName in captured) {
+      if (!captured[viewName].search && !captured[viewName].hide) {
+        $.addMissingError(
+          parent,
+          `view ${viewName} must have either a search or hide criteria`
+        );
+      }
+    }
+
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/viewClause.spec.js

@@ -0,0 +1,154 @@
+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 requires either a search or hide criteria", () => {
+    const parser = parse(`view = {
+      "no search criteria": {
+        sort  : {id: "asc"}
+        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.js

@@ -0,0 +1,70 @@
+import { ColonToken, LSquare, RSquare } from "../../lexer/control.js";
+import { IntegerLiteral } from "../../lexer/literal.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function arraySlice($) {
+  return () => {
+    $.sectionStack.push("arraySlice");
+    let startIndex = null;
+    let endIndex = null;
+
+    $.OR([
+      {
+        ALT: () => {
+          // [] - the complete array
+          $.CONSUME(LSquare);
+          $.CONSUME(RSquare);
+        },
+      },
+      {
+        ALT: () => {
+          // [1:] or [1:2] - start at index 1, to the end or to index 2
+          $.CONSUME1(LSquare); // "["
+          startIndex = $.CONSUME1(IntegerLiteral); // start index
+          $.CONSUME1(ColonToken); // ":"
+          // optional end index
+          $.OPTION(() => (endIndex = $.CONSUME3(IntegerLiteral))); // optional end index
+          $.CONSUME1(RSquare); // "]"
+        },
+      },
+      {
+        ALT: () => {
+          // [:3] - start at index 0, to index 3
+          $.CONSUME2(LSquare); // "["
+          $.CONSUME2(ColonToken); // ":"
+          endIndex = $.CONSUME2(IntegerLiteral); // end index
+          $.CONSUME2(RSquare); // "]"
+        },
+      },
+    ]);
+
+    if (startIndex && startIndex.image.startsWith("-")) {
+      $.addInvalidValueError(
+        startIndex,
+        `Array slice start index cannot be negative`
+      );
+    }
+
+    if (endIndex && endIndex.image.startsWith("-")) {
+      $.addInvalidValueError(
+        endIndex,
+        `Array slice end index cannot be negative`
+      );
+    }
+
+    if (startIndex && endIndex) {
+      const start = parseInt(startIndex.image, 10);
+      const end = parseInt(endIndex.image, 10);
+      if (end < start) {
+        $.addInvalidValueError(
+          endIndex,
+          `Array slice end index cannot be less than start index`
+        );
+      }
+    }
+
+    $.sectionStack.pop();
+  };
+}

package/parser/definitions/arraySlice.spec.js

@@ -0,0 +1,49 @@
+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.js

@@ -0,0 +1,139 @@
+import {
+  AttachmentToken,
+  AudioToken,
+  BoolToken,
+  DateToken,
+  DecimalToken,
+  EmailToken,
+  FileToken,
+  GeoLinestringToken,
+  GeoMultilinestringToken,
+  GeoMultipointToken,
+  GeoMultipolygonToken,
+  GeoPointToken,
+  GeoPolygonToken,
+  ImageToken,
+  IntToken,
+  JsonToken,
+  PasswordToken,
+  TextToken,
+  TimestampToken,
+  UuidToken,
+  VectorToken,
+  VideoToken,
+} from "../../lexer/columns.js";
+import { Question } from "../../lexer/control.js";
+import { Identifier } from "../../lexer/identifier.js";
+import { getVarName } from "../generic/utils.js";
+
+const DEFAULT_CONFIG = {
+  include_file: false,
+  isTableSchema: false, // enforces that "id" column can only be int or uuid
+};
+
+/**
+ * int id | timestamp created_at?=now
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function columnDefinition($) {
+  /**
+   * @param {typeof DEFAULT_CONFIG} [config]
+   * @returns {void}
+   */
+  return (config = {}, schema = {}) => {
+    config = { ...DEFAULT_CONFIG, ...config };
+
+    let nullable = false;
+    let iterable = false;
+    let optional = false;
+
+    $.sectionStack.push("columnDefinition");
+
+    const inputTypeToken = $.OR([
+      { ALT: () => $.CONSUME(IntToken) }, // column of type "int"
+      { ALT: () => $.CONSUME(TimestampToken) }, // column of type "timestamp"
+      { ALT: () => $.CONSUME(TextToken) }, // column of type "text"
+      { ALT: () => $.CONSUME(UuidToken) }, // column of type "uuid"
+      { ALT: () => $.CONSUME(VectorToken) }, // column of type "vector"
+      { ALT: () => $.CONSUME(DateToken) }, // column of type "date"
+      { ALT: () => $.CONSUME(BoolToken) }, // column of type "bool"
+      { ALT: () => $.CONSUME(DecimalToken) }, // column of type "decimal"
+      { ALT: () => $.CONSUME(EmailToken) }, // column of type "email"
+      { ALT: () => $.CONSUME(PasswordToken) }, // column of type "password"
+      { ALT: () => $.CONSUME(JsonToken) }, // column of type "json"
+      { ALT: () => $.CONSUME(ImageToken) }, // column of type "image"
+      { ALT: () => $.CONSUME(VideoToken) }, // column of type "video"
+      { ALT: () => $.CONSUME(AudioToken) }, // column of type "audio"
+      { ALT: () => $.CONSUME(AttachmentToken) }, // column of type "attachment"
+      { ALT: () => $.CONSUME(GeoPointToken) }, // column of type "geo_point"
+      { ALT: () => $.CONSUME(GeoMultipointToken) }, // column of type "geo_multipoint"
+      { ALT: () => $.CONSUME(GeoLinestringToken) }, // column of type "geo_linestring"
+      { ALT: () => $.CONSUME(GeoMultilinestringToken) }, // column of type "geo_multilinestring"
+      { ALT: () => $.CONSUME(GeoPolygonToken) }, // column of type "geo_polygon"
+      { ALT: () => $.CONSUME(GeoMultipolygonToken) }, // column of type "geo_multipolygon"
+      { GATE: () => !!config.include_file, ALT: () => $.CONSUME(FileToken) }, // include another file
+    ]);
+
+    // is it an array ?
+    $.OPTION1(() => {
+      iterable = true;
+      $.SUBRULE($.arraySlice);
+    });
+
+    // is it nullable ?
+    $.OPTION2(() => {
+      nullable = true;
+      $.CONSUME(Question);
+    });
+
+    // Column name (e.g., "user_id", "optional_column", "required_column")
+    const nameToken = $.CONSUME(Identifier);
+
+    // ? (is it an optional field)
+    $.OPTION6(() => {
+      optional = true;
+      $.CONSUME1(Question);
+    });
+
+    $.OPTION3(() => $.SUBRULE($.columnDefaultValueAttribute)); // Optional default value
+    $.OPTION4(() => $.SUBRULE($.filterDefinition, { ARGS: [inputTypeToken] })); // Optional filter definition
+    // $.OPTION5(() => $.SUBRULE($.columnMetadataDefinition));
+    const captured = {};
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        nameToken,
+        {
+          "description?": "[string]",
+          "table?": "[string]",
+          "size?": "[number]",
+          "sensitive?": "[boolean]",
+        },
+        captured,
+      ],
+    });
+
+    if (inputTypeToken.image == "vector" && !captured.size) {
+      $.addWarning(
+        'Column named "vector" should have a size attribute defining its length.',
+        nameToken
+      );
+    }
+
+    // add variable to schema
+    schema[getVarName(nameToken)] = {
+      typeToken: inputTypeToken,
+      nameToken: nameToken,
+    };
+
+    // add the variable to the registry
+    $.addInput(
+      nameToken.image,
+      inputTypeToken.image,
+      iterable,
+      nullable,
+      optional
+    );
+
+    $.sectionStack.pop();
+  };
+}