@xano/xanoscript-language-server 11.0.3

package/parser/api_group_parser.js

@@ -0,0 +1,143 @@
+import {
+  ActiveToken,
+  ApiGroupToken,
+  CanonicalToken,
+  CorsToken,
+  SwaggerToken,
+} from "../lexer/api_group.js";
+import { CommentToken } from "../lexer/comment.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function apiGroupDeclaration($) {
+  return () => {
+    let hasActive = false;
+    let hasCanonical = false;
+    let hasCors = false;
+    let hasDescription = false;
+    let hasDocs = false;
+    let hasHistory = false;
+    let hasSwagger = false;
+    let hasTags = false;
+
+    $.sectionStack.push("apiGroupDeclaration");
+    // Allow leading comments and newlines before the api_group declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+    $.CONSUME(ApiGroupToken); // api_group
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.OR2([
+        { ALT: () => $.CONSUME(CommentToken) },
+        {
+          GATE: () => !hasActive,
+          ALT: () => {
+            hasActive = true;
+            $.CONSUME(ActiveToken);
+            $.CONSUME1(EqualToken); // "="
+            $.SUBRULE($.booleanValue);
+          },
+        },
+        {
+          GATE: () => !hasCanonical,
+          ALT: () => {
+            hasCanonical = true;
+            $.CONSUME(CanonicalToken);
+            $.CONSUME2(EqualToken); // "="
+            $.CONSUME2(StringLiteral);
+          },
+        },
+        {
+          GATE: () => !hasCors,
+          ALT: () => {
+            hasCors = true;
+
+            const subParent = $.CONSUME(CorsToken);
+            $.CONSUME3(EqualToken); // "="
+            $.SUBRULE($.objectAttrReq, {
+              ARGS: [
+                subParent,
+                [], // required
+                [
+                  "mode",
+                  "origins",
+                  "methods",
+                  "headers",
+                  "credentials",
+                  "max_age",
+                ], // optional
+                {
+                  types: {
+                    mode: "string",
+                    origins: ($) => $.SUBRULE($.arrayOfStringLiterals),
+                    methods: ($) => $.SUBRULE1($.arrayOfStringLiterals),
+                    headers: ($) => $.SUBRULE2($.arrayOfStringLiterals),
+                    credentials: "boolean",
+                    max_age: "number",
+                  },
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasDocs,
+          ALT: () => {
+            hasDocs = true;
+            $.SUBRULE($.docsFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasSwagger,
+          ALT: () => {
+            hasSwagger = true;
+            const subRule = $.CONSUME(SwaggerToken);
+            $.CONSUME4(EqualToken); // "="
+            $.SUBRULE2($.objectAttrReq, {
+              ARGS: [
+                subRule,
+                [], // required
+                ["active", "token"], // optional
+                {
+                  active: "boolean",
+                  token: "string",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly);
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/api_group_parser.spec.js

@@ -0,0 +1,127 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("api_group", () => {
+  it("should parse a basic api_group", () => {
+    const parser = xanoscriptParser(`api_group foo {
+  canonical = "foo"
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a rich api_group", () => {
+    const parser = xanoscriptParser(`api_group "some name" {
+  description = "Some description"
+  active = false
+  canonical = "HZ4jLtdc"
+  tags = ["foo", "bar"]
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should accept a request history statement", () => {
+    const parser = xanoscriptParser(`api_group Reservations {
+  canonical = "kNryk0Kj"
+  history = "inherit"
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a protected swagger api_group", () => {
+    const parser = xanoscriptParser(`api_group "some name" {
+  description = "Some description"
+  active = false
+  canonical = "HZ4jLtdc"
+  tags = ["foo", "bar"]
+  swagger = {token: "something"}
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a disable swagger api_group", () => {
+    const parser = xanoscriptParser(`api_group Authentication {
+  active = false
+  canonical = "9kxfIBpH"
+  swagger = {active: false}
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should reject an api_group without a name", () => {
+    const parser = xanoscriptParser(`api_group {
+  canonical = "HZ4jLtdc"
+}`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should accepts an empty api_group without a canonical", () => {
+    const parser = xanoscriptParser(`api_group my_api_group {
+  description = "Some description"
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse an api_group with cors block", () => {
+    const parser = xanoscriptParser(`api_group my_api {
+  canonical = "abc123"
+  cors = {
+    mode: "custom",
+    origins: ["https://example.com", "https://app.example.com"],
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    headers: ["Content-Type", "Authorization"],
+    credentials: true,
+    max_age: 3600
+  }
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse an api_group with minimal cors block", () => {
+    const parser = xanoscriptParser(`api_group my_api {
+  canonical = "def456"
+  cors = {}
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse an api_group with partial cors configuration", () => {
+    const parser = xanoscriptParser(`api_group my_api {
+  canonical = "ghi789"
+  cors = {
+    mode: "simple",
+    origins: ["*"]
+  }
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse an api_group with cors credentials only", () => {
+    const parser = xanoscriptParser(`api_group my_api {
+  canonical = "jkl012"
+  cors = {
+    credentials: false
+  }
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a complete api_group with cors and other fields", () => {
+    const parser = xanoscriptParser(`api_group "User Management" {
+  description = "Handles user operations"
+  active = true
+  canonical = "mno345"
+  tags = ["users", "auth"]
+  cors = {
+    mode: "custom",
+    origins: ["https://frontend.example.com"],
+    methods: ["GET", "POST"],
+    headers: ["X-Custom-Header"],
+    credentials: true,
+    max_age: 7200
+  }
+  swagger = {active: true, token: "secret123"}
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/attributes/columnDefaultValueAttribute.js

@@ -0,0 +1,33 @@
+import { EqualToken } from "../../lexer/control.js";
+import {
+  FloatLiteral,
+  IntegerLiteral,
+  StringLiteral,
+} from "../../lexer/literal.js";
+import {
+  FalseToken,
+  Identifier,
+  NowToken,
+  TrueToken,
+} from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function columnDefaultValueAttribute($) {
+  return () => {
+    $.sectionStack.push("columnDefaultValueAttribute");
+    $.CONSUME(EqualToken); // "="
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) }, // e.g., "default value"
+      { ALT: () => $.CONSUME(FloatLiteral) }, // e.g., 42.54
+      { ALT: () => $.CONSUME(IntegerLiteral) }, // e.g., 42
+      { ALT: () => $.CONSUME(TrueToken) }, // true
+      { ALT: () => $.CONSUME(FalseToken) }, // false
+      { ALT: () => $.CONSUME(NowToken) }, // now
+      { ALT: () => $.CONSUME(Identifier) }, // when everything else fails, it's an identifier
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/columnDefaultValueAttribute.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) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.columnDefaultValueAttribute();
+  return parser;
+}
+
+describe("columnDefaultValueAttribute", () => {
+  it("columnDefaultValueAttribute accepts an identifier", () => {
+    const parser = parse(`= someVariableName`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("columnDefaultValueAttribute accepts a string literal", () => {
+    const parser = parse(`="foo"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("columnDefaultValueAttribute accepts a boolean", () => {
+    const parser = parse(`= true`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("columnDefaultValueAttribute accepts 'now'", () => {
+    const parser = parse(`= now`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("columnDefaultValueAttribute accepts a float", () => {
+    const parser = parse(`= 3.14`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("columnDefaultValueAttribute accepts a keyword", () => {
+    const parser = parse(`= date`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("columnDefaultValueAttribute rejects special characters", () => {
+    const parser = parse(`= @dbo`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/attributes/descriptionFieldAttribute.js

@@ -0,0 +1,24 @@
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { MultiLineStringToken } from "../../lexer/multiline.js";
+import { DescriptionToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function descriptionFieldAttribute($) {
+  return () => {
+    $.sectionStack.push("descriptionFieldAttribute");
+    $.CONSUME(DescriptionToken); // "description"
+    $.CONSUME(EqualToken); // "="
+    $.OR([
+      {
+        ALT: () => $.CONSUME(StringLiteral), // e.g., "A description of the field"
+      },
+      {
+        ALT: () => $.CONSUME(MultiLineStringToken), // e.g., "fieldDescription"
+      },
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/descriptionFieldAttribute.spec.js

@@ -0,0 +1,39 @@
+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.descriptionFieldAttribute();
+  return parser;
+}
+
+describe("descriptionFieldAttribute", () => {
+  it("descriptionFieldAttribute accepts a string literal", () => {
+    const parser = parse('description = "some description goes here"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("descriptionFieldAttribute rejects identifier", () => {
+    const parser = parse("description = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("descriptionFieldAttribute rejects digit", () => {
+    const parser = parse("description = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("descriptionFieldAttribute can be compact", () => {
+    const parser = parse('description="another description"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("descriptionFieldAttribute does not require a new line", () => {
+    const parser = parse('description="some description"');
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/attributes/disabledFieldAttribute.js

@@ -0,0 +1,19 @@
+import { EqualToken } from "../../lexer/control.js";
+import { DisabledToken, FalseToken, TrueToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function disabledFieldAttribute($) {
+  return () => {
+    $.sectionStack.push("disabledFieldAttribute");
+    $.CONSUME(DisabledToken); // "disabled"
+    $.CONSUME(EqualToken); // "="
+    $.OR([
+      { ALT: () => $.CONSUME(TrueToken) }, // e.g., true,
+      { ALT: () => $.CONSUME(FalseToken) }, // e.g., false
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/disabledFieldAttribute.spec.js

@@ -0,0 +1,34 @@
+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.disabledFieldAttribute();
+  return parser;
+}
+
+describe("disabledFieldAttribute", () => {
+  it("disabledFieldAttribute accepts a boolean", () => {
+    const parser = parse("disabled = true");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("disabledFieldAttribute rejects identifier", () => {
+    const parser = parse("disabled = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("disabledFieldAttribute rejects digit", () => {
+    const parser = parse("disabled = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("disabledFieldAttribute can be compact", () => {
+    const parser = parse('disabled=false"');
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/attributes/docsFieldAttribute.js

@@ -0,0 +1,24 @@
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { MultiLineStringToken } from "../../lexer/multiline.js";
+import { DocsToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function docsFieldAttribute($) {
+  return () => {
+    $.sectionStack.push("docsFieldAttribute");
+    $.CONSUME(DocsToken); // "docs"
+    $.CONSUME(EqualToken); // "="
+    $.OR([
+      {
+        ALT: () => $.CONSUME(StringLiteral), // e.g., "A docs of the field"
+      },
+      {
+        ALT: () => $.CONSUME(MultiLineStringToken), // e.g., "fieldDocs"
+      },
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/docsFieldAttribute.spec.js

@@ -0,0 +1,39 @@
+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.docsFieldAttribute();
+  return parser;
+}
+
+describe("docsFieldAttribute", () => {
+  it("docsFieldAttribute accepts a string literal", () => {
+    const parser = parse('docs = "some docs goes here"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("docsFieldAttribute rejects identifier", () => {
+    const parser = parse("docs = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("docsFieldAttribute rejects digit", () => {
+    const parser = parse("docs = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("docsFieldAttribute can be compact", () => {
+    const parser = parse('docs="another docs"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("docsFieldAttribute does not require a new line", () => {
+    const parser = parse('docs="some docs"');
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/attributes/inputFilterFn.js

@@ -0,0 +1,71 @@
+import { ExclamationToken } from "../../lexer/cast.js";
+import { ColonToken } from "../../lexer/control.js";
+import {
+  FloatLiteral,
+  IntegerLiteral,
+  StringLiteral,
+} from "../../lexer/literal.js";
+import {
+  DbIdentifier,
+  DbLinkToken,
+  FalseToken,
+  Identifier,
+  RegExpToken,
+  TrueToken,
+} from "../../lexer/tokens.js";
+import { inputFilterNames } from "../generic/filterNames.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function inputFilterFn($) {
+  /**
+   * @param {string} inputTypeToken the type of the input, e.g., "object", "array", etc.
+   */
+  return (inputTypeToken) => {
+    $.sectionStack.push("inputFilterFn");
+    $.OR([
+      {
+        ALT: () => {
+          $.OPTION(() => $.CONSUME(ExclamationToken));
+          const filter = $.CONSUME(Identifier);
+          $.MANY1(() => {
+            $.CONSUME1(ColonToken);
+            $.OR2([
+              { ALT: () => $.CONSUME2(Identifier) },
+              { ALT: () => $.CONSUME1(StringLiteral) },
+              { ALT: () => $.CONSUME1(RegExpToken) },
+              { ALT: () => $.CONSUME1(IntegerLiteral) },
+              { ALT: () => $.CONSUME1(FloatLiteral) },
+              { ALT: () => $.CONSUME1(FalseToken) },
+              { ALT: () => $.CONSUME1(TrueToken) },
+            ]);
+          });
+
+          // Note: For input filters, we only validate against inputFilterNames when inputTypeToken is provided
+          // We don't validate against the general filterNames list since input filters have different rules
+          if (
+            inputTypeToken &&
+            inputFilterNames[inputTypeToken.image] &&
+            !inputFilterNames[inputTypeToken.image].includes(filter.image)
+          ) {
+            $.addInvalidValueError(
+              filter,
+              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`
+            );
+          }
+        },
+      },
+      {
+        ALT: () => {
+          $.CONSUME(DbLinkToken);
+          $.CONSUME2(ColonToken);
+          $.CONSUME(DbIdentifier);
+        },
+      },
+    ]);
+
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/inputFilterFn.spec.js

@@ -0,0 +1,39 @@
+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.inputFilterFn();
+  return parser;
+}
+
+describe("inputFilterFn", () => {
+  it("inputFilterFn can reference registered filters", () => {
+    const parser = parse("trim");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputFilterFn accepts an argument", () => {
+    const parser = parse("max:12");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputFilterFn accepts regexp arguments", () => {
+    const parser = parse("pattern:/[^213]*/");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputFilterFn accepts many args", () => {
+    const parser = parse("prevent:foo:bar");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputFilterFn accepts dbo link", () => {
+    const parser = parse("@:dbo=12");
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/attributes/register.js

@@ -0,0 +1,41 @@
+import { columnDefaultValueAttribute } from "./columnDefaultValueAttribute.js";
+import { descriptionFieldAttribute } from "./descriptionFieldAttribute.js";
+import { disabledFieldAttribute } from "./disabledFieldAttribute.js";
+import { docsFieldAttribute } from "./docsFieldAttribute.js"
+import { inputFilterFn } from "./inputFilterFn.js";
+import { sensitiveFieldAttribute } from "./sensitiveFieldAttribute.js";
+import { valueFieldAttribute } from "./valueFieldAttribute.js";
+import { valuesFieldAttribute } from "./valuesFieldAttribute.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.columnDefaultValueAttribute = $.RULE(
+    "columnDefaultValueAttribute",
+    columnDefaultValueAttribute($)
+  );
+  $.descriptionFieldAttribute = $.RULE(
+    "descriptionFieldAttribute",
+    descriptionFieldAttribute($)
+  );
+  $.disabledFieldAttribute = $.RULE(
+    "disabledFieldAttribute",
+    disabledFieldAttribute($)
+  );
+  $.docsFieldAttribute = $.RULE(
+    "docsFieldAttribute",
+    docsFieldAttribute($)
+  );
+  $.inputFilterFn = $.RULE("inputFilterFn", inputFilterFn($));
+  $.sensitiveFieldAttribute = $.RULE(
+    "sensitiveFieldAttribute",
+    sensitiveFieldAttribute($)
+  );
+  $.valueFieldAttribute = $.RULE("valueFieldAttribute", valueFieldAttribute($));
+  $.valuesFieldAttribute = $.RULE(
+    "valuesFieldAttribute",
+    valuesFieldAttribute($)
+  );
+};