@zenstackhq/language 0.6.0-pre.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 ZenStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/ast.d.ts

@@ -0,0 +1,2 @@
+export * from './generated/ast';
+export { AstNode, Reference } from 'langium';

package/ast.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generated/ast"), exports);
+//# sourceMappingURL=ast.js.map

package/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC"}

package/generated/ast.d.ts

@@ -0,0 +1,268 @@
+/******************************************************************************
+ * This file was generated by langium-cli 0.5.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import { AstNode, AstReflection, Reference, ReferenceInfo, TypeMetaData } from 'langium';
+export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | Function | Generator | Plugin;
+export declare const AbstractDeclaration = "AbstractDeclaration";
+export declare function isAbstractDeclaration(item: unknown): item is AbstractDeclaration;
+export type AttributeAttributeName = string;
+export type AttributeName = string;
+export type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String';
+export type DataModelAttributeName = string;
+export type DataModelFieldAttributeName = string;
+export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ReferenceExpr | ThisExpr | UnaryExpr;
+export declare const Expression = "Expression";
+export declare function isExpression(item: unknown): item is Expression;
+export type ExpressionType = 'Any' | 'Boolean' | 'DateTime' | 'Float' | 'Int' | 'Null' | 'String';
+export type ReferenceTarget = DataModelField | EnumField | FunctionParam;
+export declare const ReferenceTarget = "ReferenceTarget";
+export declare function isReferenceTarget(item: unknown): item is ReferenceTarget;
+export type TypeDeclaration = DataModel | Enum;
+export declare const TypeDeclaration = "TypeDeclaration";
+export declare function isTypeDeclaration(item: unknown): item is TypeDeclaration;
+export interface Argument extends AstNode {
+    readonly $container: InvocationExpr;
+    name?: string;
+    value: Expression;
+}
+export declare const Argument = "Argument";
+export declare function isArgument(item: unknown): item is Argument;
+export interface ArrayExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    items: Array<Expression>;
+}
+export declare const ArrayExpr = "ArrayExpr";
+export declare function isArrayExpr(item: unknown): item is ArrayExpr;
+export interface Attribute extends AstNode {
+    readonly $container: Model;
+    attributes: Array<AttributeAttribute>;
+    name: AttributeName;
+    params: Array<AttributeParam>;
+}
+export declare const Attribute = "Attribute";
+export declare function isAttribute(item: unknown): item is Attribute;
+export interface AttributeArg extends AstNode {
+    readonly $container: AttributeAttribute | DataModelAttribute | DataModelFieldAttribute;
+    name?: string;
+    value: Expression;
+}
+export declare const AttributeArg = "AttributeArg";
+export declare function isAttributeArg(item: unknown): item is AttributeArg;
+export interface AttributeAttribute extends AstNode {
+    readonly $container: Attribute;
+    args: Array<AttributeArg>;
+    decl: Reference<Attribute>;
+}
+export declare const AttributeAttribute = "AttributeAttribute";
+export declare function isAttributeAttribute(item: unknown): item is AttributeAttribute;
+export interface AttributeParam extends AstNode {
+    readonly $container: Attribute;
+    default: boolean;
+    name: string;
+    type: AttributeParamType;
+}
+export declare const AttributeParam = "AttributeParam";
+export declare function isAttributeParam(item: unknown): item is AttributeParam;
+export interface AttributeParamType extends AstNode {
+    readonly $container: AttributeParam;
+    array: boolean;
+    optional: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: 'ContextType' | 'FieldReference' | ExpressionType;
+}
+export declare const AttributeParamType = "AttributeParamType";
+export declare function isAttributeParamType(item: unknown): item is AttributeParamType;
+export interface BinaryExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    left: Expression;
+    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | '||';
+    right: Expression;
+}
+export declare const BinaryExpr = "BinaryExpr";
+export declare function isBinaryExpr(item: unknown): item is BinaryExpr;
+export interface DataModel extends AstNode {
+    readonly $container: Model;
+    attributes: Array<DataModelAttribute>;
+    fields: Array<DataModelField>;
+    name: string;
+}
+export declare const DataModel = "DataModel";
+export declare function isDataModel(item: unknown): item is DataModel;
+export interface DataModelAttribute extends AstNode {
+    readonly $container: DataModel;
+    args: Array<AttributeArg>;
+    decl: Reference<Attribute>;
+}
+export declare const DataModelAttribute = "DataModelAttribute";
+export declare function isDataModelAttribute(item: unknown): item is DataModelAttribute;
+export interface DataModelField extends AstNode {
+    readonly $container: DataModel;
+    attributes: Array<DataModelFieldAttribute>;
+    name: string;
+    type: DataModelFieldType;
+}
+export declare const DataModelField = "DataModelField";
+export declare function isDataModelField(item: unknown): item is DataModelField;
+export interface DataModelFieldAttribute extends AstNode {
+    readonly $container: DataModelField;
+    args: Array<AttributeArg>;
+    decl: Reference<Attribute>;
+}
+export declare const DataModelFieldAttribute = "DataModelFieldAttribute";
+export declare function isDataModelFieldAttribute(item: unknown): item is DataModelFieldAttribute;
+export interface DataModelFieldType extends AstNode {
+    readonly $container: DataModelField;
+    array: boolean;
+    optional: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: BuiltinType;
+}
+export declare const DataModelFieldType = "DataModelFieldType";
+export declare function isDataModelFieldType(item: unknown): item is DataModelFieldType;
+export interface DataSource extends AstNode {
+    readonly $container: Model;
+    fields: Array<DataSourceField>;
+    name: string;
+}
+export declare const DataSource = "DataSource";
+export declare function isDataSource(item: unknown): item is DataSource;
+export interface DataSourceField extends AstNode {
+    readonly $container: DataSource;
+    name: string;
+    value: InvocationExpr | LiteralExpr;
+}
+export declare const DataSourceField = "DataSourceField";
+export declare function isDataSourceField(item: unknown): item is DataSourceField;
+export interface Enum extends AstNode {
+    readonly $container: Model;
+    fields: Array<EnumField>;
+    name: string;
+}
+export declare const Enum = "Enum";
+export declare function isEnum(item: unknown): item is Enum;
+export interface EnumField extends AstNode {
+    readonly $container: Enum;
+    name: string;
+}
+export declare const EnumField = "EnumField";
+export declare function isEnumField(item: unknown): item is EnumField;
+export interface Function extends AstNode {
+    readonly $container: Model;
+    expression?: Expression;
+    name: string;
+    params: Array<FunctionParam>;
+    returnType: FunctionParamType;
+}
+export declare const Function = "Function";
+export declare function isFunction(item: unknown): item is Function;
+export interface FunctionParam extends AstNode {
+    readonly $container: Function;
+    name: string;
+    type: FunctionParamType;
+}
+export declare const FunctionParam = "FunctionParam";
+export declare function isFunctionParam(item: unknown): item is FunctionParam;
+export interface FunctionParamType extends AstNode {
+    readonly $container: Function | FunctionParam;
+    array: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: ExpressionType;
+}
+export declare const FunctionParamType = "FunctionParamType";
+export declare function isFunctionParamType(item: unknown): item is FunctionParamType;
+export interface Generator extends AstNode {
+    readonly $container: Model;
+    fields: Array<GeneratorField>;
+    name: string;
+}
+export declare const Generator = "Generator";
+export declare function isGenerator(item: unknown): item is Generator;
+export interface GeneratorField extends AstNode {
+    readonly $container: Generator;
+    name: string;
+    value: ArrayExpr | LiteralExpr;
+}
+export declare const GeneratorField = "GeneratorField";
+export declare function isGeneratorField(item: unknown): item is GeneratorField;
+export interface InvocationExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    args: Array<Argument>;
+    function: Reference<Function>;
+}
+export declare const InvocationExpr = "InvocationExpr";
+export declare function isInvocationExpr(item: unknown): item is InvocationExpr;
+export interface LiteralExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    value: boolean | number | string;
+}
+export declare const LiteralExpr = "LiteralExpr";
+export declare function isLiteralExpr(item: unknown): item is LiteralExpr;
+export interface MemberAccessExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    member: Reference<DataModelField>;
+    operand: Expression;
+}
+export declare const MemberAccessExpr = "MemberAccessExpr";
+export declare function isMemberAccessExpr(item: unknown): item is MemberAccessExpr;
+export interface Model extends AstNode {
+    declarations: Array<AbstractDeclaration>;
+}
+export declare const Model = "Model";
+export declare function isModel(item: unknown): item is Model;
+export interface NullExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    value: string;
+}
+export declare const NullExpr = "NullExpr";
+export declare function isNullExpr(item: unknown): item is NullExpr;
+export interface Plugin extends AstNode {
+    readonly $container: Model;
+    fields: Array<PluginField>;
+    name: string;
+}
+export declare const Plugin = "Plugin";
+export declare function isPlugin(item: unknown): item is Plugin;
+export interface PluginField extends AstNode {
+    readonly $container: Plugin;
+    name: string;
+    value: ArrayExpr | LiteralExpr;
+}
+export declare const PluginField = "PluginField";
+export declare function isPluginField(item: unknown): item is PluginField;
+export interface ReferenceArg extends AstNode {
+    readonly $container: ReferenceExpr;
+    name: 'sort';
+    value: 'Asc' | 'Desc';
+}
+export declare const ReferenceArg = "ReferenceArg";
+export declare function isReferenceArg(item: unknown): item is ReferenceArg;
+export interface ReferenceExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    args: Array<ReferenceArg>;
+    target: Reference<ReferenceTarget>;
+}
+export declare const ReferenceExpr = "ReferenceExpr";
+export declare function isReferenceExpr(item: unknown): item is ReferenceExpr;
+export interface ThisExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    value: string;
+}
+export declare const ThisExpr = "ThisExpr";
+export declare function isThisExpr(item: unknown): item is ThisExpr;
+export interface UnaryExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    operand: Expression;
+    operator: '!';
+}
+export declare const UnaryExpr = "UnaryExpr";
+export declare function isUnaryExpr(item: unknown): item is UnaryExpr;
+export type ZModelAstType = 'AbstractDeclaration' | 'Argument' | 'ArrayExpr' | 'Attribute' | 'AttributeArg' | 'AttributeAttribute' | 'AttributeParam' | 'AttributeParamType' | 'BinaryExpr' | 'DataModel' | 'DataModelAttribute' | 'DataModelField' | 'DataModelFieldAttribute' | 'DataModelFieldType' | 'DataSource' | 'DataSourceField' | 'Enum' | 'EnumField' | 'Expression' | 'Function' | 'FunctionParam' | 'FunctionParamType' | 'Generator' | 'GeneratorField' | 'InvocationExpr' | 'LiteralExpr' | 'MemberAccessExpr' | 'Model' | 'NullExpr' | 'Plugin' | 'PluginField' | 'ReferenceArg' | 'ReferenceExpr' | 'ReferenceTarget' | 'ThisExpr' | 'TypeDeclaration' | 'UnaryExpr';
+export declare class ZModelAstReflection implements AstReflection {
+    getAllTypes(): string[];
+    isInstance(node: unknown, type: string): boolean;
+    isSubtype(subtype: string, supertype: string): boolean;
+    getReferenceType(refInfo: ReferenceInfo): string;
+    getTypeMetaData(type: string): TypeMetaData;
+}
+export declare const reflection: ZModelAstReflection;