zenstack 1.0.0-alpha.23 → 1.0.0-alpha.24

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

@@ -1,375 +1,321 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _ast = require("@zenstackhq/language/ast");
-var _pluralize = _interopRequireDefault(require("pluralize"));
-var _astUtils = require("../../utils/ast-utils");
-var _constants = require("../constants");
-var _utils = require("./utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_1 = require("@zenstackhq/language/ast");
+const pluralize_1 = __importDefault(require("pluralize"));
+const ast_utils_1 = require("../../utils/ast-utils");
+const constants_1 = require("../constants");
+const utils_1 = require("./utils");
 /**
  * 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) {
-      const {
-        allows,
-        denies,
-        hasFieldValidation
-      } = (0, _astUtils.analyzePolicies)(dm);
-      if (allows.length > 0 || denies.length > 0 || hasFieldValidation) {
-        // TODO: relax this requirement to require only @unique fields
-        // when access policies or field valdaition is used, require an @id field
-        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
-      });
+    validate(dm, accept) {
+        (0, utils_1.validateDuplicatedDeclarations)(dm.fields, accept);
+        this.validateFields(dm, accept);
+        this.validateAttributes(dm, accept);
     }
-    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;
+    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) {
+            const { allows, denies, hasFieldValidation } = (0, ast_utils_1.analyzePolicies)(dm);
+            if (allows.length > 0 || denies.length > 0 || hasFieldValidation) {
+                // TODO: relax this requirement to require only @unique fields
+                // when access policies or field valdaition is used, require an @id field
+                accept('error', 'Model must include a field with @id attribute', {
+                    node: dm,
+                });
+            }
         }
-      } 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;
+        else if (idFields.length > 1) {
+            accept('error', 'Model can include at most one field with @id attribute', {
+                node: dm,
+            });
         }
-      }
-      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;
+        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));
     }
-    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;
-      }
+    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);
+        }
     }
-    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
-      };
+    validateAttributes(dm, accept) {
+        dm.attributes.forEach((attr) => {
+            this.validateAttributeApplication(attr, accept);
+        });
     }
-    for (const arg of relAttr.args) {
-      if (!arg.name || arg.name === 'name') {
-        if ((0, _ast.isLiteralExpr)(arg.value)) {
-          name = arg.value.value;
+    validateAttributeApplication(attr, accept) {
+        const decl = attr.decl.ref;
+        if (!decl) {
+            return;
         }
-      } 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;
+        const targetDecl = attr.$container;
+        if (decl.name === '@@@targetField' && !(0, ast_1.isAttribute)(targetDecl)) {
+            accept('error', `attribute "${decl.name}" can only be used on attribute declarations`, { node: attr });
+            return;
         }
-      } 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 ((0, ast_1.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_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);
+            arg.$resolvedParam = 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;
     }
-    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
-          });
+    isValidAttributeTarget(attrDecl, targetDecl) {
+        var _a;
+        const targetField = attrDecl.attributes.find((attr) => { var _a; return ((_a = attr.decl.ref) === null || _a === void 0 ? void 0 : _a.name) === '@@@targetField'; });
+        if (!targetField) {
+            // no field type constraint
+            return true;
         }
-      } 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]
-              });
+        const fieldTypes = targetField.args[0].value.items.map((item) => { var _a; return (_a = item.target.ref) === null || _a === void 0 ? void 0 : _a.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_1.isDataModel)((_a = targetDecl.type.reference) === null || _a === void 0 ? void 0 : _a.ref);
+                    break;
+                default:
+                    break;
             }
-          }
-          if (!references[i].$resolvedType) {
-            if (accept) {
-              accept('error', `field reference is unresolved`, {
-                node: references[i]
-              });
+            if (allowed) {
+                break;
+            }
+        }
+        return allowed;
+    }
+    parseRelation(field, accept) {
+        var _a, _b, _c, _d;
+        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;
+                }
             }
-          }
-          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)) {
+            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', `values of "references" and "fields" must have the same type`, {
-                node: relAttr
-              });
+                accept('error', `Both "fields" and "references" must be provided`, { 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;
+        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++) {
+                    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 (((_a = fields[i].$resolvedType) === null || _a === void 0 ? void 0 : _a.decl) !== ((_b = references[i].$resolvedType) === null || _b === void 0 ? void 0 : _b.decl) ||
+                        ((_c = fields[i].$resolvedType) === null || _c === void 0 ? void 0 : _c.array) !== ((_d = references[i].$resolvedType) === null || _d === void 0 ? void 0 : _d.array)) {
+                        if (accept) {
+                            accept('error', `values of "references" and "fields" must have the same type`, {
+                                node: relAttr,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return { attr: relAttr, name, fields, references, valid };
     }
-    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
+    validateRelationField(field, accept) {
+        var _a, _b, _c, _d, _e;
+        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 _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;
         });
-        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
-          });
+        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;
+        }
+        if (relationOwner !== field && !relationOwner.type.array) {
+            // 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
+            (_e = thisRelation.fields) === null || _e === void 0 ? void 0 : _e.forEach((ref) => {
+                const refField = ref.target.ref;
+                if (refField && !refField.attributes.find((a) => { var _a; return ((_a = a.decl.ref) === null || _a === void 0 ? void 0 : _a.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