@xano/xanoscript-language-server 11.5.0 → 11.6.1

package/parser/table_trigger_parser.js

@@ -44,18 +44,14 @@ export function tableTriggerDeclaration($) {
             const subParent = $.CONSUME(ActionsToken); // "actions"
             $.CONSUME(EqualToken); // "="
 
-            $.SUBRULE($.objectAttrReq, {
+            $.SUBRULE($.schemaParseObjectFn, {
               ARGS: [
                 subParent,
-                [], // required
-                ["delete", "insert", "truncate", "update"], // optional
                 {
-                  types: {
-                    delete: "boolean",
-                    insert: "boolean",
-                    truncate: "boolean",
-                    update: "boolean",
-                  },
+                  "delete?": "[boolean]",
+                  "insert?": "[boolean]",
+                  "truncate?": "[boolean]",
+                  "update?": "[boolean]",
                 },
               ],
             });
@@ -74,9 +70,11 @@ export function tableTriggerDeclaration($) {
           GATE: () => !hasDatasources,
           ALT: () => {
             hasDatasources = true;
-            $.CONSUME(DatasourcesToken);
+            const parent = $.CONSUME(DatasourcesToken);
             $.CONSUME3(EqualToken);
-            $.SUBRULE($.arrayOfStringLiterals);
+            $.SUBRULE($.schemaFn, {
+              ARGS: [parent, ["[string]"]],
+            });
           },
         },
         {

package/parser/test_parser.js

@@ -7,9 +7,7 @@ import { parserExtension as schemaParseConstantFnExtension } from "./functions/s
 import { parserExtension as schemaParseEnumFnExtension } from "./functions/schema/schemaParseEnum.spec.js";
 import { parserExtension as schemaParseImmutableFnExtension } from "./functions/schema/schemaParseImmutableFn.spec.js";
 import { parserExtension as schemaParseObjectFnExtension } from "./functions/schema/schemaParseObjectFn.spec.js";
-import { parserExtension as arrayOfObjectAttrReqExtension } from "./generic/arrayOfObjectAttrReq.spec.js";
 import { parserExtension as functionAttrReqExtension } from "./generic/functionAttrReq.spec.js";
-import { parserExtension as objectAttrReqExtension } from "./generic/objectAttrReq.spec.js";
 import { parserExtension as objectWithAttributesExtension } from "./generic/objectWithAttributes.spec.js";
 
 /**
@@ -26,9 +24,7 @@ class TestParser extends XanoBaseParser {
     schemaParseObjectFnExtension.bind(this)();
     schemaParseEnumFnExtension.bind(this)();
     schemaParseImmutableFnExtension.bind(this)();
-    arrayOfObjectAttrReqExtension.bind(this)();
     functionAttrReqExtension.bind(this)();
-    objectAttrReqExtension.bind(this)();
     objectWithAttributesExtension.bind(this)();
     schemaParseAttributeFnExtension.bind(this)();
 

package/parser/workspace_trigger_parser.js

@@ -39,17 +39,13 @@ export function workspaceTriggerDeclaration($) {
             const subParent = $.CONSUME(ActionsToken); // "actions"
             $.CONSUME(EqualToken); // "="
 
-            $.SUBRULE($.objectAttrReq, {
+            $.SUBRULE($.schemaParseObjectFn, {
               ARGS: [
                 subParent,
-                [], // required
-                ["branch_live", "branch_merge", "branch_new"], // optional
                 {
-                  types: {
-                    branch_live: "boolean",
-                    branch_merge: "boolean",
-                    branch_new: "boolean",
-                  },
+                  "branch_live?": "[boolean]",
+                  "branch_merge?": "[boolean]",
+                  "branch_new?": "[boolean]",
                 },
               ],
             });

package/server.js

@@ -44,10 +44,10 @@ connection.onInitialize(() => {
 connection.onHover((params) => onHover(params, documents));
 connection.onCompletion((params) => onCompletion(params, documents));
 connection.onRequest("textDocument/semanticTokens/full", (params) =>
-  onSemanticCheck(params, documents, SemanticTokensBuilder)
+  onSemanticCheck(params, documents, SemanticTokensBuilder),
 );
 documents.onDidChangeContent((params) =>
-  onDidChangeContent(params, connection)
+  onDidChangeContent(params, connection),
 );
 connection.onDidOpenTextDocument((params) => {
   console.log("Document opened:", params.textDocument.uri);

package/parser/generic/arrayOfObjectAttrReq.js

@@ -1,47 +0,0 @@
-import { CommaToken, LSquare, RSquare } from "../../lexer/control.js";
-import { NewlineToken } from "../../lexer/tokens.js";
-
-/**
- * see objectAttrReq signature for arrayOfObjectAttrReq arguments details
- * @param {import('../base_parser.js').XanoBaseParser} $
- */
-export function arrayOfObjectAttrReq($) {
-  /**
-   * @param {import('chevrotain').Rule} rule
-   **/
-  return (parent, required, optional, options = {}) => {
-    $.CONSUME(LSquare); // "["
-    $.OPTION(() => {
-      $.OR([
-        // multi line, each value on a new line
-        {
-          ALT: () => {
-            $.CONSUME(NewlineToken);
-            $.AT_LEAST_ONE(() => {
-              $.SUBRULE($.objectAttrReq, {
-                ARGS: [parent, required, optional, options],
-              });
-              $.OPTION1(() => $.CONSUME(CommaToken)); // optional comma
-              $.AT_LEAST_ONE1(() => $.CONSUME3(NewlineToken));
-            });
-          },
-        },
-        // one line, comma separated [ ..., ... ]
-        {
-          ALT: () => {
-            $.AT_LEAST_ONE_SEP({
-              SEP: CommaToken,
-              DEF: () => {
-                $.SUBRULE1($.objectAttrReq, {
-                  ARGS: [parent, required, optional, options],
-                });
-              },
-            });
-            $.MANY(() => $.CONSUME2(NewlineToken));
-          },
-        },
-      ]);
-    });
-    $.CONSUME(RSquare); // "]"
-  };
-}

package/parser/generic/arrayOfObjectAttrReq.spec.js

@@ -1,254 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { EqualToken } from "../../lexer/control.js";
-import { lexDocument } from "../../lexer/lexer.js";
-import { Identifier } from "../../lexer/tokens.js";
-import { parser } from "../test_parser.js";
-
-export function parserExtension() {
-  // this rule requires a foo field to be defined
-  this.arrayOfObjectAttrReq_test_required = this.RULE(
-    "arrayOfObjectAttrReq_test_required",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, { ARGS: [name, ["foo"]] });
-    }
-  );
-
-  this.arrayOfObjectAttrReq_test_optionals = this.RULE(
-    "arrayOfObjectAttrReq_test_optionals",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [name, [], ["foo", "bar"]],
-      });
-    }
-  );
-
-  this.arrayOfObjectAttrReq_test_index = this.RULE(
-    "arrayOfObjectAttrReq_test_index",
-    () => {
-      const parent = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [
-          parent,
-          ["type", "field"],
-          [],
-          {
-            types: {
-              type: "string",
-            },
-          },
-        ],
-      });
-    }
-  );
-
-  this.arrayOfObjectAttrReq_test_recursive_value = this.RULE(
-    "test_recursive_value",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [
-          name,
-          ["name", "as", "input"],
-          ["addon"],
-          { recursive: ["addon"] },
-        ],
-      });
-    }
-  );
-  this.arrayOfObjectAttrReq_test_recursive_array_addon = this.RULE(
-    "test_recursive_array_addon",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [
-          name,
-          ["name", "as", "input"],
-          ["addon"],
-          { recursiveArray: ["addon"] },
-        ],
-      });
-    }
-  );
-}
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  return parser;
-}
-
-describe("arrayOfObjectAttrReq", () => {
-  it("arrayOfObjectAttrReq accepts required attribute", () => {
-    parse(`something = [ {foo: "true"}]`).arrayOfObjectAttrReq_test_required();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts multilines attributes", () => {
-    parse(`something = [ 
-      {
-        foo: true
-        bar: 12
-      }
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts list of single lines", () => {
-    parse(`something = [ 
-      {foo: true, bar: 12}
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts multiple values", () => {
-    parse(`something = [ 
-      {
-        foo: true
-      }
-      {
-        bar: 12
-      }
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(
-      `something = [{ foo: true }, {bar: 12}]`
-    ).arrayOfObjectAttrReq_test_optionals();
-  });
-
-  it("arrayOfObjectAttrReq detects missing required attribute", () => {
-    parse(`something = [ {}]`).arrayOfObjectAttrReq_test_required();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq allow for recursive definition", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: {
-          name : "client"
-          as   : "_client"
-          input: {client_id: ""}
-          addon: {
-            name : "client"
-            as   : "_client"
-            input: {client_id: ""}
-          }
-        }
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_value();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq detects missing definition on recursive attributes", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: {
-          name : "client"
-          input: {client_id: ""}
-        }
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_value();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq allow for recursive array", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: [
-          {
-            name : "client"
-            as   : "_client"
-            input: {client_id: ""}
-            addon: [
-              {
-                name : "client"
-                as   : "_client"
-                input: {client_id: ""}
-                addon: []
-              }
-            ]
-          }
-        ]
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_array_addon();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq detects missing definition on recursive array", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: [
-          {
-            name : "client"
-            input: {client_id: ""}
-          }
-        ]
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_array_addon();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts optional attributes", () => {
-    parse(`something = [{}]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(`something = [{foo: true}]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(`something = [{bar: "ok"}]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(
-      `something = [{bar: "ok", "foo": 12.1}]`
-    ).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(`something = [
-      {bar: "ok", "foo": 12.1},
-      {bar: "ok", "foo": 12.1}
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq can be used for single line index clause", () => {
-    parse(
-      `index = [{type: "primary", field: [{name: "id"}]}]`
-    ).arrayOfObjectAttrReq_test_index();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq can be used for index clause", () => {
-    parse(`index = [
-      {type: "primary", field: [{name: "id"}]}
-      {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-      {type: "btree", field: [{name: "created_at", op: "desc"}]}
-    ]`).arrayOfObjectAttrReq_test_index();
-    expect(parser.errors).to.be.empty;
-
-    parse(`index = [
-      {type: "primary", field: [{name: "id"}]}
-    ]`).arrayOfObjectAttrReq_test_index();
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/arrayOfStringLiterals.js

@@ -1,45 +0,0 @@
-import { CommaToken, LSquare, RSquare } from "../../lexer/control.js";
-import { StringLiteral } from "../../lexer/literal.js";
-import { NewlineToken } from "../../lexer/tokens.js";
-
-/**
- * Dynamicly raises error for missing and required attributes
- * @param {import('../base_parser.js').XanoBaseParser} $
- */
-export function arrayOfStringLiterals($) {
-  return () => {
-    $.CONSUME(LSquare); // "["
-    $.OPTION(() => {
-      $.OR([
-        // multi line, each value on a new line
-        // [
-        //   value
-        //   value2
-        // ]
-        {
-          ALT: () => {
-            $.CONSUME(NewlineToken);
-            $.AT_LEAST_ONE(() => {
-              $.CONSUME(StringLiteral);
-              $.OPTION1(() => $.CONSUME(CommaToken)); // optional comma
-              $.AT_LEAST_ONE1(() => $.CONSUME3(NewlineToken));
-            });
-          },
-        },
-        // one line, comma separated [ value, value2 ]
-        {
-          ALT: () => {
-            $.AT_LEAST_ONE_SEP({
-              SEP: CommaToken,
-              DEF: () => {
-                $.CONSUME1(StringLiteral);
-              },
-            });
-            $.MANY(() => $.CONSUME2(NewlineToken));
-          },
-        },
-      ]);
-    });
-    $.CONSUME(RSquare); // "]"
-  };
-}

package/parser/generic/arrayOfStringLiterals.spec.js

@@ -1,56 +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.arrayOfStringLiterals();
-  return parser;
-}
-
-describe("arrayOfStringLiterals", () => {
-  it("arrayOfStringLiterals accepts a single string ", () => {
-    const parser = parse(`[ "true" ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be empty ", () => {
-    const parser = parse(`[]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be multilines without trailing commas", () => {
-    const parser = parse(`[
-      "foo"
-      "bar"
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be multilines with trailing commas ", () => {
-    const parser = parse(`[
-      "foo",
-      "bar"
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be compact ", () => {
-    const parser = parse(`["foo","bar"]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals cannot contain a non string ", () => {
-    let parser = parse(`[4]`);
-    expect(parser.errors).to.not.be.empty;
-
-    parser = parse(`[true]`);
-    expect(parser.errors).to.not.be.empty;
-
-    parser = parse(`["test", 4]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});