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

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");
   }
@@ -821,10 +821,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 +843,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 +865,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 +940,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 +971,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 +1029,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)))
@@ -1339,7 +1351,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 +1365,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 +1400,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 +1408,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}`);