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

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

@@ -0,0 +1 @@
+{"version":3,"file":"datasource-validator.js","names":["supportedFields","DataSourceValidator","validate","ds","accept","validateDuplicatedDeclarations","fields","validateFields","validateProvider","validateUrl","validateRelationMode","forEach","f","includes","name","node","provider","find","value","getStringLiteral","SUPPORTED_PROVIDERS","map","p","join","url","fieldName","field","isInvocationExpr","function","ref","val"],"sources":["../../../src/language-server/validator/datasource-validator.ts"],"sourcesContent":["import { DataSource, isInvocationExpr } from '@zenstackhq/language/ast';\nimport { AstValidator } from '../types';\nimport { ValidationAcceptor } from 'langium';\nimport { getStringLiteral, validateDuplicatedDeclarations } from './utils';\nimport { SUPPORTED_PROVIDERS } from '../constants';\n\nconst supportedFields = ['provider', 'url', 'shadowDatabaseUrl', 'relationMode'];\n\n/**\n * Validates data source declarations.\n */\nexport default class DataSourceValidator implements AstValidator<DataSource> {\n    validate(ds: DataSource, accept: ValidationAcceptor): void {\n        validateDuplicatedDeclarations(ds.fields, accept);\n        this.validateFields(ds, accept);\n        this.validateProvider(ds, accept);\n        this.validateUrl(ds, accept);\n        this.validateRelationMode(ds, accept);\n    }\n\n    private validateFields(ds: DataSource, accept: ValidationAcceptor) {\n        ds.fields.forEach((f) => {\n            if (!supportedFields.includes(f.name)) {\n                accept('error', `Unexpected field \"${f.name}\"`, { node: f });\n            }\n        });\n    }\n\n    private validateProvider(ds: DataSource, accept: ValidationAcceptor) {\n        const provider = ds.fields.find((f) => f.name === 'provider');\n        if (!provider) {\n            accept('error', 'datasource must include a \"provider\" field', {\n                node: ds,\n            });\n            return;\n        }\n\n        const value = getStringLiteral(provider.value);\n        if (!value) {\n            accept('error', '\"provider\" must be set to a string literal', {\n                node: provider.value,\n            });\n        } else if (!SUPPORTED_PROVIDERS.includes(value)) {\n            accept(\n                'error',\n                `Provider \"${value}\" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '\"' + p + '\"').join(\n                    ' | '\n                )}.`,\n                { node: provider.value }\n            );\n        }\n    }\n\n    private validateUrl(ds: DataSource, accept: ValidationAcceptor) {\n        const url = ds.fields.find((f) => f.name === 'url');\n        if (!url) {\n            accept('error', 'datasource must include a \"url\" field', {\n                node: ds,\n            });\n        }\n\n        for (const fieldName of ['url', 'shadowDatabaseUrl']) {\n            const field = ds.fields.find((f) => f.name === fieldName);\n            if (!field) {\n                continue;\n            }\n            const value = getStringLiteral(field.value);\n            if (!value && !(isInvocationExpr(field.value) && field.value.function.ref?.name === 'env')) {\n                accept('error', `\"${fieldName}\" must be set to a string literal or an invocation of \"env\" function`, {\n                    node: field.value,\n                });\n            }\n        }\n    }\n\n    private validateRelationMode(ds: DataSource, accept: ValidationAcceptor) {\n        const field = ds.fields.find((f) => f.name === 'relationMode');\n        if (field) {\n            const val = getStringLiteral(field.value);\n            if (!val || !['foreignKeys', 'prisma'].includes(val)) {\n                accept('error', '\"relationMode\" must be set to \"foreignKeys\" or \"prisma\"', { node: field.value });\n            }\n        }\n    }\n}\n"],"mappings":"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"}

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+/**
+ * Validates enum declarations.
+ */
+class EnumValidator {
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  validate(_enum, accept) {
+    (0, _utils.validateDuplicatedDeclarations)(_enum.fields, accept);
+  }
+}
+exports.default = EnumValidator;
+//# sourceMappingURL=enum-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enum-validator.js","names":["EnumValidator","validate","_enum","accept","validateDuplicatedDeclarations","fields"],"sources":["../../../src/language-server/validator/enum-validator.ts"],"sourcesContent":["import { Enum } from '@zenstackhq/language/ast';\nimport { AstValidator } from '../types';\nimport { ValidationAcceptor } from 'langium';\nimport { validateDuplicatedDeclarations } from './utils';\n\n/**\n * Validates enum declarations.\n */\nexport default class EnumValidator implements AstValidator<Enum> {\n    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n    validate(_enum: Enum, accept: ValidationAcceptor) {\n        validateDuplicatedDeclarations(_enum.fields, accept);\n    }\n}\n"],"mappings":";;;;;;AAGA;AAEA;AACA;AACA;AACe,MAAMA,aAAa,CAA+B;EAC7D;EACAC,QAAQ,CAACC,KAAW,EAAEC,MAA0B,EAAE;IAC9C,IAAAC,qCAA8B,EAACF,KAAK,CAACG,MAAM,EAAEF,MAAM,CAAC;EACxD;AACJ;AAAC"}

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

