zenstack 0.1.0

package/src/generator/server/data/expression-writer.ts

@@ -0,0 +1,350 @@
+import {
+    BinaryExpr,
+    Expression,
+    isDataModel,
+    isDataModelField,
+    isEnumField,
+    isMemberAccessExpr,
+    isReferenceExpr,
+    LiteralExpr,
+    MemberAccessExpr,
+    ReferenceExpr,
+    ThisExpr,
+    UnaryExpr,
+} from '@lang/generated/ast';
+import { CodeBlockWriter } from 'ts-morph';
+import { GeneratorError } from '../../types';
+import { TypedNode } from '@lang/types';
+import PlainExpressionBuilder from './plain-expression-builder';
+
+const AUX_GUARD_FIELD = 'zenstack_guard';
+
+type ComparisonOperator = '==' | '!=' | '>' | '>=' | '<' | '<=';
+
+export default class ExpressionWriter {
+    private readonly plainExprBuilder = new PlainExpressionBuilder();
+
+    constructor(private readonly writer: CodeBlockWriter) {}
+
+    write(expr: Expression) {
+        const _write = () => {
+            switch (expr.$type) {
+                case LiteralExpr:
+                    this.writeLiteral(expr as LiteralExpr);
+                    break;
+
+                case UnaryExpr:
+                    this.writeUnary(expr as UnaryExpr);
+                    break;
+
+                case BinaryExpr:
+                    this.writeBinary(expr as BinaryExpr);
+                    break;
+
+                case ReferenceExpr:
+                    this.writeReference(expr as ReferenceExpr);
+                    break;
+
+                case MemberAccessExpr:
+                    this.writeMemberAccess(expr as MemberAccessExpr);
+                    break;
+
+                case ThisExpr:
+                    throw new Error('Not implemented');
+
+                default:
+                    throw new Error(`Not implemented: ${expr.$type}`);
+            }
+        };
+
+        this.writer.block(_write);
+    }
+
+    private writeReference(expr: ReferenceExpr) {
+        if (isEnumField(expr.target.ref)) {
+            throw new Error('Not implemented');
+        } else {
+            this.writer.write(`${expr.target.ref!.name}: true`);
+        }
+    }
+
+    private writeMemberAccess(expr: MemberAccessExpr) {
+        this.writeFieldCondition(
+            expr.operand,
+            () => {
+                this.writer.block(() => {
+                    this.writer.write(`${expr.member.ref?.name}: true`);
+                });
+            },
+            'is'
+        );
+    }
+
+    private writeExprList(exprs: Expression[]) {
+        this.writer.writeLine('[');
+        for (let i = 0; i < exprs.length; i++) {
+            this.write(exprs[i]);
+            if (i !== exprs.length - 1) {
+                this.writer.writeLine(',');
+            }
+        }
+        this.writer.writeLine(']');
+    }
+
+    private writeBinary(expr: BinaryExpr) {
+        switch (expr.operator) {
+            case '&&':
+            case '||':
+                this.writeLogical(expr, expr.operator);
+                break;
+
+            case '==':
+            case '!=':
+            case '>':
+            case '>=':
+            case '<':
+            case '<=':
+                this.writeComparison(expr, expr.operator);
+                break;
+
+            case '?':
+            case '!':
+            case '^':
+                this.writeCollectionPredicate(expr, expr.operator);
+                break;
+        }
+    }
+
+    private writeCollectionPredicate(expr: BinaryExpr, operator: string) {
+        this.writeFieldCondition(
+            expr.left,
+            () => {
+                this.write(expr.right);
+            },
+            operator === '?' ? 'some' : operator === '!' ? 'every' : 'none'
+        );
+    }
+
+    private isFieldRef(expr: Expression): expr is ReferenceExpr {
+        if (isReferenceExpr(expr) && isDataModelField(expr.target.ref)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private guard(write: () => void) {
+        this.writer.write(`${AUX_GUARD_FIELD}: `);
+        write();
+    }
+
+    private plain(expr: Expression) {
+        this.writer.write(this.plainExprBuilder.build(expr));
+    }
+
+    private writeComparison(expr: BinaryExpr, operator: ComparisonOperator) {
+        const leftIsFieldAccess =
+            this.isFieldRef(expr.left) || this.isRelationFieldAccess(expr.left);
+        const rightIsFieldAccess =
+            this.isFieldRef(expr.right) ||
+            this.isRelationFieldAccess(expr.right);
+
+        if (leftIsFieldAccess && rightIsFieldAccess) {
+            throw new GeneratorError(
+                `Comparison between fields are not supported yet`
+            );
+        }
+
+        if (!leftIsFieldAccess && !rightIsFieldAccess) {
+            // compile down to a plain expression
+            this.guard(() => {
+                this.plain(expr.left);
+                this.writer.write(' ' + operator + ' ');
+                this.plain(expr.right);
+            });
+
+            return;
+        }
+
+        let fieldAccess: Expression;
+        let operand: Expression;
+        if (leftIsFieldAccess) {
+            fieldAccess = expr.left;
+            operand = expr.right;
+        } else {
+            fieldAccess = expr.right;
+            operand = expr.left;
+            operator = this.negateOperator(operator);
+        }
+
+        const type = (fieldAccess as TypedNode).$resolvedType?.decl;
+
+        this.writeFieldCondition(
+            fieldAccess,
+            () => {
+                this.writer.block(() => {
+                    if (isDataModel(type)) {
+                        // comparing with an object, conver to "id" comparison instead
+                        this.writer.write('id: ');
+                        this.writer.block(() => {
+                            this.writeOperator(operator, () => {
+                                this.plain(operand);
+                                this.writer.write('?.id');
+                            });
+                        });
+                    } else {
+                        this.writeOperator(operator, () => {
+                            this.plain(operand);
+                        });
+                    }
+                });
+            },
+            'is'
+        );
+    }
+
+    private writeOperator(
+        operator: ComparisonOperator,
+        writeOperand: () => void
+    ) {
+        if (operator === '!=') {
+            // wrap a 'not'
+            this.writer.write('not: ');
+            this.writer.block(() => {
+                this.writeOperator('==', writeOperand);
+            });
+        } else {
+            this.writer.write(`${this.mapOperator(operator)}: `);
+            writeOperand();
+        }
+    }
+
+    private writeFieldCondition(
+        fieldAccess: Expression,
+        writeCondition: () => void,
+        relationOp: 'is' | 'some' | 'every' | 'none'
+    ) {
+        let selector: string;
+        let operand: Expression | undefined;
+
+        if (isReferenceExpr(fieldAccess)) {
+            selector = fieldAccess.target.ref?.name!;
+        } else if (isMemberAccessExpr(fieldAccess)) {
+            selector = fieldAccess.member.ref?.name!;
+            operand = fieldAccess.operand;
+        } else {
+            throw new GeneratorError(
+                `Unsupported expression type: ${fieldAccess.$type}`
+            );
+        }
+
+        if (operand) {
+            // member access expression
+            this.writeFieldCondition(
+                operand,
+                () => {
+                    this.writer.block(() => {
+                        this.writer.write(selector + ': ');
+                        if (this.isModelTyped(fieldAccess)) {
+                            // expression is resolved to a model, generate relation query
+                            this.writer.block(() => {
+                                this.writer.write(`${relationOp}: `);
+                                writeCondition();
+                            });
+                        } else {
+                            // generate plain query
+                            writeCondition();
+                        }
+                    });
+                },
+                'is'
+            );
+        } else if (this.isModelTyped(fieldAccess)) {
+            // reference resolved to a model, generate relation query
+            this.writer.write(selector + ': ');
+            this.writer.block(() => {
+                this.writer.write(`${relationOp}: `);
+                writeCondition();
+            });
+        } else {
+            // generate a plain query
+            this.writer.write(selector + ': ');
+            writeCondition();
+        }
+    }
+
+    private isModelTyped(expr: Expression) {
+        return isDataModel((expr as TypedNode).$resolvedType?.decl);
+    }
+
+    private isRelationFieldAccess(expr: Expression): boolean {
+        if (isMemberAccessExpr(expr)) {
+            return this.isRelationFieldAccess(expr.operand);
+        }
+
+        if (
+            isReferenceExpr(expr) &&
+            isDataModelField(expr.target.ref) &&
+            expr.target.ref.type.reference &&
+            isDataModel(expr.target.ref.type.reference.ref)
+        ) {
+            return true;
+        }
+
+        return false;
+    }
+
+    mapOperator(operator: '==' | '!=' | '>' | '>=' | '<' | '<=') {
+        switch (operator) {
+            case '==':
+                return 'equals';
+            case '!=':
+                throw new Error('Operation != should have been compiled away');
+            case '>':
+                return 'gt';
+            case '>=':
+                return 'ge';
+            case '<':
+                return 'lt';
+            case '<=':
+                return 'le';
+        }
+    }
+
+    private negateOperator(operator: '==' | '!=' | '>' | '>=' | '<' | '<=') {
+        switch (operator) {
+            case '>':
+                return '<=';
+            case '<':
+                return '>=';
+            case '>=':
+                return '<';
+            case '<=':
+                return '>';
+            default:
+                return operator;
+        }
+    }
+
+    private writeLogical(expr: BinaryExpr, operator: '&&' | '||') {
+        this.writer.writeLine(`${operator === '&&' ? 'AND' : 'OR'}: `);
+        this.writeExprList([expr.left, expr.right]);
+    }
+
+    private writeUnary(expr: UnaryExpr) {
+        if (expr.operator !== '!') {
+            throw new GeneratorError(
+                `Unary operator "${expr.operator}" is not supported`
+            );
+        }
+
+        this.writer.writeLine('NOT: ');
+        this.write(expr.operand);
+    }
+
+    private writeLiteral(expr: LiteralExpr) {
+        this.guard(() => {
+            this.plain(expr);
+        });
+    }
+}

package/src/generator/server/data/plain-expression-builder.ts

@@ -0,0 +1,72 @@
+import { GeneratorError } from '../../types';
+import {
+    ArrayExpr,
+    Expression,
+    InvocationExpr,
+    LiteralExpr,
+    MemberAccessExpr,
+    NullExpr,
+    ReferenceExpr,
+} from '@lang/generated/ast';
+
+export default class PlainExpressionBuilder {
+    build(expr: Expression): string {
+        switch (expr.$type) {
+            case LiteralExpr:
+                return this.literal(expr as LiteralExpr);
+
+            case ArrayExpr:
+                return this.array(expr as ArrayExpr);
+
+            case NullExpr:
+                return this.null();
+
+            case ReferenceExpr:
+                return this.reference(expr as ReferenceExpr);
+
+            case InvocationExpr:
+                return this.invocation(expr as InvocationExpr);
+
+            case MemberAccessExpr:
+                return this.memberAccess(expr as MemberAccessExpr);
+
+            default:
+                throw new GeneratorError(
+                    `Unsupported expression type: ${expr.$type}`
+                );
+        }
+    }
+
+    private memberAccess(expr: MemberAccessExpr) {
+        return `${this.build(expr.operand)}?.${expr.member.ref!.name}`;
+    }
+
+    private invocation(expr: InvocationExpr) {
+        if (expr.function.ref?.name !== 'auth') {
+            throw new GeneratorError(
+                `Function invocation is not supported: ${expr.function.ref?.name}`
+            );
+        }
+        return 'user';
+    }
+
+    private reference(expr: ReferenceExpr) {
+        return expr.target.ref!.name;
+    }
+
+    private null() {
+        return 'null';
+    }
+
+    private array(expr: ArrayExpr) {
+        return `[${expr.items.map((item) => this.build(item)).join(', ')}]`;
+    }
+
+    private literal(expr: LiteralExpr) {
+        if (typeof expr.value === 'string') {
+            return `'${expr.value}'`;
+        } else {
+            return expr.value.toString();
+        }
+    }
+}

package/src/generator/server/function/function-generator.ts

@@ -0,0 +1,32 @@
+import { Context } from '../../types';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import { ServerCodeGenerator } from '../server-code-generator';
+
+export default class FunctionServerGenerator implements ServerCodeGenerator {
+    generate(project: Project, context: Context) {
+        this.generateIndex(project, context);
+    }
+
+    private generateIndex(project: Project, context: Context) {
+        const content = `
+            import type { NextApiRequest, NextApiResponse } from 'next';
+            import { RequestHandlerOptions } from '..';
+            
+            export default async function (
+                req: NextApiRequest,
+                res: NextApiResponse,
+                path: string[],
+                options: RequestHandlerOptions
+            ) {
+                throw new Error('Not implemented');
+            }
+            `;
+        const sf = project.createSourceFile(
+            path.join(context.outDir, 'server/function/index.ts'),
+            content,
+            { overwrite: true }
+        );
+        sf.formatText();
+    }
+}

package/src/generator/server/index.ts

@@ -0,0 +1,57 @@
+import { Project } from 'ts-morph';
+import { Context, Generator } from '../types';
+import * as path from 'path';
+import DataServerGenerator from './data/data-generator';
+import FunctionServerGenerator from './function/function-generator';
+
+export default class ServerGenerator implements Generator {
+    async generate(context: Context) {
+        const project = new Project();
+
+        this.generateIndex(project, context);
+
+        new DataServerGenerator().generate(project, context);
+        new FunctionServerGenerator().generate(project, context);
+
+        await project.save();
+    }
+
+    generateIndex(project: Project, context: Context) {
+        const content = `
+        import type { NextApiRequest, NextApiResponse } from 'next';
+        import dataHandler from './data';
+        import functionHandler from './function';
+        
+        export type AuthUser = { id: string } & Record<string, any>;
+
+        export type RequestHandlerOptions = {
+            getServerUser: (
+                req: NextApiRequest,
+                res: NextApiResponse
+            ) => Promise<AuthUser | undefined>;
+        };
+        
+        export function RequestHandler(options: RequestHandlerOptions) {
+            return async (req: NextApiRequest, res: NextApiResponse) => {
+                const [route, ...rest] = req.query.path as string[];
+                switch (route) {
+                    case 'data':
+                        return dataHandler(req, res, rest, options);
+        
+                    case 'function':
+                        return functionHandler(req, res, rest, options);
+        
+                    default:
+                        res.status(404).json({ error: 'Unknown route: ' + route });
+                }
+            };
+        }
+        `;
+        const sf = project.createSourceFile(
+            path.join(context.outDir, 'server/index.ts'),
+            content,
+            { overwrite: true }
+        );
+        sf.formatText();
+    }
+}

package/src/generator/server/server-code-generator.ts

@@ -0,0 +1,6 @@
+import { Context } from '../types';
+import { Project } from 'ts-morph';
+
+export interface ServerCodeGenerator {
+    generate(project: Project, context: Context): void;
+}

package/src/generator/service/index.ts

@@ -0,0 +1,43 @@
+import { Context, Generator } from '../types';
+import { Project, StructureKind } from 'ts-morph';
+import * as path from 'path';
+import colors from 'colors';
+
+export default class ServiceGenerator implements Generator {
+    async generate(context: Context) {
+        const project = new Project();
+        const sf = project.createSourceFile(
+            path.join(context.outDir, 'service.ts'),
+            undefined,
+            { overwrite: true }
+        );
+
+        sf.addImportDeclaration({
+            namedImports: ['PrismaClient'],
+            moduleSpecifier: './.prisma',
+        });
+
+        const cls = sf.addClass({
+            name: 'ZenStackService',
+            isExported: true,
+        });
+        cls.addMember({
+            kind: StructureKind.Property,
+            name: 'private readonly _prisma',
+            initializer: 'new PrismaClient()',
+        });
+
+        cls.addGetAccessor({
+            name: 'db',
+        })
+            .addBody()
+            .setBodyText('return this._prisma;');
+
+        sf.addStatements(['export default new ZenStackService();']);
+
+        sf.formatText();
+        await project.save();
+
+        console.log(colors.blue(`  ✔️ ZenStack service generated`));
+    }
+}

package/src/generator/types.ts

@@ -0,0 +1,16 @@
+import { Model } from '@lang/generated/ast';
+
+export interface Context {
+    schema: Model;
+    outDir: 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,9 @@
+import { DataModel, isDataModel, Model } from '@lang/generated/ast';
+
+export function extractDataModelsWithAllowRules(model: Model) {
+    return model.declarations.filter(
+        (d) =>
+            isDataModel(d) &&
+            !!d.attributes.find((attr) => attr.decl.ref?.name === 'allow')
+    ) as DataModel[];
+}