zenstack 0.1.0

package/src/generator/prisma/index.ts

@@ -0,0 +1,323 @@
+import { writeFile } from 'fs/promises';
+import { AstNode } from 'langium';
+import path from 'path';
+import colors from 'colors';
+import {
+    AttributeArg,
+    DataModel,
+    DataModelAttribute,
+    DataModelField,
+    DataModelFieldAttribute,
+    DataSource,
+    Enum,
+    Expression,
+    InvocationExpr,
+    isArrayExpr,
+    isInvocationExpr,
+    isLiteralExpr,
+    isReferenceExpr,
+    LiteralExpr,
+} from '@lang/generated/ast';
+import { Context, Generator, GeneratorError } from '../types';
+import {
+    AttributeArg as PrismaAttributeArg,
+    AttributeArgValue as PrismaAttributeArgValue,
+    DataSourceUrl as PrismaDataSourceUrl,
+    FieldAttribute as PrismaFieldAttribute,
+    ModelAttribute as PrismaModelAttribute,
+    Model as PrismaDataModel,
+    FieldReference as PrismaFieldReference,
+    FieldReferenceArg as PrismaFieldReferenceArg,
+    FunctionCall as PrismaFunctionCall,
+    FunctionCallArg as PrismaFunctionCallArg,
+    PrismaModel,
+    ModelFieldType,
+} from './prisma-builder';
+import { execSync } from 'child_process';
+
+const supportedProviders = ['postgresql', 'mysql', 'sqlite', 'sqlserver'];
+const supportedAttrbutes = [
+    'id',
+    'index',
+    'relation',
+    'default',
+    'createdAt',
+    'updatedAt',
+    'unique',
+];
+
+export default class PrismaGenerator implements Generator {
+    async generate(context: Context) {
+        const { schema } = context;
+        const prisma = new PrismaModel();
+
+        for (const decl of schema.declarations) {
+            switch (decl.$type) {
+                case DataSource:
+                    this.generateDataSource(
+                        context,
+                        prisma,
+                        decl as DataSource
+                    );
+                    break;
+
+                case Enum:
+                    this.generateEnum(context, prisma, decl as Enum);
+                    break;
+
+                case DataModel:
+                    this.generateModel(context, prisma, decl as DataModel);
+                    break;
+            }
+        }
+
+        this.generateGenerator(context, prisma);
+
+        const outFile = path.join(context.outDir, 'schema.prisma');
+        await writeFile(outFile, prisma.toString());
+        console.log(colors.blue(`  ✔️ Prisma schema generated`));
+
+        // run prisma generate and install @prisma/client
+        await this.generatePrismaClient(outFile);
+    }
+
+    async generatePrismaClient(schemaFile: string) {
+        try {
+            execSync('npx prisma');
+        } catch (err) {
+            execSync(`npm i prisma @prisma/client`);
+            console.log(colors.blue('  ✔️ Prisma package installed'));
+        }
+
+        execSync(`npx prisma generate --schema "${schemaFile}"`);
+        console.log(colors.blue('  ✔️ Prisma client generated'));
+    }
+
+    private isStringLiteral(node: AstNode): node is LiteralExpr {
+        return isLiteralExpr(node) && typeof node.value === 'string';
+    }
+
+    private generateDataSource(
+        context: Context,
+        prisma: PrismaModel,
+        dataSource: DataSource
+    ) {
+        let provider: string | undefined = undefined;
+        let url: PrismaDataSourceUrl | undefined = undefined;
+        let shadowDatabaseUrl: PrismaDataSourceUrl | undefined = undefined;
+
+        for (const f of dataSource.fields) {
+            switch (f.name) {
+                case 'provider': {
+                    if (this.isStringLiteral(f.value)) {
+                        provider = f.value.value as string;
+                    } else {
+                        throw new GeneratorError(
+                            'Datasource provider must be set to a string'
+                        );
+                    }
+                    if (!supportedProviders.includes(provider)) {
+                        throw new GeneratorError(
+                            `Provider ${provider} is not supported. Supported providers: ${supportedProviders.join(
+                                ', '
+                            )}`
+                        );
+                    }
+                    break;
+                }
+
+                case 'url': {
+                    const r = this.extractDataSourceUrl(f.value);
+                    if (!r) {
+                        throw new GeneratorError(
+                            'Invalid value for datasource url'
+                        );
+                    }
+                    url = r;
+                    break;
+                }
+
+                case 'shadowDatabaseUrl': {
+                    const r = this.extractDataSourceUrl(f.value);
+                    if (!r) {
+                        throw new GeneratorError(
+                            'Invalid value for datasource url'
+                        );
+                    }
+                    shadowDatabaseUrl = r;
+                    break;
+                }
+            }
+        }
+
+        if (!provider) {
+            throw new GeneratorError('Datasource is missing "provider" field');
+        }
+        if (!url) {
+            throw new GeneratorError('Datasource is missing "url" field');
+        }
+
+        prisma.addDataSource(dataSource.name, provider, url, shadowDatabaseUrl);
+    }
+
+    private extractDataSourceUrl(fieldValue: LiteralExpr | InvocationExpr) {
+        if (this.isStringLiteral(fieldValue)) {
+            return new PrismaDataSourceUrl(fieldValue.value as string, false);
+        } else if (
+            isInvocationExpr(fieldValue) &&
+            fieldValue.function.ref?.name === 'env' &&
+            fieldValue.args.length === 1 &&
+            this.isStringLiteral(fieldValue.args[0].value)
+        ) {
+            return new PrismaDataSourceUrl(
+                fieldValue.args[0].value.value as string,
+                true
+            );
+        } else {
+            return null;
+        }
+    }
+
+    private generateGenerator(context: Context, prisma: PrismaModel) {
+        prisma.addGenerator(
+            'client',
+            'prisma-client-js',
+            path.join(context.outDir, '.prisma'),
+            ['fieldReference']
+        );
+    }
+
+    private generateModel(
+        context: Context,
+        prisma: PrismaModel,
+        decl: DataModel
+    ) {
+        const model = prisma.addModel(decl.name);
+        for (const field of decl.fields) {
+            this.generateModelField(model, field);
+        }
+
+        // add an "zenstack_guard" field for dealing with pure auth() related conditions
+        model.addField('zenstack_guard', 'Boolean', [
+            new PrismaFieldAttribute('default', [
+                new PrismaAttributeArg(
+                    undefined,
+                    new PrismaAttributeArgValue('Boolean', true)
+                ),
+            ]),
+        ]);
+
+        for (const attr of decl.attributes.filter((attr) =>
+            supportedAttrbutes.includes(attr.decl.ref?.name!)
+        )) {
+            this.generateModelAttribute(model, attr);
+        }
+    }
+
+    private generateModelField(model: PrismaDataModel, field: DataModelField) {
+        const type = new ModelFieldType(
+            (field.type.type || field.type.reference?.ref?.name)!,
+            field.type.array,
+            field.type.optional
+        );
+
+        const attributes = field.attributes
+            .filter((attr) => supportedAttrbutes.includes(attr.decl.ref?.name!))
+            .map((attr) => this.makeFieldAttribute(attr));
+        model.addField(field.name, type, attributes);
+    }
+
+    private makeFieldAttribute(attr: DataModelFieldAttribute) {
+        return new PrismaFieldAttribute(
+            attr.decl.ref?.name!,
+            attr.args.map((arg) => this.makeAttributeArg(arg))
+        );
+    }
+
+    makeAttributeArg(arg: AttributeArg): PrismaAttributeArg {
+        return new PrismaAttributeArg(
+            arg.name,
+            this.makeAttributeArgValue(arg.value)
+        );
+    }
+
+    makeAttributeArgValue(node: Expression): PrismaAttributeArgValue {
+        if (isLiteralExpr(node)) {
+            switch (typeof node.value) {
+                case 'string':
+                    return new PrismaAttributeArgValue('String', node.value);
+                case 'number':
+                    return new PrismaAttributeArgValue('Number', node.value);
+                case 'boolean':
+                    return new PrismaAttributeArgValue('Boolean', node.value);
+                default:
+                    throw new GeneratorError(
+                        `Unexpected literal type: ${typeof node.value}`
+                    );
+            }
+        } else if (isArrayExpr(node)) {
+            return new PrismaAttributeArgValue(
+                'Array',
+                new Array(
+                    ...node.items.map((item) =>
+                        this.makeAttributeArgValue(item)
+                    )
+                )
+            );
+        } else if (isReferenceExpr(node)) {
+            return new PrismaAttributeArgValue(
+                'FieldReference',
+                new PrismaFieldReference(
+                    node.target.ref?.name!,
+                    node.args.map(
+                        (arg) =>
+                            new PrismaFieldReferenceArg(arg.name, arg.value)
+                    )
+                )
+            );
+        } else if (isInvocationExpr(node)) {
+            // invocation
+            return new PrismaAttributeArgValue(
+                'FunctionCall',
+                this.makeFunctionCall(node)
+            );
+        } else {
+            throw new GeneratorError(
+                `Unsupported attribute argument expression type: ${node.$type}`
+            );
+        }
+    }
+
+    makeFunctionCall(node: InvocationExpr): PrismaFunctionCall {
+        return new PrismaFunctionCall(
+            node.function.ref?.name!,
+            node.args.map((arg) => {
+                if (!isLiteralExpr(arg.value)) {
+                    throw new GeneratorError(
+                        'Function call argument must be literal'
+                    );
+                }
+                return new PrismaFunctionCallArg(arg.name, arg.value.value);
+            })
+        );
+    }
+
+    private generateModelAttribute(
+        model: PrismaDataModel,
+        attr: DataModelAttribute
+    ) {
+        model.attributes.push(
+            new PrismaModelAttribute(
+                attr.decl.ref?.name!,
+                attr.args.map((arg) => this.makeAttributeArg(arg))
+            )
+        );
+    }
+
+    private generateEnum(context: Context, prisma: PrismaModel, decl: Enum) {
+        prisma.addEnum(
+            decl.name,
+            decl.fields.map((f) => f.name)
+        );
+    }
+}

