zenstack 0.1.45 → 0.1.47

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA40E5G,CAAC,CAAC,CAAC;AA50EQ,QAAA,aAAa,iBA40ErB"}

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/langium-ext.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=langium-ext.js.map

package/out/language-server/langium-ext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langium-ext.js","sourceRoot":"","sources":["../../src/language-server/langium-ext.ts"],"names":[],"mappings":""}

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

@@ -1,22 +1,23 @@
-enum ReferentialIntegrity {
+enum ReferentialAction {
     Cascade
 }
 
-function env() String {}
-function auth() User {}
-function now() DateTime {}
-function uuid() String {}
-function cuid() String {}
+function env(): String {}
+function auth(): User {}
+function now(): DateTime {}
+function uuid(): String {}
+function cuid(): String {}
 function autoincrement() Int {}
 
-attribute id()
-attribute index()
-attribute relation()
-attribute default()
-attribute updatedAt()
-attribute unique()
-attribute allow()
-attribute deny()
-attribute email()
-attribute url()
-attribute length()
+attribute @id(map: String?)
+attribute @default(_ value: ContextType)
+attribute @unique(map: String?)
+attribute @@unique(_ fields: FieldReference[], name: String?, map: String?)
+attribute @@index(_ fields: FieldReference[], map: String?)
+attribute @relation(_ name: String?, fields: FieldReference[]?, references: FieldReference[]?, onDelete: ReferentialAction?, onUpdate: ReferentialAction?, map: String?)
+attribute @map(_ name: String)
+attribute @@map(_ name: String)
+attribute @updatedAt()
+
+attribute @@allow(_ operation: String, _ condition: Boolean)
+attribute @@deny(_ operation: String, _ condition: Boolean)

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AttributeValidator {
+    validate(attr, accept) {
+        const defaultParams = attr.params.filter((p) => p.default);
+        if (defaultParams.length > 1) {
+            accept('error', 'Attribute can declare at most one default parameter', { node: defaultParams[1] });
+        }
+    }
+}
+exports.default = AttributeValidator;
+//# sourceMappingURL=attribute-validator%20copy.js.map

package/out/language-server/validator/attribute-validator copy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-validator copy.js","sourceRoot":"","sources":["../../../src/language-server/validator/attribute-validator copy.ts"],"names":[],"mappings":";;AAIA,MAAqB,kBAAkB;IACnC,QAAQ,CAAC,IAAe,EAAE,MAA0B;QAChD,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC3D,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,MAAM,CACF,OAAO,EACP,qDAAqD,EACrD,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAC7B,CAAC;SACL;IACL,CAAC;CACJ;AAXD,qCAWC"}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AttributeValidator {
+    validate(attr, accept) { }
+}
+exports.default = AttributeValidator;
+//# sourceMappingURL=attribute-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-validator.js","sourceRoot":"","sources":["../../../src/language-server/validator/attribute-validator.ts"],"names":[],"mappings":";;AAIA,MAAqB,kBAAkB;IACnC,QAAQ,CAAC,IAAe,EAAE,MAA0B,IAAG,CAAC;CAC3D;AAFD,qCAEC"}

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

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const ast_1 = require("../generated/ast");
+const utils_1 = require("./utils");
+const pluralize_1 = __importDefault(require("pluralize"));
+class DataModelValidator {
+    validate(dm, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(dm.fields, accept);
+        this.validateFields(dm, accept);
+        this.validateAttributes(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) {
+        var _a;
+        if (field.type.array && field.type.optional) {
+            accept('error', 'Optional lists are not supported. Use either `Type[]` or `Type?`', { node: field.type });
+        }
+        field.attributes.forEach((attr) => this.validateAttributeApplication(attr, accept));
+        if ((0, ast_1.isDataModel)((_a = field.type.reference) === null || _a === void 0 ? void 0 : _a.ref)) {
+            this.validateRelationField(field, accept);
+        }
+    }
+    validateAttributes(dm, accept) {
+        dm.attributes.forEach((attr) => {
+            this.validateAttributeApplication(attr, accept);
+        });
+    }
+    validateAttributeApplication(attr, accept) {
+        const decl = attr.decl.ref;
+        if (!decl) {
+            throw new Error(`Reference unresolved: ${attr.decl.$refText}`);
+        }
+        const filledParams = new Set();
+        for (const arg of attr.args) {
+            let paramDecl;
+            if (!arg.name) {
+                paramDecl = decl.params.find((p) => p.default && !filledParams.has(p));
+                if (!paramDecl) {
+                    accept('error', `Unexpected unnamed argument`, {
+                        node: arg,
+                    });
+                    return false;
+                }
+            }
+            else {
+                paramDecl = decl.params.find((p) => p.name === arg.name);
+                if (!paramDecl) {
+                    accept('error', `Attribute "${decl.name}" doesn't have a parameter named "${arg.name}"`, {
+                        node: arg,
+                    });
+                    return false;
+                }
+            }
+            if (!(0, utils_1.assignableToAttributeParam)(arg, paramDecl, attr)) {
+                accept('error', `Value is not assignable to parameter`, {
+                    node: arg,
+                });
+                return false;
+            }
+            if (filledParams.has(paramDecl)) {
+                accept('error', `Parameter "${paramDecl.name}" is already provided`, { node: arg });
+                return false;
+            }
+            filledParams.add(paramDecl);
+        }
+        const missingParams = decl.params.filter((p) => !p.type.optional && !filledParams.has(p));
+        if (missingParams.length > 0) {
+            accept('error', `Required ${(0, pluralize_1.default)('parameter', missingParams.length)} not provided: ${missingParams
+                .map((p) => p.name)
+                .join(', ')}`, { node: attr });
+            return false;
+        }
+        return true;
+    }
+    parseRelation(field, accept) {
+        const relAttr = field.attributes.find((attr) => { var _a; return ((_a = attr.decl.ref) === null || _a === void 0 ? void 0 : _a.name) === '@relation'; });
+        let name;
+        let fields;
+        let references;
+        let valid = true;
+        if (!relAttr) {
+            return { attr: relAttr, name, fields, references, valid: true };
+        }
+        for (const arg of relAttr.args) {
+            if (!arg.name || arg.name === 'name') {
+                if ((0, ast_1.isLiteralExpr)(arg.value)) {
+                    name = arg.value.value;
+                }
+            }
+            else if (arg.name === 'fields') {
+                fields = arg.value.items;
+                if (fields.length === 0) {
+                    if (accept) {
+                        accept('error', `"fields" value cannot be emtpy`, {
+                            node: arg,
+                        });
+                    }
+                    valid = false;
+                }
+            }
+            else if (arg.name === 'references') {
+                references = arg.value.items;
+                if (references.length === 0) {
+                    if (accept) {
+                        accept('error', `"references" value cannot be emtpy`, {
+                            node: arg,
+                        });
+                    }
+                    valid = false;
+                }
+            }
+        }
+        return { attr: relAttr, name, fields, references, valid };
+    }
+    validateRelationField(field, accept) {
+        var _a, _b, _c, _d;
+        const thisRelation = this.parseRelation(field, accept);
+        if (!thisRelation.valid) {
+            return;
+        }
+        const oppositeModel = field.type.reference.ref;
+        let oppositeFields = oppositeModel.fields.filter((f) => { var _a; return ((_a = f.type.reference) === null || _a === void 0 ? void 0 : _a.ref) === field.$container; });
+        oppositeFields = oppositeFields.filter((f) => {
+            const fieldRel = this.parseRelation(f);
+            return fieldRel.valid && fieldRel.name === thisRelation.name;
+        });
+        if (oppositeFields.length === 0) {
+            accept('error', `The relation field "${field.name}" on model "${field.$container.name}" is missing an opposite relation field on model "${oppositeModel.name}"`, { node: field });
+            return;
+        }
+        else if (oppositeFields.length > 1) {
+            oppositeFields.forEach((f) => accept('error', `Fields ${oppositeFields
+                .map((f) => '"' + f.name + '"')
+                .join(', ')} on model ${oppositeModel.name} refer to the same relation to model "${field.$container.name}"`, { node: f }));
+            return;
+        }
+        const oppositeField = oppositeFields[0];
+        const oppositeRelation = this.parseRelation(oppositeField);
+        let relationOwner;
+        if (((_a = thisRelation === null || thisRelation === void 0 ? void 0 : thisRelation.references) === null || _a === void 0 ? void 0 : _a.length) && ((_b = thisRelation.fields) === null || _b === void 0 ? void 0 : _b.length)) {
+            if ((oppositeRelation === null || oppositeRelation === void 0 ? void 0 : oppositeRelation.references) || (oppositeRelation === null || oppositeRelation === void 0 ? void 0 : oppositeRelation.fields)) {
+                accept('error', '"fields" and "references" must be provided only on one side of relation field', { node: oppositeField });
+                return;
+            }
+            else {
+                relationOwner = oppositeField;
+            }
+        }
+        else if (((_c = oppositeRelation === null || oppositeRelation === void 0 ? void 0 : oppositeRelation.references) === null || _c === void 0 ? void 0 : _c.length) &&
+            ((_d = oppositeRelation.fields) === null || _d === void 0 ? void 0 : _d.length)) {
+            if ((thisRelation === null || thisRelation === void 0 ? void 0 : thisRelation.references) || (thisRelation === null || thisRelation === void 0 ? void 0 : thisRelation.fields)) {
+                accept('error', '"fields" and "references" must be provided only on one side of relation field', { node: field });
+                return;
+            }
+            else {
+                relationOwner = field;
+            }
+        }
+        else {
+            [field, oppositeField].forEach((f) => accept('error', 'Field for one side of relation must carry @relation attribute with both "fields" and "references" fields', { node: f }));
+            return;
+        }
+        if (!relationOwner.type.array && !relationOwner.type.optional) {
+            accept('error', 'Relation field needs to be list or optional', {
+                node: relationOwner,
+            });
+            return;
+        }
+    }
+}
+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":"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"}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"datasource-validator copy.js","sourceRoot":"","sources":["../../../src/language-server/validator/datasource-validator copy.ts"],"names":[],"mappings":"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"}

package/out/language-server/validator/datasource-validator.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.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"datasource-validator.js","sourceRoot":"","sources":["../../../src/language-server/validator/datasource-validator.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+class EnumValidator {
+    validate(_enum, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(_enum.fields, accept);
+    }
+}
+exports.default = EnumValidator;
+//# sourceMappingURL=enum-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enum-validator.js","sourceRoot":"","sources":["../../../src/language-server/validator/enum-validator.ts"],"names":[],"mappings":";;AAGA,mCAAyD;AAEzD,MAAqB,aAAa;IAC9B,QAAQ,CAAC,KAAW,EAAE,MAA0B;QAC5C,IAAA,sCAA8B,EAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;CACJ;AAJD,gCAIC"}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_1 = require("../generated/ast");
+const utils_1 = require("./utils");
+class ModelValidator {
+    validate(model, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(model.declarations, accept);
+        this.validateDataSources(model, accept);
+    }
+    validateDataSources(model, accept) {
+        const dataSources = model.declarations.filter((d) => (0, ast_1.isDataSource)(d));
+        if (dataSources.length === 0) {
+            accept('error', 'Model must define a datasource', { node: model });
+        }
+        else if (dataSources.length > 1) {
+            accept('error', 'Multiple datasource declarations are not allowed', { node: dataSources[1] });
+        }
+    }
+}
+exports.default = ModelValidator;
+//# sourceMappingURL=model-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-validator.js","sourceRoot":"","sources":["../../../src/language-server/validator/model-validator.ts"],"names":[],"mappings":";;AAAA,6CAA0D;AAG1D,mCAAyD;AAEzD,MAAqB,cAAc;IAC/B,QAAQ,CAAC,KAAY,EAAE,MAA0B;QAC7C,IAAA,sCAA8B,EAAC,KAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC3D,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC5C,CAAC;IAEO,mBAAmB,CAAC,KAAY,EAAE,MAA0B;QAChE,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,kBAAY,EAAC,CAAC,CAAC,CAAC,CAAC;QACtE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,MAAM,CAAC,OAAO,EAAE,gCAAgC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;SACtE;aAAM,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/B,MAAM,CACF,OAAO,EACP,kDAAkD,EAClD,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAC3B,CAAC;SACL;IACL,CAAC;CACJ;AAlBD,iCAkBC"}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_1 = require("../generated/ast");
+const utils_1 = require("./utils");
+class SchemaValidator {
+    validate(model, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(model.declarations, accept);
+        this.validateDataSources(model, accept);
+    }
+    validateDataSources(model, accept) {
+        const dataSources = model.declarations.filter((d) => (0, ast_1.isDataSource)(d));
+        if (dataSources.length === 0) {
+            accept('error', 'Model must define a datasource', { node: model });
+        }
+        else if (dataSources.length > 1) {
+            accept('error', 'Multiple datasource declarations are not allowed', { node: dataSources[1] });
+        }
+    }
+}
+exports.default = SchemaValidator;
+//# sourceMappingURL=schema-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validator.js","sourceRoot":"","sources":["../../../src/language-server/validator/schema-validator.ts"],"names":[],"mappings":";;AAAA,6CAA0D;AAG1D,mCAAyD;AAEzD,MAAqB,eAAe;IAChC,QAAQ,CAAC,KAAY,EAAE,MAA0B;QAC7C,IAAA,sCAA8B,EAAC,KAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC3D,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC5C,CAAC;IAEO,mBAAmB,CAAC,KAAY,EAAE,MAA0B;QAChE,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,kBAAY,EAAC,CAAC,CAAC,CAAC,CAAC;QACtE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,MAAM,CAAC,OAAO,EAAE,gCAAgC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;SACtE;aAAM,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/B,MAAM,CACF,OAAO,EACP,kDAAkD,EAClD,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAC3B,CAAC;SACL;IACL,CAAC;CACJ;AAlBD,kCAkBC"}