zenstack 0.1.42 → 0.1.46

package/out/language-server/generated/grammar.js

@@ -1,13 +1,13 @@
 "use strict";
 /******************************************************************************
- * This file was generated by langium-cli 0.4.0.
+ * This file was generated by langium-cli 0.5.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZModelGrammar = void 0;
 const langium_1 = require("langium");
 let loadedZModelGrammar;
-const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, langium_1.loadGrammar)(`{
+const ZModelGrammar = () => loadedZModelGrammar !== null && loadedZModelGrammar !== void 0 ? loadedZModelGrammar : (loadedZModelGrammar = (0, langium_1.loadGrammarFromJson)(`{
   "$type": "Grammar",
   "isDeclared": true,
   "name": "ZModel",
@@ -16,7 +16,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "ParserRule",
       "name": "Model",
       "entry": true,
-      "alternatives": {
+      "definition": {
         "$type": "Assignment",
         "feature": "declarations",
         "operator": "+=",
@@ -38,7 +38,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "AbstractDeclaration",
-      "alternatives": {
+      "definition": {
         "$type": "Alternatives",
         "elements": [
           {
@@ -88,7 +88,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataSource",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -122,7 +122,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
               },
               "arguments": []
             },
-            "cardinality": "+"
+            "cardinality": "*"
           },
           {
             "$type": "Keyword",
@@ -140,7 +140,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataSourceField",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -195,7 +195,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "Expression",
-      "alternatives": {
+      "definition": {
         "$type": "RuleCall",
         "rule": {
           "$refText": "LogicalExpr"
@@ -212,7 +212,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "LiteralExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Assignment",
         "feature": "value",
         "operator": "=",
@@ -229,7 +229,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
             {
               "$type": "RuleCall",
               "rule": {
-                "$refText": "INT"
+                "$refText": "NUMBER"
               },
               "arguments": []
             },
@@ -253,7 +253,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "ArrayExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -316,7 +316,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "ThisExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Assignment",
         "feature": "value",
         "operator": "=",
@@ -338,7 +338,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "NullExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Assignment",
         "feature": "value",
         "operator": "=",
@@ -360,7 +360,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "ReferenceExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -416,7 +416,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "ParserRule",
       "name": "ReferenceArgList",
       "fragment": true,
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -464,7 +464,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "ReferenceArg",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -510,7 +510,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "InvocationExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -553,7 +553,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "UnaryExpr",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -593,7 +593,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "InferredType",
         "name": "Expression"
       },
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -655,7 +655,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "InferredType",
         "name": "Expression"
       },
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -738,7 +738,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "InferredType",
         "name": "Expression"
       },
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -817,7 +817,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "InferredType",
         "name": "Expression"
       },
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -888,7 +888,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "InferredType",
         "name": "Expression"
       },
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -959,7 +959,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "InferredType",
         "name": "Expression"
       },
-      "alternatives": {
+      "definition": {
         "$type": "Alternatives",
         "elements": [
           {
@@ -1044,7 +1044,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "ParserRule",
       "name": "ArgumentList",
       "fragment": true,
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1092,7 +1092,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "Argument",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1141,7 +1141,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataModel",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1210,7 +1210,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataModelField",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1262,7 +1262,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataModelFieldType",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1328,7 +1328,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "Enum",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1380,7 +1380,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "EnumField",
-      "alternatives": {
+      "definition": {
         "$type": "Assignment",
         "feature": "name",
         "operator": "=",
@@ -1402,7 +1402,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "Function",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1514,7 +1514,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "FunctionParam",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1553,7 +1553,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "FunctionParamType",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1602,7 +1602,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "Attribute",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1681,7 +1681,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "AttributeParam",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1729,7 +1729,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "AttributeParamType",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1783,7 +1783,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataModelFieldAttribute",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1836,7 +1836,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "DataModelAttribute",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1890,7 +1890,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "ParserRule",
       "name": "AttributeArgList",
       "fragment": true,
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1938,7 +1938,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "ParserRule",
       "name": "AttributeArg",
-      "alternatives": {
+      "definition": {
         "$type": "Group",
         "elements": [
           {
@@ -1988,7 +1988,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "ParserRule",
       "name": "BuiltinType",
       "fragment": true,
-      "alternatives": {
+      "definition": {
         "$type": "Assignment",
         "feature": "type",
         "operator": "=",
@@ -2007,13 +2007,29 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
               "$type": "Keyword",
               "value": "Int"
             },
+            {
+              "$type": "Keyword",
+              "value": "BigInt"
+            },
+            {
+              "$type": "Keyword",
+              "value": "Float"
+            },
+            {
+              "$type": "Keyword",
+              "value": "Decimal"
+            },
             {
               "$type": "Keyword",
               "value": "DateTime"
             },
             {
               "$type": "Keyword",
-              "value": "JSON"
+              "value": "Json"
+            },
+            {
+              "$type": "Keyword",
+              "value": "Bytes"
             }
           ]
         }
@@ -2028,7 +2044,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "TerminalRule",
       "hidden": true,
       "name": "WS",
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
         "regex": "\\\\s+"
       },
@@ -2041,7 +2057,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
         "$type": "ReturnType",
         "name": "boolean"
       },
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
         "regex": "true|false"
       },
@@ -2051,7 +2067,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "TerminalRule",
       "name": "NULL",
-      "terminal": {
+      "definition": {
         "$type": "CharacterRange",
         "left": {
           "$type": "Keyword",
@@ -2064,7 +2080,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "TerminalRule",
       "name": "THIS",
-      "terminal": {
+      "definition": {
         "$type": "CharacterRange",
         "left": {
           "$type": "Keyword",
@@ -2077,7 +2093,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "TerminalRule",
       "name": "ID",
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
         "regex": "[_a-zA-Z][\\\\w_]*"
       },
@@ -2087,7 +2103,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     {
       "$type": "TerminalRule",
       "name": "STRING",
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
         "regex": "\\"[^\\"]*\\"|'[^']*'"
       },
@@ -2096,14 +2112,14 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
     },
     {
       "$type": "TerminalRule",
-      "name": "INT",
+      "name": "NUMBER",
       "type": {
         "$type": "ReturnType",
         "name": "number"
       },
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
-        "regex": "[+-]?[0-9]+"
+        "regex": "[+-]?[0-9]+(\\\\.[0-9]+)?"
       },
       "fragment": false,
       "hidden": false
@@ -2112,7 +2128,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "TerminalRule",
       "hidden": true,
       "name": "ML_COMMENT",
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
         "regex": "\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\/"
       },
@@ -2122,7 +2138,7 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
       "$type": "TerminalRule",
       "hidden": true,
       "name": "SL_COMMENT",
-      "terminal": {
+      "definition": {
         "$type": "RegexToken",
         "regex": "\\\\/\\\\/[^\\\\n\\\\r]*"
       },

package/out/language-server/generated/grammar.js.map

@@ -1 +1 @@
-{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../../../src/language-server/generated/grammar.ts"],"names":[],"mappings":";AAAA;;;gFAGgF;;;AAEhF,qCAA+C;AAE/C,IAAI,mBAAwC,CAAC;AACtC,MAAM,aAAa,GAAG,GAAY,EAAE,CAAC,mBAAmB,IAAG,CAAC,mBAAmB,GAAG,IAAA,qBAAW,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqoEnG,CAAC,CAAC,CAAC;AAroEQ,QAAA,aAAa,iBAqoErB"}
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../../../src/language-server/generated/grammar.ts"],"names":[],"mappings":";AAAA;;;gFAGgF;;;AAEhF,qCAAuD;AAEvD,IAAI,mBAAwC,CAAC;AACtC,MAAM,aAAa,GAAG,GAAY,EAAE,CAAC,mBAAmB,aAAnB,mBAAmB,cAAnB,mBAAmB,GAAI,CAAC,mBAAmB,GAAG,IAAA,6BAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqpE5G,CAAC,CAAC,CAAC;AArpEQ,QAAA,aAAa,iBAqpErB"}

package/out/language-server/generated/module.js

@@ -1,6 +1,6 @@
 "use strict";
 /******************************************************************************
- * This file was generated by langium-cli 0.4.0.
+ * This file was generated by langium-cli 0.5.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 Object.defineProperty(exports, "__esModule", { value: true });

package/out/language-server/main.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const langium_1 = require("langium");
-const node_1 = require("vscode-languageserver/node");
+const node_1 = require("langium/node");
+const node_2 = require("vscode-languageserver/node");
 const zmodel_module_1 = require("./zmodel-module");
 // Create a connection to the client
-const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+const connection = (0, node_2.createConnection)(node_2.ProposedFeatures.all);
 // Inject the shared services and language-specific services
-const { shared } = (0, zmodel_module_1.createZModelServices)({ connection });
+const { shared } = (0, zmodel_module_1.createZModelServices)(Object.assign({ connection }, node_1.NodeFileSystem));
 // Start the language server with the shared services
 (0, langium_1.startLanguageServer)(shared);
 //# sourceMappingURL=main.js.map

package/out/language-server/main.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/language-server/main.ts"],"names":[],"mappings":";;AAAA,qCAA8C;AAC9C,qDAAgF;AAChF,mDAAuD;AAEvD,oCAAoC;AACpC,MAAM,UAAU,GAAG,IAAA,uBAAgB,EAAC,uBAAgB,CAAC,GAAG,CAAC,CAAC;AAE1D,4DAA4D;AAC5D,MAAM,EAAE,MAAM,EAAE,GAAG,IAAA,oCAAoB,EAAC,EAAE,UAAU,EAAE,CAAC,CAAC;AAExD,qDAAqD;AACrD,IAAA,6BAAmB,EAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/language-server/main.ts"],"names":[],"mappings":";;AAAA,qCAA8C;AAC9C,uCAA8C;AAC9C,qDAAgF;AAChF,mDAAuD;AAEvD,oCAAoC;AACpC,MAAM,UAAU,GAAG,IAAA,uBAAgB,EAAC,uBAAgB,CAAC,GAAG,CAAC,CAAC;AAE1D,4DAA4D;AAC5D,MAAM,EAAE,MAAM,EAAE,GAAG,IAAA,oCAAoB,kBAAG,UAAU,IAAK,qBAAc,EAAG,CAAC;AAE3E,qDAAqD;AACrD,IAAA,6BAAmB,EAAC,MAAM,CAAC,CAAC"}

package/out/language-server/stdlib.zmodel

@@ -15,8 +15,11 @@ attribute relation()
 attribute default()
 attribute updatedAt()
 attribute unique()
+attribute map()
+
 attribute allow()
 attribute deny()
+
 attribute email()
 attribute url()
 attribute length()

package/out/language-server/validator/datamodel-validator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const utils_1 = require("./utils");
+class DataModelValidator {
+    validate(dm, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(dm.fields, accept);
+        this.validateFields(dm, accept);
+    }
+    validateFields(dm, accept) {
+        const idFields = dm.fields.filter((f) => f.attributes.find((attr) => { var _a; return ((_a = attr.decl.ref) === null || _a === void 0 ? void 0 : _a.name) === 'id'; }));
+        if (idFields.length === 0) {
+            accept('error', 'Model must include a field with @id attribute', {
+                node: dm,
+            });
+        }
+        else if (idFields.length > 1) {
+            accept('error', 'Model can include at most one field with @id attribute', {
+                node: dm,
+            });
+        }
+        else {
+            if (idFields[0].type.optional) {
+                accept('error', 'Field with @id attribute must not be optional', { node: idFields[0] });
+            }
+            if (idFields[0].type.array ||
+                !idFields[0].type.type ||
+                !constants_1.SCALAR_TYPES.includes(idFields[0].type.type)) {
+                accept('error', 'Field with @id attribute must be of scalar type', { node: idFields[0] });
+            }
+        }
+        dm.fields.forEach((field) => this.validateField(field, accept));
+    }
+    validateField(field, accept) {
+        if (field.type.array && field.type.optional) {
+            accept('error', 'Optional lists are not supported. Use either `Type[]` or `Type?`', { node: field.type });
+        }
+    }
+}
+exports.default = DataModelValidator;
+//# sourceMappingURL=datamodel-validator.js.map

package/out/language-server/validator/datamodel-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datamodel-validator.js","sourceRoot":"","sources":["../../../src/language-server/validator/datamodel-validator.ts"],"names":[],"mappings":";;AAAA,+CAA+C;AAI/C,mCAAyD;AAEzD,MAAqB,kBAAkB;IACnC,QAAQ,CAAC,EAAa,EAAE,MAA0B;QAC9C,IAAA,sCAA8B,EAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClD,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IACpC,CAAC;IAEO,cAAc,CAAC,EAAa,EAAE,MAA0B;QAC5D,MAAM,QAAQ,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CACpC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,WAAC,OAAA,CAAA,MAAA,IAAI,CAAC,IAAI,CAAC,GAAG,0CAAE,IAAI,MAAK,IAAI,CAAA,EAAA,CAAC,CAC5D,CAAC;QACF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;YACvB,MAAM,CAAC,OAAO,EAAE,+CAA+C,EAAE;gBAC7D,IAAI,EAAE,EAAE;aACX,CAAC,CAAC;SACN;aAAM,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5B,MAAM,CACF,OAAO,EACP,wDAAwD,EACxD;gBACI,IAAI,EAAE,EAAE;aACX,CACJ,CAAC;SACL;aAAM;YACH,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE;gBAC3B,MAAM,CACF,OAAO,EACP,+CAA+C,EAC/C,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CACxB,CAAC;aACL;YAED,IACI,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK;gBACtB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI;gBACtB,CAAC,wBAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAC/C;gBACE,MAAM,CACF,OAAO,EACP,iDAAiD,EACjD,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CACxB,CAAC;aACL;SACJ;QAED,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IACpE,CAAC;IAEO,aAAa,CACjB,KAAqB,EACrB,MAA0B;QAE1B,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE;YACzC,MAAM,CACF,OAAO,EACP,kEAAkE,EAClE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CACvB,CAAC;SACL;IACL,CAAC;CACJ;AA3DD,qCA2DC"}

package/out/language-server/validator/datasource-validator copy.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_1 = require("../generated/ast");
+const utils_1 = require("./utils");
+const constants_1 = require("../constants");
+const supportedFields = [
+    'provider',
+    'url',
+    'shadowDatabaseUrl',
+    'relationMode',
+];
+class DataSourceValidator {
+    validate(ds, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(ds.fields, accept);
+        this.validateFields(ds, accept);
+        this.validateProvider(ds, accept);
+        this.validateUrl(ds, accept);
+        this.validateRelationMode(ds, accept);
+    }
+    validateFields(ds, accept) {
+        ds.fields.forEach((f) => {
+            if (!supportedFields.includes(f.name)) {
+                accept('error', `Unexpected field "${f.name}"`, { node: f });
+            }
+        });
+    }
+    validateProvider(ds, accept) {
+        const provider = ds.fields.find((f) => f.name === 'provider');
+        if (!provider) {
+            accept('error', 'datasource must include a "provider" field', {
+                node: ds,
+            });
+            return;
+        }
+        const value = (0, utils_1.getStringLiteral)(provider.value);
+        if (!value) {
+            accept('error', '"provider" must be set to a string literal', {
+                node: provider.value,
+            });
+        }
+        else if (!constants_1.SUPPORTED_PROVIDERS.includes(value)) {
+            accept('error', `Provider "${value}" is not supported. Choose from ${constants_1.SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(' | ')}.`, { node: provider.value });
+        }
+    }
+    validateUrl(ds, accept) {
+        var _a;
+        const url = ds.fields.find((f) => f.name === 'url');
+        if (!url) {
+            accept('error', 'datasource must include a "url" field', {
+                node: ds,
+            });
+        }
+        for (const fieldName of ['url', 'shadowDatabaseUrl']) {
+            const field = ds.fields.find((f) => f.name === fieldName);
+            if (!field) {
+                continue;
+            }
+            const value = (0, utils_1.getStringLiteral)(field.value);
+            if (!value &&
+                !((0, ast_1.isInvocationExpr)(field.value) &&
+                    ((_a = field.value.function.ref) === null || _a === void 0 ? void 0 : _a.name) === 'env')) {
+                accept('error', `"${fieldName}" must be set to a string literal or an invocation of "env" function`, { node: field.value });
+            }
+        }
+    }
+    validateRelationMode(ds, accept) {
+        const field = ds.fields.find((f) => f.name === 'relationMode');
+        if (field) {
+            const val = (0, utils_1.getStringLiteral)(field.value);
+            if (!val || !['foreignKeys', 'prisma'].includes(val)) {
+                accept('error', '"relationMode" must be set to "foreignKeys" or "prisma"', { node: field.value });
+            }
+        }
+    }
+}
+exports.default = DataSourceValidator;
+//# sourceMappingURL=datasource-validator%20copy.js.map