zenstack 0.4.2 → 0.6.0-pre.1

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

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

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

@@ -1,14 +0,0 @@
-import { Enum } from '@lang/generated/ast';
-import { AstValidator } from '@lang/types';
-import { ValidationAcceptor } from 'langium';
-import { validateDuplicatedDeclarations } from './utils';
-
-/**
- * Validates enum declarations.
- */
-export default class EnumValidator implements AstValidator<Enum> {
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    validate(_enum: Enum, accept: ValidationAcceptor) {
-        validateDuplicatedDeclarations(_enum.fields, accept);
-    }
-}

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

@@ -1,48 +0,0 @@
-import {
-    Expression,
-    isBinaryExpr,
-    isInvocationExpr,
-} from '@lang/generated/ast';
-import { AstValidator } from '@lang/types';
-import { isFromStdlib } from '@lang/utils';
-import { ValidationAcceptor } from 'langium';
-
-/**
- * Validates expressions.
- */
-export default class ExpressionValidator implements AstValidator<Expression> {
-    validate(expr: Expression, accept: ValidationAcceptor): void {
-        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,
-                });
-            }
-        }
-    }
-
-    private isCollectionPredicate(expr: Expression) {
-        return isBinaryExpr(expr) && ['?', '!', '^'].includes(expr.operator);
-    }
-
-    private isAuthInvocation(expr: Expression) {
-        return (
-            isInvocationExpr(expr) &&
-            expr.function.ref?.name === 'auth' &&
-            isFromStdlib(expr.function.ref)
-        );
-    }
-}

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

@@ -1,31 +0,0 @@
-import { STD_LIB_MODULE_NAME } from '@lang/constants';
-import { isDataSource, Model } from '@lang/generated/ast';
-import { AstValidator } from '@lang/types';
-import { ValidationAcceptor } from 'langium';
-import { validateDuplicatedDeclarations } from './utils';
-
-/**
- * Validates toplevel schema.
- */
-export default class SchemaValidator implements AstValidator<Model> {
-    validate(model: Model, accept: ValidationAcceptor): void {
-        validateDuplicatedDeclarations(model.declarations, accept);
-
-        if (!model.$document?.uri.path.endsWith(STD_LIB_MODULE_NAME)) {
-            this.validateDataSources(model, accept);
-        }
-    }
-
-    private validateDataSources(model: Model, accept: ValidationAcceptor) {
-        const dataSources = model.declarations.filter((d) => 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] }
-            );
-        }
-    }
-}

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

