@zenstackhq/sdk 3.0.0-beta.7 → 3.0.0-beta.9

package/dist/index.js

@@ -101,12 +101,365 @@ function getIdFields(dm) {
 __name(getIdFields, "getIdFields");
 var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
+// src/expression-utils.ts
+import { match } from "ts-pattern";
+var ExpressionVisitor = class {
+  static {
+    __name(this, "ExpressionVisitor");
+  }
+  visit(expr) {
+    match(expr).with({
+      kind: "literal"
+    }, (e) => this.visitLiteral(e)).with({
+      kind: "array"
+    }, (e) => this.visitArray(e)).with({
+      kind: "field"
+    }, (e) => this.visitField(e)).with({
+      kind: "member"
+    }, (e) => this.visitMember(e)).with({
+      kind: "binary"
+    }, (e) => this.visitBinary(e)).with({
+      kind: "unary"
+    }, (e) => this.visitUnary(e)).with({
+      kind: "call"
+    }, (e) => this.visitCall(e)).with({
+      kind: "this"
+    }, (e) => this.visitThis(e)).with({
+      kind: "null"
+    }, (e) => this.visitNull(e)).exhaustive();
+  }
+  visitLiteral(_e) {
+  }
+  visitArray(e) {
+    e.items.forEach((item) => this.visit(item));
+  }
+  visitField(_e) {
+  }
+  visitMember(e) {
+    this.visit(e.receiver);
+  }
+  visitBinary(e) {
+    this.visit(e.left);
+    this.visit(e.right);
+  }
+  visitUnary(e) {
+    this.visit(e.operand);
+  }
+  visitCall(e) {
+    e.args?.forEach((arg) => this.visit(arg));
+  }
+  visitThis(_e) {
+  }
+  visitNull(_e) {
+  }
+};
+
+// src/default-operation-node-visitor.ts
+import { OperationNodeVisitor } from "kysely";
+var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
+  static {
+    __name(this, "DefaultOperationNodeVisitor");
+  }
+  defaultVisit(node) {
+    Object.values(node).forEach((value) => {
+      if (!value) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((el) => this.defaultVisit(el));
+      }
+      if (typeof value === "object" && "kind" in value && typeof value.kind === "string") {
+        this.visitNode(value);
+      }
+    });
+  }
+  visitSelectQuery(node) {
+    this.defaultVisit(node);
+  }
+  visitSelection(node) {
+    this.defaultVisit(node);
+  }
+  visitColumn(node) {
+    this.defaultVisit(node);
+  }
+  visitAlias(node) {
+    this.defaultVisit(node);
+  }
+  visitTable(node) {
+    this.defaultVisit(node);
+  }
+  visitFrom(node) {
+    this.defaultVisit(node);
+  }
+  visitReference(node) {
+    this.defaultVisit(node);
+  }
+  visitAnd(node) {
+    this.defaultVisit(node);
+  }
+  visitOr(node) {
+    this.defaultVisit(node);
+  }
+  visitValueList(node) {
+    this.defaultVisit(node);
+  }
+  visitParens(node) {
+    this.defaultVisit(node);
+  }
+  visitJoin(node) {
+    this.defaultVisit(node);
+  }
+  visitRaw(node) {
+    this.defaultVisit(node);
+  }
+  visitWhere(node) {
+    this.defaultVisit(node);
+  }
+  visitInsertQuery(node) {
+    this.defaultVisit(node);
+  }
+  visitDeleteQuery(node) {
+    this.defaultVisit(node);
+  }
+  visitReturning(node) {
+    this.defaultVisit(node);
+  }
+  visitCreateTable(node) {
+    this.defaultVisit(node);
+  }
+  visitAddColumn(node) {
+    this.defaultVisit(node);
+  }
+  visitColumnDefinition(node) {
+    this.defaultVisit(node);
+  }
+  visitDropTable(node) {
+    this.defaultVisit(node);
+  }
+  visitOrderBy(node) {
+    this.defaultVisit(node);
+  }
+  visitOrderByItem(node) {
+    this.defaultVisit(node);
+  }
+  visitGroupBy(node) {
+    this.defaultVisit(node);
+  }
+  visitGroupByItem(node) {
+    this.defaultVisit(node);
+  }
+  visitUpdateQuery(node) {
+    this.defaultVisit(node);
+  }
+  visitColumnUpdate(node) {
+    this.defaultVisit(node);
+  }
+  visitLimit(node) {
+    this.defaultVisit(node);
+  }
+  visitOffset(node) {
+    this.defaultVisit(node);
+  }
+  visitOnConflict(node) {
+    this.defaultVisit(node);
+  }
+  visitOnDuplicateKey(node) {
+    this.defaultVisit(node);
+  }
+  visitCheckConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitDataType(node) {
+    this.defaultVisit(node);
+  }
+  visitSelectAll(node) {
+    this.defaultVisit(node);
+  }
+  visitIdentifier(node) {
+    this.defaultVisit(node);
+  }
+  visitSchemableIdentifier(node) {
+    this.defaultVisit(node);
+  }
+  visitValue(node) {
+    this.defaultVisit(node);
+  }
+  visitPrimitiveValueList(node) {
+    this.defaultVisit(node);
+  }
+  visitOperator(node) {
+    this.defaultVisit(node);
+  }
+  visitCreateIndex(node) {
+    this.defaultVisit(node);
+  }
+  visitDropIndex(node) {
+    this.defaultVisit(node);
+  }
+  visitList(node) {
+    this.defaultVisit(node);
+  }
+  visitPrimaryKeyConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitUniqueConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitReferences(node) {
+    this.defaultVisit(node);
+  }
+  visitWith(node) {
+    this.defaultVisit(node);
+  }
+  visitCommonTableExpression(node) {
+    this.defaultVisit(node);
+  }
+  visitCommonTableExpressionName(node) {
+    this.defaultVisit(node);
+  }
+  visitHaving(node) {
+    this.defaultVisit(node);
+  }
+  visitCreateSchema(node) {
+    this.defaultVisit(node);
+  }
+  visitDropSchema(node) {
+    this.defaultVisit(node);
+  }
+  visitAlterTable(node) {
+    this.defaultVisit(node);
+  }
+  visitDropColumn(node) {
+    this.defaultVisit(node);
+  }
+  visitRenameColumn(node) {
+    this.defaultVisit(node);
+  }
+  visitAlterColumn(node) {
+    this.defaultVisit(node);
+  }
+  visitModifyColumn(node) {
+    this.defaultVisit(node);
+  }
+  visitAddConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitDropConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitForeignKeyConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitCreateView(node) {
+    this.defaultVisit(node);
+  }
+  visitDropView(node) {
+    this.defaultVisit(node);
+  }
+  visitGenerated(node) {
+    this.defaultVisit(node);
+  }
+  visitDefaultValue(node) {
+    this.defaultVisit(node);
+  }
+  visitOn(node) {
+    this.defaultVisit(node);
+  }
+  visitValues(node) {
+    this.defaultVisit(node);
+  }
+  visitSelectModifier(node) {
+    this.defaultVisit(node);
+  }
+  visitCreateType(node) {
+    this.defaultVisit(node);
+  }
+  visitDropType(node) {
+    this.defaultVisit(node);
+  }
+  visitExplain(node) {
+    this.defaultVisit(node);
+  }
+  visitDefaultInsertValue(node) {
+    this.defaultVisit(node);
+  }
+  visitAggregateFunction(node) {
+    this.defaultVisit(node);
+  }
+  visitOver(node) {
+    this.defaultVisit(node);
+  }
+  visitPartitionBy(node) {
+    this.defaultVisit(node);
+  }
+  visitPartitionByItem(node) {
+    this.defaultVisit(node);
+  }
+  visitSetOperation(node) {
+    this.defaultVisit(node);
+  }
+  visitBinaryOperation(node) {
+    this.defaultVisit(node);
+  }
+  visitUnaryOperation(node) {
+    this.defaultVisit(node);
+  }
+  visitUsing(node) {
+    this.defaultVisit(node);
+  }
+  visitFunction(node) {
+    this.defaultVisit(node);
+  }
+  visitCase(node) {
+    this.defaultVisit(node);
+  }
+  visitWhen(node) {
+    this.defaultVisit(node);
+  }
+  visitJSONReference(node) {
+    this.defaultVisit(node);
+  }
+  visitJSONPath(node) {
+    this.defaultVisit(node);
+  }
+  visitJSONPathLeg(node) {
+    this.defaultVisit(node);
+  }
+  visitJSONOperatorChain(node) {
+    this.defaultVisit(node);
+  }
+  visitTuple(node) {
+    this.defaultVisit(node);
+  }
+  visitMergeQuery(node) {
+    this.defaultVisit(node);
+  }
+  visitMatched(node) {
+    this.defaultVisit(node);
+  }
+  visitAddIndex(node) {
+    this.defaultVisit(node);
+  }
+  visitCast(node) {
+    this.defaultVisit(node);
+  }
+  visitFetch(node) {
+    this.defaultVisit(node);
+  }
+  visitTop(node) {
+    this.defaultVisit(node);
+  }
+  visitOutput(node) {
+    this.defaultVisit(node);
+  }
+};
+
 // src/prisma/prisma-schema-generator.ts
 import { lowerCaseFirst } from "@zenstackhq/common-helpers";