@@ -0,0 +1,11 @@
+import { Expression } from '@zenstackhq/language/ast';
+import { AstValidator } from '../types';
+import { ValidationAcceptor } from 'langium';
+/**
+ * Validates expressions.
+ */
+export default class ExpressionValidator implements AstValidator<Expression> {
+    validate(expr: Expression, accept: ValidationAcceptor): void;
+    private isCollectionPredicate;
+    private isAuthInvocation;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ast = require("@zenstackhq/language/ast");
+var _utils = require("../utils");
+/**
+ * Validates expressions.
+ */
+class ExpressionValidator {
+  validate(expr, accept) {
+    if (!expr.$resolvedType) {
+      if (this.isAuthInvocation(expr)) {
+        // check was done at link time
+        accept('error', 'auth() cannot be resolved because no "User" model is defined', {
+          node: expr
+        });
+      } else if (this.isCollectionPredicate(expr)) {
+        accept('error', 'collection predicate can only be used on an array of model type', {
+          node: expr
+        });
+      } else {
+        accept('error', 'expression cannot be resolved', {
+          node: expr
+        });
+      }
+    }
+  }
+  isCollectionPredicate(expr) {
+    return (0, _ast.isBinaryExpr)(expr) && ['?', '!', '^'].includes(expr.operator);
+  }
+  isAuthInvocation(expr) {
+    var _expr$function$ref;
+    return (0, _ast.isInvocationExpr)(expr) && ((_expr$function$ref = expr.function.ref) === null || _expr$function$ref === void 0 ? void 0 : _expr$function$ref.name) === 'auth' && (0, _utils.isFromStdlib)(expr.function.ref);
+  }
+}
+exports.default = ExpressionValidator;
+//# sourceMappingURL=expression-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression-validator.js","names":["ExpressionValidator","validate","expr","accept","$resolvedType","isAuthInvocation","node","isCollectionPredicate","isBinaryExpr","includes","operator","isInvocationExpr","function","ref","name","isFromStdlib"],"sources":["../../../src/language-server/validator/expression-validator.ts"],"sourcesContent":["import { Expression, isBinaryExpr, isInvocationExpr } from '@zenstackhq/language/ast';\nimport { AstValidator } from '../types';\nimport { isFromStdlib } from '../utils';\nimport { ValidationAcceptor } from 'langium';\n\n/**\n * Validates expressions.\n */\nexport default class ExpressionValidator implements AstValidator<Expression> {\n    validate(expr: Expression, accept: ValidationAcceptor): void {\n        if (!expr.$resolvedType) {\n            if (this.isAuthInvocation(expr)) {\n                // check was done at link time\n                accept('error', 'auth() cannot be resolved because no \"User\" model is defined', { node: expr });\n            } else if (this.isCollectionPredicate(expr)) {\n                accept('error', 'collection predicate can only be used on an array of model type', { node: expr });\n            } else {\n                accept('error', 'expression cannot be resolved', {\n                    node: expr,\n                });\n            }\n        }\n    }\n\n    private isCollectionPredicate(expr: Expression) {\n        return isBinaryExpr(expr) && ['?', '!', '^'].includes(expr.operator);\n    }\n\n    private isAuthInvocation(expr: Expression) {\n        return isInvocationExpr(expr) && expr.function.ref?.name === 'auth' && isFromStdlib(expr.function.ref);\n    }\n}\n"],"mappings":";;;;;;AAAA;AAEA;AAGA;AACA;AACA;AACe,MAAMA,mBAAmB,CAAqC;EACzEC,QAAQ,CAACC,IAAgB,EAAEC,MAA0B,EAAQ;IACzD,IAAI,CAACD,IAAI,CAACE,aAAa,EAAE;MACrB,IAAI,IAAI,CAACC,gBAAgB,CAACH,IAAI,CAAC,EAAE;QAC7B;QACAC,MAAM,CAAC,OAAO,EAAE,8DAA8D,EAAE;UAAEG,IAAI,EAAEJ;QAAK,CAAC,CAAC;MACnG,CAAC,MAAM,IAAI,IAAI,CAACK,qBAAqB,CAACL,IAAI,CAAC,EAAE;QACzCC,MAAM,CAAC,OAAO,EAAE,iEAAiE,EAAE;UAAEG,IAAI,EAAEJ;QAAK,CAAC,CAAC;MACtG,CAAC,MAAM;QACHC,MAAM,CAAC,OAAO,EAAE,+BAA+B,EAAE;UAC7CG,IAAI,EAAEJ;QACV,CAAC,CAAC;MACN;IACJ;EACJ;EAEQK,qBAAqB,CAACL,IAAgB,EAAE;IAC5C,OAAO,IAAAM,iBAAY,EAACN,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAACO,QAAQ,CAACP,IAAI,CAACQ,QAAQ,CAAC;EACxE;EAEQL,gBAAgB,CAACH,IAAgB,EAAE;IAAA;IACvC,OAAO,IAAAS,qBAAgB,EAACT,IAAI,CAAC,IAAI,uBAAAA,IAAI,CAACU,QAAQ,CAACC,GAAG,uDAAjB,mBAAmBC,IAAI,MAAK,MAAM,IAAI,IAAAC,mBAAY,EAACb,IAAI,CAACU,QAAQ,CAACC,GAAG,CAAC;EAC1G;AACJ;AAAC"}

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

@@ -0,0 +1,10 @@
+import { Model } from '@zenstackhq/language/ast';
+import { AstValidator } from '../types';
+import { ValidationAcceptor } from 'langium';
+/**
+ * Validates toplevel schema.
+ */
+export default class SchemaValidator implements AstValidator<Model> {
+    validate(model: Model, accept: ValidationAcceptor): void;
+    private validateDataSources;
+}

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

@@ -0,0 +1,35 @@
+"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");
+/**
+ * Validates toplevel schema.
+ */
+class SchemaValidator {
+  validate(model, accept) {
+    var _model$$document;
+    (0, _utils.validateDuplicatedDeclarations)(model.declarations, accept);
+    if (!((_model$$document = model.$document) !== null && _model$$document !== void 0 && _model$$document.uri.path.endsWith(_constants.STD_LIB_MODULE_NAME))) {
+      this.validateDataSources(model, accept);
+    }
+  }
+  validateDataSources(model, accept) {
+    const dataSources = model.declarations.filter(d => (0, _ast.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/language-server/validator/schema-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validator.js","names":["SchemaValidator","validate","model","accept","validateDuplicatedDeclarations","declarations","$document","uri","path","endsWith","STD_LIB_MODULE_NAME","validateDataSources","dataSources","filter","d","isDataSource","length","node"],"sources":["../../../src/language-server/validator/schema-validator.ts"],"sourcesContent":["import { STD_LIB_MODULE_NAME } from '../constants';\nimport { isDataSource, Model } from '@zenstackhq/language/ast';\nimport { AstValidator } from '../types';\nimport { ValidationAcceptor } from 'langium';\nimport { validateDuplicatedDeclarations } from './utils';\n\n/**\n * Validates toplevel schema.\n */\nexport default class SchemaValidator implements AstValidator<Model> {\n    validate(model: Model, accept: ValidationAcceptor): void {\n        validateDuplicatedDeclarations(model.declarations, accept);\n\n        if (!model.$document?.uri.path.endsWith(STD_LIB_MODULE_NAME)) {\n            this.validateDataSources(model, accept);\n        }\n    }\n\n    private validateDataSources(model: Model, accept: ValidationAcceptor) {\n        const dataSources = model.declarations.filter((d) => isDataSource(d));\n        if (dataSources.length === 0) {\n            accept('error', 'Model must define a datasource', { node: model });\n        } else if (dataSources.length > 1) {\n            accept('error', 'Multiple datasource declarations are not allowed', { node: dataSources[1] });\n        }\n    }\n}\n"],"mappings":";;;;;;AAAA;AACA;AAGA;AAEA;AACA;AACA;AACe,MAAMA,eAAe,CAAgC;EAChEC,QAAQ,CAACC,KAAY,EAAEC,MAA0B,EAAQ;IAAA;IACrD,IAAAC,qCAA8B,EAACF,KAAK,CAACG,YAAY,EAAEF,MAAM,CAAC;IAE1D,IAAI,sBAACD,KAAK,CAACI,SAAS,6CAAf,iBAAiBC,GAAG,CAACC,IAAI,CAACC,QAAQ,CAACC,8BAAmB,CAAC,GAAE;MAC1D,IAAI,CAACC,mBAAmB,CAACT,KAAK,EAAEC,MAAM,CAAC;IAC3C;EACJ;EAEQQ,mBAAmB,CAACT,KAAY,EAAEC,MAA0B,EAAE;IAClE,MAAMS,WAAW,GAAGV,KAAK,CAACG,YAAY,CAACQ,MAAM,CAAEC,CAAC,IAAK,IAAAC,iBAAY,EAACD,CAAC,CAAC,CAAC;IACrE,IAAIF,WAAW,CAACI,MAAM,KAAK,CAAC,EAAE;MAC1Bb,MAAM,CAAC,OAAO,EAAE,gCAAgC,EAAE;QAAEc,IAAI,EAAEf;MAAM,CAAC,CAAC;IACtE,CAAC,MAAM,IAAIU,WAAW,CAACI,MAAM,GAAG,CAAC,EAAE;MAC/Bb,MAAM,CAAC,OAAO,EAAE,kDAAkD,EAAE;QAAEc,IAAI,EAAEL,WAAW,CAAC,CAAC;MAAE,CAAC,CAAC;IACjG;EACJ;AACJ;AAAC"}

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

@@ -0,0 +1,24 @@
+import { AttributeArg, AttributeParam, BuiltinType, DataModelAttribute, DataModelFieldAttribute, ExpressionType } from '@zenstackhq/language/ast';
+import { AstNode, ValidationAcceptor } from 'langium';
+/**
+ * Checks if the given declarations have duplicated names
+ */
+export declare function validateDuplicatedDeclarations(decls: Array<AstNode & {
+    name: string;
+}>, accept: ValidationAcceptor): void;
+/**
+ * Try getting string value from a potential string literal expression
+ */
+export declare function getStringLiteral(node: AstNode | undefined): string | undefined;
+/**
+ * Determines if the given sourceType is assignable to a destination of destType
+ */
+export declare function typeAssignable(destType: ExpressionType, sourceType: ExpressionType): boolean;
+/**
+ * Maps a ZModel builtin type to expression type
+ */
+export declare function mapBuiltinTypeToExpressionType(type: BuiltinType | 'Any' | 'Null'): ExpressionType | 'Any';
+/**
+ * Determines if the given attribute argument is assignable to the given attribute parameter
+ */
+export declare function assignableToAttributeParam(arg: AttributeArg, param: AttributeParam, attr: DataModelAttribute | DataModelFieldAttribute): boolean;

package/language-server/validator/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignableToAttributeParam = assignableToAttributeParam;
+exports.getStringLiteral = getStringLiteral;
+exports.mapBuiltinTypeToExpressionType = mapBuiltinTypeToExpressionType;
+exports.typeAssignable = typeAssignable;
+exports.validateDuplicatedDeclarations = validateDuplicatedDeclarations;
+var _ast = require("@zenstackhq/language/ast");
+/**
+ * Checks if the given declarations have duplicated names
+ */
+function validateDuplicatedDeclarations(decls, accept) {
+  const groupByName = decls.reduce((group, decl) => {
+    group[decl.name] = group[decl.name] ?? [];
+    group[decl.name].push(decl);
+    return group;
+  }, {});
+  for (const [name, decls] of Object.entries(groupByName)) {
+    if (decls.length > 1) {
+      accept('error', `Duplicated declaration name "${name}"`, {
+        node: decls[1]
+      });
+    }
+  }
+}
+
+/**
+ * Try getting string value from a potential string literal expression
+ */
+function getStringLiteral(node) {
+  if ((0, _ast.isLiteralExpr)(node) && typeof node.value === 'string') {
+    return node.value;
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Determines if the given sourceType is assignable to a destination of destType
+ */
+function typeAssignable(destType, sourceType) {
+  switch (destType) {
+    case 'Any':
+      return true;
+    case 'Float':
+      return sourceType === 'Any' || sourceType === 'Int' || sourceType === 'Float';
+    default:
+      return sourceType === 'Any' || sourceType === destType;
+  }
+}
+
+/**
+ * Maps a ZModel builtin type to expression type
+ */
+function mapBuiltinTypeToExpressionType(type) {
+  switch (type) {
+    case 'Any':
+    case 'Boolean':
+    case 'String':
+    case 'DateTime':
+    case 'Int':
+    case 'Float':
+    case 'Null':
+      return type;
+    case 'BigInt':
+      return 'Int';
+    case 'Decimal':
+      return 'Float';
+    case 'Json':
+    case 'Bytes':
+      return 'Any';
+  }
+}
+
+/**
+ * Determines if the given attribute argument is assignable to the given attribute parameter
+ */
+function assignableToAttributeParam(arg, param, attr) {
+  const argResolvedType = arg.$resolvedType;
+  if (!argResolvedType) {
+    return false;
+  }
+  let dstType = param.type.type;
+  const dstIsArray = param.type.array;
+  const dstRef = param.type.reference;
+  if (dstType) {
+    if (typeof (argResolvedType === null || argResolvedType === void 0 ? void 0 : argResolvedType.decl) !== 'string') {
+      // destination type is not a reference, so argument type must be a plain expression
+      return false;
+    }
+    if (dstType === 'FieldReference' || dstType === 'TransitiveFieldReference') {
+      if (dstIsArray) {
+        return (0, _ast.isArrayExpr)(arg.value) && !arg.value.items.find(item => !(0, _ast.isReferenceExpr)(item) || !(0, _ast.isDataModelField)(item.target.ref));
+      } else {
+        return (0, _ast.isReferenceExpr)(arg.value) && (0, _ast.isDataModelField)(arg.value.target.ref);
+      }
+    } else if (dstType === 'ContextType') {
+      if ((0, _ast.isDataModelField)(attr.$container)) {
+        var _attr$$container, _attr$$container$type;
+        if (!((_attr$$container = attr.$container) !== null && _attr$$container !== void 0 && (_attr$$container$type = _attr$$container.type) !== null && _attr$$container$type !== void 0 && _attr$$container$type.type)) {
+          return false;
+        }
+        dstType = mapBuiltinTypeToExpressionType(attr.$container.type.type);
+      } else {
+        dstType = 'Any';
+      }
+    }
+    return typeAssignable(dstType, argResolvedType.decl) && dstIsArray === argResolvedType.array;
+  } else {
+    return (dstRef === null || dstRef === void 0 ? void 0 : dstRef.ref) === argResolvedType.decl && dstIsArray === argResolvedType.array;
+  }
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["validateDuplicatedDeclarations","decls","accept","groupByName","reduce","group","decl","name","push","Object","entries","length","node","getStringLiteral","isLiteralExpr","value","undefined","typeAssignable","destType","sourceType","mapBuiltinTypeToExpressionType","type","assignableToAttributeParam","arg","param","attr","argResolvedType","$resolvedType","dstType","dstIsArray","array","dstRef","reference","isArrayExpr","items","find","item","isReferenceExpr","isDataModelField","target","ref","$container"],"sources":["../../../src/language-server/validator/utils.ts"],"sourcesContent":["import {\n    AttributeArg,\n    AttributeParam,\n    BuiltinType,\n    DataModelAttribute,\n    DataModelFieldAttribute,\n    ExpressionType,\n    isArrayExpr,\n    isDataModelField,\n    isLiteralExpr,\n    isReferenceExpr,\n} from '@zenstackhq/language/ast';\nimport { AstNode, ValidationAcceptor } from 'langium';\n\n/**\n * Checks if the given declarations have duplicated names\n */\nexport function validateDuplicatedDeclarations(\n    decls: Array<AstNode & { name: string }>,\n    accept: ValidationAcceptor\n): void {\n    const groupByName = decls.reduce<Record<string, Array<AstNode & { name: string }>>>((group, decl) => {\n        group[decl.name] = group[decl.name] ?? [];\n        group[decl.name].push(decl);\n        return group;\n    }, {});\n\n    for (const [name, decls] of Object.entries<AstNode[]>(groupByName)) {\n        if (decls.length > 1) {\n            accept('error', `Duplicated declaration name \"${name}\"`, {\n                node: decls[1],\n            });\n        }\n    }\n}\n\n/**\n * Try getting string value from a potential string literal expression\n */\nexport function getStringLiteral(node: AstNode | undefined): string | undefined {\n    if (isLiteralExpr(node) && typeof node.value === 'string') {\n        return node.value;\n    } else {\n        return undefined;\n    }\n}\n\n/**\n * Determines if the given sourceType is assignable to a destination of destType\n */\nexport function typeAssignable(destType: ExpressionType, sourceType: ExpressionType): boolean {\n    switch (destType) {\n        case 'Any':\n            return true;\n        case 'Float':\n            return sourceType === 'Any' || sourceType === 'Int' || sourceType === 'Float';\n        default:\n            return sourceType === 'Any' || sourceType === destType;\n    }\n}\n\n/**\n * Maps a ZModel builtin type to expression type\n */\nexport function mapBuiltinTypeToExpressionType(type: BuiltinType | 'Any' | 'Null'): ExpressionType | 'Any' {\n    switch (type) {\n        case 'Any':\n        case 'Boolean':\n        case 'String':\n        case 'DateTime':\n        case 'Int':\n        case 'Float':\n        case 'Null':\n            return type;\n        case 'BigInt':\n            return 'Int';\n        case 'Decimal':\n            return 'Float';\n        case 'Json':\n        case 'Bytes':\n            return 'Any';\n    }\n}\n\n/**\n * Determines if the given attribute argument is assignable to the given attribute parameter\n */\nexport function assignableToAttributeParam(\n    arg: AttributeArg,\n    param: AttributeParam,\n    attr: DataModelAttribute | DataModelFieldAttribute\n): boolean {\n    const argResolvedType = arg.$resolvedType;\n    if (!argResolvedType) {\n        return false;\n    }\n\n    let dstType = param.type.type;\n    const dstIsArray = param.type.array;\n    const dstRef = param.type.reference;\n\n    if (dstType) {\n        if (typeof argResolvedType?.decl !== 'string') {\n            // destination type is not a reference, so argument type must be a plain expression\n            return false;\n        }\n\n        if (dstType === 'FieldReference' || dstType === 'TransitiveFieldReference') {\n            if (dstIsArray) {\n                return (\n                    isArrayExpr(arg.value) &&\n                    !arg.value.items.find((item) => !isReferenceExpr(item) || !isDataModelField(item.target.ref))\n                );\n            } else {\n                return isReferenceExpr(arg.value) && isDataModelField(arg.value.target.ref);\n            }\n        } else if (dstType === 'ContextType') {\n            if (isDataModelField(attr.$container)) {\n                if (!attr.$container?.type?.type) {\n                    return false;\n                }\n                dstType = mapBuiltinTypeToExpressionType(attr.$container.type.type);\n            } else {\n                dstType = 'Any';\n            }\n        }\n\n        return typeAssignable(dstType, argResolvedType.decl) && dstIsArray === argResolvedType.array;\n    } else {\n        return dstRef?.ref === argResolvedType.decl && dstIsArray === argResolvedType.array;\n    }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,21 @@
+import { ValidationAcceptor, ValidationRegistry } from 'langium';
+import { Attribute, DataModel, DataSource, Enum, Expression, Model } from '@zenstackhq/language/ast';
+import type { ZModelServices } from '../zmodel-module';
+/**
+ * Registry for validation checks.
+ */
+export declare class ZModelValidationRegistry extends ValidationRegistry {
+    constructor(services: ZModelServices);
+}
+/**
+ * Implementation of custom validations.
+ */
+export declare class ZModelValidator {
+    private shouldCheck;
+    checkModel(node: Model, accept: ValidationAcceptor): void;
+    checkDataSource(node: DataSource, accept: ValidationAcceptor): void;
+    checkDataModel(node: DataModel, accept: ValidationAcceptor): void;
+    checkEnum(node: Enum, accept: ValidationAcceptor): void;
+    checkAttribute(node: Attribute, accept: ValidationAcceptor): void;
+    checkExpression(node: Expression, accept: ValidationAcceptor): void;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZModelValidator = exports.ZModelValidationRegistry = void 0;
+var _langium = require("langium");
+var _schemaValidator = _interopRequireDefault(require("./schema-validator"));
+var _datasourceValidator = _interopRequireDefault(require("./datasource-validator"));
+var _datamodelValidator = _interopRequireDefault(require("./datamodel-validator"));
+var _attributeValidator = _interopRequireDefault(require("./attribute-validator"));
+var _enumValidator = _interopRequireDefault(require("./enum-validator"));
+var _expressionValidator = _interopRequireDefault(require("./expression-validator"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Registry for validation checks.
+ */
+class ZModelValidationRegistry extends _langium.ValidationRegistry {
+  constructor(services) {
+    super(services);
+    const validator = services.validation.ZModelValidator;
+    const checks = {
+      Model: validator.checkModel,
+      DataSource: validator.checkDataSource,
+      DataModel: validator.checkDataModel,
+      Enum: validator.checkEnum,
+      Attribute: validator.checkAttribute,
+      Expression: validator.checkExpression
+    };
+    this.register(checks, validator);
+  }
+}
+
+/**
+ * Implementation of custom validations.
+ */
+exports.ZModelValidationRegistry = ZModelValidationRegistry;
+class ZModelValidator {
+  shouldCheck(node) {
+    var _doc, _doc2;
+    let doc;
+    let currNode = node;
+    while (currNode) {
+      if (currNode.$document) {
+        doc = currNode.$document;
+        break;
+      }
+      currNode = currNode.$container;
+    }
+    return ((_doc = doc) === null || _doc === void 0 ? void 0 : _doc.parseResult.lexerErrors.length) === 0 && ((_doc2 = doc) === null || _doc2 === void 0 ? void 0 : _doc2.parseResult.parserErrors.length) === 0;
+  }
+  checkModel(node, accept) {
+    this.shouldCheck(node) && new _schemaValidator.default().validate(node, accept);
+  }
+  checkDataSource(node, accept) {
+    this.shouldCheck(node) && new _datasourceValidator.default().validate(node, accept);
+  }
+  checkDataModel(node, accept) {
+    this.shouldCheck(node) && new _datamodelValidator.default().validate(node, accept);
+  }
+  checkEnum(node, accept) {
+    this.shouldCheck(node) && new _enumValidator.default().validate(node, accept);
+  }
+  checkAttribute(node, accept) {
+    this.shouldCheck(node) && new _attributeValidator.default().validate(node, accept);
+  }
+  checkExpression(node, accept) {
+    new _expressionValidator.default().validate(node, accept);
+  }
+}
+exports.ZModelValidator = ZModelValidator;
+//# sourceMappingURL=zmodel-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zmodel-validator.js","names":["ZModelValidationRegistry","ValidationRegistry","constructor","services","validator","validation","ZModelValidator","checks","Model","checkModel","DataSource","checkDataSource","DataModel","checkDataModel","Enum","checkEnum","Attribute","checkAttribute","Expression","checkExpression","register","shouldCheck","node","doc","currNode","$document","$container","parseResult","lexerErrors","length","parserErrors","accept","SchemaValidator","validate","DataSourceValidator","DataModelValidator","EnumValidator","AttributeValidator","ExpressionValidator"],"sources":["../../../src/language-server/validator/zmodel-validator.ts"],"sourcesContent":["import { AstNode, LangiumDocument, ValidationAcceptor, ValidationChecks, ValidationRegistry } from 'langium';\nimport { Attribute, DataModel, DataSource, Enum, Expression, Model, ZModelAstType } from '@zenstackhq/language/ast';\nimport type { ZModelServices } from '../zmodel-module';\nimport SchemaValidator from './schema-validator';\nimport DataSourceValidator from './datasource-validator';\nimport DataModelValidator from './datamodel-validator';\nimport AttributeValidator from './attribute-validator';\nimport EnumValidator from './enum-validator';\nimport ExpressionValidator from './expression-validator';\n\n/**\n * Registry for validation checks.\n */\nexport class ZModelValidationRegistry extends ValidationRegistry {\n    constructor(services: ZModelServices) {\n        super(services);\n        const validator = services.validation.ZModelValidator;\n        const checks: ValidationChecks<ZModelAstType> = {\n            Model: validator.checkModel,\n            DataSource: validator.checkDataSource,\n            DataModel: validator.checkDataModel,\n            Enum: validator.checkEnum,\n            Attribute: validator.checkAttribute,\n            Expression: validator.checkExpression,\n        };\n        this.register(checks, validator);\n    }\n}\n\n/**\n * Implementation of custom validations.\n */\nexport class ZModelValidator {\n    private shouldCheck(node: AstNode) {\n        let doc: LangiumDocument | undefined;\n        let currNode: AstNode | undefined = node;\n        while (currNode) {\n            if (currNode.$document) {\n                doc = currNode.$document;\n                break;\n            }\n            currNode = currNode.$container;\n        }\n\n        return doc?.parseResult.lexerErrors.length === 0 && doc?.parseResult.parserErrors.length === 0;\n    }\n\n    checkModel(node: Model, accept: ValidationAcceptor): void {\n        this.shouldCheck(node) && new SchemaValidator().validate(node, accept);\n    }\n\n    checkDataSource(node: DataSource, accept: ValidationAcceptor): void {\n        this.shouldCheck(node) && new DataSourceValidator().validate(node, accept);\n    }\n\n    checkDataModel(node: DataModel, accept: ValidationAcceptor): void {\n        this.shouldCheck(node) && new DataModelValidator().validate(node, accept);\n    }\n\n    checkEnum(node: Enum, accept: ValidationAcceptor): void {\n        this.shouldCheck(node) && new EnumValidator().validate(node, accept);\n    }\n\n    checkAttribute(node: Attribute, accept: ValidationAcceptor): void {\n        this.shouldCheck(node) && new AttributeValidator().validate(node, accept);\n    }\n\n    checkExpression(node: Expression, accept: ValidationAcceptor): void {\n        new ExpressionValidator().validate(node, accept);\n    }\n}\n"],"mappings":";;;;;;AAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AAAyD;AAEzD;AACA;AACA;AACO,MAAMA,wBAAwB,SAASC,2BAAkB,CAAC;EAC7DC,WAAW,CAACC,QAAwB,EAAE;IAClC,KAAK,CAACA,QAAQ,CAAC;IACf,MAAMC,SAAS,GAAGD,QAAQ,CAACE,UAAU,CAACC,eAAe;IACrD,MAAMC,MAAuC,GAAG;MAC5CC,KAAK,EAAEJ,SAAS,CAACK,UAAU;MAC3BC,UAAU,EAAEN,SAAS,CAACO,eAAe;MACrCC,SAAS,EAAER,SAAS,CAACS,cAAc;MACnCC,IAAI,EAAEV,SAAS,CAACW,SAAS;MACzBC,SAAS,EAAEZ,SAAS,CAACa,cAAc;MACnCC,UAAU,EAAEd,SAAS,CAACe;IAC1B,CAAC;IACD,IAAI,CAACC,QAAQ,CAACb,MAAM,EAAEH,SAAS,CAAC;EACpC;AACJ;;AAEA;AACA;AACA;AAFA;AAGO,MAAME,eAAe,CAAC;EACjBe,WAAW,CAACC,IAAa,EAAE;IAAA;IAC/B,IAAIC,GAAgC;IACpC,IAAIC,QAA6B,GAAGF,IAAI;IACxC,OAAOE,QAAQ,EAAE;MACb,IAAIA,QAAQ,CAACC,SAAS,EAAE;QACpBF,GAAG,GAAGC,QAAQ,CAACC,SAAS;QACxB;MACJ;MACAD,QAAQ,GAAGA,QAAQ,CAACE,UAAU;IAClC;IAEA,OAAO,SAAAH,GAAG,yCAAH,KAAKI,WAAW,CAACC,WAAW,CAACC,MAAM,MAAK,CAAC,IAAI,UAAAN,GAAG,0CAAH,MAAKI,WAAW,CAACG,YAAY,CAACD,MAAM,MAAK,CAAC;EAClG;EAEApB,UAAU,CAACa,IAAW,EAAES,MAA0B,EAAQ;IACtD,IAAI,CAACV,WAAW,CAACC,IAAI,CAAC,IAAI,IAAIU,wBAAe,EAAE,CAACC,QAAQ,CAACX,IAAI,EAAES,MAAM,CAAC;EAC1E;EAEApB,eAAe,CAACW,IAAgB,EAAES,MAA0B,EAAQ;IAChE,IAAI,CAACV,WAAW,CAACC,IAAI,CAAC,IAAI,IAAIY,4BAAmB,EAAE,CAACD,QAAQ,CAACX,IAAI,EAAES,MAAM,CAAC;EAC9E;EAEAlB,cAAc,CAACS,IAAe,EAAES,MAA0B,EAAQ;IAC9D,IAAI,CAACV,WAAW,CAACC,IAAI,CAAC,IAAI,IAAIa,2BAAkB,EAAE,CAACF,QAAQ,CAACX,IAAI,EAAES,MAAM,CAAC;EAC7E;EAEAhB,SAAS,CAACO,IAAU,EAAES,MAA0B,EAAQ;IACpD,IAAI,CAACV,WAAW,CAACC,IAAI,CAAC,IAAI,IAAIc,sBAAa,EAAE,CAACH,QAAQ,CAACX,IAAI,EAAES,MAAM,CAAC;EACxE;EAEAd,cAAc,CAACK,IAAe,EAAES,MAA0B,EAAQ;IAC9D,IAAI,CAACV,WAAW,CAACC,IAAI,CAAC,IAAI,IAAIe,2BAAkB,EAAE,CAACJ,QAAQ,CAACX,IAAI,EAAES,MAAM,CAAC;EAC7E;EAEAZ,eAAe,CAACG,IAAgB,EAAES,MAA0B,EAAQ;IAChE,IAAIO,4BAAmB,EAAE,CAACL,QAAQ,CAACX,IAAI,EAAES,MAAM,CAAC;EACpD;AACJ;AAAC"}

package/language-server/zmodel-linker.d.ts

@@ -0,0 +1,29 @@
+import { DefaultLinker, LangiumDocument, LangiumServices } from 'langium';
+import { CancellationToken } from 'vscode-jsonrpc';
+/**
+ * Langium linker implementation which links references and resolves expression types
+ */
+export declare class ZModelLinker extends DefaultLinker {
+    private readonly descriptions;
+    constructor(services: LangiumServices);
+    link(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    private linkReference;
+    private resolveFromScopeProviders;
+    private resolve;
+    private resolveBinary;
+    private resolveUnary;
+    private resolveReference;
+    private resolveArray;
+    private resolveInvocation;
+    private getContainingDataModel;
+    private resolveLiteral;
+    private resolveMemberAccess;
+    private resolveCollectionPredicate;
+    private resolveThis;
+    private resolveNull;
+    private resolveAttributeArg;
+    private findAttrParamForArg;
+    private resolveDefault;
+    private resolveToDeclaredType;
+    private resolveToBuiltinTypeOrDecl;
+}