zenstack 0.6.0-pre.8 → 1.0.0-alpha.19

package/language-server/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","names":["connection","createConnection","ProposedFeatures","all","shared","createZModelServices","NodeFileSystem","startLanguageServer"],"sources":["../../src/language-server/main.ts"],"sourcesContent":["import { startLanguageServer } from 'langium';\nimport { NodeFileSystem } from 'langium/node';\nimport { createConnection, ProposedFeatures } from 'vscode-languageserver/node';\nimport { createZModelServices } from './zmodel-module';\n\n// Create a connection to the client\nconst connection = createConnection(ProposedFeatures.all);\n\n// Inject the shared services and language-specific services\nconst { shared } = createZModelServices({ connection, ...NodeFileSystem });\n\n// Start the language server with the shared services\nstartLanguageServer(shared);\n"],"mappings":";;AAAA;AACA;AACA;AACA;AAEA;AACA,MAAMA,UAAU,GAAG,IAAAC,uBAAgB,EAACC,uBAAgB,CAACC,GAAG,CAAC;;AAEzD;AACA,MAAM;EAAEC;AAAO,CAAC,GAAG,IAAAC,kCAAoB,EAAC;EAAEL,UAAU;EAAE,GAAGM;AAAe,CAAC,CAAC;;AAE1E;AACA,IAAAC,4BAAmB,EAACH,MAAM,CAAC"}

package/language-server/types.d.ts

@@ -0,0 +1,10 @@
+import { AstNode, ValidationAcceptor } from 'langium';
+/**
+ * AST validator contract
+ */
+export interface AstValidator<T extends AstNode> {
+    /**
+     * Validates an AST node
+     */
+    validate(node: T, accept: ValidationAcceptor): void;
+}

package/language-server/types.js

@@ -0,0 +1 @@
+"use strict";

package/language-server/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/language-server/types.ts"],"sourcesContent":["import { AstNode, ValidationAcceptor } from 'langium';\n\n/**\n * AST validator contract\n */\nexport interface AstValidator<T extends AstNode> {\n    /**\n     * Validates an AST node\n     */\n    validate(node: T, accept: ValidationAcceptor): void;\n}\n"],"mappings":""}

package/language-server/utils.d.ts

@@ -0,0 +1,10 @@
+import { AstNode } from 'langium';
+import { Model } from '@zenstackhq/language/ast';
+/**
+ * Gets the toplevel Model containing the given node.
+ */
+export declare function getContainingModel(node: AstNode | undefined): Model | null;
+/**
+ * Returns if the given node is declared in stdlib.
+ */
+export declare function isFromStdlib(node: AstNode): boolean | null | undefined;

package/language-server/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getContainingModel = getContainingModel;
+exports.isFromStdlib = isFromStdlib;
+var _constants = require("./constants");
+var _ast = require("@zenstackhq/language/ast");
+/**
+ * Gets the toplevel Model containing the given node.
+ */
+function getContainingModel(node) {
+  if (!node) {
+    return null;
+  }
+  return (0, _ast.isModel)(node) ? node : getContainingModel(node.$container);
+}
+
+/**
+ * Returns if the given node is declared in stdlib.
+ */
+function isFromStdlib(node) {
+  var _model$$document;
+  const model = getContainingModel(node);
+  return model && ((_model$$document = model.$document) === null || _model$$document === void 0 ? void 0 : _model$$document.uri.path.endsWith(_constants.STD_LIB_MODULE_NAME));
+}
+//# sourceMappingURL=utils.js.map

