zenstack 0.5.0 → 0.6.0-pre.2

package/src/language-server/generated/module.ts

@@ -1,24 +0,0 @@
-/******************************************************************************
- * This file was generated by langium-cli 0.5.0.
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-
-import { LangiumGeneratedServices, LangiumGeneratedSharedServices, LangiumSharedServices, LangiumServices, LanguageMetaData, Module } from 'langium';
-import { ZModelAstReflection } from './ast';
-import { ZModelGrammar } from './grammar';
-
-export const ZModelLanguageMetaData: LanguageMetaData = {
-    languageId: 'zmodel',
-    fileExtensions: ['.zmodel'],
-    caseInsensitive: false
-};
-
-export const ZModelGeneratedSharedModule: Module<LangiumSharedServices, LangiumGeneratedSharedServices> = {
-    AstReflection: () => new ZModelAstReflection()
-};
-
-export const ZModelGeneratedModule: Module<LangiumServices, LangiumGeneratedServices> = {
-    Grammar: () => ZModelGrammar(),
-    LanguageMetaData: () => ZModelLanguageMetaData,
-    parser: {}
-};

package/src/language-server/langium-ext.d.ts

@@ -1,22 +0,0 @@
-import { ResolvedType } from '@lang/types';
-import { AttributeParam } from './generated/ast';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { AttributeArg } from './generated/ast';
-
-declare module 'langium' {
-    export interface AstNode {
-        /**
-         * Resolved type information attached to expressions
-         */
-        $resolvedType?: ResolvedType;
-    }
-}
-
-declare module './generated/ast' {
-    interface AttributeArg {
-        /**
-         * Resolved attribute param declaration
-         */
-        $resolvedParam?: AttributeParam;
-    }
-}

package/src/language-server/main.ts

@@ -1,13 +0,0 @@
-import { startLanguageServer } from 'langium';
-import { NodeFileSystem } from 'langium/node';
-import { createConnection, ProposedFeatures } from 'vscode-languageserver/node';
-import { createZModelServices } from './zmodel-module';
-
-// Create a connection to the client
-const connection = createConnection(ProposedFeatures.all);
-
-// Inject the shared services and language-specific services
-const { shared } = createZModelServices({ connection, ...NodeFileSystem });
-
-// Start the language server with the shared services
-startLanguageServer(shared);

package/src/language-server/types.ts

@@ -1,25 +0,0 @@
-import { AstNode, ValidationAcceptor } from 'langium';
-import { AbstractDeclaration, ExpressionType } from './generated/ast';
-
-/**
- * Shape of type resolution result: an expression type or reference to a declaration
- */
-export type ResolvedShape = ExpressionType | AbstractDeclaration;
-
-/**
- * Resolved type information (attached to expressions by linker)
- */
-export type ResolvedType = {
-    decl?: ResolvedShape;
-    array?: boolean;
-};
-
-/**
- * AST validator contract
- */
-export interface AstValidator<T extends AstNode> {
-    /**
-     * Validates an AST node
-     */
-    validate(node: T, accept: ValidationAcceptor): void;
-}

package/src/language-server/utils.ts

@@ -1,21 +0,0 @@
-import { AstNode } from 'langium';
-import { STD_LIB_MODULE_NAME } from './constants';
-import { isModel, Model } from './generated/ast';
-
-/**
- * Gets the toplevel Model containing the given node.
- */
-export function getContainingModel(node: AstNode | undefined): Model | null {
-    if (!node) {
-        return null;
-    }
-    return isModel(node) ? node : getContainingModel(node.$container);
-}
-
-/**
- * Returns if the given node is declared in stdlib.
- */
-export function isFromStdlib(node: AstNode) {
-    const model = getContainingModel(node);
-    return model && model.$document?.uri.path.endsWith(STD_LIB_MODULE_NAME);
-}

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

@@ -1,11 +0,0 @@
-import { Attribute } from '@lang/generated/ast';
-import { AstValidator } from '@lang/types';
-import { ValidationAcceptor } from 'langium';
-
-/**
- * Validates attribute declarations.
- */
-export default class AttributeValidator implements AstValidator<Attribute> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-    validate(attr: Attribute, accept: ValidationAcceptor): void {}
-}

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

