@zenstackhq/sdk 3.0.0-beta.3 → 3.0.0-beta.5

package/dist/index.d.cts

@@ -122,9 +122,11 @@ declare class PrismaSchemaGenerator {
 }
 
 declare class TsSchemaGenerator {
+    private usedExpressionUtils;
     generate(model: Model, outputDir: string): Promise<void>;
     private generateSchema;
     private generateSchemaStatements;
+    private createExpressionUtilsCall;
     private createSchemaObject;
     private createProviderObject;
     private createModelsObject;

package/dist/index.d.ts

@@ -122,9 +122,11 @@ declare class PrismaSchemaGenerator {
 }
 
 declare class TsSchemaGenerator {
+    private usedExpressionUtils;
     generate(model: Model, outputDir: string): Promise<void>;
     private generateSchema;
     private generateSchemaStatements;
+    private createExpressionUtilsCall;
     private createSchemaObject;
     private createProviderObject;
     private createModelsObject;

package/dist/index.js

@@ -20,7 +20,7 @@ __export(model_utils_exports, {
   isUniqueField: () => isUniqueField,
   resolved: () => resolved
 });
-import { isDataModel, isLiteralExpr, isModel } from "@zenstackhq/language/ast";
+import { isDataModel, isLiteralExpr, isModel, isTypeDef } from "@zenstackhq/language/ast";
 import { getAllFields, getModelIdFields, getModelUniqueFields } from "@zenstackhq/language/utils";
 function isIdField(field, contextModel) {
   if (hasAttribute(field, "@id")) {
@@ -88,7 +88,7 @@ function resolved(ref) {
 }
 __name(resolved, "resolved");
 function getAuthDecl(model) {
-  let found = model.declarations.find((d) => isDataModel(d) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+  let found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
   if (!found) {
     found = model.declarations.find((d) => isDataModel(d) && d.name === "User");
   }
@@ -103,7 +103,7 @@ var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
 // src/prisma/prisma-schema-generator.ts
 import { lowerCaseFirst } from "@zenstackhq/common-helpers";
-import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isModel as isModel2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isModel as isModel2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
 import { getAllAttributes, getAllFields as getAllFields2, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
 import { AstUtils } from "langium";
 import { match } from "ts-pattern";
@@ -619,7 +619,7 @@ var PrismaSchemaGenerator = class {
     if (field.type.type) {
       fieldType = field.type.type;
     } else if (field.type.reference?.ref) {
-      if (isTypeDef(field.type.reference.ref)) {
+      if (isTypeDef2(field.type.reference.ref)) {
         fieldType = "Json";
       } else {
         fieldType = field.type.reference.ref.name;
@@ -635,7 +635,7 @@ var PrismaSchemaGenerator = class {
     }
     const isArray = (
       // typed-JSON fields should be translated to scalar Json type
-      isTypeDef(field.type.reference?.ref) ? false : field.type.array
+      isTypeDef2(field.type.reference?.ref) ? false : field.type.array
     );
     const type = new ModelFieldType(fieldType, isArray, field.type.optional);
     const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithPluginInvocation(attr)).filter((attr) => (
@@ -778,7 +778,7 @@ var PrismaSchemaGenerator = class {
 
 // src/ts-schema-generator.ts
 import { invariant } from "@zenstackhq/common-helpers";
-import { isArrayExpr as isArrayExpr2, isBinaryExpr, isDataField, isDataModel as isDataModel3, isDataSource, isEnum, isEnumField, isInvocationExpr as isInvocationExpr2, isLiteralExpr as isLiteralExpr3, isMemberAccessExpr, isNullExpr as isNullExpr2, isProcedure, isReferenceExpr as isReferenceExpr2, isThisExpr, isTypeDef as isTypeDef2, isUnaryExpr } from "@zenstackhq/language/ast";
+import { isArrayExpr as isArrayExpr2, isBinaryExpr, isDataField, isDataModel as isDataModel3, isDataSource, isEnum, isEnumField, isInvocationExpr as isInvocationExpr2, isLiteralExpr as isLiteralExpr3, isMemberAccessExpr, isNullExpr as isNullExpr2, isProcedure, isReferenceExpr as isReferenceExpr2, isThisExpr, isTypeDef as isTypeDef3, isUnaryExpr } from "@zenstackhq/language/ast";
 import { getAllAttributes as getAllAttributes2, getAllFields as getAllFields3, isDataFieldReference } from "@zenstackhq/language/utils";
 import fs from "fs";
 import path from "path";
@@ -788,10 +788,12 @@ var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
+  usedExpressionUtils = false;
   async generate(model, outputDir) {
     fs.mkdirSync(outputDir, {
       recursive: true
     });
+    this.usedExpressionUtils = false;
     this.generateSchema(model, outputDir);
     this.generateModelsAndTypeDefs(model, outputDir);
     this.generateInputTypes(model, outputDir);
@@ -808,18 +810,21 @@ var TsSchemaGenerator = class {
   }
   generateSchemaStatements(model, statements) {
     const hasComputedFields = model.declarations.some((d) => isDataModel3(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
+    const schemaObject = this.createSchemaObject(model);
     const runtimeImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("SchemaDef")),
       ...hasComputedFields ? [
         ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("OperandExpression"))
       ] : [],
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
+      ...this.usedExpressionUtils ? [
+        ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
+      ] : []
     ])), ts.factory.createStringLiteral("@zenstackhq/runtime/schema"));
     statements.push(runtimeImportDecl);
     const declaration = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(this.createSchemaObject(model), ts.factory.createTypeReferenceNode("const")), ts.factory.createTypeReferenceNode("SchemaDef")))
+      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(schemaObject, ts.factory.createTypeReferenceNode("const")), ts.factory.createTypeReferenceNode("SchemaDef")))
     ], ts.NodeFlags.Const));
     statements.push(declaration);
     const typeDeclaration = ts.factory.createTypeAliasDeclaration([
@@ -827,6 +832,10 @@ var TsSchemaGenerator = class {
     ], "SchemaType", void 0, ts.factory.createTypeReferenceNode("typeof schema"));
     statements.push(typeDeclaration);
   }
+  createExpressionUtilsCall(method, args) {
+    this.usedExpressionUtils = true;
+    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
+  }
   createSchemaObject(model) {
     const properties = [
       // provider
@@ -834,7 +843,7 @@ var TsSchemaGenerator = class {
       // models
       ts.factory.createPropertyAssignment("models", this.createModelsObject(model)),
       // typeDefs
-      ...model.declarations.some(isTypeDef2) ? [
+      ...model.declarations.some(isTypeDef3) ? [
         ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
       ] : []
     ];
@@ -863,7 +872,7 @@ var TsSchemaGenerator = class {
     return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isDataModel3(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm))), true);
   }
   createTypeDefsObject(model) {
-    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isTypeDef2(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td))), true);
+    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isTypeDef3(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td))), true);
   }
   createDataModelObject(dm) {
     const allFields = getAllFields3(dm);
@@ -898,6 +907,9 @@ var TsSchemaGenerator = class {
       // subModels
       ...subModels.length > 0 ? [
         ts.factory.createPropertyAssignment("subModels", ts.factory.createArrayLiteralExpression(subModels.map((subModel) => ts.factory.createStringLiteral(subModel))))
+      ] : [],
+      ...dm.isView ? [
+        ts.factory.createPropertyAssignment("isView", ts.factory.createTrue())
       ] : []
     ];
     const computedFields = dm.fields.filter((f) => hasAttribute(f, "@computed"));
@@ -926,9 +938,9 @@ var TsSchemaGenerator = class {
   }
   createComputedFieldsObject(fields) {
     return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [
-      // parameter: `context: { currentModel: string }`
+      // parameter: `context: { modelAlias: string }`
       ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([
-        ts.factory.createPropertySignature(void 0, "currentModel", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
+        ts.factory.createPropertySignature(void 0, "modelAlias", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
       ]), void 0)
     ], ts.factory.createTypeReferenceNode("OperandExpression", [
       ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type))
@@ -984,15 +996,15 @@ var TsSchemaGenerator = class {
     if (defaultValue !== void 0) {
       if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
         if ("call" in defaultValue) {
-          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createExpressionUtilsCall("call", [
             ts.factory.createStringLiteral(defaultValue.call),
             ...defaultValue.args.length > 0 ? [
               ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createLiteralNode(arg)))
             ] : []
           ])));
         } else if ("authMember" in defaultValue) {
-          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.member"), void 0, [
-            ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createExpressionUtilsCall("member", [
+            this.createExpressionUtilsCall("call", [
               ts.factory.createStringLiteral("auth")
             ]),
             ts.factory.createArrayLiteralExpression(defaultValue.authMember.map((m) => ts.factory.createStringLiteral(m)))
@@ -1306,7 +1318,7 @@ var TsSchemaGenerator = class {
     });
   }
   createThisExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._this"), void 0, []);
+    return this.createExpressionUtilsCall("_this");
   }
   createMemberExpression(expr) {
     const members = [];
@@ -1320,32 +1332,32 @@ var TsSchemaGenerator = class {
       this.createExpression(receiver),
       ts.factory.createArrayLiteralExpression(members.map((m) => ts.factory.createStringLiteral(m)))
     ];
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.member"), void 0, args);
+    return this.createExpressionUtilsCall("member", args);
   }
   createNullExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._null"), void 0, []);
+    return this.createExpressionUtilsCall("_null");
   }
   createBinaryExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.binary"), void 0, [