@@ -1,158 +0,0 @@
-import {
-    AttributeArg,
-    AttributeParam,
-    BuiltinType,
-    DataModelAttribute,
-    DataModelFieldAttribute,
-    ExpressionType,
-    isArrayExpr,
-    isDataModelField,
-    isLiteralExpr,
-    isReferenceExpr,
-} from '@lang/generated/ast';
-import { AstNode, ValidationAcceptor } from 'langium';
-
-/**
- * Checks if the given declarations have duplicated names
- */
-export function validateDuplicatedDeclarations(
-    decls: Array<AstNode & { name: string }>,
-    accept: ValidationAcceptor
-): void {
-    const groupByName = decls.reduce<
-        Record<string, Array<AstNode & { name: string }>>
-    >((group, decl) => {
-        group[decl.name] = group[decl.name] ?? [];
-        group[decl.name].push(decl);
-        return group;
-    }, {});
-
-    for (const [name, decls] of Object.entries<AstNode[]>(groupByName)) {
-        if (decls.length > 1) {
-            accept('error', `Duplicated declaration name "${name}"`, {
-                node: decls[1],
-            });
-        }
-    }
-}
-
-/**
- * Try getting string value from a potential string literal expression
- */
-export function getStringLiteral(node: AstNode): string | undefined {
-    if (isLiteralExpr(node) && typeof node.value === 'string') {
-        return node.value;
-    } else {
-        return undefined;
-    }
-}
-
-/**
- * Determines if the given sourceType is assignable to a destination of destType
- */
-export function typeAssignable(
-    destType: ExpressionType,
-    sourceType: ExpressionType
-): boolean {
-    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
- */
-export function mapBuiltinTypeToExpressionType(
-    type: BuiltinType | 'Any' | 'Null'
-): ExpressionType | 'Any' {
-    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
- */
-export function assignableToAttributeParam(
-    arg: AttributeArg,
-    param: AttributeParam,
-    attr: DataModelAttribute | DataModelFieldAttribute
-): boolean {
-    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?.decl !== 'string') {
-            // destination type is not a reference, so argument type must be a plain expression
-            return false;
-        }
-
-        if (dstType === 'FieldReference') {
-            if (dstIsArray) {
-                return (
-                    isArrayExpr(arg.value) &&
-                    !arg.value.items.find(
-                        (item) =>
-                            !isReferenceExpr(item) ||
-                            !isDataModelField(item.target.ref)
-                    )
-                );
-            } else {
-                return (
-                    isReferenceExpr(arg.value) &&
-                    isDataModelField(arg.value.target.ref)
-                );
-            }
-        } else if (dstType === 'ContextType') {
-            if (isDataModelField(attr.$container)) {
-                if (!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?.ref === argResolvedType.decl &&
-            dstIsArray === argResolvedType.array
-        );
-    }
-}

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

@@ -1,91 +0,0 @@
-import {
-    AstNode,
-    LangiumDocument,
-    ValidationAcceptor,
-    ValidationChecks,
-    ValidationRegistry,
-} from 'langium';
-import {
-    Attribute,
-    DataModel,
-    DataSource,
-    Enum,
-    Expression,
-    Model,
-    ZModelAstType,
-} from '../generated/ast';
-import type { ZModelServices } from '../zmodel-module';
-import SchemaValidator from './schema-validator';
-import DataSourceValidator from './datasource-validator';
-import DataModelValidator from './datamodel-validator';
-import AttributeValidator from './attribute-validator';
-import EnumValidator from './enum-validator';
-import ExpressionValidator from './expression-validator';
-
-/**
- * Registry for validation checks.
- */
-export class ZModelValidationRegistry extends ValidationRegistry {
-    constructor(services: ZModelServices) {
-        super(services);
-        const validator = services.validation.ZModelValidator;
-        const checks: ValidationChecks<ZModelAstType> = {
-            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.
- */
-export class ZModelValidator {
-    private shouldCheck(node: AstNode) {
-        let doc: LangiumDocument | undefined;
-        let currNode: AstNode | undefined = node;
-        while (currNode) {
-            if (currNode.$document) {
-                doc = currNode.$document;
-                break;
-            }
-            currNode = currNode.$container;
-        }
-
-        return (
-            doc?.parseResult.lexerErrors.length === 0 &&
-            doc?.parseResult.parserErrors.length === 0
-        );
-    }
-
-    checkModel(node: Model, accept: ValidationAcceptor): void {
-        this.shouldCheck(node) && new SchemaValidator().validate(node, accept);
-    }
-
-    checkDataSource(node: DataSource, accept: ValidationAcceptor): void {
-        this.shouldCheck(node) &&
-            new DataSourceValidator().validate(node, accept);
-    }
-
-    checkDataModel(node: DataModel, accept: ValidationAcceptor): void {
-        this.shouldCheck(node) &&
-            new DataModelValidator().validate(node, accept);
-    }
-
-    checkEnum(node: Enum, accept: ValidationAcceptor): void {
-        this.shouldCheck(node) && new EnumValidator().validate(node, accept);
-    }
-
-    checkAttribute(node: Attribute, accept: ValidationAcceptor): void {
-        this.shouldCheck(node) &&
-            new AttributeValidator().validate(node, accept);
-    }
-
-    checkExpression(node: Expression, accept: ValidationAcceptor): void {
-        new ExpressionValidator().validate(node, accept);
-    }
-}