zenstack 0.1.0 → 0.1.1

package/out/utils/indent-string.js

@@ -1,25 +1,9 @@
 "use strict";
 // https://github.com/sindresorhus/indent-string
 Object.defineProperty(exports, "__esModule", { value: true });
-function indentString(string, count = 4, options = {}) {
-    const { indent = ' ', includeEmptyLines = false } = options;
-    if (typeof string !== 'string') {
-        throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof string}\``);
-    }
-    if (typeof count !== 'number') {
-        throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
-    }
-    if (count < 0) {
-        throw new RangeError(`Expected \`count\` to be at least 0, got \`${count}\``);
-    }
-    if (typeof indent !== 'string') {
-        throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``);
-    }
-    if (count === 0) {
-        return string;
-    }
-    const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-    return string.replace(regex, indent.repeat(count));
+function indentString(string, count = 4) {
+    const indent = ' ';
+    return string.replace(/^(?!\s*$)/gm, indent.repeat(count));
 }
 exports.default = indentString;
 //# sourceMappingURL=indent-string.js.map

package/out/utils/indent-string.js.map

@@ -1 +1 @@
-{"version":3,"file":"indent-string.js","sourceRoot":"","sources":["../../src/utils/indent-string.ts"],"names":[],"mappings":";AAAA,gDAAgD;;AAEhD,SAAwB,YAAY,CAChC,MAAc,EACd,KAAK,GAAG,CAAC,EACT,UAA4D,EAAE;IAE9D,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,iBAAiB,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IAE5D,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,SAAS,CACf,gDAAgD,OAAO,MAAM,IAAI,CACpE,CAAC;KACL;IAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC3B,MAAM,IAAI,SAAS,CACf,gDAAgD,OAAO,KAAK,IAAI,CACnE,CAAC;KACL;IAED,IAAI,KAAK,GAAG,CAAC,EAAE;QACX,MAAM,IAAI,UAAU,CAChB,8CAA8C,KAAK,IAAI,CAC1D,CAAC;KACL;IAED,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,SAAS,CACf,yDAAyD,OAAO,MAAM,IAAI,CAC7E,CAAC;KACL;IAED,IAAI,KAAK,KAAK,CAAC,EAAE;QACb,OAAO,MAAM,CAAC;KACjB;IAED,MAAM,KAAK,GAAG,iBAAiB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC;IAExD,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC;AAtCD,+BAsCC"}
+{"version":3,"file":"indent-string.js","sourceRoot":"","sources":["../../src/utils/indent-string.ts"],"names":[],"mappings":";AAAA,gDAAgD;;AAEhD,SAAwB,YAAY,CAAC,MAAc,EAAE,KAAK,GAAG,CAAC;IAC1D,MAAM,MAAM,GAAG,GAAG,CAAC;IACnB,OAAO,MAAM,CAAC,OAAO,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/D,CAAC;AAHD,+BAGC"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "zenstack",
   "displayName": "ZenStack CLI and Language Tools",
   "description": "ZenStack CLI and Language Tools",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "engines": {
     "vscode": "^1.56.0"
   },
@@ -48,11 +48,13 @@
   },
   "main": "./out/extension.js",
   "dependencies": {
+    "@zenstackhq/runtime": "0.1.1",
     "change-case": "^4.1.2",
     "chevrotain": "^9.1.0",
     "colors": "^1.4.0",
     "commander": "^8.0.0",
     "langium": "^0.4.0",
+    "prisma": "^4.4.0",
     "promisify": "^0.0.3",
     "ts-morph": "^16.0.0",
     "vscode-jsonrpc": "^8.0.2",
@@ -82,13 +84,14 @@
   },
   "scripts": {
     "vscode:prepublish": "npm run build && npm run lint",
-    "build": "tsc && tsc-alias && cp src/language-server/stdlib.zmodel ./out/language-server/",
+    "build": "tsc && tsc-alias && cp src/language-server/stdlib.zmodel ./out/language-server/ && cp src/generator/*.template.json ./out/generator/",
     "ts:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
     "lint": "eslint src --ext ts",
     "langium:generate": "langium generate",
     "langium:watch": "langium generate --watch",
     "watch": "concurrently --kill-others \"npm:langium:watch\" \"npm:ts:watch\" \"npm:tsc-alias:watch\"",
-    "test": "jest"
+    "test": "jest",
+    "npm-publish": "pnpm build && pnpm publish --no-git-checks --access public"
   }
 }

