zenstackhq · Azzerty23 · Jul 20, 2025 · Jul 21, 2025 · Jul 23, 2025 · Jul 23, 2025
diff --git a/packages/language/src/generated/ast.ts b/packages/language/src/generated/ast.ts
diff --git a/packages/language/src/generated/grammar.ts b/packages/language/src/generated/grammar.ts
diff --git a/packages/language/src/zmodel.langium b/packages/language/src/zmodel.langium
@@ -11,7 +11,7 @@ ModelImport:
     'import' path=STRING  ';'?;
 
 AbstractDeclaration:
-    DataSource | GeneratorDecl| Plugin | DataModel | TypeDef | Enum | FunctionDecl | Attribute;
+    DataSource | GeneratorDecl | Plugin | DataModel | TypeDef | Enum | FunctionDecl | AliasDecl | Attribute;
 
 // datasource
 DataSource:
@@ -91,8 +91,10 @@ ObjectExpr:
 FieldInitializer:
     name=(RegularID | STRING) ':' value=(Expression);
 
+type AbstractCallable = FunctionDecl | AliasDecl;
+
 InvocationExpr:
-    function=[FunctionDecl] '(' ArgumentList? ')';
+    function=[AbstractCallable] '(' ArgumentList? ')';
 
 type MemberAccessTarget = DataModelField | TypeDefField;
 
@@ -215,6 +217,11 @@ EnumField:
     (comments+=TRIPLE_SLASH_COMMENT)*
     name=RegularIDWithTypeNames (attributes+=DataModelFieldAttribute)*;
 
+// alias
+AliasDecl:
+    TRIPLE_SLASH_COMMENT* 'alias' name=RegularID '(' (params+=FunctionParam (',' params+=FunctionParam)*)? ')' '{' expression=Expression '}' (attributes+=InternalAttribute)*;
+
+
 // function
 FunctionDecl:
     TRIPLE_SLASH_COMMENT* 'function' name=RegularID '(' (params+=FunctionParam (',' params+=FunctionParam)*)? ')' ':' returnType=FunctionParamType '{' (expression=Expression)? '}' (attributes+=InternalAttribute)*;
@@ -228,7 +235,7 @@ FunctionParamType:
 // https://github.com/langium/langium/discussions/1012
 RegularID returns string:
     // include keywords that we'd like to work as ID in most places
-    ID | 'model' | 'enum' | 'attribute' | 'datasource' | 'plugin' | 'abstract' | 'in' | 'view' | 'import' | 'type';
+    ID | 'model' | 'enum' | 'attribute' | 'datasource' | 'plugin' | 'abstract' | 'in' | 'view' | 'import' | 'type' | 'alias';
 
 RegularIDWithTypeNames returns string:
     RegularID | 'String' | 'Boolean' | 'Int' | 'BigInt' | 'Float' | 'Decimal' | 'DateTime' | 'Json' | 'Bytes' | 'Null' | 'Object' | 'Any' | 'Unsupported';
@@ -245,7 +252,7 @@ AttributeParam:
 AttributeParamType:
     (type=(ExpressionType | 'FieldReference' | 'TransitiveFieldReference' | 'ContextType') | reference=[TypeDeclaration:RegularID]) (array?='[' ']')? (optional?='?')?;
 
-type TypeDeclaration = DataModel | TypeDef | Enum;
+type TypeDeclaration = DataModel | TypeDef | Enum | AliasDecl;
 DataModelFieldAttribute:
     decl=[Attribute:FIELD_ATTRIBUTE_NAME] ('(' AttributeArgList? ')')?;
 

diff --git a/packages/language/syntaxes/zmodel.tmLanguage b/packages/language/syntaxes/zmodel.tmLanguage
@@ -20,7 +20,7 @@
         <key>name</key>
         <string>keyword.control.zmodel</string>
         <key>match</key>
-        <string>\b(Any|BigInt|Boolean|Bytes|ContextType|DateTime|Decimal|FieldReference|Float|Int|Json|Null|Object|String|TransitiveFieldReference|Unsupported|abstract|attribute|datasource|enum|extends|false|function|generator|import|in|model|null|plugin|this|true|type|view)\b</string>
+        <string>\b(Any|BigInt|Boolean|Bytes|ContextType|DateTime|Decimal|FieldReference|Float|Int|Json|Null|Object|String|TransitiveFieldReference|Unsupported|abstract|alias|attribute|datasource|enum|extends|false|function|generator|import|in|model|null|plugin|this|true|type|view)\b</string>
       </dict>
       <dict>
         <key>name</key>