@@ -1,426 +0,0 @@
-import { SCALAR_TYPES } from '@lang/constants';
-import {
-    ArrayExpr,
-    Attribute,
-    AttributeParam,
-    DataModel,
-    DataModelAttribute,
-    DataModelField,
-    DataModelFieldAttribute,
-    isAttribute,
-    isDataModel,
-    isDataModelField,
-    isLiteralExpr,
-    ReferenceExpr,
-} from '@lang/generated/ast';
-import { AstValidator } from '@lang/types';
-import { ValidationAcceptor } from 'langium';
-import {
-    assignableToAttributeParam,
-    validateDuplicatedDeclarations,
-} from './utils';
-import pluralize from 'pluralize';
-
-/**
- * Validates data model declarations.
- */
-export default class DataModelValidator implements AstValidator<DataModel> {
-    validate(dm: DataModel, accept: ValidationAcceptor): void {
-        validateDuplicatedDeclarations(dm.fields, accept);
-        this.validateFields(dm, accept);
-        this.validateAttributes(dm, accept);
-    }
-
-    private validateFields(dm: DataModel, accept: ValidationAcceptor) {
-        const idFields = dm.fields.filter((f) =>
-            f.attributes.find((attr) => attr.decl.ref?.name === '@id')
-        );
-        if (idFields.length === 0) {
-            accept('error', 'Model must include a field with @id attribute', {
-                node: dm,
-            });
-        } else if (idFields.length > 1) {
-            accept(
-                'error',
-                'Model can include at most one field with @id attribute',
-                {
-                    node: dm,
-                }
-            );
-        } else {
-            if (idFields[0].type.optional) {
-                accept(
-                    'error',
-                    'Field with @id attribute must not be optional',
-                    { node: idFields[0] }
-                );
-            }
-
-            if (
-                idFields[0].type.array ||
-                !idFields[0].type.type ||
-                !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));
-    }
-
-    private validateField(
-        field: DataModelField,
-        accept: ValidationAcceptor
-    ): void {
-        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 (isDataModel(field.type.reference?.ref)) {
-            this.validateRelationField(field, accept);
-        }
-    }
-
-    private validateAttributes(dm: DataModel, accept: ValidationAcceptor) {
-        dm.attributes.forEach((attr) => {
-            this.validateAttributeApplication(attr, accept);
-        });
-    }
-
-    private validateAttributeApplication(
-        attr: DataModelAttribute | DataModelFieldAttribute,
-        accept: ValidationAcceptor
-    ) {
-        const decl = attr.decl.ref;
-        if (!decl) {
-            return;
-        }
-
-        const targetDecl = attr.$container;
-        if (decl.name === '@@@targetField' && !isAttribute(targetDecl)) {
-            accept(
-                'error',
-                `attribute "${decl.name}" can only be used on attribute declarations`,
-                { node: attr }
-            );
-            return;
-        }
-
-        if (
-            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<AttributeParam>();
-
-        for (const arg of attr.args) {
-            let paramDecl: AttributeParam | undefined;
-            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 (!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 ${pluralize(
-                    'parameter',
-                    missingParams.length
-                )} not provided: ${missingParams
-                    .map((p) => p.name)
-                    .join(', ')}`,
-                { node: attr }
-            );
-            return false;
-        }
-
-        return true;
-    }
-
-    private isValidAttributeTarget(
-        attrDecl: Attribute,
-        targetDecl: DataModelField
-    ) {
-        const targetField = attrDecl.attributes.find(
-            (attr) => attr.decl.ref?.name === '@@@targetField'
-        );
-        if (!targetField) {
-            // no field type constraint
-            return true;
-        }
-
-        const fieldTypes = (targetField.args[0].value as ArrayExpr).items.map(
-            (item) => (item as ReferenceExpr).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 || isDataModel(targetDecl.type.reference?.ref);
-                    break;
-                default:
-                    break;
-            }
-            if (allowed) {
-                break;
-            }
-        }
-
-        return allowed;
-    }
-
-    private parseRelation(field: DataModelField, accept?: ValidationAcceptor) {
-        const relAttr = field.attributes.find(
-            (attr) => attr.decl.ref?.name === '@relation'
-        );
-
-        let name: string | undefined;
-        let fields: ReferenceExpr[] | undefined;
-        let references: ReferenceExpr[] | undefined;
-        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 (isLiteralExpr(arg.value)) {
-                    name = arg.value.value as string;
-                }
-            } else if (arg.name === 'fields') {
-                fields = (arg.value as ArrayExpr).items as ReferenceExpr[];
-                if (fields.length === 0) {
-                    if (accept) {
-                        accept('error', `"fields" value cannot be emtpy`, {
-                            node: arg,
-                        });
-                    }
-                    valid = false;
-                }
-            } else if (arg.name === 'references') {
-                references = (arg.value as ArrayExpr).items as ReferenceExpr[];
-                if (references.length === 0) {
-                    if (accept) {
-                        accept('error', `"references" value cannot be emtpy`, {
-                            node: arg,
-                        });
-                    }
-                    valid = false;
-                }
-            }
-        }
-
-        return { attr: relAttr, name, fields, references, valid };
-    }
-
-    private validateRelationField(
-        field: DataModelField,
-        accept: ValidationAcceptor
-    ) {
-        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! as DataModel;
-
-        let oppositeFields = oppositeModel.fields.filter(
-            (f) => f.type.reference?.ref === field.$container
-        );
-        oppositeFields = oppositeFields.filter((f) => {
-            const fieldRel = this.parseRelation(f);
-            return fieldRel.valid && fieldRel.name === thisRelation.name;
-        });
-
-        if (oppositeFields.length === 0) {
-            accept(
-                'error',
-                `The relation field "${field.name}" on model "${field.$container.name}" is missing an opposite relation field on model "${oppositeModel.name}"`,
-                { node: field }
-            );
-            return;
-        } else if (oppositeFields.length > 1) {
-            oppositeFields.forEach((f) =>
-                accept(
-                    'error',
-                    `Fields ${oppositeFields
-                        .map((f) => '"' + f.name + '"')
-                        .join(', ')} on model "${
-                        oppositeModel.name
-                    }" refer to the same relation to model "${
-                        field.$container.name
-                    }"`,
-                    { node: f }
-                )
-            );
-            return;
-        }
-
-        const oppositeField = oppositeFields[0];
-        const oppositeRelation = this.parseRelation(oppositeField);
-
-        let relationOwner: DataModelField;
-
-        if (thisRelation?.references?.length && thisRelation.fields?.length) {
-            if (oppositeRelation?.references || 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?.references?.length &&
-            oppositeRelation.fields?.length
-        ) {
-            if (thisRelation?.references || 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
-
-            thisRelation.fields?.forEach((ref) => {
-                const refField = ref.target.ref as DataModelField;
-                if (
-                    refField &&
-                    !refField.attributes.find(
-                        (a) => 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 }
-                    );
-                }
-            });
-        }
-    }
-}

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);
-    }
-}