package/src/cli/index.ts

@@ -4,14 +4,7 @@ import { ZModelLanguageMetaData } from '../language-server/generated/module';
 import { createZModelServices } from '../language-server/zmodel-module';
 import { extractAstNode } from './cli-util';
 import { Context } from '../generator/types';
-import * as path from 'path';
-import * as fs from 'fs';
-import colors from 'colors';
-import PrismaGenerator from '../generator/prisma';
-import ServiceGenerator from '../generator/service';
-import ReactHooksGenerator from '../generator/react-hooks';
-import NextAuthGenerator from '../generator/next-auth';
-import ServerGenerator from '../generator/server';
+import { ZenStackGenerator } from '../generator';
 
 export const generateAction = async (
     fileName: string,
@@ -22,34 +15,14 @@ export const generateAction = async (
 
     const context: Context = {
         schema: model,
-        outDir: path.resolve(opts.destination),
+        outDir: opts.destination || 'node_modules/.zenstack',
     };
 
-    if (!fs.existsSync(context.outDir)) {
-        fs.mkdirSync(context.outDir);
-    }
-
-    console.log(colors.bold('⌛️ Running ZenStack generators'));
-
-    const generators = [
-        new PrismaGenerator(),
-        new ServiceGenerator(),
-        new ReactHooksGenerator(),
-        new ServerGenerator(),
-        new NextAuthGenerator(),
-    ];
-
-    for (const generator of generators) {
-        await generator.generate(context);
-    }
-
-    console.log(
-        colors.green(colors.bold('👻 All generators completed successfully!'))
-    );
+    await new ZenStackGenerator().generate(context);
 };
 
 export type GenerateOptions = {
-    destination: string;
+    destination?: string;
 };
 
 export default function (): void {
@@ -68,8 +41,7 @@ export default function (): void {
         )
         .option(
             '-d, --destination <dir>',
-            'destination directory of generating',
-            '.zenstack'
+            'destination directory of generating'
         )
         .description(
             'generates JavaScript code that prints "Hello, {name}!" for each greeting in a source file'

package/src/generator/constants.ts

@@ -0,0 +1,2 @@
+export const RUNTIME_PACKAGE = '@zenstackhq/runtime';
+export const GUARD_FIELD_NAME = 'zenstack_guard';

package/src/generator/index.ts

@@ -0,0 +1,59 @@
+import { Context } from './types';
+import * as fs from 'fs';
+import colors from 'colors';
+import PrismaGenerator from './prisma';
+import ServiceGenerator from './service';
+import ReactHooksGenerator from './react-hooks';
+import NextAuthGenerator from './next-auth';
+import path from 'path';
+import { execSync } from 'child_process';
+
+export class ZenStackGenerator {
+    async generate(context: Context) {
+        if (!fs.existsSync(context.outDir)) {
+            fs.mkdirSync(context.outDir);
+        }
+
+        console.log(colors.bold('⌛️ Running ZenStack generators'));
+
+        const generators = [
+            new PrismaGenerator(),
+            new ServiceGenerator(),
+            new ReactHooksGenerator(),
+            new NextAuthGenerator(),
+        ];
+
+        for (const generator of generators) {
+            await generator.generate(context);
+        }
+
+        // generate package.json
+        const packageJson = require(path.join(
+            __dirname,
+            'package.template.json'
+        ));
+        fs.writeFileSync(
+            path.join(context.outDir, 'package.json'),
+            JSON.stringify(packageJson, undefined, 4)
+        );
+
+        // compile ts sources
+        const tsConfig = require(path.join(
+            __dirname,
+            'tsconfig.template.json'
+        ));
+        fs.writeFileSync(
+            path.join(context.outDir, 'tsconfig.json'),
+            JSON.stringify(tsConfig, undefined, 4)
+        );
+
+        execSync(`npx tsc -p "${path.join(context.outDir, 'tsconfig.json')}"`);
+        console.log(colors.blue('  ✔️ Typescript source files transpiled'));
+
+        console.log(
+            colors.green(
+                colors.bold('👻 All generators completed successfully!')
+            )
+        );
+    }
+}

package/src/generator/next-auth/index.ts

@@ -30,9 +30,9 @@ export default class NextAuthGenerator implements Generator {
 
     generateAdapter(project: Project, context: Context) {
         const content = `
-        import { ZenStackService } from '../service';
+        import { ZenStackService } from '..';
         import { Adapter } from 'next-auth/adapters';
-        import { Prisma } from '@zenstack/.prisma';
+        import { Prisma } from '../.prisma';
         
         export function NextAuthAdapter(service: ZenStackService): Adapter {
             const db = service.db;
@@ -101,7 +101,7 @@ export default class NextAuthGenerator implements Generator {
 
     generateAuthorize(project: Project, context: Context) {
         const content = `
-        import { ZenStackService } from '../service';
+        import { ZenStackService } from '..';
         import { hash, compare } from 'bcryptjs';
         
         async function hashPassword(password: string) {

package/src/generator/package.template.json

@@ -0,0 +1,9 @@
+{
+    "name": ".zenstack",
+    "version": "1.0.0",
+    "description": "ZenStack generated code",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "author": "ZenStack",
+    "license": "MIT"
+}

package/src/generator/{server/data → prisma}/expression-writer.ts

@@ -6,14 +6,14 @@ import {
     isEnumField,
     isMemberAccessExpr,
     isReferenceExpr,
+    isThisExpr,
     LiteralExpr,
     MemberAccessExpr,
     ReferenceExpr,
-    ThisExpr,
     UnaryExpr,
 } from '@lang/generated/ast';
 import { CodeBlockWriter } from 'ts-morph';
-import { GeneratorError } from '../../types';
+import { GeneratorError } from '../types';
 import { TypedNode } from '@lang/types';
 import PlainExpressionBuilder from './plain-expression-builder';
 
@@ -49,20 +49,17 @@ export default class ExpressionWriter {
                     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);
+        this.block(_write);
     }
 
     private writeReference(expr: ReferenceExpr) {
         if (isEnumField(expr.target.ref)) {
-            throw new Error('Not implemented');
+            throw new Error('We should never get here');
         } else {
             this.writer.write(`${expr.target.ref!.name}: true`);
         }
@@ -72,7 +69,7 @@ export default class ExpressionWriter {
         this.writeFieldCondition(
             expr.operand,
             () => {
-                this.writer.block(() => {
+                this.block(() => {
                     this.writer.write(`${expr.member.ref?.name}: true`);
                 });
             },
@@ -125,12 +122,17 @@ export default class ExpressionWriter {
         );
     }
 
-    private isFieldRef(expr: Expression): expr is ReferenceExpr {
+    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;
-        } else {
-            return false;
         }
+        return false;
     }
 
     private guard(write: () => void) {
@@ -143,11 +145,8 @@ export default class ExpressionWriter {
     }
 
     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);
+        const leftIsFieldAccess = this.isFieldAccess(expr.left);
+        const rightIsFieldAccess = this.isFieldAccess(expr.right);
 
         if (leftIsFieldAccess && rightIsFieldAccess) {
             throw new GeneratorError(
@@ -177,27 +176,30 @@ export default class ExpressionWriter {
             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.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.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'
         );
@@ -210,7 +212,7 @@ export default class ExpressionWriter {
         if (operator === '!=') {
             // wrap a 'not'
             this.writer.write('not: ');
-            this.writer.block(() => {
+            this.block(() => {
                 this.writeOperator('==', writeOperand);
             });
         } else {
@@ -227,7 +229,11 @@ export default class ExpressionWriter {
         let selector: string;
         let operand: Expression | undefined;
 
-        if (isReferenceExpr(fieldAccess)) {
+        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!;
@@ -243,26 +249,31 @@ export default class ExpressionWriter {
             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}: `);
+                    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();
-                            });
-                        } 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.writer.block(() => {
+            this.block(() => {
                 this.writer.write(`${relationOp}: `);
                 writeCondition();
             });
@@ -273,25 +284,16 @@ export default class ExpressionWriter {
         }
     }
 
-    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;
+    private block(write: () => void, condition = true) {
+        if (condition) {
+            this.writer.block(write);
+        } else {
+            write();
         }
+    }
 
-        return false;
+    private isModelTyped(expr: Expression) {
+        return isDataModel((expr as TypedNode).$resolvedType?.decl);
     }
 
     mapOperator(operator: '==' | '!=' | '>' | '>=' | '<' | '<=') {