zenstack 0.3.18 → 0.3.20

package/package.json

@@ -3,7 +3,7 @@
   "publisher": "zenstack",
   "displayName": "ZenStack Language Tools",
   "description": "A toolkit for modeling data and access policies in full-stack development with Next.js and Typescript",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "author": {
     "name": "ZenStack Team"
   },
@@ -65,7 +65,6 @@
   },
   "main": "./bundle/extension.js",
   "dependencies": {
-    "@zenstackhq/runtime": "0.3.18",
     "async-exit-hook": "^2.0.1",
     "change-case": "^4.1.2",
     "chevrotain": "^9.1.0",
@@ -76,7 +75,7 @@
     "mixpanel": "^0.17.0",
     "node-machine-id": "^1.1.12",
     "pluralize": "^8.0.0",
-    "prisma": "^4.5.0",
+    "prisma": "~4.5.0",
     "promisify": "^0.0.3",
     "sleep-promise": "^9.1.0",
     "ts-morph": "^16.0.0",
@@ -85,10 +84,11 @@
     "vscode-languageclient": "^8.0.2",
     "vscode-languageserver": "^8.0.2",
     "vscode-languageserver-textdocument": "^1.0.7",
-    "vscode-uri": "^3.0.6"
+    "vscode-uri": "^3.0.6",
+    "@zenstackhq/runtime": "0.3.20"
   },
   "devDependencies": {
-    "@prisma/internals": "^4.5.0",
+    "@prisma/internals": "~4.5.0",
     "@types/async-exit-hook": "^2.0.0",
     "@types/jest": "^29.2.0",
     "@types/node": "^14.18.32",

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

@@ -27,11 +27,6 @@ export default class NextAuthGenerator implements Generator {
         try {
             execSync('npm ls next-auth');
         } catch (err) {
-            console.warn(
-                colors.yellow(
-                    'Next-auth module is not installed, skipping generating adapter.'
-                )
-            );
             return;
         }
 

package/src/generator/react-hooks/index.ts

@@ -2,9 +2,8 @@ import { Context, Generator } from '../types';
 import { Project } from 'ts-morph';
 import * as path from 'path';
 import { paramCase } from 'change-case';
-import { DataModel } from '@lang/generated/ast';
+import { DataModel, isDataModel } from '@lang/generated/ast';
 import colors from 'colors';
-import { extractDataModelsWithAllowRules } from '../ast-utils';
 import { API_ROUTE_NAME, RUNTIME_PACKAGE } from '../constants';
 
 /**
@@ -17,8 +16,24 @@ export default class ReactHooksGenerator implements Generator {
 
     async generate(context: Context): Promise<void> {
         const project = new Project();
+        const models: DataModel[] = [];
 
-        const models = extractDataModelsWithAllowRules(context.schema);
+        for (const model of context.schema.declarations.filter(
+            (d): d is DataModel => isDataModel(d)
+        )) {
+            const hasAllowRule = model.attributes.find(
+                (attr) => attr.decl.ref?.name === '@@allow'
+            );
+            if (!hasAllowRule) {
+                console.warn(
+                    colors.yellow(
+                        `Not generating hooks for "${model.name}" because it doesn't have any @@allow rule`
+                    )
+                );
+            } else {
+                models.push(model);
+            }
+        }
 
         this.generateIndex(project, context, models);
 

package/src/generator/service/index.ts

@@ -1,8 +1,10 @@
-import { Context, Generator } from '../types';
-import { Project } from 'ts-morph';
-import * as path from 'path';
+import { DataModel, isDataModel } from '@lang/generated/ast';
+import { camelCase } from 'change-case';
 import colors from 'colors';
+import * as path from 'path';
+import { Project } from 'ts-morph';
 import { RUNTIME_PACKAGE } from '../constants';
+import { Context, Generator } from '../types';
 
 /**
  * Generates ZenStack service code
@@ -20,9 +22,18 @@ export default class ServiceGenerator implements Generator {
             { overwrite: true }
         );
 
+        const models = context.schema.declarations.filter((d): d is DataModel =>
+            isDataModel(d)
+        );
+
         sf.addStatements([
-            `import { PrismaClient } from "../.prisma";`,
+            `import { Prisma as P, PrismaClient } from "../.prisma";`,
             `import { DefaultService } from "${RUNTIME_PACKAGE}/lib/service";`,
+            `import { CRUD } from "${RUNTIME_PACKAGE}/lib/handler/data/crud";`,
+            `import type { QueryContext } from "${RUNTIME_PACKAGE}/lib/types";`,
+            `import type { ${models
+                .map((m) => m.name)
+                .join(', ')} } from "../.prisma";`,
         ]);
 
         const cls = sf.addClass({
@@ -31,6 +42,11 @@ export default class ServiceGenerator implements Generator {
             extends: 'DefaultService<PrismaClient>',
         });
 
+        cls.addProperty({
+            name: 'private crud',
+            initializer: `new CRUD<PrismaClient>(this)`,
+        });
+
         cls.addMethod({
             name: 'initializePrisma',
         }).setBodyText(`
@@ -53,6 +69,26 @@ export default class ServiceGenerator implements Generator {
             return import('./field-constraint');
         `);
 
+        // server-side CRUD operations per model
+        for (const model of models) {
+            cls.addGetAccessor({
+                name: camelCase(model.name),
+            }).setBodyText(`
+                return {
+                    get: <T extends P.${model.name}FindFirstArgs>(context: QueryContext, id: string, args?: P.SelectSubset<T, P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>>) => 
+                        this.crud.get('${model.name}', id, args, context) as Promise<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>,
+                    find: <T extends P.${model.name}FindManyArgs>(context: QueryContext, args?: P.SelectSubset<T, P.${model.name}FindManyArgs>) => 
+                        this.crud.find('${model.name}', args, context) as Promise<P.CheckSelect<T, Array<${model.name}>, Array<P.${model.name}GetPayload<T>>>>,
+                    create: <T extends P.${model.name}CreateArgs>(context: QueryContext, args: P.${model.name}CreateArgs) => 
+                        this.crud.create('${model.name}', args, context) as Promise<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>,
+                    update: <T extends Omit<P.${model.name}UpdateArgs, 'where'>>(context: QueryContext, id: string, args: Omit<P.${model.name}UpdateArgs, 'where'>) => 
+                        this.crud.update('${model.name}', id, args, context) as Promise<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>,
+                    del: <T extends Omit<P.${model.name}DeleteArgs, 'where'>>(context: QueryContext, id: string, args?: Omit<P.${model.name}DeleteArgs, 'where'>) => 
+                        this.crud.del('${model.name}', id, args, context) as Promise<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>,
+                }
+            `);
+        }
+
         // Recommended by Prisma for Next.js
         // https://www.prisma.io/docs/guides/database/troubleshooting-orm/help-articles/nextjs-prisma-client-dev-practices#problem
         sf.addStatements([

package/src/language-server/utils.ts

@@ -0,0 +1,21 @@
+import { AstNode } from 'langium';
+import { STD_LIB_MODULE_NAME } from './constants';
+import { isModel, Model } from './generated/ast';
+
+/**
+ * Gets the toplevel Model containing the given node.
+ */
+export function getContainingModel(node: AstNode | undefined): Model | null {
+    if (!node) {
+        return null;
+    }
+    return isModel(node) ? node : getContainingModel(node.$container);
+}
+
+/**
+ * Returns if the given node is declared in stdlib.
+ */
+export function isFromStdlib(node: AstNode) {
+    const model = getContainingModel(node);
+    return model && model.$document?.uri.path.endsWith(STD_LIB_MODULE_NAME);
+}

package/src/language-server/validator/datamodel-validator.ts

@@ -390,5 +390,37 @@ export default class DataModelValidator implements AstValidator<DataModel> {
             });
             return;
         }
