zenstack 0.1.47 → 0.1.50

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

@@ -0,0 +1,24 @@
+/******************************************************************************
+ * 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

@@ -0,0 +1,10 @@
+import { ResolvedType } from '@lang/types';
+
+declare module 'langium' {
+    export interface AstNode {
+        /**
+         * Resolved type information attached to expressions
+         */
+        $resolvedType?: ResolvedType;
+    }
+}

package/src/language-server/lsp/zmodel-definition-provider.ts

@@ -0,0 +1,87 @@
+import {
+    CstNode,
+    DefinitionProvider,
+    findDeclarationNodeAtOffset,
+    getDocument,
+    GoToLink,
+    LangiumDocument,
+    LangiumServices,
+    MaybePromise,
+    NameProvider,
+} from 'langium';
+import { GrammarConfig } from 'langium/lib/grammar/grammar-config';
+import { References } from 'langium/lib/references/references';
+import { DefinitionParams, LocationLink } from 'vscode-languageserver';
+
+/**
+ * Custom Langium DefinitionProvider implementation
+ */
+export default class ZModelDefinitionProvider implements DefinitionProvider {
+    protected readonly nameProvider: NameProvider;
+    protected readonly references: References;
+    protected readonly grammarConfig: GrammarConfig;
+
+    constructor(services: LangiumServices) {
+        this.nameProvider = services.references.NameProvider;
+        this.references = services.references.References;
+        this.grammarConfig = services.parser.GrammarConfig;
+    }
+
+    getDefinition(
+        document: LangiumDocument,
+        params: DefinitionParams
+    ): MaybePromise<LocationLink[] | undefined> {
+        const rootNode = document.parseResult.value;
+        if (rootNode.$cstNode) {
+            const cst = rootNode.$cstNode;
+            const sourceCstNode = findDeclarationNodeAtOffset(
+                cst,
+                document.textDocument.offsetAt(params.position),
+                this.grammarConfig.nameRegexp
+            );
+            if (sourceCstNode) {
+                return this.collectLocationLinks(sourceCstNode, params);
+            }
+        }
+        return undefined;
+    }
+
+    protected collectLocationLinks(
+        sourceCstNode: CstNode,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _params: DefinitionParams
+    ): MaybePromise<LocationLink[] | undefined> {
+        const goToLink = this.findLink(sourceCstNode);
+        if (goToLink) {
+            if (
+                // this condition is for working around a potential Langium bug
+                // https://github.com/langium/langium/discussions/732
+                !goToLink.targetDocument.textDocument.uri.endsWith(
+                    'stdlib.zmodel'
+                )
+            ) {
+                return [
+                    LocationLink.create(
+                        goToLink.targetDocument.textDocument.uri,
+                        (goToLink.target.element.$cstNode ?? goToLink.target)
+                            .range,
+                        goToLink.target.range,
+                        goToLink.source.range
+                    ),
+                ];
+            }
+        }
+        return undefined;
+    }
+
+    protected findLink(source: CstNode): GoToLink | undefined {
+        const target = this.references.findDeclarationNode(source);
+        if (target?.element) {
+            const targetDocument = getDocument(target.element);
+            if (target && targetDocument) {
+                return { source, target, targetDocument };
+            }
+        }
+        return undefined;
+    }
+}

package/src/language-server/main.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,25 @@
+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/validator/attribute-validator.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,311 @@
+import { SCALAR_TYPES } from '@lang/constants';
+import {
+    ArrayExpr,
+    AttributeParam,
+    DataModel,
+    DataModelAttribute,
+    DataModelField,
+    DataModelFieldAttribute,
+    isDataModel,
+    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 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);
+        }
+
+        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 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;
+        }
+    }
+}

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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,14 @@
+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/schema-validator.ts

@@ -0,0 +1,31 @@
+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] }
+            );
+        }
+    }
+}