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

package/dist/expression-Ce_oulwU.d.cts

@@ -0,0 +1,44 @@
+type Expression = LiteralExpression | ArrayExpression | FieldExpression | MemberExpression | CallExpression | UnaryExpression | BinaryExpression | ThisExpression | NullExpression;
+type LiteralExpression = {
+    kind: 'literal';
+    value: string | number | boolean;
+};
+type ArrayExpression = {
+    kind: 'array';
+    items: Expression[];
+};
+type FieldExpression = {
+    kind: 'field';
+    field: string;
+};
+type MemberExpression = {
+    kind: 'member';
+    receiver: Expression;
+    members: string[];
+};
+type UnaryExpression = {
+    kind: 'unary';
+    op: UnaryOperator;
+    operand: Expression;
+};
+type BinaryExpression = {
+    kind: 'binary';
+    op: BinaryOperator;
+    left: Expression;
+    right: Expression;
+};
+type CallExpression = {
+    kind: 'call';
+    function: string;
+    args?: Expression[];
+};
+type ThisExpression = {
+    kind: 'this';
+};
+type NullExpression = {
+    kind: 'null';
+};
+type UnaryOperator = '!';
+type BinaryOperator = '&&' | '||' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '?' | '!' | '^' | 'in';
+
+export type { ArrayExpression as A, BinaryExpression as B, CallExpression as C, Expression as E, FieldExpression as F, LiteralExpression as L, MemberExpression as M, NullExpression as N, ThisExpression as T, UnaryExpression as U, UnaryOperator as a, BinaryOperator as b };

package/dist/expression-Ce_oulwU.d.ts

@@ -0,0 +1,44 @@
+type Expression = LiteralExpression | ArrayExpression | FieldExpression | MemberExpression | CallExpression | UnaryExpression | BinaryExpression | ThisExpression | NullExpression;
+type LiteralExpression = {
+    kind: 'literal';
+    value: string | number | boolean;
+};
+type ArrayExpression = {
+    kind: 'array';
+    items: Expression[];
+};
+type FieldExpression = {
+    kind: 'field';
+    field: string;
+};
+type MemberExpression = {
+    kind: 'member';
+    receiver: Expression;
+    members: string[];
+};
+type UnaryExpression = {
+    kind: 'unary';
+    op: UnaryOperator;
+    operand: Expression;
+};
+type BinaryExpression = {
+    kind: 'binary';
+    op: BinaryOperator;
+    left: Expression;
+    right: Expression;
+};
+type CallExpression = {
+    kind: 'call';
+    function: string;
+    args?: Expression[];
+};
+type ThisExpression = {
+    kind: 'this';
+};
+type NullExpression = {
+    kind: 'null';
+};
+type UnaryOperator = '!';
+type BinaryOperator = '&&' | '||' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '?' | '!' | '^' | 'in';
+
+export type { ArrayExpression as A, BinaryExpression as B, CallExpression as C, Expression as E, FieldExpression as F, LiteralExpression as L, MemberExpression as M, NullExpression as N, ThisExpression as T, UnaryExpression as U, UnaryOperator as a, BinaryOperator as b };

package/dist/index.cjs

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DefaultOperationNodeVisitor: () => DefaultOperationNodeVisitor,
+  ExpressionVisitor: () => ExpressionVisitor,
   ModelUtils: () => model_utils_exports,
   PrismaSchemaGenerator: () => PrismaSchemaGenerator,
   TsSchemaGenerator: () => TsSchemaGenerator,
