zenstack 0.1.47 → 0.1.50

package/src/generator/types.ts

@@ -0,0 +1,17 @@
+import { Model } from '@lang/generated/ast';
+
+export interface Context {
+    schema: Model;
+    outDir: string;
+    generatedCodeDir: string;
+}
+
+export interface Generator {
+    generate(context: Context): Promise<void>;
+}
+
+export class GeneratorError extends Error {
+    constructor(message: string) {
+        super(message);
+    }
+}

package/src/generator/utils.ts

@@ -0,0 +1,18 @@
+import { DataModel, isDataModel, Model } from '@lang/generated/ast';
+import { AstNode, Reference } from 'langium';
+import { GeneratorError } from './types';
+
+export function extractDataModelsWithAllowRules(model: Model): DataModel[] {
+    return model.declarations.filter(
+        (d) =>
+            isDataModel(d) &&
+            !!d.attributes.find((attr) => attr.decl.ref?.name === '@@allow')
+    ) as DataModel[];
+}
+
+export function resolved<T extends AstNode>(ref: Reference<T>): T {
+    if (!ref.ref) {
+        throw new GeneratorError(`Reference not resolved: ${ref.$refText}`);
+    }
+    return ref.ref;
+}

package/src/language-server/constants.ts

@@ -0,0 +1,28 @@
+/**
+ * Supported Prisma db providers
+ */
+export const SUPPORTED_PROVIDERS = [
+    'postgresql',
+    'mysql',
+    'sqlite',
+    'sqlserver',
+];
+
+/**
+ * All scalar types
+ */
+export const SCALAR_TYPES = [
+    'String',
+    'Int',
+    'Float',
+    'Decimal',
+    'BigInt',
+    'Boolean',
+    'Bytes',
+    'DateTime',
+];
+
+/**
+ * Name of standard library module
+ */
+export const STD_LIB_MODULE_NAME = 'stdlib.zmodel';

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

@@ -0,0 +1,616 @@
+/******************************************************************************
+ * This file was generated by langium-cli 0.5.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable @typescript-eslint/array-type */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+import { AstNode, AstReflection, Reference, ReferenceInfo, 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 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 const Expression = 'Expression';
+
+export function isExpression(item: unknown): item is Expression {
+    return reflection.isInstance(item, Expression);
+}
+
+export type ExpressionType = 'Any' | 'Boolean' | 'DateTime' | 'Float' | 'Int' | 'Null' | 'String';
+
+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: AttributeName
+    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;
+    default: boolean
+    name: string
+    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
+    reference?: Reference<TypeDeclaration>
+    type?: 'ContextType' | 'FieldReference' | ExpressionType
+}
+
+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?: BuiltinType
+}
+
+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?: ExpressionType
+}
+
+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 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(refInfo: ReferenceInfo): string {
+        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
+        switch (referenceId) {
+            case 'AttributeParamType:reference': {
+                return TypeDeclaration;
+            }
+            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: 'default', 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 → src/language-server/generated/grammar.ts}

@@ -1,13 +1,12 @@
-"use strict";
 /******************************************************************************
  * This file was generated by langium-cli 0.5.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 !== null && loadedZModelGrammar !== void 0 ? loadedZModelGrammar : (loadedZModelGrammar = (0, langium_1.loadGrammarFromJson)(`{
+
+import { loadGrammarFromJson, Grammar } from 'langium';
+
+let loadedZModelGrammar: Grammar | undefined;
+export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModelGrammar = loadGrammarFromJson(`{
   "$type": "Grammar",
   "isDeclared": true,
   "name": "ZModel",
@@ -2388,5 +2387,3 @@ const ZModelGrammar = () => loadedZModelGrammar !== null && loadedZModelGrammar
   "interfaces": [],
   "usedGrammars": []
 }`));
-exports.ZModelGrammar = ZModelGrammar;
-//# sourceMappingURL=grammar.js.map