package/language-server/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["getContainingModel","node","isModel","$container","isFromStdlib","model","$document","uri","path","endsWith","STD_LIB_MODULE_NAME"],"sources":["../../src/language-server/utils.ts"],"sourcesContent":["import { AstNode } from 'langium';\nimport { STD_LIB_MODULE_NAME } from './constants';\nimport { isModel, Model } from '@zenstackhq/language/ast';\n\n/**\n * Gets the toplevel Model containing the given node.\n */\nexport function getContainingModel(node: AstNode | undefined): Model | null {\n    if (!node) {\n        return null;\n    }\n    return isModel(node) ? node : getContainingModel(node.$container);\n}\n\n/**\n * Returns if the given node is declared in stdlib.\n */\nexport function isFromStdlib(node: AstNode) {\n    const model = getContainingModel(node);\n    return model && model.$document?.uri.path.endsWith(STD_LIB_MODULE_NAME);\n}\n"],"mappings":";;;;;;;AACA;AACA;AAEA;AACA;AACA;AACO,SAASA,kBAAkB,CAACC,IAAyB,EAAgB;EACxE,IAAI,CAACA,IAAI,EAAE;IACP,OAAO,IAAI;EACf;EACA,OAAO,IAAAC,YAAO,EAACD,IAAI,CAAC,GAAGA,IAAI,GAAGD,kBAAkB,CAACC,IAAI,CAACE,UAAU,CAAC;AACrE;;AAEA;AACA;AACA;AACO,SAASC,YAAY,CAACH,IAAa,EAAE;EAAA;EACxC,MAAMI,KAAK,GAAGL,kBAAkB,CAACC,IAAI,CAAC;EACtC,OAAOI,KAAK,yBAAIA,KAAK,CAACC,SAAS,qDAAf,iBAAiBC,GAAG,CAACC,IAAI,CAACC,QAAQ,CAACC,8BAAmB,CAAC;AAC3E"}

package/language-server/validator/attribute-validator.d.ts