-import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isModel as isModel2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
-import { getAllAttributes, getAllFields as getAllFields2, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
+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 { AstUtils } from "langium";
-import { match } from "ts-pattern";
+import { match as match2 } from "ts-pattern";
 
 // src/prisma/indent-string.ts
 function indentString(string, count = 4) {
@@ -586,13 +939,20 @@ var PrismaSchemaGenerator = class {
       }
     }
     const allAttributes = getAllAttributes(decl);
-    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2) && !this.isInheritedMapAttribute(attr2, decl))) {
       this.generateContainerAttribute(model, attr);
     }
     decl.comments.forEach((c) => model.addComment(c));
     this.generateDelegateRelationForBase(model, decl);
     this.generateDelegateRelationForConcrete(model, decl);
   }
+  isInheritedMapAttribute(attr, contextModel) {
+    if (attr.$container === contextModel) {
+      return false;
+    }
+    const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+    return attrName === "@@map";
+  }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
       return false;
@@ -638,7 +998,7 @@ var PrismaSchemaGenerator = class {
       isTypeDef2(field.type.reference?.ref) ? false : field.type.array
     );
     const type = new ModelFieldType(fieldType, isArray, field.type.optional);
-    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithPluginInvocation(attr)).filter((attr) => (
+    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithAuthInvocation(attr)).filter((attr) => (
       // when building physical schema, exclude `@default` for id fields inherited from delegate base
       !(model_utils_exports.isIdField(field, contextModel) && this.isInheritedFromDelegate(field, contextModel) && attr.decl.$refText === "@default")
     )).map((attr) => this.makeFieldAttribute(attr));
@@ -648,7 +1008,7 @@ var PrismaSchemaGenerator = class {
     const result = model.addField(field.name, type, attributes, docs, addToFront);
     return result;
   }
-  isDefaultWithPluginInvocation(attr) {
+  isDefaultWithAuthInvocation(attr) {
     if (attr.decl.ref?.name !== "@default") {
       return false;
     }
@@ -656,11 +1016,7 @@ var PrismaSchemaGenerator = class {
     if (!expr) {
       return false;
     }
-    return AstUtils.streamAst(expr).some((node) => isInvocationExpr(node) && this.isFromPlugin(node.function.ref));
-  }
-  isFromPlugin(node) {
-    const model = AstUtils.getContainerOfType(node, isModel2);
-    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+    return AstUtils.streamAst(expr).some(isAuthInvocation);
   }
   isInheritedFromDelegate(field, contextModel) {
     return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
@@ -674,7 +1030,7 @@ var PrismaSchemaGenerator = class {
   }
   makeAttributeArgValue(node) {
     if (isLiteralExpr2(node)) {
-      const argType = match(node.$type).with(StringLiteral, () => "String").with(NumberLiteral, () => "Number").with(BooleanLiteral, () => "Boolean").exhaustive();
+      const argType = match2(node.$type).with(StringLiteral, () => "String").with(NumberLiteral, () => "Number").with(BooleanLiteral, () => "Boolean").exhaustive();
       return new AttributeArgValue(argType, node.value);
     } else if (isArrayExpr(node)) {
       return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
@@ -693,7 +1049,7 @@ var PrismaSchemaGenerator = class {
   }
   makeFunctionCall(node) {
     return new FunctionCall(node.function.ref.name, node.args.map((arg) => {
-      const val = match(arg.value).when(isStringLiteral, (v) => `"${v.value}"`).when(isLiteralExpr2, (v) => v.value.toString()).when(isNullExpr, () => "null").otherwise(() => {
+      const val = match2(arg.value).when(isStringLiteral, (v) => `"${v.value}"`).when(isLiteralExpr2, (v) => v.value.toString()).when(isNullExpr, () => "null").otherwise(() => {
         throw new Error("Function call argument must be literal or null");
       });
       return new FunctionCallArg(val);
@@ -782,7 +1138,7 @@ import { isArrayExpr as isArrayExpr2, isBinaryExpr, isDataField, isDataModel as
 import { getAllAttributes as getAllAttributes2, getAllFields as getAllFields3, isDataFieldReference } from "@zenstackhq/language/utils";
 import fs from "fs";
 import path from "path";
-import { match as match2 } from "ts-pattern";
+import { match as match3 } from "ts-pattern";
 import * as ts from "typescript";
 var TsSchemaGenerator = class {
   static {
@@ -951,7 +1307,7 @@ var TsSchemaGenerator = class {
     ], true))), true);
   }
   mapFieldTypeToTSType(type) {
-    let result = match2(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
+    let result = match3(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
     if (type.array) {
       result = `${result}[]`;
     }
@@ -999,7 +1355,9 @@ var TsSchemaGenerator = class {
           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)))
+              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [
+                this.createLiteralNode(arg)
+              ])))
             ] : []
           ])));
         } else if ("authMember" in defaultValue) {
@@ -1313,7 +1671,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createExpression(value) {
-    return match2(value).when(isLiteralExpr3, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr2, (expr) => this.createCallExpression(expr)).when(isReferenceExpr2, (expr) => this.createRefExpression(expr)).when(isArrayExpr2, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr2, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
+    return match3(value).when(isLiteralExpr3, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr2, (expr) => this.createCallExpression(expr)).when(isReferenceExpr2, (expr) => this.createRefExpression(expr)).when(isArrayExpr2, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr2, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
       throw new Error(`Unsupported attribute arg value: ${value.$type}`);
     });
   }
@@ -1375,7 +1733,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createLiteralExpression(type, value) {
-    return match2(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
+    return match3(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
     ])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [
       ts.factory.createIdentifier(value)
@@ -2031,6 +2389,8 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
 export {
+  DefaultOperationNodeVisitor,
+  ExpressionVisitor,
   model_utils_exports as ModelUtils,
   PrismaSchemaGenerator,
   TsSchemaGenerator,