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

package/dist/index.cjs

@@ -1371,6 +1371,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) ? [
@@ -1486,11 +1487,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", [
@@ -1499,20 +1504,23 @@ var TsSchemaGenerator = class {
     ]);
   }
   createArrayExpression(expr) {
+    const arrayResolved = expr.$resolvedType?.decl;
+    const arrayType = typeof arrayResolved === "string" ? arrayResolved : arrayResolved?.name;
+    (0, import_common_helpers2.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 ((0, import_ast3.isDataField)(expr.target.ref)) {
-      return this.createExpressionUtilsCall("field", [
-        this.createLiteralNode(expr.target.$refText)
-      ]);
-    } else if ((0, import_ast3.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 (0, import_ts_pattern2.match)(target).when(import_ast3.isDataField, () => this.createExpressionUtilsCall("field", [
+      this.createLiteralNode(expr.target.$refText)
+    ])).when(import_ast3.isEnumField, () => this.createLiteralExpression("StringLiteral", expr.target.$refText)).when(import_ast3.isCollectionPredicateBinding, () => this.createExpressionUtilsCall("binding", [
+      this.createLiteralNode(expr.target.$refText)
+    ])).otherwise(() => {
+      throw Error(`Unsupported reference type: ${expr.target.$refText}`);
+    });
   }
   createCallExpression(expr) {
     return this.createExpressionUtilsCall("call", [