@zenstackhq/sdk 3.3.0-beta.2 → 3.3.0-beta.4

package/dist/index.js

@@ -815,7 +815,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 as isDataSource2, 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 { isArrayExpr as isArrayExpr2, isBinaryExpr, isCollectionPredicateBinding, isDataField, isDataModel as isDataModel3, isDataSource as isDataSource2, 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, getAttributeArg, isDataFieldReference } from "@zenstackhq/language/utils";
 import fs from "fs";
 import path from "path";
@@ -1339,6 +1339,7 @@ var TsSchemaGenerator = class {
   }
   createEnumObject(e) {
     return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(e.name)),
       ts.factory.createPropertyAssignment("values", ts.factory.createObjectLiteralExpression(e.fields.map((f) => ts.factory.createPropertyAssignment(f.name, ts.factory.createStringLiteral(f.name))), true)),
       // only generate `fields` if there are attributes on the fields
       ...e.fields.some((f) => f.attributes.length > 0) ? [
@@ -1454,11 +1455,15 @@ var TsSchemaGenerator = class {
     return this.createExpressionUtilsCall("_null");
   }
   createBinaryExpression(expr) {
-    return this.createExpressionUtilsCall("binary", [
+    const args = [
       this.createExpression(expr.left),
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.right)
-    ]);
+    ];
+    if (expr.binding) {
+      args.push(this.createLiteralNode(expr.binding.name));
+    }
+    return this.createExpressionUtilsCall("binary", args);
   }
   createUnaryExpression(expr) {
     return this.createExpressionUtilsCall("unary", [
@@ -1467,20 +1472,23 @@ var TsSchemaGenerator = class {
     ]);
   }
   createArrayExpression(expr) {
+    const arrayResolved = expr.$resolvedType?.decl;
+    const arrayType = typeof arrayResolved === "string" ? arrayResolved : arrayResolved?.name;
+    invariant(arrayType, "Array type must be resolved to a string or declaration");
     return this.createExpressionUtilsCall("array", [
+      this.createLiteralNode(arrayType),
       ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))
     ]);
   }
   createRefExpression(expr) {
-    if (isDataField(expr.target.ref)) {
-      return this.createExpressionUtilsCall("field", [
-        this.createLiteralNode(expr.target.$refText)
-      ]);
-    } else if (isEnumField(expr.target.ref)) {
-      return this.createLiteralExpression("StringLiteral", expr.target.$refText);
-    } else {
-      throw new Error(`Unsupported reference type: ${expr.target.$refText}`);
-    }
+    const target = expr.target.ref;
+    return match2(target).when(isDataField, () => this.createExpressionUtilsCall("field", [
+      this.createLiteralNode(expr.target.$refText)
+    ])).when(isEnumField, () => this.createLiteralExpression("StringLiteral", expr.target.$refText)).when(isCollectionPredicateBinding, () => this.createExpressionUtilsCall("binding", [
+      this.createLiteralNode(expr.target.$refText)
+    ])).otherwise(() => {
+      throw Error(`Unsupported reference type: ${expr.target.$refText}`);
+    });
   }
   createCallExpression(expr) {
     return this.createExpressionUtilsCall("call", [