+
+        if (relationOwner !== field && !relationOwner.type.array) {
+            // one-to-one relation requires defining side's reference field to be @unique
+            // e.g.:
+            //     model User {
+            //         id String @id @default(cuid())
+            //         data UserData?
+            //     }
+            //     model UserData {
+            //         id String @id @default(cuid())
+            //         user User  @relation(fields: [userId], references: [id])
+            //         userId String
+            //     }
+            //
+            // UserData.userId field needs to be @unique
+
+            thisRelation.fields?.forEach((ref) => {
+                const refField = ref.target.ref as DataModelField;
+                if (
+                    refField &&
+                    !refField.attributes.find(
+                        (a) => a.decl.ref?.name === '@unique'
+                    )
+                ) {
+                    accept(
+                        'error',
+                        `Field "${refField.name}" is part of a one-to-one relation and must be marked as @unique`,
+                        { node: refField }
+                    );
+                }
+            });
+        }
     }
 }

package/src/language-server/validator/expression-validator.ts

@@ -0,0 +1,48 @@
+import {
+    Expression,
+    isBinaryExpr,
+    isInvocationExpr,
+} from '@lang/generated/ast';
+import { AstValidator } from '@lang/types';
+import { isFromStdlib } from '@lang/utils';
+import { ValidationAcceptor } from 'langium';
+
+/**
+ * Validates expressions.
+ */
+export default class ExpressionValidator implements AstValidator<Expression> {
+    validate(expr: Expression, accept: ValidationAcceptor): void {
+        if (!expr.$resolvedType) {
+            if (this.isAuthInvocation(expr)) {
+                // check was done at link time
+                accept(
+                    'error',
+                    'auth() cannot be resolved because no "User" model is defined',
+                    { node: expr }
+                );
+            } else if (this.isCollectionPredicate(expr)) {
+                accept(
+                    'error',
+                    'collection predicate can only be used on an array of model type',
+                    { node: expr }
+                );
+            } else {
+                accept('error', 'expression cannot be resolved', {
+                    node: expr,
+                });
+            }
+        }
+    }
+
+    private isCollectionPredicate(expr: Expression) {
+        return isBinaryExpr(expr) && ['?', '!', '^'].includes(expr.operator);
+    }
+
+    private isAuthInvocation(expr: Expression) {
+        return (
+            isInvocationExpr(expr) &&
+            expr.function.ref?.name === 'auth' &&
+            isFromStdlib(expr.function.ref)
+        );
+    }
+}