package/src/generator/prisma/prisma-builder.ts

@@ -0,0 +1,366 @@
+import indentString from '../../utils/indent-string';
+
+export class PrismaModel {
+    private datasources: DataSource[] = [];
+    private generators: Generator[] = [];
+    private models: Model[] = [];
+    private enums: Enum[] = [];
+
+    addDataSource(
+        name: string,
+        provider: string,
+        url: DataSourceUrl,
+        shadowDatabaseUrl?: DataSourceUrl
+    ) {
+        const ds = new DataSource(name, provider, url, shadowDatabaseUrl);
+        this.datasources.push(ds);
+        return ds;
+    }
+
+    addGenerator(
+        name: string,
+        provider: string,
+        output: string,
+        previewFeatures?: string[]
+    ) {
+        const generator = new Generator(
+            name,
+            provider,
+            output,
+            previewFeatures
+        );
+        this.generators.push(generator);
+        return generator;
+    }
+
+    addModel(name: string) {
+        const model = new Model(name);
+        this.models.push(model);
+        return model;
+    }
+
+    addEnum(name: string, fields: string[]) {
+        const e = new Enum(name, fields);
+        this.enums.push(e);
+        return e;
+    }
+
+    toString() {
+        return [
+            ...this.datasources,
+            ...this.generators,
+            ...this.enums,
+            ...this.models,
+        ]
+            .map((d) => d.toString())
+            .join('\n\n');
+    }
+}
+
+export class DataSource {
+    constructor(
+        public name: string,
+        public provider: string,
+        public url: DataSourceUrl,
+        public shadowDatabaseUrl?: DataSourceUrl
+    ) {}
+
+    toString() {
+        return (
+            `datasource ${this.name} {\n` +
+            indentString(`provider="${this.provider}"\n`) +
+            indentString(`url=${this.url}\n`) +
+            (this.shadowDatabaseUrl
+                ? indentString(`shadowDatabaseurl=${this.shadowDatabaseUrl}\n`)
+                : '') +
+            `}`
+        );
+    }
+}
+
+export class DataSourceUrl {
+    constructor(public value: string, public isEnv: boolean) {}
+
+    toString() {
+        return this.isEnv ? `env("${this.value}")` : `"${this.value}"`;
+    }
+}
+
+export class Generator {
+    constructor(
+        public name: string,
+        public provider: string,
+        public output: string,
+        public previewFeatures?: string[]
+    ) {}
+
+    toString() {
+        return (
+            `generator ${this.name} {\n` +
+            indentString(`provider = "${this.provider}"\n`) +
+            indentString(`output = "${this.output}"\n`) +
+            (this.previewFeatures
+                ? indentString(
+                      `previewFeatures = [${this.previewFeatures
+                          ?.map((f) => '"' + f + '"')
+                          .join(',')}]\n`
+                  )
+                : '') +
+            `}`
+        );
+    }
+}
+
+export class Model {
+    public fields: ModelField[] = [];
+    public attributes: ModelAttribute[] = [];
+    constructor(public name: string) {}
+
+    addField(
+        name: string,
+        type: ModelFieldType | string,
+        attributes: FieldAttribute[] = []
+    ) {
+        const field = new ModelField(name, type, attributes);
+        this.fields.push(field);
+        return field;
+    }
+
+    addAttribute(name: string, args: AttributeArg[] = []) {
+        const attr = new ModelAttribute(name, args);
+        this.attributes.push(attr);
+        return attr;
+    }
+
+    toString() {
+        return (
+            `model ${this.name} {\n` +
+            indentString(
+                [...this.fields, ...this.attributes]
+                    .map((d) => d.toString())
+                    .join('\n')
+            ) +
+            `\n}`
+        );
+    }
+}
+
+export type ScalarTypes =
+    | 'String'
+    | 'Boolean'
+    | 'Int'
+    | 'BigInt'
+    | 'Float'
+    | 'Decimal'
+    | 'DateTime'
+    | 'Json'
+    | 'Bytes'
+    | 'Unsupported';
+
+export class ModelFieldType {
+    constructor(
+        public type: ScalarTypes | string,
+        public array?: boolean,
+        public optional?: boolean
+    ) {}
+
+    toString() {
+        return `${this.type}${this.array ? '[]' : ''}${
+            this.optional ? '?' : ''
+        }`;
+    }
+}
+
+export class ModelField {
+    constructor(
+        public name: string,
+        public type: ModelFieldType | string,
+        public attributes: FieldAttribute[] = []
+    ) {}
+
+    addAttribute(name: string, args: AttributeArg[] = []) {
+        const attr = new FieldAttribute(name, args);
+        this.attributes.push(attr);
+        return attr;
+    }
+
+    toString() {
+        return (
+            `${this.name} ${this.type}` +
+            (this.attributes.length > 0
+                ? ' ' + this.attributes.map((a) => a.toString()).join(' ')
+                : '')
+        );
+    }
+}
+
+export class FieldAttribute {
+    constructor(public name: string, public args: AttributeArg[] = []) {}
+
+    toString() {
+        return (
+            `@${this.name}(` +
+            this.args.map((a) => a.toString()).join(', ') +
+            `)`
+        );
+    }
+}
+
+export class ModelAttribute {
+    constructor(public name: string, public args: AttributeArg[] = []) {}
+
+    toString() {
+        return (
+            `@@${this.name}(` +
+            this.args.map((a) => a.toString()).join(', ') +
+            `)`
+        );
+    }
+}
+
+export class AttributeArg {
+    constructor(
+        public name: string | undefined,
+        public value: AttributeArgValue
+    ) {}
+
+    toString() {
+        return this.name
+            ? `${this.name}: ${this.value}`
+            : this.value.toString();
+    }
+}
+
+export class AttributeArgValue {
+    constructor(
+        public type:
+            | 'String'
+            | 'FieldReference'
+            | 'Number'
+            | 'Boolean'
+            | 'Array'
+            | 'FunctionCall',
+        public value:
+            | string
+            | number
+            | boolean
+            | FieldReference
+            | FunctionCall
+            | AttributeArgValue[]
+    ) {
+        switch (type) {
+            case 'String':
+                if (typeof value !== 'string')
+                    throw new Error('Value must be string');
+                break;
+            case 'Number':
+                if (typeof value !== 'number')
+                    throw new Error('Value must be number');
+                break;
+            case 'Boolean':
+                if (typeof value !== 'boolean')
+                    throw new Error('Value must be boolean');
+                break;
+            case 'Array':
+                if (!Array.isArray(value))
+                    throw new Error('Value must be array');
+                break;
+            case 'FieldReference':
+                if (
+                    typeof value !== 'string' &&
+                    !(value instanceof FieldReference)
+                )
+                    throw new Error('Value must be string or FieldReference');
+                break;
+            case 'FunctionCall':
+                if (!(value instanceof FunctionCall))
+                    throw new Error('Value must be FunctionCall');
+                break;
+        }
+    }
+
+    toString(): string {
+        switch (this.type) {
+            case 'String':
+                return `"${this.value}"`;
+            case 'Number':
+                return this.value.toString();
+            case 'FieldReference': {
+                if (typeof this.value === 'string') {
+                    return this.value;
+                } else {
+                    const fr = this.value as FieldReference;
+                    let r = fr.field;
+                    if (fr.args.length > 0) {
+                        r +=
+                            '(' +
+                            fr.args.map((a) => a.toString()).join(',') +
+                            ')';
+                    }
+                    return r;
+                }
+            }
+            case 'FunctionCall':
+                return this.value.toString();
+            case 'Boolean':
+                return this.value ? 'true' : 'false';
+            case 'Array':
+                return (
+                    '[' +
+                    (this.value as AttributeArgValue[])
+                        .map((v) => v.toString())
+                        .join(', ') +
+                    ']'
+                );
+            default:
+                throw new Error(`Unknown attribute value type ${this.type}`);
+        }
+    }
+}
+
+export class FieldReference {
+    constructor(public field: string, public args: FieldReferenceArg[] = []) {}
+}
+
+export class FieldReferenceArg {
+    constructor(public name: 'sort', public value: 'Asc' | 'Desc') {}
+
+    toString() {
+        return `${this.name}: ${this.value}`;
+    }
+}
+
+export class FunctionCall {
+    constructor(public func: string, public args: FunctionCallArg[] = []) {}
+
+    toString() {
+        return (
+            `${this.func}` +
+            '(' +
+            this.args.map((a) => a.toString()).join(', ') +
+            ')'
+        );
+    }
+}
+
+export class FunctionCallArg {
+    constructor(public name: string | undefined, public value: any) {}
+
+    toString() {
+        return this.name ? `${this.name}: ${this.value}` : this.value;
+    }
+}
+
+export class Enum {
+    constructor(public name: string, public fields: EnumField[]) {}
+
+    toString() {
+        return (
+            `enum ${this.name} {\n` +
+            indentString(this.fields.join('\n')) +
+            '\n}'
+        );
+    }
+}
+
+type EnumField = String;