@zenstackhq/orm 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/index.js

@@ -4086,6 +4086,8 @@ var InputValidator = class {
   makePrimitiveSchema(type, attributes) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefSchema(type);
+    } else if (this.schema.enums && type in this.schema.enums) {
+      return this.makeEnumSchema(type);
     } else {
       return match13(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(z2.string(), attributes) : z2.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number()).with("Boolean", () => z2.boolean()).with("BigInt", () => z2.union([
         this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int(),
@@ -4102,6 +4104,21 @@ var InputValidator = class {
       ])).with("Bytes", () => z2.instanceof(Uint8Array)).otherwise(() => z2.unknown());
     }
   }
+  makeEnumSchema(type) {
+    const key = stableStringify({
+      type: "enum",
+      name: type
+    });
+    let schema = this.getSchemaCache(key);
+    if (schema) {
+      return schema;
+    }
+    const enumDef = getEnum(this.schema, type);
+    invariant7(enumDef, `Enum "${type}" not found in schema`);
+    schema = z2.enum(Object.keys(enumDef.values));
+    this.setSchemaCache(key, schema);
+    return schema;
+  }
   makeTypeDefSchema(type) {
     const key = stableStringify({
       type: "typedef",
@@ -4112,9 +4129,9 @@ var InputValidator = class {
     if (schema) {
       return schema;
     }
-    const typeDef = this.schema.typeDefs?.[type];
+    const typeDef = getTypeDef(this.schema, type);
     invariant7(typeDef, `Type definition "${type}" not found in schema`);
-    schema = z2.object(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    schema = z2.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makePrimitiveSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -4126,7 +4143,7 @@ var InputValidator = class {
         field,
         fieldSchema
       ];
-    }))).passthrough();
+    })));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4163,7 +4180,7 @@ var InputValidator = class {
       } else {
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
-          if (Object.keys(enumDef).length > 0) {
+          if (Object.keys(enumDef.values).length > 0) {
             fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, withAggregations);
           }
         } else if (fieldDef.array) {
@@ -4185,7 +4202,7 @@ var InputValidator = class {
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
-              if (Object.keys(enumDef).length > 0) {
+              if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
               } else {
                 fieldSchema = z2.never();
@@ -4225,7 +4242,7 @@ var InputValidator = class {
     return result;
   }
   makeEnumFilterSchema(enumDef, optional, withAggregations) {
-    const baseSchema = z2.enum(Object.keys(enumDef));
+    const baseSchema = z2.enum(Object.keys(enumDef.values));
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
       "equals",
       "in",
@@ -5218,7 +5235,7 @@ import { match as match14 } from "ts-pattern";
 
 // src/client/executor/name-mapper.ts
 import { invariant as invariant8 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode2, ColumnNode as ColumnNode2, FromNode, IdentifierNode, OperationNodeTransformer, ReferenceNode as ReferenceNode2, SelectAllNode, SelectionNode, TableNode as TableNode2 } from "kysely";
+import { AliasNode as AliasNode2, ColumnNode as ColumnNode2, ColumnUpdateNode, expressionBuilder as expressionBuilder3, ExpressionWrapper, FromNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode as ReferenceNode2, SelectAllNode, SelectionNode, TableNode as TableNode2, ValueListNode, ValueNode, ValuesNode } from "kysely";
 var QueryNameMapper = class extends OperationNodeTransformer {
   static {
     __name(this, "QueryNameMapper");
@@ -5273,13 +5290,26 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     if (!node.into) {
       return super.transformInsertQuery(node);
     }
+    const model = extractModelName(node.into);
+    invariant8(model, 'InsertQueryNode must have a model name in the "into" clause');
     return this.withScope({
-      model: node.into.table.identifier.name
-    }, () => ({
-      ...super.transformInsertQuery(node),
-      // map table name
-      into: this.processTableRef(node.into)
-    }));
+      model
+    }, () => {
+      const baseResult = super.transformInsertQuery(node);
+      let values = baseResult.values;
+      if (node.columns && values) {
+        values = this.processEnumMappingForColumns(model, node.columns, values);
+      }
+      return {
+        ...baseResult,
+        // map table name
+        into: this.processTableRef(node.into),
+        values
+      };
+    });
+  }
+  isOperationNode(value) {
+    return !!value && typeof value === "object" && "kind" in value;
   }
   transformReturning(node) {
     return {
@@ -5302,7 +5332,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
           mappedTableName = this.mapTableName(scope.model);
         }
       }
-      return ReferenceNode2.create(ColumnNode2.create(mappedFieldName), mappedTableName ? TableNode2.create(mappedTableName) : void 0);
+      return ReferenceNode2.create(ColumnNode2.create(mappedFieldName), mappedTableName ? this.createTableNode(mappedTableName, void 0) : void 0);
     } else {
       return node;
     }
@@ -5323,12 +5353,24 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     if (!innerTable || !TableNode2.is(innerTable)) {
       return super.transformUpdateQuery(node);
     }
+    const model = extractModelName(innerTable);
+    invariant8(model, 'UpdateQueryNode must have a model name in the "table" clause');
     return this.withScope({
-      model: innerTable.table.identifier.name,
+      model,
       alias
     }, () => {
+      const baseResult = super.transformUpdateQuery(node);
+      const updates = baseResult.updates?.map((update, i) => {
+        if (ColumnNode2.is(update.column)) {
+          const origColumn = node.updates[i].column;
+          return ColumnUpdateNode.create(update.column, this.processEnumMappingForValue(model, origColumn, update.value));
+        } else {
+          return update;
+        }
+      });
       return {
-        ...super.transformUpdateQuery(node),
+        ...baseResult,
+        updates,
         // map table name
         table: this.wrapAlias(this.processTableRef(innerTable), alias)
       };
@@ -5363,29 +5405,54 @@ var QueryNameMapper = class extends OperationNodeTransformer {
   processSelectQuerySelections(node) {
     const selections = [];
     for (const selection of node.selections ?? []) {
+      const processedSelections = [];
       if (SelectAllNode.is(selection.selection)) {
-        const scope = this.scopes[this.scopes.length - 1];
+        const scope = this.requireCurrentScope();
         if (scope?.model && !scope.namesMapped) {
-          selections.push(...this.createSelectAllFields(scope.model, scope.alias));
+          processedSelections.push(...this.createSelectAllFields(scope.model, scope.alias));
         } else {
-          selections.push(super.transformSelection(selection));
+          processedSelections.push({
+            originalField: void 0,
+            selection: super.transformSelection(selection)
+          });
         }
       } else if (ReferenceNode2.is(selection.selection) || ColumnNode2.is(selection.selection)) {
         const transformed = this.transformNode(selection.selection);
+        const originalField = extractFieldName(selection.selection);
         if (AliasNode2.is(transformed)) {
-          selections.push(SelectionNode.create(transformed));
+          processedSelections.push({
+            originalField,
+            selection: SelectionNode.create(transformed)
+          });
         } else {
-          const origFieldName = extractFieldName(selection.selection);
           const fieldName = extractFieldName(transformed);
-          if (fieldName !== origFieldName) {
-            selections.push(SelectionNode.create(this.wrapAlias(transformed, origFieldName ? IdentifierNode.create(origFieldName) : void 0)));
+          if (fieldName !== originalField) {
+            processedSelections.push({
+              originalField,
+              selection: SelectionNode.create(this.wrapAlias(transformed, originalField ? IdentifierNode.create(originalField) : void 0))
+            });
           } else {
-            selections.push(SelectionNode.create(transformed));
+            processedSelections.push({
+              originalField,
+              selection: SelectionNode.create(transformed)
+            });
           }
         }
       } else {
-        selections.push(super.transformSelection(selection));
+        const { node: innerNode } = stripAlias(selection.selection);
+        processedSelections.push({
+          originalField: extractFieldName(innerNode),
+          selection: super.transformSelection(selection)
+        });
       }
+      const enumProcessedSelections = processedSelections.map(({ originalField, selection: selection2 }) => {
+        if (!originalField) {
+          return selection2;
+        } else {
+          return SelectionNode.create(this.processEnumSelection(selection2.selection, originalField));
+        }
+      });
+      selections.push(...enumProcessedSelections);
     }
     return selections;
   }
@@ -5449,7 +5516,9 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     if (!TableNode2.is(node)) {
       return super.transformNode(node);
     }
-    return TableNode2.create(this.mapTableName(node.table.identifier.name));
+    const mappedName = this.mapTableName(node.table.identifier.name);
+    const tableSchema = this.getTableSchema(node.table.identifier.name);
+    return this.createTableNode(mappedName, tableSchema);
   }
   getMappedName(def) {
     const mapAttr = def.attributes?.find((attr) => attr.name === "@@map" || attr.name === "@map");
@@ -5489,8 +5558,9 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       const modelName = innerNode.table.identifier.name;
       const mappedName = this.mapTableName(modelName);
       const finalAlias = alias ?? (mappedName !== modelName ? IdentifierNode.create(modelName) : void 0);
+      const tableSchema = this.getTableSchema(modelName);
       return {
-        node: this.wrapAlias(TableNode2.create(mappedName), finalAlias),
+        node: this.wrapAlias(this.createTableNode(mappedName, tableSchema), finalAlias),
         scope: {
           alias: alias ?? IdentifierNode.create(modelName),
           model: modelName,
@@ -5508,6 +5578,20 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       };
     }
   }
+  getTableSchema(model) {
+    if (this.schema.provider.type !== "postgresql") {
+      return void 0;
+    }
+    let schema = this.schema.provider.defaultSchema ?? "public";
+    const schemaAttr = this.schema.models[model]?.attributes?.find((attr) => attr.name === "@@schema");
+    if (schemaAttr) {
+      const nameArg = schemaAttr.args?.find((arg) => arg.name === "map");
+      if (nameArg && nameArg.value.kind === "literal") {
+        schema = nameArg.value.value;
+      }
+    }
+    return schema;
+  }
   createSelectAllFields(model, alias) {
     const modelDef = requireModel(this.schema, model);
     return this.getModelFields(modelDef).map((fieldDef) => {
@@ -5515,9 +5599,15 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       const columnRef = ReferenceNode2.create(ColumnNode2.create(columnName), alias && IdentifierNode.is(alias) ? TableNode2.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
         const aliased = AliasNode2.create(columnRef, IdentifierNode.create(fieldDef.name));
-        return SelectionNode.create(aliased);
+        return {
+          originalField: fieldDef.name,
+          selection: SelectionNode.create(aliased)
+        };
       } else {
-        return SelectionNode.create(columnRef);
+        return {
+          originalField: fieldDef.name,
+          selection: SelectionNode.create(columnRef)
+        };
       }
     });
   }
@@ -5541,26 +5631,155 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     return result;
   }
   processSelection(node) {
-    let alias;
-    if (!AliasNode2.is(node)) {
-      alias = extractFieldName(node);
+    const { alias, node: innerNode } = stripAlias(node);
+    const originalField = extractFieldName(innerNode);
+    let result = super.transformNode(node);
+    if (originalField) {
+      result = this.processEnumSelection(result, originalField);
+    }
+    if (!AliasNode2.is(result)) {
+      const addAlias = alias ?? (originalField ? IdentifierNode.create(originalField) : void 0);
+      if (addAlias) {
+        result = this.wrapAlias(result, addAlias);
+      }
     }
-    const result = super.transformNode(node);
-    return this.wrapAlias(result, alias ? IdentifierNode.create(alias) : void 0);
+    return result;
   }
   processSelectAll(node) {
-    const scope = this.scopes[this.scopes.length - 1];
-    invariant8(scope);
-    if (!scope.model || !this.hasMappedColumns(scope.model)) {
+    const scope = this.requireCurrentScope();
+    if (!scope.model || !(this.hasMappedColumns(scope.model) || this.modelUsesEnumWithMappedValues(scope.model))) {
       return super.transformSelectAll(node);
     }
     const modelDef = requireModel(this.schema, scope.model);
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
       const columnRef = ReferenceNode2.create(ColumnNode2.create(columnName));
-      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, IdentifierNode.create(fieldDef.name)) : columnRef;
+      const enumProcessed = this.processEnumSelection(columnRef, fieldDef.name);
+      return columnName !== fieldDef.name && !AliasNode2.is(enumProcessed) ? this.wrapAlias(enumProcessed, IdentifierNode.create(fieldDef.name)) : enumProcessed;
+    });
+  }
+  createTableNode(tableName, schemaName) {
+    return schemaName ? TableNode2.createWithSchema(schemaName, tableName) : TableNode2.create(tableName);
+  }
+  requireCurrentScope() {
+    const scope = this.scopes[this.scopes.length - 1];
+    invariant8(scope, "No scope available");
+    return scope;
+  }
+  // #endregion
+  // #region enum value mapping
+  modelUsesEnumWithMappedValues(model) {
+    const modelDef = getModel(this.schema, model);
+    if (!modelDef) {
+      return false;
+    }
+    return this.getModelFields(modelDef).some((fieldDef) => {
+      const enumDef = getEnum(this.schema, fieldDef.type);
+      if (!enumDef) {
+        return false;
+      }
+      return Object.values(enumDef.fields ?? {}).some((f) => f.attributes?.some((attr) => attr.name === "@map"));
     });
   }
+  getEnumValueMapping(enumDef) {
+    const mapping = {};
+    for (const [key, field] of Object.entries(enumDef.fields ?? {})) {
+      const mappedName = this.getMappedName(field);
+      if (mappedName) {
+        mapping[key] = mappedName;
+      }
+    }
+    return mapping;
+  }
+  processEnumMappingForColumns(model, columns, values) {
+    if (ValuesNode.is(values)) {
+      return ValuesNode.create(values.values.map((valueItems) => {
+        if (PrimitiveValueListNode.is(valueItems)) {
+          return PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+        } else {
+          return ValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+        }
+      }));
+    } else if (PrimitiveValueListNode.is(values)) {
+      return PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, values.values));
+    } else {
+      return values;
+    }
+  }
+  processEnumMappingForValues(model, columns, values) {
+    const result = [];
+    for (let i = 0; i < columns.length; i++) {
+      const value = values[i];
+      if (value === null || value === void 0) {
+        result.push(value);
+        continue;
+      }
+      result.push(this.processEnumMappingForValue(model, columns[i], value));
+    }
+    return result;
+  }
+  processEnumMappingForValue(model, column, value) {
+    const fieldDef = getField(this.schema, model, column.column.name);
+    if (!fieldDef) {
+      return value;
+    }
+    if (!isEnum(this.schema, fieldDef.type)) {
+      return value;
+    }
+    const enumDef = getEnum(this.schema, fieldDef.type);
+    if (!enumDef) {
+      return value;
+    }
+    const enumValueMapping = this.getEnumValueMapping(enumDef);
+    if (this.isOperationNode(value) && ValueNode.is(value) && typeof value.value === "string") {
+      const mappedValue = enumValueMapping[value.value];
+      if (mappedValue) {
+        return ValueNode.create(mappedValue);
+      }
+    } else if (typeof value === "string") {
+      const mappedValue = enumValueMapping[value];
+      if (mappedValue) {
+        return mappedValue;
+      }
+    }
+    return value;
+  }
+  processEnumSelection(selection, fieldName) {
+    const { alias, node } = stripAlias(selection);
+    const fieldScope = this.resolveFieldFromScopes(fieldName);
+    if (!fieldScope || !fieldScope.model) {
+      return selection;
+    }
+    const aliasName = alias && IdentifierNode.is(alias) ? alias.name : fieldName;
+    const fieldDef = getField(this.schema, fieldScope.model, fieldName);
+    if (!fieldDef) {
+      return selection;
+    }
+    const enumDef = getEnum(this.schema, fieldDef.type);
+    if (!enumDef) {
+      return selection;
+    }
+    const enumValueMapping = this.getEnumValueMapping(enumDef);
+    if (Object.keys(enumValueMapping).length === 0) {
+      return selection;
+    }
+    const eb = expressionBuilder3();
+    const caseBuilder = eb.case();
+    let caseWhen;
+    for (const [key, value] of Object.entries(enumValueMapping)) {
+      if (!caseWhen) {
+        caseWhen = caseBuilder.when(new ExpressionWrapper(node), "=", value).then(key);
+      } else {
+        caseWhen = caseWhen.when(new ExpressionWrapper(node), "=", value).then(key);
+      }
+    }
+    const finalExpr = caseWhen.else(eb.cast(new ExpressionWrapper(node), "text")).end();
+    if (aliasName) {
+      return finalExpr.as(aliasName).toOperationNode();
+    } else {
+      return finalExpr.toOperationNode();
+    }
+  }
 };
 
 // src/client/executor/zenstack-query-executor.ts