package/src/language-server/validator/zmodel-validator.ts

@@ -10,6 +10,7 @@ import {
     DataModel,
     DataSource,
     Enum,
+    Expression,
     Model,
     ZModelAstType,
 } from '../generated/ast';
@@ -19,6 +20,7 @@ import DataSourceValidator from './datasource-validator';
 import DataModelValidator from './datamodel-validator';
 import AttributeValidator from './attribute-validator';
 import EnumValidator from './enum-validator';
+import ExpressionValidator from './expression-validator';
 
 /**
  * Registry for validation checks.
@@ -33,6 +35,7 @@ export class ZModelValidationRegistry extends ValidationRegistry {
             DataModel: validator.checkDataModel,
             Enum: validator.checkEnum,
             Attribute: validator.checkAttribute,
+            Expression: validator.checkExpression,
         };
         this.register(checks, validator);
     }
@@ -81,4 +84,8 @@ export class ZModelValidator {
         this.shouldCheck(node) &&
             new AttributeValidator().validate(node, accept);
     }
+
+    checkExpression(node: Expression, accept: ValidationAcceptor): void {
+        new ExpressionValidator().validate(node, accept);
+    }
 }

package/src/language-server/zmodel-linker.ts

@@ -35,6 +35,7 @@ import {
     UnaryExpr,
 } from './generated/ast';
 import { ResolvedShape } from './types';
+import { getContainingModel, isFromStdlib } from './utils';
 import { mapBuiltinTypeToExpressionType } from './validator/utils';
 
 interface DefaultReference extends Reference {
@@ -291,7 +292,18 @@ export class ZModelLinker extends DefaultLinker {
         if (node.function.ref) {
             // eslint-disable-next-line @typescript-eslint/ban-types
             const funcDecl = node.function.ref as Function;
-            this.resolveToDeclaredType(node, funcDecl.returnType);
+            if (funcDecl.name === 'auth' && isFromStdlib(funcDecl)) {
+                // auth() function is resolved to User model in the current document
+                const model = getContainingModel(node);
+                const userModel = model?.declarations.find(
+                    (d) => isDataModel(d) && d.name === 'User'
+                );
+                if (userModel) {
+                    node.$resolvedType = { decl: userModel };
+                }
+            } else {
+                this.resolveToDeclaredType(node, funcDecl.returnType);
+            }
         }
     }
 
@@ -355,8 +367,7 @@ export class ZModelLinker extends DefaultLinker {
             this.resolve(node.right, document, extraScopes);
             this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
         } else {
-            // TODO: handle this during validation
-            console.warn(`Unresolved collection predicate`);
+            // error is reported in validation pass
         }
     }