@zenstackhq/sdk 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/index.cjs

@@ -121,7 +121,7 @@ function resolved(ref) {
 }
 __name(resolved, "resolved");
 function getAuthDecl(model) {
-  let found = model.declarations.find((d) => (0, import_ast.isDataModel)(d) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+  let found = model.declarations.find((d) => ((0, import_ast.isDataModel)(d) || (0, import_ast.isTypeDef)(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
   if (!found) {
     found = model.declarations.find((d) => (0, import_ast.isDataModel)(d) && d.name === "User");
   }
@@ -619,13 +619,20 @@ var PrismaSchemaGenerator = class {
       }
     }
     const allAttributes = (0, import_utils2.getAllAttributes)(decl);
-    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2) && !this.isInheritedMapAttribute(attr2, decl))) {
       this.generateContainerAttribute(model, attr);
     }
     decl.comments.forEach((c) => model.addComment(c));
     this.generateDelegateRelationForBase(model, decl);
     this.generateDelegateRelationForConcrete(model, decl);
   }
+  isInheritedMapAttribute(attr, contextModel) {
+    if (attr.$container === contextModel) {
+      return false;
+    }
+    const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+    return attrName === "@@map";
+  }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
       return false;
@@ -671,7 +678,7 @@ var PrismaSchemaGenerator = class {
       (0, import_ast2.isTypeDef)(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) => (
+    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithAuthInvocation(attr)).filter((attr) => (
       // when building physical schema, exclude `@default` for id fields inherited from delegate base
       !(model_utils_exports.isIdField(field, contextModel) && this.isInheritedFromDelegate(field, contextModel) && attr.decl.$refText === "@default")
     )).map((attr) => this.makeFieldAttribute(attr));
@@ -681,7 +688,7 @@ var PrismaSchemaGenerator = class {
     const result = model.addField(field.name, type, attributes, docs, addToFront);
     return result;
   }
-  isDefaultWithPluginInvocation(attr) {
+  isDefaultWithAuthInvocation(attr) {
     if (attr.decl.ref?.name !== "@default") {
       return false;
     }
@@ -689,11 +696,7 @@ var PrismaSchemaGenerator = class {
     if (!expr) {
       return false;
     }
-    return import_langium.AstUtils.streamAst(expr).some((node) => (0, import_ast2.isInvocationExpr)(node) && this.isFromPlugin(node.function.ref));
-  }
-  isFromPlugin(node) {
-    const model = import_langium.AstUtils.getContainerOfType(node, import_ast2.isModel);
-    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+    return import_langium.AstUtils.streamAst(expr).some(import_utils2.isAuthInvocation);
   }
   isInheritedFromDelegate(field, contextModel) {
     return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
@@ -821,10 +824,12 @@ var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
+  usedExpressionUtils = false;
   async generate(model, outputDir) {
     import_node_fs.default.mkdirSync(outputDir, {
       recursive: true
     });
+    this.usedExpressionUtils = false;
     this.generateSchema(model, outputDir);
     this.generateModelsAndTypeDefs(model, outputDir);
     this.generateInputTypes(model, outputDir);
@@ -841,18 +846,21 @@ var TsSchemaGenerator = class {
   }
   generateSchemaStatements(model, statements) {
     const hasComputedFields = model.declarations.some((d) => (0, import_ast3.isDataModel)(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([
@@ -860,6 +868,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
@@ -931,6 +943,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"));
@@ -959,9 +974,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))
@@ -1017,15 +1032,17 @@ 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)))
+              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [
+                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)))
@@ -1339,7 +1356,7 @@ var TsSchemaGenerator = class {
     });
   }
   createThisExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._this"), void 0, []);
+    return this.createExpressionUtilsCall("_this");
   }
   createMemberExpression(expr) {
     const members = [];
@@ -1353,32 +1370,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 ((0, import_ast3.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 ((0, import_ast3.isEnumField)(expr.target.ref)) {
@@ -1388,7 +1405,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)))
@@ -1396,11 +1413,11 @@ var TsSchemaGenerator = class {
     ]);
   }
   createLiteralExpression(type, value) {
-    return (0, import_ts_pattern2.match)(type).with("BooleanLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    return (0, import_ts_pattern2.match)(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}`);