zenstack 0.1.41 → 1.0.0

package/packages/schema/src/generator/prisma/expression-writer.ts

@@ -0,0 +1,352 @@
+import {
+    BinaryExpr,
+    Expression,
+    isDataModel,
+    isDataModelField,
+    isEnumField,
+    isMemberAccessExpr,
+    isReferenceExpr,
+    isThisExpr,
+    LiteralExpr,
+    MemberAccessExpr,
+    ReferenceExpr,
+    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;
+
+                default:
+                    throw new Error(`Not implemented: ${expr.$type}`);
+            }
+        };
+
+        this.block(_write);
+    }
+
+    private writeReference(expr: ReferenceExpr) {
+        if (isEnumField(expr.target.ref)) {
+            throw new Error('We should never get here');
+        } else {
+            this.writer.write(`${expr.target.ref!.name}: true`);
+        }
+    }
+
+    private writeMemberAccess(expr: MemberAccessExpr) {
+        this.writeFieldCondition(
+            expr.operand,
+            () => {
+                this.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 isFieldAccess(expr: Expression): boolean {
+        if (isThisExpr(expr)) {
+            return true;
+        }
+        if (isMemberAccessExpr(expr)) {
+            return this.isFieldAccess(expr.operand);
+        }
+        if (isReferenceExpr(expr) && isDataModelField(expr.target.ref)) {
+            return true;
+        }
+        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.isFieldAccess(expr.left);
+        const rightIsFieldAccess = this.isFieldAccess(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);
+        }
+
+        this.writeFieldCondition(
+            fieldAccess,
+            () => {
+                this.block(
+                    () => {
+                        if (this.isModelTyped(fieldAccess)) {
+                            // comparing with an object, conver to "id" comparison instead
+                            this.writer.write('id: ');
+                            this.block(() => {
+                                this.writeOperator(operator, () => {
+                                    this.plain(operand);
+                                    this.writer.write('?.id');
+                                });
+                            });
+                        } else {
+                            this.writeOperator(operator, () => {
+                                this.plain(operand);
+                            });
+                        }
+                    },
+                    // "this" expression is compiled away (to .id access), so we should
+                    // avoid generating a new layer
+                    !isThisExpr(fieldAccess)
+                );
+            },
+            'is'
+        );
+    }
+
+    private writeOperator(
+        operator: ComparisonOperator,
+        writeOperand: () => void
+    ) {
+        if (operator === '!=') {
+            // wrap a 'not'
+            this.writer.write('not: ');
+            this.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 (isThisExpr(fieldAccess)) {
+            // pass on
+            writeCondition();
+            return;
+        } else 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.block(
+                        () => {
+                            this.writer.write(selector + ': ');
+                            if (this.isModelTyped(fieldAccess)) {
+                                // expression is resolved to a model, generate relation query
+                                this.block(() => {
+                                    this.writer.write(`${relationOp}: `);
+                                    writeCondition();
+                                });
+                            } else {
+                                // generate plain query
+                                writeCondition();
+                            }
+                        },
+                        // if operand is "this", it doesn't really generate a new layer of query,
+                        // so we should avoid generating a new block
+                        !isThisExpr(operand)
+                    );
+                },
+                'is'
+            );
+        } else if (this.isModelTyped(fieldAccess)) {
+            // reference resolved to a model, generate relation query
+            this.writer.write(selector + ': ');
+            this.block(() => {
+                this.writer.write(`${relationOp}: `);
+                writeCondition();
+            });
+        } else {
+            // generate a plain query
+            this.writer.write(selector + ': ');
+            writeCondition();
+        }
+    }
+
+    private block(write: () => void, condition = true) {
+        if (condition) {
+            this.writer.block(write);
+        } else {
+            write();
+        }
+    }
+
+    private isModelTyped(expr: Expression) {
+        return isDataModel((expr as TypedNode).$resolvedType?.decl);
+    }
+
+    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/packages/schema/src/generator/prisma/index.ts

@@ -0,0 +1,32 @@
+import colors from 'colors';
+import { Context, Generator, GeneratorError } from '../types';
+import { execSync } from '../../utils/exec-utils';
+import PrismaSchemaGenerator from './schema-generator';
+import QueryGuardGenerator from './query-gard-generator';
+
+export default class PrismaGenerator implements Generator {
+    async generate(context: Context) {
+        // generate prisma schema
+        const schemaFile = await new PrismaSchemaGenerator(context).generate();
+
+        // run prisma generate and install @prisma/client
+        await this.generatePrismaClient(schemaFile);
+
+        // generate prisma query guard
+        await new QueryGuardGenerator(context).generate();
+
+        console.log(
+            colors.blue(`  ✔️ Prisma schema and query guard generated`)
+        );
+    }
+
+    async generatePrismaClient(schemaFile: string) {
+        try {
+            execSync(`npx prisma generate --schema "${schemaFile}"`);
+        } catch {
+            throw new GeneratorError(
+                `Failed to generate client code with Prisma. Check errors above for clues.\nThis normally shouldn't happen. Please file an issue at: http://go.zenstack.dev/bug.`
+            );
+        }
+    }
+}

package/packages/schema/src/generator/prisma/plain-expression-builder.ts

@@ -0,0 +1,91 @@
+import { GeneratorError } from '../types';
+import {
+    ArrayExpr,
+    Expression,
+    InvocationExpr,
+    isEnumField,
+    isThisExpr,
+    LiteralExpr,
+    MemberAccessExpr,
+    NullExpr,
+    ReferenceExpr,
+    ThisExpr,
+} 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 ThisExpr:
+                return this.this(expr as ThisExpr);
+
+            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 this(expr: ThisExpr) {
+        // "this" is mapped to id comparison
+        return 'id';
+    }
+
+    private memberAccess(expr: MemberAccessExpr) {
+        if (isThisExpr(expr.operand)) {
+            return expr.member.ref!.name;
+        } else {
+            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) {
+        if (isEnumField(expr.target.ref)) {
+            return `${expr.target.ref.$container.name}.${expr.target.ref.name}`;
+        } else {
+            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();
+        }
+    }
+}