@@ -5576,7 +5795,8 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   nameMapper;
   constructor(client, driver, compiler, adapter, connectionProvider, plugins = [], suppressMutationHooks = false) {
     super(compiler, adapter, connectionProvider, plugins), this.client = client, this.driver = driver, this.compiler = compiler, this.connectionProvider = connectionProvider, this.suppressMutationHooks = suppressMutationHooks;
-    if (this.schemaHasMappedNames(client.$schema)) {
+    if (client.$schema.provider.type === "postgresql" || // postgres queries need to be schema-qualified
+    this.schemaHasMappedNames(client.$schema)) {
       this.nameMapper = new QueryNameMapper(client.$schema);
     }
   }
@@ -5872,7 +6092,7 @@ __export(functions_exports, {
   startsWith: () => startsWith
 });
 import { invariant as invariant10, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
-import { sql as sql5, ValueNode } from "kysely";
+import { sql as sql5, ValueNode as ValueNode2 } from "kysely";
 import { match as match15 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
 var search = /* @__PURE__ */ __name((_eb, _args) => {
@@ -5981,7 +6201,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  invariant10(ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  invariant10(ValueNode2.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
   result = match15(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
@@ -5993,7 +6213,7 @@ function readBoolean(expr, defaultValue) {
     return defaultValue;
   }
   const opNode = expr.toOperationNode();
-  invariant10(ValueNode.is(opNode), "expression must be a literal value");
+  invariant10(ValueNode2.is(opNode), "expression must be a literal value");
   return !!opNode.value;
 }
 __name(readBoolean, "readBoolean");
@@ -6017,7 +6237,22 @@ var SchemaDbPusher = class {
     await this.kysely.transaction().execute(async (tx) => {
       if (this.schema.enums && this.schema.provider.type === "postgresql") {
         for (const [name, enumDef] of Object.entries(this.schema.enums)) {
-          const createEnum = tx.schema.createType(name).asEnum(Object.values(enumDef));
+          let enumValues;
+          if (enumDef.fields) {
+            enumValues = Object.values(enumDef.fields).map((f) => {
+              const mapAttr = f.attributes?.find((a) => a.name === "@map");
+              if (!mapAttr || !mapAttr.args?.[0]) {
+                return f.name;
+              } else {
+                const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
+                invariant11(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+                return mappedName;
+              }
+            });
+          } else {
+            enumValues = Object.values(enumDef.values);
+          }
+          const createEnum = tx.schema.createType(name).asEnum(enumValues);
           await createEnum.execute();
         }
       }