@@ -0,0 +1,9 @@
+import { Attribute } from '@zenstackhq/language/ast';
+import { AstValidator } from '../types';
+import { ValidationAcceptor } from 'langium';
+/**
+ * Validates attribute declarations.
+ */
+export default class AttributeValidator implements AstValidator<Attribute> {
+    validate(attr: Attribute, accept: ValidationAcceptor): void;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Validates attribute declarations.
+ */
+class AttributeValidator {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+  validate(attr, accept) {}
+}
+exports.default = AttributeValidator;
+//# sourceMappingURL=attribute-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-validator.js","names":["AttributeValidator","validate","attr","accept"],"sources":["../../../src/language-server/validator/attribute-validator.ts"],"sourcesContent":["import { Attribute } from '@zenstackhq/language/ast';\nimport { AstValidator } from '../types';\nimport { ValidationAcceptor } from 'langium';\n\n/**\n * Validates attribute declarations.\n */\nexport default class AttributeValidator implements AstValidator<Attribute> {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function\n    validate(attr: Attribute, accept: ValidationAcceptor): void {}\n}\n"],"mappings":";;;;;;AAIA;AACA;AACA;AACe,MAAMA,kBAAkB,CAAoC;EACvE;EACAC,QAAQ,CAACC,IAAe,EAAEC,MAA0B,EAAQ,CAAC;AACjE;AAAC"}

package/language-server/validator/datamodel-validator.d.ts

@@ -0,0 +1,16 @@
+import { DataModel } from '@zenstackhq/language/ast';
+import { AstValidator } from '../types';
+import { ValidationAcceptor } from 'langium';
+/**
+ * Validates data model declarations.
+ */
+export default class DataModelValidator implements AstValidator<DataModel> {
+    validate(dm: DataModel, accept: ValidationAcceptor): void;
+    private validateFields;
+    private validateField;
+    private validateAttributes;
+    private validateAttributeApplication;
+    private isValidAttributeTarget;
+    private parseRelation;
+    private validateRelationField;
+}

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

@@ -0,0 +1,365 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../constants");
+var _ast = require("@zenstackhq/language/ast");
+var _utils = require("./utils");
+var _pluralize = _interopRequireDefault(require("pluralize"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Validates data model declarations.
+ */
+class DataModelValidator {
+  validate(dm, accept) {
+    (0, _utils.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 _attr$decl$ref;
+      return ((_attr$decl$ref = attr.decl.ref) === null || _attr$decl$ref === void 0 ? void 0 : _attr$decl$ref.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.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 _field$type$reference;
+    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.isDataModel)((_field$type$reference = field.type.reference) === null || _field$type$reference === void 0 ? void 0 : _field$type$reference.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) {
+      return;
+    }
+    const targetDecl = attr.$container;
+    if (decl.name === '@@@targetField' && !(0, _ast.isAttribute)(targetDecl)) {
+      accept('error', `attribute "${decl.name}" can only be used on attribute declarations`, {
+        node: attr
+      });
+      return;
+    }
+    if ((0, _ast.isDataModelField)(targetDecl) && !this.isValidAttributeTarget(decl, targetDecl)) {
+      accept('error', `attribute "${decl.name}" cannot be used on this type of field`, {
+        node: attr
+      });
+    }
+    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.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);
+      arg.$resolvedParam = paramDecl;
+    }
+    const missingParams = decl.params.filter(p => !p.type.optional && !filledParams.has(p));
+    if (missingParams.length > 0) {
+      accept('error', `Required ${(0, _pluralize.default)('parameter', missingParams.length)} not provided: ${missingParams.map(p => p.name).join(', ')}`, {
+        node: attr
+      });
+      return false;
+    }
+    return true;
+  }
+  isValidAttributeTarget(attrDecl, targetDecl) {
+    var _targetDecl$type$refe;
+    const targetField = attrDecl.attributes.find(attr => {
+      var _attr$decl$ref2;
+      return ((_attr$decl$ref2 = attr.decl.ref) === null || _attr$decl$ref2 === void 0 ? void 0 : _attr$decl$ref2.name) === '@@@targetField';
+    });
+    if (!targetField) {
+      // no field type constraint
+      return true;
+    }
+    const fieldTypes = targetField.args[0].value.items.map(item => {
+      var _target$ref;
+      return (_target$ref = item.target.ref) === null || _target$ref === void 0 ? void 0 : _target$ref.name;
+    });
+    let allowed = false;
+    for (const allowedType of fieldTypes) {
+      switch (allowedType) {
+        case 'StringField':
+          allowed = allowed || targetDecl.type.type === 'String';
+          break;
+        case 'IntField':
+          allowed = allowed || targetDecl.type.type === 'Int';
+          break;
+        case 'FloatField':
+          allowed = allowed || targetDecl.type.type === 'Float';
+          break;
+        case 'DecimalField':
+          allowed = allowed || targetDecl.type.type === 'Decimal';
+          break;
+        case 'BooleanField':
+          allowed = allowed || targetDecl.type.type === 'Boolean';
+          break;
+        case 'DateTimeField':
+          allowed = allowed || targetDecl.type.type === 'DateTime';
+          break;
+        case 'JsonField':
+          allowed = allowed || targetDecl.type.type === 'Json';
+          break;
+        case 'BytesField':
+          allowed = allowed || targetDecl.type.type === 'Bytes';
+          break;
+        case 'ModelField':
+          allowed = allowed || (0, _ast.isDataModel)((_targetDecl$type$refe = targetDecl.type.reference) === null || _targetDecl$type$refe === void 0 ? void 0 : _targetDecl$type$refe.ref);
+          break;
+        default:
+          break;
+      }
+      if (allowed) {
+        break;
+      }
+    }
+    return allowed;
+  }
+  parseRelation(field, accept) {
+    const relAttr = field.attributes.find(attr => {
+      var _attr$decl$ref3;
+      return ((_attr$decl$ref3 = attr.decl.ref) === null || _attr$decl$ref3 === void 0 ? void 0 : _attr$decl$ref3.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.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;
+        }
+      }
+    }
+    if (!fields || !references) {
+      if (accept) {
+        accept('error', `Both "fields" and "references" must be provided`, {
+          node: relAttr
+        });
+      }
+    } else {
+      // validate "fields" and "references" typing consistency
+      if (fields.length !== references.length) {
+        if (accept) {
+          accept('error', `"references" and "fields" must have the same length`, {
+            node: relAttr
+          });
+        }
+      } else {
+        for (let i = 0; i < fields.length; i++) {
+          var _fields$i$$resolvedTy, _references$i$$resolv, _fields$i$$resolvedTy2, _references$i$$resolv2;
+          if (!fields[i].$resolvedType) {
+            if (accept) {
+              accept('error', `field reference is unresolved`, {
+                node: fields[i]
+              });
+            }
+          }
+          if (!references[i].$resolvedType) {
+            if (accept) {
+              accept('error', `field reference is unresolved`, {
+                node: references[i]
+              });
+            }
+          }
+          if (((_fields$i$$resolvedTy = fields[i].$resolvedType) === null || _fields$i$$resolvedTy === void 0 ? void 0 : _fields$i$$resolvedTy.decl) !== ((_references$i$$resolv = references[i].$resolvedType) === null || _references$i$$resolv === void 0 ? void 0 : _references$i$$resolv.decl) || ((_fields$i$$resolvedTy2 = fields[i].$resolvedType) === null || _fields$i$$resolvedTy2 === void 0 ? void 0 : _fields$i$$resolvedTy2.array) !== ((_references$i$$resolv2 = references[i].$resolvedType) === null || _references$i$$resolv2 === void 0 ? void 0 : _references$i$$resolv2.array)) {
+            if (accept) {
+              accept('error', `values of "references" and "fields" must have the same type`, {
+                node: relAttr
+              });
+            }
+          }
+        }
+      }
+    }
+    return {
+      attr: relAttr,
+      name,
+      fields,
+      references,
+      valid
+    };
+  }
+  validateRelationField(field, accept) {
+    var _thisRelation$referen, _thisRelation$fields, _oppositeRelation$ref, _oppositeRelation$fie;
+    const thisRelation = this.parseRelation(field, accept);
+    if (!thisRelation.valid) {
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const oppositeModel = field.type.reference.ref;
+    let oppositeFields = oppositeModel.fields.filter(f => {
+      var _f$type$reference;
+      return ((_f$type$reference = f.type.reference) === null || _f$type$reference === void 0 ? void 0 : _f$type$reference.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 (thisRelation !== null && thisRelation !== void 0 && (_thisRelation$referen = thisRelation.references) !== null && _thisRelation$referen !== void 0 && _thisRelation$referen.length && (_thisRelation$fields = thisRelation.fields) !== null && _thisRelation$fields !== void 0 && _thisRelation$fields.length) {
+      if (oppositeRelation !== null && oppositeRelation !== void 0 && oppositeRelation.references || oppositeRelation !== null && oppositeRelation !== 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 (oppositeRelation !== null && oppositeRelation !== void 0 && (_oppositeRelation$ref = oppositeRelation.references) !== null && _oppositeRelation$ref !== void 0 && _oppositeRelation$ref.length && (_oppositeRelation$fie = oppositeRelation.fields) !== null && _oppositeRelation$fie !== void 0 && _oppositeRelation$fie.length) {
+      if (thisRelation !== null && thisRelation !== void 0 && thisRelation.references || thisRelation !== null && thisRelation !== 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;
+    }
+    if (relationOwner !== field && !relationOwner.type.array) {
+      var _thisRelation$fields2;
+      // one-to-one relation requires defining side's reference field to be @unique
+      // e.g.:
+      //     model User {
+      //         id String @id @default(cuid())
+      //         data UserData?
+      //     }
+      //     model UserData {
+      //         id String @id @default(cuid())
+      //         user User  @relation(fields: [userId], references: [id])
+      //         userId String
+      //     }
+      //
+      // UserData.userId field needs to be @unique
+
+      (_thisRelation$fields2 = thisRelation.fields) === null || _thisRelation$fields2 === void 0 ? void 0 : _thisRelation$fields2.forEach(ref => {
+        const refField = ref.target.ref;
+        if (refField && !refField.attributes.find(a => {
+          var _a$decl$ref;
+          return ((_a$decl$ref = a.decl.ref) === null || _a$decl$ref === void 0 ? void 0 : _a$decl$ref.name) === '@unique';
+        })) {
+          accept('error', `Field "${refField.name}" is part of a one-to-one relation and must be marked as @unique`, {
+            node: refField
+          });
+        }
+      });
+    }
+  }
+}
+exports.default = DataModelValidator;
+//# sourceMappingURL=datamodel-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"datamodel-validator.js","names":["DataModelValidator","validate","dm","accept","validateDuplicatedDeclarations","fields","validateFields","validateAttributes","idFields","filter","f","attributes","find","attr","decl","ref","name","length","node","type","optional","array","SCALAR_TYPES","includes","forEach","field","validateField","validateAttributeApplication","isDataModel","reference","validateRelationField","targetDecl","$container","isAttribute","isDataModelField","isValidAttributeTarget","filledParams","Set","arg","args","paramDecl","params","p","default","has","assignableToAttributeParam","add","$resolvedParam","missingParams","pluralize","map","join","attrDecl","targetField","fieldTypes","value","items","item","target","allowed","allowedType","parseRelation","relAttr","references","valid","isLiteralExpr","i","$resolvedType","thisRelation","oppositeModel","oppositeFields","fieldRel","oppositeField","oppositeRelation","relationOwner","refField","a"],"sources":["../../../src/language-server/validator/datamodel-validator.ts"],"sourcesContent":["import { SCALAR_TYPES } from '../constants';\nimport {\n    ArrayExpr,\n    Attribute,\n    AttributeParam,\n    DataModel,\n    DataModelAttribute,\n    DataModelField,\n    DataModelFieldAttribute,\n    isAttribute,\n    isDataModel,\n    isDataModelField,\n    isLiteralExpr,\n    ReferenceExpr,\n} from '@zenstackhq/language/ast';\nimport { AstValidator } from '../types';\nimport { ValidationAcceptor } from 'langium';\nimport { assignableToAttributeParam, validateDuplicatedDeclarations } from './utils';\nimport pluralize from 'pluralize';\n\n/**\n * Validates data model declarations.\n */\nexport default class DataModelValidator implements AstValidator<DataModel> {\n    validate(dm: DataModel, accept: ValidationAcceptor): void {\n        validateDuplicatedDeclarations(dm.fields, accept);\n        this.validateFields(dm, accept);\n        this.validateAttributes(dm, accept);\n    }\n\n    private validateFields(dm: DataModel, accept: ValidationAcceptor) {\n        const idFields = dm.fields.filter((f) => f.attributes.find((attr) => attr.decl.ref?.name === '@id'));\n        if (idFields.length === 0) {\n            accept('error', 'Model must include a field with @id attribute', {\n                node: dm,\n            });\n        } else if (idFields.length > 1) {\n            accept('error', 'Model can include at most one field with @id attribute', {\n                node: dm,\n            });\n        } else {\n            if (idFields[0].type.optional) {\n                accept('error', 'Field with @id attribute must not be optional', { node: idFields[0] });\n            }\n\n            if (idFields[0].type.array || !idFields[0].type.type || !SCALAR_TYPES.includes(idFields[0].type.type)) {\n                accept('error', 'Field with @id attribute must be of scalar type', { node: idFields[0] });\n            }\n        }\n\n        dm.fields.forEach((field) => this.validateField(field, accept));\n    }\n\n    private validateField(field: DataModelField, accept: ValidationAcceptor): void {\n        if (field.type.array && field.type.optional) {\n            accept('error', 'Optional lists are not supported. Use either `Type[]` or `Type?`', { node: field.type });\n        }\n\n        field.attributes.forEach((attr) => this.validateAttributeApplication(attr, accept));\n\n        if (isDataModel(field.type.reference?.ref)) {\n            this.validateRelationField(field, accept);\n        }\n    }\n\n    private validateAttributes(dm: DataModel, accept: ValidationAcceptor) {\n        dm.attributes.forEach((attr) => {\n            this.validateAttributeApplication(attr, accept);\n        });\n    }\n\n    private validateAttributeApplication(\n        attr: DataModelAttribute | DataModelFieldAttribute,\n        accept: ValidationAcceptor\n    ) {\n        const decl = attr.decl.ref;\n        if (!decl) {\n            return;\n        }\n\n        const targetDecl = attr.$container;\n        if (decl.name === '@@@targetField' && !isAttribute(targetDecl)) {\n            accept('error', `attribute \"${decl.name}\" can only be used on attribute declarations`, { node: attr });\n            return;\n        }\n\n        if (isDataModelField(targetDecl) && !this.isValidAttributeTarget(decl, targetDecl)) {\n            accept('error', `attribute \"${decl.name}\" cannot be used on this type of field`, { node: attr });\n        }\n\n        const filledParams = new Set<AttributeParam>();\n\n        for (const arg of attr.args) {\n            let paramDecl: AttributeParam | undefined;\n            if (!arg.name) {\n                paramDecl = decl.params.find((p) => p.default && !filledParams.has(p));\n                if (!paramDecl) {\n                    accept('error', `Unexpected unnamed argument`, {\n                        node: arg,\n                    });\n                    return false;\n                }\n            } else {\n                paramDecl = decl.params.find((p) => p.name === arg.name);\n                if (!paramDecl) {\n                    accept('error', `Attribute \"${decl.name}\" doesn't have a parameter named \"${arg.name}\"`, {\n                        node: arg,\n                    });\n                    return false;\n                }\n            }\n\n            if (!assignableToAttributeParam(arg, paramDecl, attr)) {\n                accept('error', `Value is not assignable to parameter`, {\n                    node: arg,\n                });\n                return false;\n            }\n\n            if (filledParams.has(paramDecl)) {\n                accept('error', `Parameter \"${paramDecl.name}\" is already provided`, { node: arg });\n                return false;\n            }\n            filledParams.add(paramDecl);\n            arg.$resolvedParam = paramDecl;\n        }\n\n        const missingParams = decl.params.filter((p) => !p.type.optional && !filledParams.has(p));\n        if (missingParams.length > 0) {\n            accept(\n                'error',\n                `Required ${pluralize('parameter', missingParams.length)} not provided: ${missingParams\n                    .map((p) => p.name)\n                    .join(', ')}`,\n                { node: attr }\n            );\n            return false;\n        }\n\n        return true;\n    }\n\n    private isValidAttributeTarget(attrDecl: Attribute, targetDecl: DataModelField) {\n        const targetField = attrDecl.attributes.find((attr) => attr.decl.ref?.name === '@@@targetField');\n        if (!targetField) {\n            // no field type constraint\n            return true;\n        }\n\n        const fieldTypes = (targetField.args[0].value as ArrayExpr).items.map(\n            (item) => (item as ReferenceExpr).target.ref?.name\n        );\n\n        let allowed = false;\n        for (const allowedType of fieldTypes) {\n            switch (allowedType) {\n                case 'StringField':\n                    allowed = allowed || targetDecl.type.type === 'String';\n                    break;\n                case 'IntField':\n                    allowed = allowed || targetDecl.type.type === 'Int';\n                    break;\n                case 'FloatField':\n                    allowed = allowed || targetDecl.type.type === 'Float';\n                    break;\n                case 'DecimalField':\n                    allowed = allowed || targetDecl.type.type === 'Decimal';\n                    break;\n                case 'BooleanField':\n                    allowed = allowed || targetDecl.type.type === 'Boolean';\n                    break;\n                case 'DateTimeField':\n                    allowed = allowed || targetDecl.type.type === 'DateTime';\n                    break;\n                case 'JsonField':\n                    allowed = allowed || targetDecl.type.type === 'Json';\n                    break;\n                case 'BytesField':\n                    allowed = allowed || targetDecl.type.type === 'Bytes';\n                    break;\n                case 'ModelField':\n                    allowed = allowed || isDataModel(targetDecl.type.reference?.ref);\n                    break;\n                default:\n                    break;\n            }\n            if (allowed) {\n                break;\n            }\n        }\n\n        return allowed;\n    }\n\n    private parseRelation(field: DataModelField, accept?: ValidationAcceptor) {\n        const relAttr = field.attributes.find((attr) => attr.decl.ref?.name === '@relation');\n\n        let name: string | undefined;\n        let fields: ReferenceExpr[] | undefined;\n        let references: ReferenceExpr[] | undefined;\n        let valid = true;\n\n        if (!relAttr) {\n            return { attr: relAttr, name, fields, references, valid: true };\n        }\n\n        for (const arg of relAttr.args) {\n            if (!arg.name || arg.name === 'name') {\n                if (isLiteralExpr(arg.value)) {\n                    name = arg.value.value as string;\n                }\n            } else if (arg.name === 'fields') {\n                fields = (arg.value as ArrayExpr).items as ReferenceExpr[];\n                if (fields.length === 0) {\n                    if (accept) {\n                        accept('error', `\"fields\" value cannot be emtpy`, {\n                            node: arg,\n                        });\n                    }\n                    valid = false;\n                }\n            } else if (arg.name === 'references') {\n                references = (arg.value as ArrayExpr).items as ReferenceExpr[];\n                if (references.length === 0) {\n                    if (accept) {\n                        accept('error', `\"references\" value cannot be emtpy`, {\n                            node: arg,\n                        });\n                    }\n                    valid = false;\n                }\n            }\n        }\n\n        if (!fields || !references) {\n            if (accept) {\n                accept('error', `Both \"fields\" and \"references\" must be provided`, { node: relAttr });\n            }\n        } else {\n            // validate \"fields\" and \"references\" typing consistency\n            if (fields.length !== references.length) {\n                if (accept) {\n                    accept('error', `\"references\" and \"fields\" must have the same length`, { node: relAttr });\n                }\n            } else {\n                for (let i = 0; i < fields.length; i++) {\n                    if (!fields[i].$resolvedType) {\n                        if (accept) {\n                            accept('error', `field reference is unresolved`, { node: fields[i] });\n                        }\n                    }\n                    if (!references[i].$resolvedType) {\n                        if (accept) {\n                            accept('error', `field reference is unresolved`, { node: references[i] });\n                        }\n                    }\n\n                    if (\n                        fields[i].$resolvedType?.decl !== references[i].$resolvedType?.decl ||\n                        fields[i].$resolvedType?.array !== references[i].$resolvedType?.array\n                    ) {\n                        if (accept) {\n                            accept('error', `values of \"references\" and \"fields\" must have the same type`, {\n                                node: relAttr,\n                            });\n                        }\n                    }\n                }\n            }\n        }\n\n        return { attr: relAttr, name, fields, references, valid };\n    }\n\n    private validateRelationField(field: DataModelField, accept: ValidationAcceptor) {\n        const thisRelation = this.parseRelation(field, accept);\n        if (!thisRelation.valid) {\n            return;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        const oppositeModel = field.type.reference!.ref! as DataModel;\n\n        let oppositeFields = oppositeModel.fields.filter((f) => f.type.reference?.ref === field.$container);\n        oppositeFields = oppositeFields.filter((f) => {\n            const fieldRel = this.parseRelation(f);\n            return fieldRel.valid && fieldRel.name === thisRelation.name;\n        });\n\n        if (oppositeFields.length === 0) {\n            accept(\n                'error',\n                `The relation field \"${field.name}\" on model \"${field.$container.name}\" is missing an opposite relation field on model \"${oppositeModel.name}\"`,\n                { node: field }\n            );\n            return;\n        } else if (oppositeFields.length > 1) {\n            oppositeFields.forEach((f) =>\n                accept(\n                    'error',\n                    `Fields ${oppositeFields.map((f) => '\"' + f.name + '\"').join(', ')} on model \"${\n                        oppositeModel.name\n                    }\" refer to the same relation to model \"${field.$container.name}\"`,\n                    { node: f }\n                )\n            );\n            return;\n        }\n\n        const oppositeField = oppositeFields[0];\n        const oppositeRelation = this.parseRelation(oppositeField);\n\n        let relationOwner: DataModelField;\n\n        if (thisRelation?.references?.length && thisRelation.fields?.length) {\n            if (oppositeRelation?.references || oppositeRelation?.fields) {\n                accept('error', '\"fields\" and \"references\" must be provided only on one side of relation field', {\n                    node: oppositeField,\n                });\n                return;\n            } else {\n                relationOwner = oppositeField;\n            }\n        } else if (oppositeRelation?.references?.length && oppositeRelation.fields?.length) {\n            if (thisRelation?.references || thisRelation?.fields) {\n                accept('error', '\"fields\" and \"references\" must be provided only on one side of relation field', {\n                    node: field,\n                });\n                return;\n            } else {\n                relationOwner = field;\n            }\n        } else {\n            [field, oppositeField].forEach((f) =>\n                accept(\n                    'error',\n                    'Field for one side of relation must carry @relation attribute with both \"fields\" and \"references\" fields',\n                    { node: f }\n                )\n            );\n            return;\n        }\n\n        if (!relationOwner.type.array && !relationOwner.type.optional) {\n            accept('error', 'Relation field needs to be list or optional', {\n                node: relationOwner,\n            });\n            return;\n        }\n\n        if (relationOwner !== field && !relationOwner.type.array) {\n            // one-to-one relation requires defining side's reference field to be @unique\n            // e.g.:\n            //     model User {\n            //         id String @id @default(cuid())\n            //         data UserData?\n            //     }\n            //     model UserData {\n            //         id String @id @default(cuid())\n            //         user User  @relation(fields: [userId], references: [id])\n            //         userId String\n            //     }\n            //\n            // UserData.userId field needs to be @unique\n\n            thisRelation.fields?.forEach((ref) => {\n                const refField = ref.target.ref as DataModelField;\n                if (refField && !refField.attributes.find((a) => a.decl.ref?.name === '@unique')) {\n                    accept(\n                        'error',\n                        `Field \"${refField.name}\" is part of a one-to-one relation and must be marked as @unique`,\n                        { node: refField }\n                    );\n                }\n            });\n        }\n    }\n}\n"],"mappings":"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"}

package/language-server/validator/datasource-validator.d.ts

@@ -0,0 +1,13 @@
+import { DataSource } from '@zenstackhq/language/ast';
+import { AstValidator } from '../types';
+import { ValidationAcceptor } from 'langium';
+/**
+ * Validates data source declarations.
+ */
+export default class DataSourceValidator implements AstValidator<DataSource> {
+    validate(ds: DataSource, accept: ValidationAcceptor): void;
+    private validateFields;
+    private validateProvider;
+    private validateUrl;
+    private validateRelationMode;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ast = require("@zenstackhq/language/ast");
+var _utils = require("./utils");
+var _constants = require("../constants");
+const supportedFields = ['provider', 'url', 'shadowDatabaseUrl', 'relationMode'];
+
+/**
+ * Validates data source declarations.
+ */
+class DataSourceValidator {
+  validate(ds, accept) {
+    (0, _utils.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.getStringLiteral)(provider.value);
+    if (!value) {
+      accept('error', '"provider" must be set to a string literal', {
+        node: provider.value
+      });
+    } else if (!_constants.SUPPORTED_PROVIDERS.includes(value)) {
+      accept('error', `Provider "${value}" is not supported. Choose from ${_constants.SUPPORTED_PROVIDERS.map(p => '"' + p + '"').join(' | ')}.`, {
+        node: provider.value
+      });
+    }
+  }
+  validateUrl(ds, accept) {
+    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']) {
+      var _field$value$function;
+      const field = ds.fields.find(f => f.name === fieldName);
+      if (!field) {
+        continue;
+      }
+      const value = (0, _utils.getStringLiteral)(field.value);
+      if (!value && !((0, _ast.isInvocationExpr)(field.value) && ((_field$value$function = field.value.function.ref) === null || _field$value$function === void 0 ? void 0 : _field$value$function.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.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