@@ -134,12 +136,365 @@ function getIdFields(dm) {
 __name(getIdFields, "getIdFields");
 var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
+// src/expression-utils.ts
+var import_ts_pattern = require("ts-pattern");
+var ExpressionVisitor = class {
+  static {
+    __name(this, "ExpressionVisitor");
+  }
+  visit(expr) {
+    (0, import_ts_pattern.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
+var import_kysely = require("kysely");
+var DefaultOperationNodeVisitor = class extends import_kysely.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
 var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_ast2 = require("@zenstackhq/language/ast");
 var import_utils2 = require("@zenstackhq/language/utils");
 var import_langium = require("langium");
-var import_ts_pattern = require("ts-pattern");
+var import_ts_pattern2 = require("ts-pattern");
 
 // src/prisma/indent-string.ts
 function indentString(string, count = 4) {
@@ -619,13 +974,20 @@ var PrismaSchemaGenerator = class {
       }
     }
     const allAttributes = (0, import_utils2.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;
@@ -671,7 +1033,7 @@ var PrismaSchemaGenerator = class {
       (0, import_ast2.isTypeDef)(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));
@@ -681,7 +1043,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;
     }
@@ -689,11 +1051,7 @@ var PrismaSchemaGenerator = class {
     if (!expr) {
       return false;
     }
-    return import_langium.AstUtils.streamAst(expr).some((node) => (0, import_ast2.isInvocationExpr)(node) && this.isFromPlugin(node.function.ref));
-  }
-  isFromPlugin(node) {
-    const model = import_langium.AstUtils.getContainerOfType(node, import_ast2.isModel);
-    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+    return import_langium.AstUtils.streamAst(expr).some(import_utils2.isAuthInvocation);
   }
   isInheritedFromDelegate(field, contextModel) {
     return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
@@ -707,7 +1065,7 @@ var PrismaSchemaGenerator = class {
   }
   makeAttributeArgValue(node) {
     if ((0, import_ast2.isLiteralExpr)(node)) {
-      const argType = (0, import_ts_pattern.match)(node.$type).with(import_ast2.StringLiteral, () => "String").with(import_ast2.NumberLiteral, () => "Number").with(import_ast2.BooleanLiteral, () => "Boolean").exhaustive();
+      const argType = (0, import_ts_pattern2.match)(node.$type).with(import_ast2.StringLiteral, () => "String").with(import_ast2.NumberLiteral, () => "Number").with(import_ast2.BooleanLiteral, () => "Boolean").exhaustive();
       return new AttributeArgValue(argType, node.value);
     } else if ((0, import_ast2.isArrayExpr)(node)) {
       return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
@@ -726,7 +1084,7 @@ var PrismaSchemaGenerator = class {
   }
   makeFunctionCall(node) {
     return new FunctionCall(node.function.ref.name, node.args.map((arg) => {
-      const val = (0, import_ts_pattern.match)(arg.value).when(import_ast2.isStringLiteral, (v) => `"${v.value}"`).when(import_ast2.isLiteralExpr, (v) => v.value.toString()).when(import_ast2.isNullExpr, () => "null").otherwise(() => {
+      const val = (0, import_ts_pattern2.match)(arg.value).when(import_ast2.isStringLiteral, (v) => `"${v.value}"`).when(import_ast2.isLiteralExpr, (v) => v.value.toString()).when(import_ast2.isNullExpr, () => "null").otherwise(() => {
         throw new Error("Function call argument must be literal or null");
       });
       return new FunctionCallArg(val);
@@ -815,7 +1173,7 @@ var import_ast3 = require("@zenstackhq/language/ast");
 var import_utils3 = require("@zenstackhq/language/utils");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_ts_pattern2 = require("ts-pattern");
+var import_ts_pattern3 = require("ts-pattern");
 var ts = __toESM(require("typescript"), 1);
 var TsSchemaGenerator = class {
   static {
@@ -984,7 +1342,7 @@ var TsSchemaGenerator = class {
     ], true))), true);
   }
   mapFieldTypeToTSType(type) {
-    let result = (0, import_ts_pattern2.match)(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
+    let result = (0, import_ts_pattern3.match)(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}[]`;
     }
@@ -1032,7 +1390,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) {
@@ -1346,7 +1706,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createExpression(value) {
-    return (0, import_ts_pattern2.match)(value).when(import_ast3.isLiteralExpr, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(import_ast3.isInvocationExpr, (expr) => this.createCallExpression(expr)).when(import_ast3.isReferenceExpr, (expr) => this.createRefExpression(expr)).when(import_ast3.isArrayExpr, (expr) => this.createArrayExpression(expr)).when(import_ast3.isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(import_ast3.isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(import_ast3.isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(import_ast3.isNullExpr, () => this.createNullExpression()).when(import_ast3.isThisExpr, () => this.createThisExpression()).otherwise(() => {
+    return (0, import_ts_pattern3.match)(value).when(import_ast3.isLiteralExpr, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(import_ast3.isInvocationExpr, (expr) => this.createCallExpression(expr)).when(import_ast3.isReferenceExpr, (expr) => this.createRefExpression(expr)).when(import_ast3.isArrayExpr, (expr) => this.createArrayExpression(expr)).when(import_ast3.isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(import_ast3.isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(import_ast3.isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(import_ast3.isNullExpr, () => this.createNullExpression()).when(import_ast3.isThisExpr, () => this.createThisExpression()).otherwise(() => {
       throw new Error(`Unsupported attribute arg value: ${value.$type}`);
     });
   }
@@ -1408,7 +1768,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createLiteralExpression(type, value) {
-    return (0, import_ts_pattern2.match)(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
+    return (0, import_ts_pattern3.match)(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
     ])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [
       ts.factory.createIdentifier(value)
@@ -2065,6 +2425,8 @@ _ts_decorate([
 ], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DefaultOperationNodeVisitor,
+  ExpressionVisitor,
   ModelUtils,
   PrismaSchemaGenerator,
   TsSchemaGenerator,