@xano/xanoscript-language-server 11.0.3

package/parser/functions/schema/schemaParseImmutableFn.js

@@ -0,0 +1,134 @@
+import { every, isArray } from "lodash-es";
+import { Identifier } from "../../../lexer/identifier.js";
+import {
+  FloatLiteral,
+  IntegerLiteral,
+  SingleQuotedStringLiteral,
+  StringLiteral,
+  TimestampLiteralToken,
+} from "../../../lexer/literal.js";
+import { MultiLineStringToken } from "../../../lexer/multiline.js";
+import { NullToken } from "../../../lexer/tokens.js";
+import { isOptionalAttribute, isSchemaGenericType } from "./utils.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function schemaParseImmutableFn($) {
+  return (token, schema, captured = {}) => {
+    let attributeCapturedType;
+    const capturedValue = $.OR({
+      DEF: [
+        {
+          ALT: () => {
+            attributeCapturedType = "string";
+            return $.CONSUME(StringLiteral); // e.g., "A instructions of the field"
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "string";
+            return $.CONSUME(SingleQuotedStringLiteral); // e.g., 'field\ninstructions\n'
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "string";
+            return $.CONSUME(MultiLineStringToken); // e.g., """field\ninstructions\n"""
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "number";
+            return $.CONSUME(FloatLiteral); // e.g., 42.54
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "number";
+            return $.CONSUME(IntegerLiteral); // e.g., 42
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "boolean";
+            $.SUBRULE($.booleanValue); // e.g., true | false
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "timestamp";
+            return $.CONSUME(TimestampLiteralToken); // e.g., 2024-01-01 12:00:00+0000
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "null";
+            return $.CONSUME(NullToken); // e.g., null
+          },
+        },
+        { ALT: () => false },
+      ],
+    });
+
+    $.OPTION({
+      GATE: () => !capturedValue,
+      DEF: () => {
+        $.addExpectedValueTypeError(
+          attributeCapturedType,
+          `invalid immutable value`
+        );
+        $.CONSUME(Identifier);
+      },
+    });
+
+    captured.value = capturedValue;
+
+    $.ACTION(() => {
+      const isEnum = isArray(schema);
+      const attributeType = isEnum
+        ? schema.map(getImmutableAttributeType)
+        : getImmutableAttributeType(schema);
+
+      if (isEnum) {
+        if (!every(attributeType)) {
+          throw new Error(
+            `schemaParseImmutableFn called with invalid enum attribute: ${schema}`
+          );
+        }
+
+        if (!attributeType.includes(attributeCapturedType)) {
+          $.addExpectedValueTypeError(token, attributeType.join(" or "));
+        }
+      } else {
+        if (!attributeType) {
+          throw new Error(
+            `schemaParseImmutableFn called with invalid attribute: ${schema}`
+          );
+        }
+        if (attributeCapturedType !== attributeType) {
+          $.addExpectedValueTypeError(token, attributeType);
+        }
+      }
+    });
+  };
+}
+
+/**
+ * If an attribute is typed, return the type
+ * @param {string} attr
+ * @returns {string|null}
+ */
+function getImmutableAttributeType(attr) {
+  const validTypes = ["string", "number", "boolean", "timestamp", "null"];
+  if (isSchemaGenericType(attr)) {
+    // remove the brackets and optional marker if present
+    const typeName = isOptionalAttribute(attr)
+      ? attr.slice(1, -2)
+      : attr.slice(1, -1);
+    if (validTypes.includes(typeName)) {
+      return typeName;
+    }
+  }
+  return null;
+}

package/parser/functions/schema/schemaParseImmutableFn.spec.js

