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

package/dist/index.d.cts

@@ -100,10 +100,12 @@ declare class PrismaSchemaGenerator {
     private literalToText;
     private generateGenerator;
     private generateModel;
+    private getDatasourceField;
+    private datasourceHasSchemasSetting;
+    private getDefaultPostgresSchemaName;
     private isInheritedMapAttribute;
     private isPrismaAttribute;
     private getUnsupportedFieldType;
-    private getStringLiteral;
     private generateModelField;
     private isDefaultWithAuthInvocation;
     private isInheritedFromDelegate;
@@ -144,6 +146,7 @@ declare class TsSchemaGenerator {
     private createDataFieldObject;
     private isDiscriminatorField;
     private getDataSourceProvider;
+    private getDataSourceDefaultSchema;
     private getFieldMappedDefault;
     private getMappedValue;
     private getMemberAccessChain;

package/dist/index.d.ts

@@ -100,10 +100,12 @@ declare class PrismaSchemaGenerator {
     private literalToText;
     private generateGenerator;
     private generateModel;
+    private getDatasourceField;
+    private datasourceHasSchemasSetting;
+    private getDefaultPostgresSchemaName;
     private isInheritedMapAttribute;
     private isPrismaAttribute;
     private getUnsupportedFieldType;
-    private getStringLiteral;
     private generateModelField;
     private isDefaultWithAuthInvocation;
     private isInheritedFromDelegate;
@@ -144,6 +146,7 @@ declare class TsSchemaGenerator {
     private createDataFieldObject;
     private isDiscriminatorField;
     private getDataSourceProvider;
+    private getDataSourceDefaultSchema;
     private getFieldMappedDefault;
     private getMappedValue;
     private getMemberAccessChain;

package/dist/index.js

@@ -104,8 +104,8 @@ var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 // src/prisma/prisma-schema-generator.ts
 import { lowerCaseFirst } from "@zenstackhq/common-helpers";
 import { ZModelCodeGenerator } from "@zenstackhq/language";
-import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
-import { getAllAttributes, getAllFields as getAllFields2, isAuthInvocation, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
+import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isDataSource, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { getAllAttributes, getAllFields as getAllFields2, getStringLiteral, isAuthInvocation, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
 import { AstUtils } from "langium";
 import { match } from "ts-pattern";
 
@@ -501,6 +501,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");
@@ -538,7 +541,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)
     }));
@@ -586,14 +589,30 @@ var PrismaSchemaGenerator = class {
         this.generateModelField(model, field, decl);
       }
     }
-    const allAttributes = getAllAttributes(decl);
-    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2) && !this.isInheritedMapAttribute(attr2, decl))) {
+    const allAttributes = 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(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 getStringLiteral(defaultSchemaField?.value) ?? "public";
+  }
   isInheritedMapAttribute(attr, contextModel) {
     if (attr.$container === contextModel) {
       return false;
@@ -609,7 +628,7 @@ var PrismaSchemaGenerator = class {
   }
   getUnsupportedFieldType(fieldType) {
     if (fieldType.unsupported) {
-      const value = this.getStringLiteral(fieldType.unsupported.value);
+      const value = getStringLiteral(fieldType.unsupported.value);
       if (value) {
         return `Unsupported("${value}")`;
       } else {
@@ -619,9 +638,6 @@ var PrismaSchemaGenerator = class {
       return void 0;
     }
   }
-  getStringLiteral(node) {
-    return isStringLiteral(node) ? node.value : void 0;
-  }
   generateModelField(model, field, contextModel, addToFront = false) {
     let fieldType;
     if (field.type.type) {
@@ -782,8 +798,8 @@ var PrismaSchemaGenerator = class {
 
 // src/ts-schema-generator.ts
 import { invariant } from "@zenstackhq/common-helpers";
-import { isArrayExpr as isArrayExpr2, isBinaryExpr, isDataField, isDataModel as isDataModel3, isDataSource, 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, isDataFieldReference } from "@zenstackhq/language/utils";
+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 { getAllAttributes as getAllAttributes2, getAllFields as getAllFields3, getAttributeArg, isDataFieldReference } from "@zenstackhq/language/utils";
 import fs from "fs";
 import path from "path";
 import { match as match2 } from "ts-pattern";
@@ -883,8 +899,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) {
@@ -1058,14 +1078,21 @@ var TsSchemaGenerator = class {
     return getAttribute(origin, "@@delegate")?.args.some((arg) => arg.$resolvedParam.name === "discriminator" && isDataFieldReference(arg.value) && arg.value.target.ref === field);
   }
   getDataSourceProvider(model) {
-    const dataSource = model.declarations.find(isDataSource);
+    const dataSource = model.declarations.find(isDataSource2);
     invariant(dataSource, "No data source found in the model");
     const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    invariant(isLiteralExpr3(providerExpr), "Provider must be a literal");
-    const type = providerExpr.value;
-    return {
-      type
-    };
+    invariant(isLiteralExpr3(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
+    return providerExpr.value;
+  }
+  getDataSourceDefaultSchema(model) {
+    const dataSource = model.declarations.find(isDataSource2);
+    invariant(dataSource, "No data source found in the model");
+    const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
+    if (!defaultSchemaExpr) {
+      return void 0;
+    }
+    invariant(isLiteralExpr3(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
+    return defaultSchemaExpr.value;
   }
   getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
@@ -1231,7 +1258,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 = getAttributeArg(attr, "fields");
+        if (!fieldsArg) {
+          continue;
+        }
+        const fieldNames = this.getReferenceNames(fieldsArg);
         if (!fieldNames) {
           continue;
         }
@@ -1270,7 +1301,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 (!isLiteralExpr3(expr)) {
@@ -1459,7 +1504,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);