zenstack 0.1.41 → 1.0.0

package/packages/schema/src/language-server/generated/ast.ts

@@ -0,0 +1,603 @@
+/******************************************************************************
+ * This file was generated by langium-cli 0.4.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable @typescript-eslint/array-type */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+import { AstNode, AstReflection, Reference, isAstNode, TypeMetaData } from 'langium';
+
+export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | Function;
+
+export const AbstractDeclaration = 'AbstractDeclaration';
+
+export function isAbstractDeclaration(item: unknown): item is AbstractDeclaration {
+    return reflection.isInstance(item, AbstractDeclaration);
+}
+
+export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ReferenceExpr | ThisExpr | UnaryExpr;
+
+export const Expression = 'Expression';
+
+export function isExpression(item: unknown): item is Expression {
+    return reflection.isInstance(item, Expression);
+}
+
+export type ReferenceTarget = DataModelField | EnumField | FunctionParam;
+
+export const ReferenceTarget = 'ReferenceTarget';
+
+export function isReferenceTarget(item: unknown): item is ReferenceTarget {
+    return reflection.isInstance(item, ReferenceTarget);
+}
+
+export type TypeDeclaration = DataModel | Enum;
+
+export const TypeDeclaration = 'TypeDeclaration';
+
+export function isTypeDeclaration(item: unknown): item is TypeDeclaration {
+    return reflection.isInstance(item, TypeDeclaration);
+}
+
+export interface Argument extends AstNode {
+    readonly $container: InvocationExpr;
+    name?: string
+    value: Expression
+}
+
+export const Argument = 'Argument';
+
+export function isArgument(item: unknown): item is Argument {
+    return reflection.isInstance(item, Argument);
+}
+
+export interface ArrayExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    items: Array<Expression>
+}
+
+export const ArrayExpr = 'ArrayExpr';
+
+export function isArrayExpr(item: unknown): item is ArrayExpr {
+    return reflection.isInstance(item, ArrayExpr);
+}
+
+export interface Attribute extends AstNode {
+    readonly $container: Model;
+    name: string
+    params: Array<AttributeParam>
+}
+
+export const Attribute = 'Attribute';
+
+export function isAttribute(item: unknown): item is Attribute {
+    return reflection.isInstance(item, Attribute);
+}
+
+export interface AttributeArg extends AstNode {
+    readonly $container: DataModelAttribute | DataModelFieldAttribute;
+    name?: string
+    value: Expression
+}
+
+export const AttributeArg = 'AttributeArg';
+
+export function isAttributeArg(item: unknown): item is AttributeArg {
+    return reflection.isInstance(item, AttributeArg);
+}
+
+export interface AttributeParam extends AstNode {
+    readonly $container: Attribute;
+    name: string
+    positional: boolean
+    type: AttributeParamType
+}
+
+export const AttributeParam = 'AttributeParam';
+
+export function isAttributeParam(item: unknown): item is AttributeParam {
+    return reflection.isInstance(item, AttributeParam);
+}
+
+export interface AttributeParamType extends AstNode {
+    readonly $container: AttributeParam;
+    array: boolean
+    optional: boolean
+    type: 'Boolean' | 'DateTime' | 'FieldReference' | 'Int' | 'JSON' | 'String'
+}
+
+export const AttributeParamType = 'AttributeParamType';
+
+export function isAttributeParamType(item: unknown): item is AttributeParamType {
+    return reflection.isInstance(item, AttributeParamType);
+}
+
+export interface BinaryExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    left: Expression
+    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | '||'
+    right: Expression
+}
+
+export const BinaryExpr = 'BinaryExpr';
+
+export function isBinaryExpr(item: unknown): item is BinaryExpr {
+    return reflection.isInstance(item, BinaryExpr);
+}
+
+export interface DataModel extends AstNode {
+    readonly $container: Model;
+    attributes: Array<DataModelAttribute>
+    fields: Array<DataModelField>
+    name: string
+}
+
+export const DataModel = 'DataModel';
+
+export function isDataModel(item: unknown): item is DataModel {
+    return reflection.isInstance(item, DataModel);
+}
+
+export interface DataModelAttribute extends AstNode {
+    readonly $container: DataModel;
+    args: Array<AttributeArg>
+    decl: Reference<Attribute>
+}
+
+export const DataModelAttribute = 'DataModelAttribute';
+
+export function isDataModelAttribute(item: unknown): item is DataModelAttribute {
+    return reflection.isInstance(item, DataModelAttribute);
+}
+
+export interface DataModelField extends AstNode {
+    readonly $container: DataModel;
+    attributes: Array<DataModelFieldAttribute>
+    name: string
+    type: DataModelFieldType
+}
+
+export const DataModelField = 'DataModelField';
+
+export function isDataModelField(item: unknown): item is DataModelField {
+    return reflection.isInstance(item, DataModelField);
+}
+
+export interface DataModelFieldAttribute extends AstNode {
+    readonly $container: DataModelField;
+    args: Array<AttributeArg>
+    decl: Reference<Attribute>
+}
+
+export const DataModelFieldAttribute = 'DataModelFieldAttribute';
+
+export function isDataModelFieldAttribute(item: unknown): item is DataModelFieldAttribute {
+    return reflection.isInstance(item, DataModelFieldAttribute);
+}
+
+export interface DataModelFieldType extends AstNode {
+    readonly $container: DataModelField;
+    array: boolean
+    optional: boolean
+    reference?: Reference<TypeDeclaration>
+    type?: 'Boolean' | 'DateTime' | 'Int' | 'JSON' | 'String'
+}
+
+export const DataModelFieldType = 'DataModelFieldType';
+
+export function isDataModelFieldType(item: unknown): item is DataModelFieldType {
+    return reflection.isInstance(item, DataModelFieldType);
+}
+
+export interface DataSource extends AstNode {
+    readonly $container: Model;
+    fields: Array<DataSourceField>
+    name: string
+}
+
+export const DataSource = 'DataSource';
+
+export function isDataSource(item: unknown): item is DataSource {
+    return reflection.isInstance(item, DataSource);
+}
+
+export interface DataSourceField extends AstNode {
+    readonly $container: DataSource;
+    name: string
+    value: InvocationExpr | LiteralExpr
+}
+
+export const DataSourceField = 'DataSourceField';
+
+export function isDataSourceField(item: unknown): item is DataSourceField {
+    return reflection.isInstance(item, DataSourceField);
+}
+
+export interface Enum extends AstNode {
+    readonly $container: Model;
+    fields: Array<EnumField>
+    name: string
+}
+
+export const Enum = 'Enum';
+
+export function isEnum(item: unknown): item is Enum {
+    return reflection.isInstance(item, Enum);
+}
+
+export interface EnumField extends AstNode {
+    readonly $container: Enum;
+    name: string
+}
+
+export const EnumField = 'EnumField';
+
+export function isEnumField(item: unknown): item is EnumField {
+    return reflection.isInstance(item, EnumField);
+}
+
+export interface Function extends AstNode {
+    readonly $container: Model;
+    expression?: Expression
+    name: string
+    params: Array<FunctionParam>
+    returnType: FunctionParamType
+}
+
+export const Function = 'Function';
+
+export function isFunction(item: unknown): item is Function {
+    return reflection.isInstance(item, Function);
+}
+
+export interface FunctionParam extends AstNode {
+    readonly $container: Function;
+    name: string
+    type: FunctionParamType
+}
+
+export const FunctionParam = 'FunctionParam';
+
+export function isFunctionParam(item: unknown): item is FunctionParam {
+    return reflection.isInstance(item, FunctionParam);
+}
+
+export interface FunctionParamType extends AstNode {
+    readonly $container: Function | FunctionParam;
+    array: boolean
+    reference?: Reference<TypeDeclaration>
+    type?: 'Boolean' | 'DateTime' | 'Int' | 'JSON' | 'String'
+}
+
+export const FunctionParamType = 'FunctionParamType';
+
+export function isFunctionParamType(item: unknown): item is FunctionParamType {
+    return reflection.isInstance(item, FunctionParamType);
+}
+
+export interface InvocationExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    args: Array<Argument>
+    function: Reference<Function>
+}
+
+export const InvocationExpr = 'InvocationExpr';
+
+export function isInvocationExpr(item: unknown): item is InvocationExpr {
+    return reflection.isInstance(item, InvocationExpr);
+}
+
+export interface LiteralExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    value: boolean | number | string
+}
+
+export const LiteralExpr = 'LiteralExpr';
+
+export function isLiteralExpr(item: unknown): item is LiteralExpr {
+    return reflection.isInstance(item, LiteralExpr);
+}
+
+export interface MemberAccessExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    member: Reference<DataModelField>
+    operand: Expression
+}
+
+export const MemberAccessExpr = 'MemberAccessExpr';
+
+export function isMemberAccessExpr(item: unknown): item is MemberAccessExpr {
+    return reflection.isInstance(item, MemberAccessExpr);
+}
+
+export interface Model extends AstNode {
+    declarations: Array<AbstractDeclaration>
+}
+
+export const Model = 'Model';
+
+export function isModel(item: unknown): item is Model {
+    return reflection.isInstance(item, Model);
+}
+
+export interface NullExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    value: string
+}
+
+export const NullExpr = 'NullExpr';
+
+export function isNullExpr(item: unknown): item is NullExpr {
+    return reflection.isInstance(item, NullExpr);
+}
+
+export interface ReferenceArg extends AstNode {
+    readonly $container: ReferenceExpr;
+    name: 'sort'
+    value: 'Asc' | 'Desc'
+}
+
+export const ReferenceArg = 'ReferenceArg';
+
+export function isReferenceArg(item: unknown): item is ReferenceArg {
+    return reflection.isInstance(item, ReferenceArg);
+}
+
+export interface ReferenceExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    args: Array<ReferenceArg>
+    target: Reference<ReferenceTarget>
+}
+
+export const ReferenceExpr = 'ReferenceExpr';
+
+export function isReferenceExpr(item: unknown): item is ReferenceExpr {
+    return reflection.isInstance(item, ReferenceExpr);
+}
+
+export interface ThisExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    value: string
+}
+
+export const ThisExpr = 'ThisExpr';
+
+export function isThisExpr(item: unknown): item is ThisExpr {
+    return reflection.isInstance(item, ThisExpr);
+}
+
+export interface UnaryExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
+    operand: Expression
+    operator: '!'
+}
+
+export const UnaryExpr = 'UnaryExpr';
+
+export function isUnaryExpr(item: unknown): item is UnaryExpr {
+    return reflection.isInstance(item, UnaryExpr);
+}
+
+export type ZModelAstType = 'AbstractDeclaration' | 'Argument' | 'ArrayExpr' | 'Attribute' | 'AttributeArg' | 'AttributeParam' | 'AttributeParamType' | 'BinaryExpr' | 'DataModel' | 'DataModelAttribute' | 'DataModelField' | 'DataModelFieldAttribute' | 'DataModelFieldType' | 'DataSource' | 'DataSourceField' | 'Enum' | 'EnumField' | 'Expression' | 'Function' | 'FunctionParam' | 'FunctionParamType' | 'InvocationExpr' | 'LiteralExpr' | 'MemberAccessExpr' | 'Model' | 'NullExpr' | 'ReferenceArg' | 'ReferenceExpr' | 'ReferenceTarget' | 'ThisExpr' | 'TypeDeclaration' | 'UnaryExpr';
+
+export type ZModelAstReference = 'DataModelAttribute:decl' | 'DataModelFieldAttribute:decl' | 'DataModelFieldType:reference' | 'FunctionParamType:reference' | 'InvocationExpr:function' | 'MemberAccessExpr:member' | 'ReferenceExpr:target';
+
+export class ZModelAstReflection implements AstReflection {
+
+    getAllTypes(): string[] {
+        return ['AbstractDeclaration', 'Argument', 'ArrayExpr', 'Attribute', 'AttributeArg', 'AttributeParam', 'AttributeParamType', 'BinaryExpr', 'DataModel', 'DataModelAttribute', 'DataModelField', 'DataModelFieldAttribute', 'DataModelFieldType', 'DataSource', 'DataSourceField', 'Enum', 'EnumField', 'Expression', 'Function', 'FunctionParam', 'FunctionParamType', 'InvocationExpr', 'LiteralExpr', 'MemberAccessExpr', 'Model', 'NullExpr', 'ReferenceArg', 'ReferenceExpr', 'ReferenceTarget', 'ThisExpr', 'TypeDeclaration', 'UnaryExpr'];
+    }
+
+    isInstance(node: unknown, type: string): boolean {
+        return isAstNode(node) && this.isSubtype(node.$type, type);
+    }
+
+    isSubtype(subtype: string, supertype: string): boolean {
+        if (subtype === supertype) {
+            return true;
+        }
+        switch (subtype) {
+            case ArrayExpr:
+            case BinaryExpr:
+            case InvocationExpr:
+            case LiteralExpr:
+            case MemberAccessExpr:
+            case NullExpr:
+            case ReferenceExpr:
+            case ThisExpr:
+            case UnaryExpr: {
+                return this.isSubtype(Expression, supertype);
+            }
+            case Attribute:
+            case DataSource:
+            case Function: {
+                return this.isSubtype(AbstractDeclaration, supertype);
+            }
+            case DataModel:
+            case Enum: {
+                return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
+            }
+            case DataModelField:
+            case EnumField:
+            case FunctionParam: {
+                return this.isSubtype(ReferenceTarget, supertype);
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+
+    getReferenceType(referenceId: ZModelAstReference): string {
+        switch (referenceId) {
+            case 'DataModelAttribute:decl': {
+                return Attribute;
+            }
+            case 'DataModelFieldAttribute:decl': {
+                return Attribute;
+            }
+            case 'DataModelFieldType:reference': {
+                return TypeDeclaration;
+            }
+            case 'FunctionParamType:reference': {
+                return TypeDeclaration;
+            }
+            case 'InvocationExpr:function': {
+                return Function;
+            }
+            case 'MemberAccessExpr:member': {
+                return DataModelField;
+            }
+            case 'ReferenceExpr:target': {
+                return ReferenceTarget;
+            }
+            default: {
+                throw new Error(`${referenceId} is not a valid reference id.`);
+            }
+        }
+    }
+
+    getTypeMetaData(type: string): TypeMetaData {
+        switch (type) {
+            case 'ArrayExpr': {
+                return {
+                    name: 'ArrayExpr',
+                    mandatory: [
+                        { name: 'items', type: 'array' }
+                    ]
+                };
+            }
+            case 'Attribute': {
+                return {
+                    name: 'Attribute',
+                    mandatory: [
+                        { name: 'params', type: 'array' }
+                    ]
+                };
+            }
+            case 'AttributeParam': {
+                return {
+                    name: 'AttributeParam',
+                    mandatory: [
+                        { name: 'positional', type: 'boolean' }
+                    ]
+                };
+            }
+            case 'AttributeParamType': {
+                return {
+                    name: 'AttributeParamType',
+                    mandatory: [
+                        { name: 'array', type: 'boolean' },
+                        { name: 'optional', type: 'boolean' }
+                    ]
+                };
+            }
+            case 'DataModel': {
+                return {
+                    name: 'DataModel',
+                    mandatory: [
+                        { name: 'attributes', type: 'array' },
+                        { name: 'fields', type: 'array' }
+                    ]
+                };
+            }
+            case 'DataModelAttribute': {
+                return {
+                    name: 'DataModelAttribute',
+                    mandatory: [
+                        { name: 'args', type: 'array' }
+                    ]
+                };
+            }
+            case 'DataModelField': {
+                return {
+                    name: 'DataModelField',
+                    mandatory: [
+                        { name: 'attributes', type: 'array' }
+                    ]
+                };
+            }
+            case 'DataModelFieldAttribute': {
+                return {
+                    name: 'DataModelFieldAttribute',
+                    mandatory: [
+                        { name: 'args', type: 'array' }
+                    ]
+                };
+            }
+            case 'DataModelFieldType': {
+                return {
+                    name: 'DataModelFieldType',
+                    mandatory: [
+                        { name: 'array', type: 'boolean' },
+                        { name: 'optional', type: 'boolean' }
+                    ]
+                };
+            }
+            case 'DataSource': {
+                return {
+                    name: 'DataSource',
+                    mandatory: [
+                        { name: 'fields', type: 'array' }
+                    ]
+                };
+            }
+            case 'Enum': {
+                return {
+                    name: 'Enum',
+                    mandatory: [
+                        { name: 'fields', type: 'array' }
+                    ]
+                };
+            }
+            case 'Function': {
+                return {
+                    name: 'Function',
+                    mandatory: [
+                        { name: 'params', type: 'array' }
+                    ]
+                };
+            }
+            case 'FunctionParamType': {
+                return {
+                    name: 'FunctionParamType',
+                    mandatory: [
+                        { name: 'array', type: 'boolean' }
+                    ]
+                };
+            }
+            case 'InvocationExpr': {
+                return {
+                    name: 'InvocationExpr',
+                    mandatory: [
+                        { name: 'args', type: 'array' }
+                    ]
+                };
+            }
+            case 'Model': {
+                return {
+                    name: 'Model',
+                    mandatory: [
+                        { name: 'declarations', type: 'array' }
+                    ]
+                };
+            }
+            case 'ReferenceExpr': {
+                return {
+                    name: 'ReferenceExpr',
+                    mandatory: [
+                        { name: 'args', type: 'array' }
+                    ]
+                };
+            }
+            default: {
+                return {
+                    name: type,
+                    mandatory: []
+                };
+            }
+        }
+    }
+}
+
+export const reflection = new ZModelAstReflection();

package/{out/language-server/generated/grammar.js → packages/schema/src/language-server/generated/grammar.ts}

@@ -1,13 +1,12 @@
-"use strict";
 /******************************************************************************
  * This file was generated by langium-cli 0.4.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZModelGrammar = void 0;
-const langium_1 = require("langium");
-let loadedZModelGrammar;
-const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, langium_1.loadGrammar)(`{
+
+import { loadGrammar, Grammar } from 'langium';
+
+let loadedZModelGrammar: Grammar | undefined;
+export const ZModelGrammar = (): Grammar => loadedZModelGrammar ||(loadedZModelGrammar = loadGrammar(`{
   "$type": "Grammar",
   "isDeclared": true,
   "name": "ZModel",
@@ -2189,5 +2188,3 @@ const ZModelGrammar = () => loadedZModelGrammar || (loadedZModelGrammar = (0, la
   "interfaces": [],
   "usedGrammars": []
 }`));
-exports.ZModelGrammar = ZModelGrammar;
-//# sourceMappingURL=grammar.js.map

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

@@ -0,0 +1,24 @@
+/******************************************************************************
+ * This file was generated by langium-cli 0.4.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/packages/schema/src/language-server/main.ts

@@ -0,0 +1,12 @@
+import { startLanguageServer } from 'langium';
+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 });
+
+// Start the language server with the shared services
+startLanguageServer(shared);

package/packages/schema/src/language-server/types.ts

@@ -0,0 +1,9 @@
+import { AstNode } from 'langium';
+import { AbstractDeclaration } from './generated/ast';
+
+export type TypedNode = AstNode & {
+    $resolvedType?: {
+        decl?: string | AbstractDeclaration;
+        array?: boolean;
+    };
+};