+    return this.createExpressionUtilsCall("binary", [
       this.createExpression(expr.left),
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.right)
     ]);
   }
   createUnaryExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.unary"), void 0, [
+    return this.createExpressionUtilsCall("unary", [
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.operand)
     ]);
   }
   createArrayExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.array"), void 0, [
+    return this.createExpressionUtilsCall("array", [
       ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))
     ]);
   }
   createRefExpression(expr) {
     if (isDataField(expr.target.ref)) {
-      return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
+      return this.createExpressionUtilsCall("field", [
         this.createLiteralNode(expr.target.$refText)
       ]);
     } else if (isEnumField(expr.target.ref)) {
@@ -1355,7 +1367,7 @@ var TsSchemaGenerator = class {
     }
   }
   createCallExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+    return this.createExpressionUtilsCall("call", [
       ts.factory.createStringLiteral(expr.function.$refText),
       ...expr.args.length > 0 ? [
         ts.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))
@@ -1363,11 +1375,11 @@ var TsSchemaGenerator = class {
     ]);
   }
   createLiteralExpression(type, value) {
-    return match2(type).with("BooleanLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    return match2(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
-    ])).with("NumberLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    ])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [
       ts.factory.createIdentifier(value)
-    ])).with("StringLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    ])).with("StringLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
     ])).otherwise(() => {
       throw new Error(`Unsupported literal type: ${type}`);
@@ -1378,7 +1390,7 @@ var TsSchemaGenerator = class {
     statements.push(this.generateSchemaImport(model, true, true));
     statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`)),
-      ...model.declarations.some(isTypeDef2) ? [
+      ...model.declarations.some(isTypeDef3) ? [
         ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))
       ] : []
     ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
@@ -1395,7 +1407,7 @@ var TsSchemaGenerator = class {
       }
       statements.push(modelType);
     }
-    const typeDefs = model.declarations.filter(isTypeDef2);
+    const typeDefs = model.declarations.filter(isTypeDef3);
     for (const td of typeDefs) {
       let typeDef = ts.factory.createTypeAliasDeclaration([
         ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)