@zenstackhq/sdk 3.0.0-beta.20 → 3.0.0-beta.21

package/dist/index.cjs

@@ -533,6 +533,9 @@ var EnumField = class extends DeclarationBase {
 
 // src/prisma/prisma-schema-generator.ts
 var IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
+var NON_PRISMA_DATASOURCE_FIELDS = [
+  "defaultSchema"
+];
 var PrismaSchemaGenerator = class {
   static {
     __name(this, "PrismaSchemaGenerator");
@@ -570,7 +573,7 @@ var PrismaSchemaGenerator = class {
     return this.PRELUDE + prisma.toString();
   }
   generateDataSource(prisma, dataSource) {
-    const fields = dataSource.fields.map((f) => ({
+    const fields = dataSource.fields.filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name)).map((f) => ({
       name: f.name,
       text: this.configExprToText(f.value)
     }));
@@ -618,14 +621,30 @@ var PrismaSchemaGenerator = class {
         this.generateModelField(model, field, decl);
       }
     }
-    const allAttributes = (0, import_utils2.getAllAttributes)(decl);
-    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2) && !this.isInheritedMapAttribute(attr2, decl))) {
+    const allAttributes = (0, import_utils2.getAllAttributes)(decl).filter((attr) => this.isPrismaAttribute(attr) && !this.isInheritedMapAttribute(attr, decl));
+    for (const attr of allAttributes) {
       this.generateContainerAttribute(model, attr);
     }
+    if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) {
+      model.addAttribute("@@schema", [
+        new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))
+      ]);
+    }
     decl.comments.forEach((c) => model.addComment(c));
     this.generateDelegateRelationForBase(model, decl);
     this.generateDelegateRelationForConcrete(model, decl);
   }
+  getDatasourceField(zmodel, fieldName) {
+    const dataSource = zmodel.declarations.find(import_ast2.isDataSource);
+    return dataSource?.fields.find((f) => f.name === fieldName);
+  }
+  datasourceHasSchemasSetting(zmodel) {
+    return !!this.getDatasourceField(zmodel, "schemas");
+  }
+  getDefaultPostgresSchemaName(zmodel) {
+    const defaultSchemaField = this.getDatasourceField(zmodel, "defaultSchema");
+    return (0, import_utils2.getStringLiteral)(defaultSchemaField?.value) ?? "public";
+  }
   isInheritedMapAttribute(attr, contextModel) {
     if (attr.$container === contextModel) {
       return false;
@@ -641,7 +660,7 @@ var PrismaSchemaGenerator = class {
   }
   getUnsupportedFieldType(fieldType) {
     if (fieldType.unsupported) {
-      const value = this.getStringLiteral(fieldType.unsupported.value);
+      const value = (0, import_utils2.getStringLiteral)(fieldType.unsupported.value);
       if (value) {
         return `Unsupported("${value}")`;
       } else {
@@ -651,9 +670,6 @@ var PrismaSchemaGenerator = class {
       return void 0;
     }
   }
-  getStringLiteral(node) {
-    return (0, import_ast2.isStringLiteral)(node) ? node.value : void 0;
-  }
   generateModelField(model, field, contextModel, addToFront = false) {
     let fieldType;
     if (field.type.type) {
@@ -915,8 +931,12 @@ var TsSchemaGenerator = class {
   }
   createProviderObject(model) {
     const dsProvider = this.getDataSourceProvider(model);
+    const defaultSchema = this.getDataSourceDefaultSchema(model);
     return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type))
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider)),
+      ...defaultSchema ? [
+        ts.factory.createPropertyAssignment("defaultSchema", ts.factory.createStringLiteral(defaultSchema))
+      ] : []
     ], true);
   }
   createModelsObject(model, lite) {
@@ -1093,11 +1113,18 @@ var TsSchemaGenerator = class {
     const dataSource = model.declarations.find(import_ast3.isDataSource);
     (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
     const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
-    const type = providerExpr.value;
-    return {
-      type
-    };
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
+    return providerExpr.value;
+  }
+  getDataSourceDefaultSchema(model) {
+    const dataSource = model.declarations.find(import_ast3.isDataSource);
+    (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
+    const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
+    if (!defaultSchemaExpr) {
+      return void 0;
+    }
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
+    return defaultSchemaExpr.value;
   }
   getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
@@ -1263,7 +1290,11 @@ var TsSchemaGenerator = class {
     const seenKeys = /* @__PURE__ */ new Set();
     for (const attr of allAttributes) {
       if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
-        const fieldNames = this.getReferenceNames(attr.args[0].value);
+        const fieldsArg = (0, import_utils3.getAttributeArg)(attr, "fields");
+        if (!fieldsArg) {
+          continue;
+        }
+        const fieldNames = this.getReferenceNames(fieldsArg);
         if (!fieldNames) {
           continue;
         }
@@ -1302,7 +1333,21 @@ var TsSchemaGenerator = class {
     return field.type.type ? ts.factory.createStringLiteral(field.type.type) : field.type.reference ? ts.factory.createStringLiteral(field.type.reference.$refText) : ts.factory.createStringLiteral("Unsupported");
   }
   createEnumObject(e) {
-    return ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createStringLiteral(field.name))), true);
+    return ts.factory.createObjectLiteralExpression([
+      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) ? [
+        ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
+          ...field.attributes.length > 0 ? [
+            ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes?.map((attr) => this.createAttributeObject(attr)) ?? [], true))
+          ] : []
+        ], true))), true))
+      ] : [],
+      ...e.attributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(e.attributes.map((attr) => this.createAttributeObject(attr)), true))
+      ] : []
+    ], true);
   }
   getLiteral(expr) {
     if (!(0, import_ast3.isLiteralExpr)(expr)) {
@@ -1491,7 +1536,7 @@ var TsSchemaGenerator = class {
       let enumDecl = ts.factory.createVariableStatement([
         ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
       ], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)))
+        ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)), ts.factory.createIdentifier("values")))
       ], ts.NodeFlags.Const));
       if (e.comments.length > 0) {
         enumDecl = this.generateDocs(enumDecl, e);