zenstack 0.1.47 → 0.1.50

package/{out/generator/next-auth/index.js → src/generator/next-auth/index.ts}

@@ -1,63 +1,40 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ts_morph_1 = require("ts-morph");
-const path = __importStar(require("path"));
-const colors_1 = __importDefault(require("colors"));
-class NextAuthGenerator {
-    generate(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const project = new ts_morph_1.Project();
-            this.generateIndex(project, context);
-            this.generateAdapter(project, context);
-            this.generateAuthorize(project, context);
-            yield project.save();
-            console.log(colors_1.default.blue(`  ✔️ Next-auth adapter generated`));
-        });
+import { Context, Generator } from '../types';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import colors from 'colors';
+
+/**
+ * Generates NextAuth adaptor code
+ */
+export default class NextAuthGenerator implements Generator {
+    async generate(context: Context): Promise<void> {
+        const project = new Project();
+
+        this.generateIndex(project, context);
+        this.generateAdapter(project, context);
+        this.generateAuthorize(project, context);
+
+        await project.save();
+
+        console.log(colors.blue(`  ✔️ Next-auth adapter generated`));
     }
-    generateIndex(project, context) {
-        const sf = project.createSourceFile(path.join(context.generatedCodeDir, 'src/auth/index.ts'), undefined, { overwrite: true });
+
+    private generateIndex(project: Project, context: Context) {
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, 'src/auth/index.ts'),
+            undefined,
+            { overwrite: true }
+        );
+
         sf.addStatements([
             `export * from './next-auth-adapter';`,
             `export * from './authorize';`,
         ]);
+
         sf.formatText();
     }
-    generateAdapter(project, context) {
+
+    private generateAdapter(project: Project, context: Context) {
         const content = `
         import { ZenStackService } from '..';
         import { Adapter } from 'next-auth/adapters';
@@ -118,10 +95,20 @@ class NextAuthGenerator {
             };
         }                
         `;
-        const sf = project.createSourceFile(path.join(context.generatedCodeDir, 'src/auth/next-auth-adapter.ts'), content, { overwrite: true });
+
+        const sf = project.createSourceFile(
+            path.join(
+                context.generatedCodeDir,
+                'src/auth/next-auth-adapter.ts'
+            ),
+            content,
+            { overwrite: true }
+        );
+
         sf.formatText();
     }
-    generateAuthorize(project, context) {
+
+    private generateAuthorize(project: Project, context: Context) {
         const content = `
         import { ZenStackService } from '..';
         import { hash, compare } from 'bcryptjs';
@@ -201,9 +188,13 @@ class NextAuthGenerator {
             };
         }
         `;
-        const sf = project.createSourceFile(path.join(context.generatedCodeDir, 'src/auth/authorize.ts'), content, { overwrite: true });
+
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, 'src/auth/authorize.ts'),
+            content,
+            { overwrite: true }
+        );
+
         sf.formatText();
     }
 }
-exports.default = NextAuthGenerator;
-//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,360 @@
+import {
+    BinaryExpr,
+    Expression,
+    isDataModel,
+    isDataModelField,
+    isEnumField,
+    isMemberAccessExpr,
+    isReferenceExpr,
+    isThisExpr,
+    LiteralExpr,
+    MemberAccessExpr,
+    ReferenceExpr,
+    UnaryExpr,
+} from '@lang/generated/ast';
+import { CodeBlockWriter } from 'ts-morph';
+import { GUARD_FIELD_NAME } from '../constants';
+import { GeneratorError } from '../types';
+import TypeScriptExpressionTransformer from './typescript-expression-transformer';
+
+type ComparisonOperator = '==' | '!=' | '>' | '>=' | '<' | '<=';
+
+/**
+ * Utility for writing ZModel expression as Prisma query argument objects into a ts-morph writer
+ */
+export default class ExpressionWriter {
+    private readonly plainExprBuilder = new TypeScriptExpressionTransformer();
+
+    constructor(private readonly writer: CodeBlockWriter) {}
+
+    /**
+     * Writes the given ZModel expression.
+     */
+    write(expr: Expression): void {
+        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(`${GUARD_FIELD_NAME}: `);
+        write();
+    }
+
+    private plain(expr: Expression) {
+        this.writer.write(this.plainExprBuilder.transform(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 | undefined;
+        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 (!selector) {
+            throw new GeneratorError(`Failed to write FieldAccess expression`);
+        }
+
+        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.$resolvedType?.decl);
+    }
+
+    private 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/prisma/index.ts

@@ -0,0 +1,35 @@
+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';
+
+/**
+ * Generates Prisma schema and db client
+ */
+export default class PrismaGenerator implements Generator {
+    async generate(context: Context): Promise<void> {
+        // 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`)
+        );
+    }
+
+    private 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.`
+            );
+        }
+    }
+}