diff --git a/packages/language/syntaxes/zmodel.tmLanguage.json b/packages/language/syntaxes/zmodel.tmLanguage.json
@@ -10,7 +10,7 @@
     },
     {
       "name": "keyword.control.zmodel",
-      "match": "\\b(Any|BigInt|Boolean|Bytes|ContextType|DateTime|Decimal|FieldReference|Float|Int|Json|Null|Object|String|TransitiveFieldReference|Unsupported|abstract|attribute|datasource|enum|extends|false|function|generator|import|in|model|null|plugin|this|true|type|view)\\b"
+      "match": "\\b(Any|BigInt|Boolean|Bytes|ContextType|DateTime|Decimal|FieldReference|Float|Int|Json|Null|Object|String|TransitiveFieldReference|Unsupported|abstract|alias|attribute|datasource|enum|extends|false|function|generator|import|in|model|null|plugin|this|true|type|view)\\b"
     },
     {
       "name": "string.quoted.double.zmodel",

diff --git a/packages/schema/src/language-server/validator/attribute-application-validator.ts b/packages/schema/src/language-server/validator/attribute-application-validator.ts
@@ -1,4 +1,5 @@
 import {
+    AliasDecl,
     ArrayExpr,
     Attribute,
     AttributeArg,
@@ -8,6 +9,7 @@ import {
     DataModelFieldAttribute,
     InternalAttribute,
     ReferenceExpr,
+    isAliasDecl,
     isArrayExpr,
     isAttribute,
     isDataModel,
@@ -294,6 +296,11 @@ function assignableToAttributeParam(arg: AttributeArg, param: AttributeParam, at
         }
     }
 
+    // Handle alias expressions by comparing to their resolved shape
+    if (isAliasDecl(arg.$resolvedType?.decl)) {
+        return isAliasAssignableToType(arg.$resolvedType.decl, dstType ?? 'Any', attr);
+    }
+
     // destination is field reference or transitive field reference, check if
     // argument is reference or array or reference
     if (dstType === 'FieldReference' || dstType === 'TransitiveFieldReference') {
@@ -406,6 +413,32 @@ function isValidAttributeTarget(attrDecl: Attribute, targetDecl: DataModelField)
     return allowed;
 }
 
+function isAliasAssignableToType(alias: AliasDecl, dstType: string, attr: AttributeApplication): boolean {
+    const effectiveDstType = resolveEffectiveDestinationType(dstType, attr);
+    if (effectiveDstType === null) {
+        return false;
+    }
+
+    const aliasExpressionType = alias.expression.$resolvedType?.decl;
+    return effectiveDstType === aliasExpressionType || effectiveDstType === 'Any' || aliasExpressionType === 'Any';
+}
+
+function resolveEffectiveDestinationType(dstType: string, attr: AttributeApplication): string | null {
+    if (dstType !== 'ContextType') {
+        return dstType;
+    }
+
+    // ContextType is inferred from the attribute's container's type
+    if (isDataModelField(attr.$container)) {
+        if (!attr.$container?.type?.type) {
+            return null;
+        }
+        return mapBuiltinTypeToExpressionType(attr.$container.type.type);
+    }
+
+    return 'Any';
+}
+
 export function validateAttributeApplication(attr: AttributeApplication, accept: ValidationAcceptor) {
     new AttributeApplicationValidator().validate(attr, accept);
 }
diff --git a/packages/schema/src/language-server/validator/expression-validator.ts b/packages/schema/src/language-server/validator/expression-validator.ts
@@ -4,6 +4,7 @@ import {
     DataModelAttribute,
     Expression,
     ExpressionType,
+    isAliasDecl,
     isArrayExpr,
     isDataModel,
     isDataModelAttribute,
@@ -21,7 +22,7 @@ import {
     isDataModelFieldReference,
     isEnumFieldReference,
 } from '@zenstackhq/sdk';
-import { ValidationAcceptor, streamAst } from 'langium';
+import { ValidationAcceptor, getContainerOfType, streamAst } from 'langium';
 import { findUpAst, getContainingDataModel } from '../../utils/ast-utils';
 import { AstValidator } from '../types';
 import { isAuthOrAuthMemberAccess, typeAssignable } from './utils';
@@ -33,7 +34,7 @@ export default class ExpressionValidator implements AstValidator<Expression> {
     validate(expr: Expression, accept: ValidationAcceptor): void {
         // deal with a few cases where reference resolution fail silently
         if (!expr.$resolvedType) {
-            if (isAuthInvocation(expr)) {
+            if (isAuthInvocation(expr) && !getContainerOfType(expr, isAliasDecl)) {
                 // check was done at link time
                 accept(
                     'error',
@@ -50,9 +51,9 @@ export default class ExpressionValidator implements AstValidator<Expression> {
                     }
                     return false;
                 });
-                if (!hasReferenceResolutionError) {
+                if (hasReferenceResolutionError) {
                     // report silent errors not involving linker errors
-                    accept('error', 'Expression cannot be resolved', {
+                    accept('error', `Expression cannot be resolved: ${expr.$cstNode?.text}`, {
                         node: expr,
                     });
                 }
@@ -107,31 +108,26 @@ export default class ExpressionValidator implements AstValidator<Expression> {
                     supportedShapes = ['Boolean', 'Any'];
                 }
 
-                if (
-                    typeof expr.left.$resolvedType?.decl !== 'string' ||
-                    !supportedShapes.includes(expr.left.$resolvedType.decl)
-                ) {
+                if (!this.isValidOperandType(expr.left, supportedShapes)) {
                     accept('error', `invalid operand type for "${expr.operator}" operator`, {
                         node: expr.left,
                     });
                     return;
                 }
-                if (
-                    typeof expr.right.$resolvedType?.decl !== 'string' ||
-                    !supportedShapes.includes(expr.right.$resolvedType.decl)
-                ) {
+
+                if (!this.isValidOperandType(expr.right, supportedShapes)) {
                     accept('error', `invalid operand type for "${expr.operator}" operator`, {
                         node: expr.right,
                     });
                     return;
                 }
 
                 // DateTime comparison is only allowed between two DateTime values
-                if (expr.left.$resolvedType.decl === 'DateTime' && expr.right.$resolvedType.decl !== 'DateTime') {
+                if (expr.left.$resolvedType?.decl === 'DateTime' && expr.right.$resolvedType?.decl !== 'DateTime') {
                     accept('error', 'incompatible operand types', { node: expr });
                 } else if (
-                    expr.right.$resolvedType.decl === 'DateTime' &&
-                    expr.left.$resolvedType.decl !== 'DateTime'
+                    expr.right.$resolvedType?.decl === 'DateTime' &&
+                    expr.left.$resolvedType?.decl !== 'DateTime'
                 ) {
                     accept('error', 'incompatible operand types', { node: expr });
                 }
@@ -297,4 +293,20 @@ export default class ExpressionValidator implements AstValidator<Expression> {
             (isArrayExpr(expr) && expr.items.every((item) => this.isNotModelFieldExpr(item)))
         );
     }
+
+    private isValidOperandType(operand: Expression, supportedShapes: string[]): boolean {
+        let decl = operand.$resolvedType?.decl;
+        if (isAliasDecl(decl)) {
+            // If it's an alias, we check the resolved type of the expression
+            decl = decl.expression?.$resolvedType?.decl;
+        }
+
+        // Check for valid type
+        if (typeof decl === 'string') {
+            return supportedShapes.includes(decl);
+        }
+
+        // Any other type is invalid
+        return false;
+    }
 }
diff --git a/packages/schema/src/language-server/validator/function-invocation-validator.ts b/packages/schema/src/language-server/validator/function-invocation-validator.ts
@@ -1,12 +1,14 @@
 import {
+    AbstractCallable,
+    AliasDecl,
     Argument,
     DataModel,
     DataModelAttribute,
     DataModelFieldAttribute,
     Expression,
-    FunctionDecl,
     FunctionParam,
     InvocationExpr,
+    isAliasDecl,
     isArrayExpr,
     isDataModel,
     isDataModelAttribute,
@@ -47,24 +49,24 @@ function func(name: string) {
  */
 export default class FunctionInvocationValidator implements AstValidator<Expression> {
     validate(expr: InvocationExpr, accept: ValidationAcceptor): void {
-        const funcDecl = expr.function.ref;
-        if (!funcDecl) {
-            accept('error', 'function cannot be resolved', { node: expr });
+        const callableDecl = expr.function.ref;
+        if (!callableDecl) {
+            accept('error', 'function or alias cannot be resolved', { node: expr });
             return;
         }
 
-        if (!this.validateArgs(funcDecl, expr.args, accept)) {
+        if (!this.validateArgs(callableDecl, expr.args, accept)) {
             return;
         }
 
-        if (isFromStdlib(funcDecl)) {
+        if (isFromStdlib(callableDecl)) {
             // validate standard library functions
 
             // find the containing attribute context for the invocation
             let curr: AstNode | undefined = expr.$container;
-            let containerAttribute: DataModelAttribute | DataModelFieldAttribute | undefined;
+            let containerAttribute: DataModelAttribute | DataModelFieldAttribute | AliasDecl | undefined;
             while (curr) {
-                if (isDataModelAttribute(curr) || isDataModelFieldAttribute(curr)) {
+                if (isDataModelAttribute(curr) || isDataModelFieldAttribute(curr) || isAliasDecl(curr)) {
                     containerAttribute = curr;
                     break;
                 }
@@ -75,12 +77,12 @@ export default class FunctionInvocationValidator implements AstValidator<Express
             const exprContext = this.getExpressionContext(containerAttribute);
 
             // get the context allowed for the function
-            const funcAllowedContext = getFunctionExpressionContext(funcDecl);
+            const funcAllowedContext = getFunctionExpressionContext(callableDecl);
 
             if (funcAllowedContext.length > 0 && (!exprContext || !funcAllowedContext.includes(exprContext))) {
                 accept(
                     'error',
-                    `function "${funcDecl.name}" is not allowed in the current context${
+                    `function "${callableDecl.name}" is not allowed in the current context${
                         exprContext ? ': ' + exprContext : ''
                     }`,
                     {
@@ -93,7 +95,7 @@ export default class FunctionInvocationValidator implements AstValidator<Express
             // TODO: express function validation rules declaratively in ZModel
 
             const allCasing = ['original', 'upper', 'lower', 'capitalize', 'uncapitalize'];
-            if (['currentModel', 'currentOperation'].includes(funcDecl.name)) {
+            if (['currentModel', 'currentOperation'].includes(callableDecl.name)) {
                 const arg = getLiteral<string>(expr.args[0]?.value);
                 if (arg && !allCasing.includes(arg)) {
                     accept('error', `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(', ')}`, {
@@ -130,7 +132,7 @@ export default class FunctionInvocationValidator implements AstValidator<Express
                     !(
                         isArrayExpr(secondArg) &&
                         secondArg.items.every(
-                            (item) =>
+                            (item: Expression) =>
                                 isLiteralExpr(item) || isEnumFieldReference(item) || isAuthOrAuthMemberAccess(item)
                         )
                     )
@@ -144,19 +146,24 @@ export default class FunctionInvocationValidator implements AstValidator<Express
                     );
                 }
             }
-        }
 
-        // run checkers for specific functions
-        const checker = invocationCheckers.get(expr.function.$refText);
-        if (checker) {
-            checker.value.call(this, expr, accept);
+            // run checkers for specific functions
+            const checker = invocationCheckers.get(expr.function.$refText);
+            if (checker) {
+                checker.value.call(this, expr, accept);
+            }
         }
     }
 
-    private getExpressionContext(containerAttribute: DataModelAttribute | DataModelFieldAttribute | undefined) {
+    private getExpressionContext(
+        containerAttribute: DataModelAttribute | DataModelFieldAttribute | AliasDecl | undefined
+    ) {
         if (!containerAttribute) {
             return undefined;
         }
+        if (isAliasDecl(containerAttribute)) {
+            return ExpressionContext.AliasFunction;
+        }
         if (isValidationAttribute(containerAttribute)) {
             return ExpressionContext.ValidationRule;
         }
@@ -171,7 +178,7 @@ export default class FunctionInvocationValidator implements AstValidator<Express
         return isInvocationExpr(expr) && ['currentModel', 'currentOperation'].includes(expr.function.$refText);
     }
 
-    private validateArgs(funcDecl: FunctionDecl, args: Argument[], accept: ValidationAcceptor) {
+    private validateArgs(funcDecl: AbstractCallable, args: Argument[], accept: ValidationAcceptor) {
         let success = true;
         for (let i = 0; i < funcDecl.params.length; i++) {
             const param = funcDecl.params[i];
@@ -289,7 +296,7 @@ export default class FunctionInvocationValidator implements AstValidator<Express
             }
 
             const policyAttrs = currModel.attributes.filter(
-                (attr) => attr.decl.$refText === '@@allow' || attr.decl.$refText === '@@deny'
+                (attr: DataModelAttribute) => attr.decl.$refText === '@@allow' || attr.decl.$refText === '@@deny'
             );
             for (const attr of policyAttrs) {
                 const rule = attr.args[1];

diff --git a/packages/schema/src/language-server/validator/utils.ts b/packages/schema/src/language-server/validator/utils.ts
@@ -86,6 +86,8 @@ export function mapBuiltinTypeToExpressionType(
         case 'Int':
         case 'Float':
         case 'Null':
+        case 'Object':
+        case 'Unsupported':
             return type;
         case 'BigInt':
             return 'Int';
@@ -94,10 +96,6 @@ export function mapBuiltinTypeToExpressionType(
         case 'Json':
         case 'Bytes':
             return 'Any';
-        case 'Object':
-            return 'Object';
-        case 'Unsupported':
-            return 'Unsupported';
     }
 }