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

package/dist/index.cjs

@@ -5302,7 +5302,7 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     ] : []
   ];
   bases.forEach((base) => {
-    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) || isDataModel(d) && d.name === base.$refText);
+    const baseDecl = decl.$container.declarations.find((d) => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5425,6 +5425,10 @@ function getArray(expr) {
   return isArrayExpr(expr) || isConfigArrayExpr(expr) ? expr.items : void 0;
 }
 __name(getArray, "getArray");
+function getAttributeArg(attr, name) {
+  return attr.args.find((arg) => arg.$resolvedParam?.name === name)?.value;
+}
+__name(getAttributeArg, "getAttributeArg");
 function getFunctionExpressionContext(funcDecl) {
   const funcAllowedContext = [];
   const funcAttr = funcDecl.attributes.find((attr) => attr.decl.$refText === "@@@expressionContext");
@@ -5693,6 +5697,7 @@ function findRootNode(node) {
 __name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_langium3 = require("langium");
 var import_pluralize = __toESM(require("pluralize"), 1);
 function _ts_decorate(decorators, target, key, desc) {
@@ -5913,7 +5918,7 @@ var AttributeApplicationValidator = class {
     }
   }
   _checkConstraint(attr, accept) {
-    const fields = attr.args[0]?.value;
+    const fields = getAttributeArg(attr, "fields");
     const attrName = attr.decl.ref?.name;
     if (!fields) {
       accept("error", `expects an array of field references`, {
@@ -5953,6 +5958,24 @@ var AttributeApplicationValidator = class {
       });
     }
   }
+  _checkSchema(attr, accept) {
+    const schemaName = getStringLiteral(attr.args[0]?.value);
+    (0, import_common_helpers.invariant)(schemaName, `@@schema expects a string literal`);
+    const zmodel = import_langium3.AstUtils.getContainerOfType(attr, isModel);
+    const datasource = zmodel.declarations.find(isDataSource);
+    if (datasource) {
+      let found = false;
+      const schemas = datasource.fields.find((f) => f.name === "schemas");
+      if (schemas && isConfigArrayExpr(schemas.value)) {
+        found = schemas.value.items.some((item) => isLiteralExpr(item) && item.value === schemaName);
+      }
+      if (!found) {
+        accept("error", `Schema "${schemaName}" is not defined in the datasource`, {
+          node: attr
+        });
+      }
+    }
+  }
   validatePolicyKinds(kind, candidates, attr, accept) {
     const items = kind.split(",").map((x) => x.trim());
     items.forEach((item) => {
@@ -6005,6 +6028,15 @@ _ts_decorate([
   ]),
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkConstraint", null);
+_ts_decorate([
+  check("@@schema"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkSchema", null);
 function assignableToAttributeParam(arg, param, attr) {
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
@@ -6138,7 +6170,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_langium4 = require("langium");
 
 // src/validators/common.ts
@@ -6509,7 +6541,7 @@ var DataModelValidator = class {
     if (!model.baseModel) {
       return;
     }
-    (0, import_common_helpers.invariant)(model.baseModel.ref, "baseModel must be resolved");
+    (0, import_common_helpers2.invariant)(model.baseModel.ref, "baseModel must be resolved");
     if (!isDelegateModel(model.baseModel.ref)) {
       accept("error", `Model ${model.baseModel.$refText} cannot be extended because it's not a delegate model`, {
         node: model,
@@ -6531,7 +6563,7 @@ var DataModelValidator = class {
       }
       seen.push(current);
       if (current.baseModel) {
-        (0, import_common_helpers.invariant)(current.baseModel.ref, "baseModel must be resolved");
+        (0, import_common_helpers2.invariant)(current.baseModel.ref, "baseModel must be resolved");
         todo.push(current.baseModel.ref);
       }
     }
@@ -6562,7 +6594,6 @@ var DataSourceValidator = class {
     validateDuplicatedDeclarations(ds, ds.fields, accept);
     this.validateProvider(ds, accept);
     this.validateUrl(ds, accept);
-    this.validateRelationMode(ds, accept);
   }
   validateProvider(ds, accept) {
     const provider = ds.fields.find((f) => f.name === "provider");
@@ -6572,16 +6603,52 @@ var DataSourceValidator = class {
       });
       return;
     }
-    const value = getStringLiteral(provider.value);
-    if (!value) {
+    const providerValue = getStringLiteral(provider.value);
+    if (!providerValue) {
       accept("error", '"provider" must be set to a string literal', {
         node: provider.value
       });
-    } else if (!SUPPORTED_PROVIDERS.includes(value)) {
-      accept("error", `Provider "${value}" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(" | ")}.`, {
+    } else if (!SUPPORTED_PROVIDERS.includes(providerValue)) {
+      accept("error", `Provider "${providerValue}" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(" | ")}.`, {
         node: provider.value
       });
     }
+    const defaultSchemaField = ds.fields.find((f) => f.name === "defaultSchema");
+    let defaultSchemaValue;
+    if (defaultSchemaField) {
+      if (providerValue !== "postgresql") {
+        accept("error", '"defaultSchema" is only supported for "postgresql" provider', {
+          node: defaultSchemaField
+        });
+      }
+      defaultSchemaValue = getStringLiteral(defaultSchemaField.value);
+      if (!defaultSchemaValue) {
+        accept("error", '"defaultSchema" must be a string literal', {
+          node: defaultSchemaField.value
+        });
+      }
+    }
+    const schemasField = ds.fields.find((f) => f.name === "schemas");
+    if (schemasField) {
+      if (providerValue !== "postgresql") {
+        accept("error", '"schemas" is only supported for "postgresql" provider', {
+          node: schemasField
+        });
+      }
+      const schemasValue = schemasField.value;
+      if (!isConfigArrayExpr(schemasValue) || !schemasValue.items.every((e) => isLiteralExpr(e) && typeof getStringLiteral(e) === "string")) {
+        accept("error", '"schemas" must be an array of string literals', {
+          node: schemasField
+        });
+      } else if (
+        // validate `defaultSchema` is included in `schemas`
+        defaultSchemaValue && !schemasValue.items.some((e) => getStringLiteral(e) === defaultSchemaValue)
+      ) {
+        accept("error", `"${defaultSchemaValue}" must be included in the "schemas" array`, {
+          node: schemasField
+        });
+      }
+    }
   }
   validateUrl(ds, accept) {
     const urlField = ds.fields.find((f) => f.name === "url");
@@ -6595,20 +6662,6 @@ var DataSourceValidator = class {
       });
     }
   }
-  validateRelationMode(ds, accept) {
-    const field = ds.fields.find((f) => f.name === "relationMode");
-    if (field) {
-      const val = getStringLiteral(field.value);
-      if (!val || ![
-        "foreignKeys",
-        "prisma"
-      ].includes(val)) {
-        accept("error", '"relationMode" must be set to "foreignKeys" or "prisma"', {
-          node: field.value
-        });
-      }
-    }
-  }
 };
 
 // src/validators/enum-validator.ts