@xano/xanoscript-language-server 11.8.1 → 11.8.3

package/lexer/table.js

@@ -19,7 +19,18 @@ export const ItemsToken = createTokenByName("items", {
   categories: [Identifier],
 });
 
-export const TableTokens = [TableToken, AutoCompleteToken, ItemsToken];
+// "visibility"
+export const VisibilityToken = createTokenByName("visibility", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const TableTokens = [
+  TableToken,
+  AutoCompleteToken,
+  ItemsToken,
+  VisibilityToken,
+];
 
 /**
  * Maps a token name to a type
@@ -31,6 +42,7 @@ export function mapTokenToType(token) {
       return "keyword";
     case AutoCompleteToken.name:
     case ItemsToken.name:
+    case VisibilityToken.name:
       return "identifier";
     default:
       return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.8.1",
+  "version": "11.8.3",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/attributes/register.js

@@ -1,12 +1,13 @@
 import { columnDefaultValueAttribute } from "./columnDefaultValueAttribute.js";
 import { descriptionFieldAttribute } from "./descriptionFieldAttribute.js";
 import { disabledFieldAttribute } from "./disabledFieldAttribute.js";
-import { docsFieldAttribute } from "./docsFieldAttribute.js"
+import { docsFieldAttribute } from "./docsFieldAttribute.js";
 import { guidFieldAttribute } from "./guidFieldAttribute.js";
 import { inputFilterFn } from "./inputFilterFn.js";
 import { sensitiveFieldAttribute } from "./sensitiveFieldAttribute.js";
 import { valueFieldAttribute } from "./valueFieldAttribute.js";
 import { valuesFieldAttribute } from "./valuesFieldAttribute.js";
+import { visibilityFieldAttribute } from "./visibilityFieldAttribute.js";
 
 /**
  * Registers all the parsers in this folder
@@ -15,32 +16,30 @@ import { valuesFieldAttribute } from "./valuesFieldAttribute.js";
 export const register = ($) => {
   $.columnDefaultValueAttribute = $.RULE(
     "columnDefaultValueAttribute",
-    columnDefaultValueAttribute($)
+    columnDefaultValueAttribute($),
   );
   $.descriptionFieldAttribute = $.RULE(
     "descriptionFieldAttribute",
-    descriptionFieldAttribute($)
+    descriptionFieldAttribute($),
   );
   $.disabledFieldAttribute = $.RULE(
     "disabledFieldAttribute",
-    disabledFieldAttribute($)
-  );
-  $.docsFieldAttribute = $.RULE(
-    "docsFieldAttribute",
-    docsFieldAttribute($)
-  );
-  $.guidFieldAttribute = $.RULE(
-    "guidFieldAttribute",
-    guidFieldAttribute($)
+    disabledFieldAttribute($),
   );
+  $.docsFieldAttribute = $.RULE("docsFieldAttribute", docsFieldAttribute($));
+  $.guidFieldAttribute = $.RULE("guidFieldAttribute", guidFieldAttribute($));
   $.inputFilterFn = $.RULE("inputFilterFn", inputFilterFn($));
   $.sensitiveFieldAttribute = $.RULE(
     "sensitiveFieldAttribute",
-    sensitiveFieldAttribute($)
+    sensitiveFieldAttribute($),
   );
   $.valueFieldAttribute = $.RULE("valueFieldAttribute", valueFieldAttribute($));
   $.valuesFieldAttribute = $.RULE(
     "valuesFieldAttribute",
-    valuesFieldAttribute($)
+    valuesFieldAttribute($),
+  );
+  $.visibilityFieldAttribute = $.RULE(
+    "visibilityFieldAttribute",
+    visibilityFieldAttribute($),
   );
 };

package/parser/attributes/visibilityFieldAttribute.js

@@ -0,0 +1,17 @@
+import { EqualToken } from "../../lexer/control.js";
+import { VisibilityToken } from "../../lexer/table.js";
+
+/**
+ * Visibility Field Attribute Parser on table metadata definitions
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const visibilityFieldAttribute = ($) => () => {
+  $.sectionStack.push("visibilityFieldAttribute");
+  const parent = $.CONSUME(VisibilityToken); // "visibility"
+  $.CONSUME(EqualToken); // "="
+  $.SUBRULE($.schemaParseEnumFn, {
+    ARGS: [parent, ["private", "internal", "public"]],
+  });
+  $.sectionStack.pop();
+};

package/parser/attributes/visibilityFieldAttribute.spec.js

@@ -0,0 +1,44 @@
+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.visibilityFieldAttribute();
+  return parser;
+}
+
+describe("visibilityFieldAttribute", () => {
+  it("visibilityFieldAttribute accepts a private value", () => {
+    const parser = parse(`visibility = "private"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("visibilityFieldAttribute accepts an internal value", () => {
+    const parser = parse(`visibility = "internal"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("visibilityFieldAttribute accepts a public value", () => {
+    const parser = parse(`visibility = "public"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("visibilityFieldAttribute rejects anything else", () => {
+    const parser = parse(`visibility = "something"`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("visibilityFieldAttribute rejects digit", () => {
+    const parser = parse("visibility = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("visibilityFieldAttribute can be compact", () => {
+    const parser = parse(`visibility="private"`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/schemaClause.spec.js

@@ -3,10 +3,19 @@ import { describe, it } from "mocha";
 import { lexDocument } from "../../lexer/lexer.js";
 import { parser } from "../test_parser.js";
 
-function parse(inputText) {
+function parse(inputText, context = null) {
+  parser.reset();
   const lexResult = lexDocument(inputText);
   parser.input = lexResult.tokens;
-  parser.schemaClause();
+
+  if (context) {
+    parser.sectionStack.push(context);
+    parser.schemaClause();
+    parser.sectionStack.pop();
+  } else {
+    parser.schemaClause();
+  }
+
   return parser;
 }
 
@@ -39,6 +48,33 @@ describe("schemaClause", () => {
     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 {

package/parser/definitions/columnDefinition.js

@@ -107,6 +107,7 @@ export function columnDefinition($) {
           "table?": "[string]",
           "size?": "[number]",
           "sensitive?": "[boolean]",
+          "visibility?": ["public", "private", "internal"],
         },
         captured,
       ],
@@ -115,7 +116,15 @@ export function columnDefinition($) {
     if (inputTypeToken.image == "vector" && !captured.size) {
       $.addWarning(
         'Column named "vector" should have a size attribute defining its length.',
-        nameToken
+        nameToken,
+      );
+    }
+
+    const inTable = $.sectionStack.includes("tableDeclaration");
+    if (captured.visibility && !inTable) {
+      $.addInvalidValueError(
+        nameToken,
+        'The "visibility" attribute is only valid within a table schema definition.',
       );
     }
 
@@ -131,7 +140,7 @@ export function columnDefinition($) {
       inputTypeToken.image,
       iterable,
       nullable,
-      optional
+      optional,
     );
 
     $.sectionStack.pop();

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

@@ -34,6 +34,15 @@ describe("dbQueryFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("dbQueryFn where can split line on binary operators", () => {
+    const parser = parse(`query user {
+      where = $db.user.visa_work_permit_end_date != null && 
+        $db.user.visa_work_permit_end_date <= $input.next_120_days && $db.bug_test_candidate.candidate_status == "mediated" && ($db.user.billing_end_date > now || $db.user.billing_end_date == null)
+      return = {type: "list"} 
+    } as $results`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("dbQueryFn accepts a description", () => {
     const parser = parse(`query user {
       where = $db.array_columns @> $db.array_columns.id

package/parser/functions/redis/redisPopFn.js

@@ -17,6 +17,7 @@ export function redisPopFn($) {
           key: "[expression]",
           "description?": "[string]",
           "disabled?": "[boolean]",
+          "count?": "[expression]",
         },
       ],
     });

package/parser/functions/redis/redisPopFn.spec.js

@@ -64,4 +64,12 @@ describe("redis.pop", () => {
     } as $x7`);
     expect(parser.errors).to.be.empty;
   });
+
+  it("pop accepts an optional count attribute", () => {
+    const parser = parse(`pop {
+      key = "list"
+      count = 5
+    } as $x7`);
+    expect(parser.errors).to.be.empty;
+  });
 });

package/parser/functions/redis/redisShiftFn.js

@@ -17,6 +17,7 @@ export function redisShiftFn($) {
           key: "[expression]",
           "description?": "[string]",
           "disabled?": "[boolean]",
+          "count?": "[expression]",
         },
       ],
     });

package/parser/functions/redis/redisShiftFn.spec.js

@@ -64,4 +64,12 @@ describe("redis.shift", () => {
     } as $x8`);
     expect(parser.errors).to.be.empty;
   });
+
+  it("shift accepts an optional count attribute", () => {
+    const parser = parse(`shift {
+      key = "list"
+      count = 5
+    } as $x8`);
+    expect(parser.errors).to.be.empty;
+  });
 });

package/parser/functions/workflowExpectFn.spec.js

@@ -27,7 +27,6 @@ describe("workflowExpectFn", () => {
     ) {
       value = $som_value
     }`);
-    console.log(parser.errors);
     expect(parser.errors).to.be.empty;
   });
 });

package/parser/generic/expressionFn.js

@@ -354,6 +354,7 @@ export function expressionTestFn($) {
       DEF: () => $.CONSUME1(Question), // "?"
     });
 
+    $.OPTION1(() => $.CONSUME(NewlineToken));
     $.SUBRULE($.expressionFn, { ARGS: [token, options] });
   };
 }

package/parser/generic/expressionFn.spec.js

@@ -107,6 +107,13 @@ describe("expressionFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("expressionFn can split on multiple lines on binary operators", () => {
+    let parser = parse(`$var.value == "test" &&
+      $var.other_value != "example" ||
+      $var.another_value > 10`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("expressionFn accepts modulus symbol in expression", () => {
     const parser = parse("$this % 2 == 1");
     expect(parser.errors).to.be.empty;

package/parser/metadata/enumColumnMetadataDefinition.js

@@ -1,46 +1,33 @@
-import { LCurly, RCurly } from "../../lexer/control.js";
-import { NewlineToken } from "../../lexer/tokens.js";
-
 /**
  *
  * @param {import('../base_parser.js').XanoBaseParser} $
  */
 export function enumColumnMetadataDefinition($) {
-  return (parent) => {
+  return (parent, captured = {}) => {
     $.sectionStack.push("enumColumnMetadataDefinition");
-    $.CONSUME(LCurly); // "{"
-    // values = [...] is a required field here
-    let hasValues = false;
-    let hasDescription = false;
-    let hasSensitive = false;
 
-    $.MANY(() => {
-      $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // Require at least one new line
-      $.OR([
-        {
-          GATE: () => !hasValues,
-          ALT: () => {
-            hasValues = true;
-            $.SUBRULE($.valuesFieldAttribute);
-          },
-        },
-        {
-          GATE: () => !hasDescription,
-          ALT: () => $.SUBRULE($.sensitiveFieldAttribute),
-        },
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
         {
-          GATE: () => !hasSensitive,
-          ALT: () => $.SUBRULE($.descriptionFieldAttribute),
+          "description?": "[string]",
+          values: ["[string]"],
+          "sensitive?": "[boolean]",
+          "visibility?": ["public", "private", "internal"],
         },
-      ]);
+        captured,
+      ],
     });
 
-    if (!hasValues) {
-      $.addMissingError(parent, "{} is missing the values attribute");
+    // you can only provide a visibility attribute if you're in a table definition
+    const inTable = $.sectionStack.includes("tableDeclaration");
+    if (!inTable && "visibility" in captured) {
+      $.addInvalidValueError(
+        parent,
+        'The "visibility" attribute is only valid within a table schema definition.',
+      );
     }
 
-    $.AT_LEAST_ONE2(() => $.CONSUME2(NewlineToken)); // Require at least one new line after
-    $.CONSUME(RCurly); // "}"
     $.sectionStack.pop();
   };
 }

package/parser/metadata/enumColumnMetadataDefinition.spec.js

@@ -3,9 +3,12 @@ import { describe, it } from "mocha";
 import { lexDocument } from "../../lexer/lexer.js";
 import { parser } from "../test_parser.js";
 
-function parse(inputText) {
+function parse(inputText, context = null) {
   const lexResult = lexDocument(inputText);
   parser.input = lexResult.tokens;
+  if (context) {
+    parser.sectionStack.push(context);
+  }
   parser.enumColumnMetadataDefinition();
   return parser;
 }
@@ -27,6 +30,25 @@ describe("enumColumnMetadataDefinition", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("enumColumnMetadataDefinition accepts a visibility value when in a table declaration", () => {
+    const parser = parse(
+      `{ 
+      values = ["active", "inactive", "unknown"]
+      visibility = "private"
+    }`,
+      "tableDeclaration",
+    );
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("enumColumnMetadataDefinition rejects a visibility value when not in a table declaration", () => {
+    const parser = parse(`{ 
+      values = ["active", "inactive", "unknown"]
+      visibility = "private"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
   it("enumColumnMetadataDefinition accepts a description value", () => {
     const parser = parse(`{ 
       values = ["active", "inactive", "unknown"]

package/parser/metadata/objectColumnMetadataDefinition.js

@@ -7,20 +7,57 @@ import { NewlineToken } from "../../lexer/tokens.js";
 export function objectColumnMetadataDefinition($) {
   return () => {
     $.sectionStack.push("objectColumnMetadataDefinition");
+
+    let hasSensitiveField = false;
+    let hasVisibilityField = false;
+    let hasDescriptionField = false;
+    let hasSchemaClause = false;
+
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // Require at least one new line after {
       $.OR([
-        { ALT: () => $.SUBRULE($.sensitiveFieldAttribute) },
-        { ALT: () => $.SUBRULE($.descriptionFieldAttribute) },
         {
-          ALT: () =>
-            $.SUBRULE($.schemaClause, { ARGS: [{ include_file: false }] }),
+          GATE: () => !hasSensitiveField, // Only allow the sensitive attribute if it hasn't been used yet
+          ALT: () => {
+            $.SUBRULE($.sensitiveFieldAttribute);
+            hasSensitiveField = true;
+          },
+        },
+        {
+          GATE: () => !hasDescriptionField, // Only allow the description attribute if it hasn't been used yet
+          ALT: () => {
+            $.SUBRULE($.descriptionFieldAttribute);
+            hasDescriptionField = true;
+          },
+        },
+        {
+          GATE: () => !hasVisibilityField, // Only allow the visibility attribute if it hasn't been used yet
+          ALT: () => {
+            $.SUBRULE($.visibilityFieldAttribute);
+            hasVisibilityField = true;
+          },
+        },
+        {
+          GATE: () => !hasSchemaClause, // Only allow the schema clause if it hasn't been used yet
+          ALT: () => {
+            $.SUBRULE($.schemaClause, { ARGS: [{ include_file: false }] });
+            hasSchemaClause = true;
+          },
         },
       ]);
     });
     $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // Require at least one new line after {
     $.CONSUME(RCurly); // "}"
+
+    const inTable = $.sectionStack.includes("tableDeclaration");
+    if (hasVisibilityField && !inTable) {
+      $.addInvalidValueError(
+        null,
+        'The "visibility" attribute is only valid within a table schema definition.',
+      );
+    }
+
     $.sectionStack.pop();
   };
 }

package/parser/table_parser.spec.js

@@ -69,6 +69,24 @@ describe("table_parser", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("should should accept a private and internal visibility on input", () => {
+    const parser = xanoscriptParser(`table foo {
+        auth = false
+
+        schema {
+          int id {
+            visibility = "private"
+          }
+          text cd {
+            visibility = "internal"
+          }
+        }
+
+        autocomplete = [{ name: "id" }, { name: "cd" }]
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
   // autocomplete = [{ name: "id" }, { name: "cd" }];
   it("should requires a new line between statements", () => {
     const parser = xanoscriptParser(`table foo {

package/parser/tests/table/valid_sources/rich_columns.xs

@@ -3,11 +3,14 @@ table array_columns {
 
   schema {
     int id
-    timestamp created_at?=now
+    timestamp created_at?=now {
+      visibility = "internal"
+    }
     text[] many_text? filters=trim
     email[] many_email_required_sensitive filters=trim|lower {
       description = "with a description"
       sensitive = true
+      visibility = "private"
     }
   
     enum[] many_enum_required_private {

package/parser/workflow_test_parser.spec.js

@@ -131,7 +131,6 @@ describe("workflow_test_parser", () => {
         }
       }
     }`);
-    console.log(parser.errors);
     expect(parser.errors).to.be.empty;
   });
 });