@@ -0,0 +1,99 @@
+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.schemaParseImmutableFn_test_immutable_string = this.RULE(
+    "schemaFn_test_immutable_string",
+    () => {
+      const schema = "[string]";
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseImmutableFn_test_immutable_boolean = this.RULE(
+    "schemaFn_test_immutable_boolean",
+    () => {
+      const schema = "[boolean]";
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseImmutableFn_test_immutable_number = this.RULE(
+    "schemaFn_test_immutable_number",
+    () => {
+      const schema = "[number]";
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaParseImmutableFn", () => {
+  it("schemaParseImmutableFn immutable string", () => {
+    parse(`something = "foo"`).schemaParseImmutableFn_test_immutable_string();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = 'foo'`).schemaParseImmutableFn_test_immutable_string();
+    expect(parser.errors).to.be.empty;
+
+    // bar is not a string
+    parse(`something = bar`).schemaParseImmutableFn_test_immutable_string();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseImmutableFn immutable restricts string", () => {
+    parse(`something = 123`).schemaParseImmutableFn_test_immutable_string();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = false`).schemaParseImmutableFn_test_immutable_string();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseImmutableFn immutable boolean", () => {
+    parse(`something = true`).schemaParseImmutableFn_test_immutable_boolean();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = false`).schemaParseImmutableFn_test_immutable_boolean();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseImmutableFn immutable restricts boolean", () => {
+    parse(`something = 123`).schemaParseImmutableFn_test_immutable_boolean();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = "foo"`).schemaParseImmutableFn_test_immutable_boolean();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseImmutableFn immutable number", () => {
+    parse(`something = 123`).schemaParseImmutableFn_test_immutable_number();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = 45.67`).schemaParseImmutableFn_test_immutable_number();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseImmutableFn immutable restricts number", () => {
+    parse(`something = true`).schemaParseImmutableFn_test_immutable_number();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = "foo"`).schemaParseImmutableFn_test_immutable_number();
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/schema/schemaParseObjectFn.js

@@ -0,0 +1,171 @@
+import { get, isPlainObject, keys, some } from "lodash-es";
+import { ExclamationToken } from "../../../lexer/cast.js";
+import {
+  ColonToken,
+  CommaToken,
+  LCurly,
+  RCurly,
+} from "../../../lexer/control.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { DotToken, Identifier, NewlineToken } from "../../../lexer/tokens.js";
+import {
+  canBeDisabledAttribute,
+  isMultiAttribute,
+  isOptionalAttribute,
+  isSchemaGenericType,
+  valueMatchRequirements,
+} from "./utils.js";
+
+/**
+ * Parse an object schema, set isAttribute to true if parsing an attribute
+ * object (uses = instead of :)
+ * captured will contain the tokens of the captured keys on the object
+ * allowing for better error messages later on
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function schemaParseObjectFn($) {
+  return (token, schema, captured = {}, options) => {
+    let needSeparator = false;
+    let lastToken = null;
+
+    // grab all the keys, they contain the schema for the keys
+    const objectKeys = keys(schema);
+    const missingKeys = [...objectKeys];
+    const keyNames = [];
+
+    // you cannot have a generic mixed with another generic
+    $.ACTION(() => {
+      if (
+        objectKeys.length > 1 &&
+        some(objectKeys, (k) => isSchemaGenericType(k))
+      ) {
+        throw new Error(
+          "schemaParseObjectFn supports only one generic type when multiple keys are defined"
+        );
+      }
+    });
+
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.MANY1(() => {
+        needSeparator = false;
+        $.CONSUME(NewlineToken);
+      });
+
+      if (needSeparator) {
+        $.addInvalidValueError(
+          lastToken,
+          "Expected a comma, a new line or closing bracket"
+        );
+      }
+
+      const disabledToken = $.OPTION1(() => $.CONSUME(ExclamationToken)); // "!"
+
+      // first we capture the key
+      let objectKeyToken;
+      const keyValue = $.OR([
+        {
+          ALT: () => {
+            objectKeyToken = $.CONSUME(Identifier);
+            const tokens = [objectKeyToken];
+            $.MANY3(() => {
+              tokens.push($.CONSUME(DotToken));
+              tokens.push($.CONSUME1(Identifier));
+            });
+            const fullKey = tokens.map((t) => t.image).join(".");
+            return fullKey;
+          },
+        },
+        {
+          ALT: () => {
+            const objectKeyToken = $.CONSUME(StringLiteral);
+            return objectKeyToken.image.slice(1, -1);
+          },
+        },
+      ]);
+
+      const subSchemaKey = valueMatchRequirements(keyValue, objectKeys);
+      if (!subSchemaKey) {
+        $.addInvalidValueError(
+          objectKeyToken,
+          `The key '${keyValue}' is not valid in this context`
+        );
+      } else if (disabledToken && !canBeDisabledAttribute(subSchemaKey)) {
+        $.addInvalidValueError(
+          disabledToken,
+          `The key '${keyValue}' cannot be disabled`
+        );
+      }
+
+      if (keyNames.includes(keyValue) && !isMultiAttribute(subSchemaKey)) {
+        $.addInvalidValueError(
+          objectKeyToken,
+          `Duplicate key '${keyValue}' found`
+        );
+      } else {
+        keyNames.push(keyValue);
+        captured[keyValue] = { key: objectKeyToken, value: null };
+      }
+
+      // remove from missing keys
+      missingKeys.splice(missingKeys.indexOf(subSchemaKey), 1);
+
+      $.CONSUME(ColonToken); // ":"
+
+      const subSchema = get(schema, subSchemaKey, null);
+
+      $.SUBRULE($.schemaFn, {
+        ARGS: [objectKeyToken, subSchema, captured[keyValue], options],
+      });
+
+      needSeparator = true;
+      $.OPTION(() => {
+        needSeparator = false;
+        $.CONSUME1(CommaToken);
+      });
+
+      $.MANY2(() => {
+        needSeparator = false;
+        $.CONSUME1(NewlineToken);
+      });
+    });
+    $.CONSUME(RCurly); // "}"
+
+    if (missingKeys.length) {
+      const missingKeyNames = missingKeys.filter(
+        (k) => !isOptionalAttribute(k)
+      );
+      if (missingKeyNames.length > 1) {
+        $.addMissingError(
+          lastToken || token,
+          `{} is missing the following required entries: ${missingKeyNames.join(
+            ", "
+          )}`
+        );
+      } else if (missingKeyNames.length === 1) {
+        if (isSchemaGenericType(missingKeyNames[0])) {
+          $.addMissingError(
+            lastToken || token,
+            `{} requires a least one entry`
+          );
+        } else {
+          $.addMissingError(
+            lastToken || token,
+            `{} is missing required key '${missingKeyNames[0]}'`
+          );
+        }
+      }
+    }
+
+    return { foo: "foo-bar" };
+  };
+}
+
+/**
+ *
+ * @param {*} attr
+ * @returns
+ */
+export function schemaExpectObject(attr) {
+  return isPlainObject(attr);
+}

package/parser/functions/schema/schemaParseObjectFn.spec.js

@@ -0,0 +1,223 @@
+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.schemaParseObjectFn_flat = this.RULE("schemaParseObjectFn_flat", () => {
+    const schema = { "[string]": "[number]" };
+    const name = this.CONSUME(Identifier);
+    this.CONSUME(EqualToken); // "="
+    const obj = {};
+    this.SUBRULE(this.schemaParseObjectFn, {
+      ARGS: [name, schema, obj],
+    });
+  });
+
+  this.schemaParseObjectFn_deep = this.RULE("schemaParseObjectFn_deep", () => {
+    const schema = {
+      "[string]": {
+        test: ["[number]"],
+        bool: "[boolean]",
+        hey: "some constant",
+      },
+    };
+    const name = this.CONSUME(Identifier);
+    this.CONSUME(EqualToken); // "="
+    this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
+  });
+
+  this.schemaParseObjectFn_disabled = this.RULE(
+    "schemaParseObjectFn_disabled",
+    () => {
+      const schema = {
+        "![string]": {
+          valid: "[boolean]",
+          "!invalid": "[boolean]",
+        },
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseObjectFn_optional = this.RULE(
+    "schemaParseObjectFn_optional",
+    () => {
+      const schema = {
+        "[string]": {
+          "optional?": "[number]",
+          required: "[boolean]",
+        },
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseObjectFn_multiple = this.RULE(
+    "schemaParseObjectFn_multiple",
+    () => {
+      const schema = {
+        "[string]": {
+          "multi*": "[number]",
+          required: "[boolean]",
+        },
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaParseObjectFn", () => {
+  it("schemaParseObjectFn accepts mix types and constants", () => {
+    parse(`value = {something: 345}`).schemaParseObjectFn_flat();
+    expect(parser.errors).to.be.empty;
+
+    parse(`value = {
+      something: 123.2,
+      other_thing: 44
+    }`).schemaParseObjectFn_flat();
+    expect(parser.errors).to.be.empty;
+
+    parse(
+      `value = { something: 123.2, other_thing: 44 }`
+    ).schemaParseObjectFn_flat();
+    expect(parser.errors).to.be.empty;
+
+    parse(`value = {
+      something: 123.2,
+      other_thing: 44,
+    }`).schemaParseObjectFn_flat();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseObjectFn rejects duplicate keys", () => {
+    parse(
+      `value = {something: 345, something: 123}`
+    ).schemaParseObjectFn_flat();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(
+      `value = {
+        my.property.key: 345, 
+        my.property.key: 123
+      }`
+    ).schemaParseObjectFn_flat();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseObjectFn accepts different sub-property on duplicate roots", () => {
+    parse(`value = {
+      my.property.foo: 345, 
+      my.property.key: 123
+    }`).schemaParseObjectFn_flat();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseObjectFn immutable restricts to valid token", () => {
+    parse(`value = {123: 124}`).schemaParseObjectFn_flat();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseObjectFn accepts deep definition", () => {
+    parse(`value = {
+      something: {
+        test: [123, 456]
+        bool: true
+        hey: "some constant"
+      } 
+    }`).schemaParseObjectFn_deep();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseObjectFn rejects errors in deep definition", () => {
+    parse(`value = {
+      something: {
+        test: 123,
+        bool: true,
+        hey: "some constant"
+      } 
+    }`).schemaParseObjectFn_deep();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseObjectFn rejects missing keys", () => {
+    parse(`value = {
+      something: {
+        test: [123, 456]
+        hey: "some constant"
+      } 
+    }`).schemaParseObjectFn_deep();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseObjectFn accepts membership format for keys", () => {
+    parse(`value = {
+      some.thing.here: {
+        test: [123, 456]
+        bool: true
+        hey: "some constant"
+      } 
+    }`).schemaParseObjectFn_deep();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseObjectFn accepts optional keys", () => {
+    parse(`value = {
+      something: {
+        optional: 123
+        required: true
+      } 
+    }`).schemaParseObjectFn_optional();
+    expect(parser.errors).to.be.empty;
+
+    parse(`value = {
+      something: {
+        required: true
+      } 
+    }`).schemaParseObjectFn_optional();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseObjectFn accept disabled keys", () => {
+    parse(`value = {
+      !disabled: { valid: true, invalid: false }
+      no_disabled: { valid: false, !invalid: true }
+    }`).schemaParseObjectFn_disabled();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseObjectFn accept disabled keys", () => {
+    parse(`value = {
+      !disabled: { valid: true, invalid: false }
+      no_disabled: { !valid: false, !invalid: true }
+    }`).schemaParseObjectFn_disabled();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseObjectFn accepts multiple keys", () => {
+    parse(`value = {
+      something: { multi: 123, multi: 456, required: true }
+    }`).schemaParseObjectFn_multiple();
+    expect(parser.errors).to.be.empty;
+    parse(`value = {
+      something: { required: true }
+    }`).schemaParseObjectFn_multiple();
+    expect(parser.errors).to.be.empty;
+  });
+});