@zenstackhq/sdk 3.0.0-beta.27 → 3.0.0-beta.28

package/dist/index.cjs

@@ -901,8 +901,8 @@ var TsSchemaGenerator = class {
   }
   generateSchemaStatements(model, statements, lite) {
     const hasComputedFields = model.declarations.some((d) => (0, import_ast3.isDataModel)(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
-    const schemaObject = this.createSchemaObject(model, lite);
-    const runtimeImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
+    const schemaClass = this.createSchemaClass(model, lite);
+    const runtimeImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(void 0, 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"))
@@ -912,57 +912,53 @@ var TsSchemaGenerator = class {
       ] : []
     ])), ts.factory.createStringLiteral("@zenstackhq/orm/schema"));
     statements.push(runtimeImportDecl);
-    const _schemaDecl = ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([
-      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(_schemaDecl);
-    const brandedSchemaType = ts.factory.createTypeAliasDeclaration(void 0, "Schema", void 0, ts.factory.createIntersectionTypeNode([
-      ts.factory.createTypeQueryNode(ts.factory.createIdentifier("_schema")),
-      ts.factory.createTypeLiteralNode([
-        ts.factory.createPropertySignature(void 0, "__brand", ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("schema")))
-      ])
-    ]));
-    statements.push(brandedSchemaType);
-    const schemaExportDecl = ts.factory.createVariableStatement([
+    statements.push(schemaClass);
+    const schemaDecl = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration("schema", void 0, ts.factory.createTypeReferenceNode("Schema"), ts.factory.createIdentifier("_schema"))
+      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createNewExpression(ts.factory.createIdentifier("SchemaType"), void 0, []))
     ], ts.NodeFlags.Const));
-    statements.push(schemaExportDecl);
-    const schemaTypeDeclaration = ts.factory.createTypeAliasDeclaration([
-      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-    ], "SchemaType", void 0, ts.factory.createTypeReferenceNode("Schema"));
-    statements.push(schemaTypeDeclaration);
+    statements.push(schemaDecl);
   }
   createExpressionUtilsCall(method, args) {
     this.usedExpressionUtils = true;
     return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
   }
-  createSchemaObject(model, lite) {
-    const properties = [
+  createSchemaClass(model, lite) {
+    const members = [
       // provider
-      ts.factory.createPropertyAssignment("provider", this.createProviderObject(model)),
+      ts.factory.createPropertyDeclaration(void 0, "provider", void 0, void 0, this.createAsConst(this.createProviderObject(model))),
       // models
-      ts.factory.createPropertyAssignment("models", this.createModelsObject(model, lite)),
+      ts.factory.createPropertyDeclaration(void 0, "models", void 0, void 0, this.createAsConst(this.createModelsObject(model, lite))),
       // typeDefs
       ...model.declarations.some(import_ast3.isTypeDef) ? [
-        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model, lite))
+        ts.factory.createPropertyDeclaration(void 0, "typeDefs", void 0, void 0, this.createAsConst(this.createTypeDefsObject(model, lite)))
       ] : []
     ];
     const enums = model.declarations.filter(import_ast3.isEnum);
     if (enums.length > 0) {
-      properties.push(ts.factory.createPropertyAssignment("enums", ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true)));
+      members.push(ts.factory.createPropertyDeclaration(void 0, "enums", void 0, void 0, this.createAsConst(ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true))));
     }
     const authType = getAuthDecl(model);
     if (authType) {
-      properties.push(ts.factory.createPropertyAssignment("authType", this.createLiteralNode(authType.name)));
+      members.push(ts.factory.createPropertyDeclaration(void 0, "authType", void 0, void 0, this.createAsConst(this.createLiteralNode(authType.name))));
     }
     const procedures = model.declarations.filter(import_ast3.isProcedure);
     if (procedures.length > 0) {
-      properties.push(ts.factory.createPropertyAssignment("procedures", this.createProceduresObject(procedures)));
+      members.push(ts.factory.createPropertyDeclaration(void 0, "procedures", void 0, void 0, this.createAsConst(this.createProceduresObject(procedures))));
     }
-    properties.push(ts.factory.createPropertyAssignment("plugins", ts.factory.createObjectLiteralExpression([], true)));
-    return ts.factory.createObjectLiteralExpression(properties, true);
+    members.push(ts.factory.createPropertyDeclaration(void 0, "plugins", void 0, void 0, ts.factory.createObjectLiteralExpression([], true)));
+    const schemaClass = ts.factory.createClassDeclaration([
+      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+    ], "SchemaType", void 0, [
+      ts.factory.createHeritageClause(ts.SyntaxKind.ImplementsKeyword, [
+        ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier("SchemaDef"), void 0)
+      ])
+    ], members);
+    return schemaClass;
+  }
+  createAsConst(expr) {
+    return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode("const"));
   }
   createProviderObject(model) {
     const dsProvider = this.getDataSourceProvider(model);