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

package/dist/index.cjs

@@ -4116,6 +4116,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 (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
         this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
@@ -4132,6 +4134,21 @@ var InputValidator = class {
       ])).with("Bytes", () => import_zod2.z.instanceof(Uint8Array)).otherwise(() => import_zod2.z.unknown());
     }
   }
+  makeEnumSchema(type) {
+    const key = (0, import_json_stable_stringify.default)({
+      type: "enum",
+      name: type
+    });
+    let schema = this.getSchemaCache(key);
+    if (schema) {
+      return schema;
+    }
+    const enumDef = getEnum(this.schema, type);
+    (0, import_common_helpers7.invariant)(enumDef, `Enum "${type}" not found in schema`);
+    schema = import_zod2.z.enum(Object.keys(enumDef.values));
+    this.setSchemaCache(key, schema);
+    return schema;
+  }
   makeTypeDefSchema(type) {
     const key = (0, import_json_stable_stringify.default)({
       type: "typedef",
@@ -4142,9 +4159,9 @@ var InputValidator = class {
     if (schema) {
       return schema;
     }
-    const typeDef = this.schema.typeDefs?.[type];
+    const typeDef = getTypeDef(this.schema, type);
     (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
-    schema = import_zod2.z.object(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makePrimitiveSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -4156,7 +4173,7 @@ var InputValidator = class {
         field,
         fieldSchema
       ];
-    }))).passthrough();
+    })));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4193,7 +4210,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) {
@@ -4215,7 +4232,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 = import_zod2.z.never();
@@ -4255,7 +4272,7 @@ var InputValidator = class {
     return result;
   }
   makeEnumFilterSchema(enumDef, optional, withAggregations) {
-    const baseSchema = import_zod2.z.enum(Object.keys(enumDef));
+    const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
       "equals",
       "in",
@@ -5303,13 +5320,26 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     if (!node.into) {
       return super.transformInsertQuery(node);
     }
+    const model = extractModelName(node.into);
+    (0, import_common_helpers8.invariant)(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 {
@@ -5332,7 +5362,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
           mappedTableName = this.mapTableName(scope.model);
         }
       }
-      return import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(mappedFieldName), mappedTableName ? import_kysely6.TableNode.create(mappedTableName) : void 0);
+      return import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(mappedFieldName), mappedTableName ? this.createTableNode(mappedTableName, void 0) : void 0);
     } else {
       return node;
     }
@@ -5353,12 +5383,24 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     if (!innerTable || !import_kysely6.TableNode.is(innerTable)) {
       return super.transformUpdateQuery(node);
     }
+    const model = extractModelName(innerTable);
+    (0, import_common_helpers8.invariant)(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 (import_kysely6.ColumnNode.is(update.column)) {
+          const origColumn = node.updates[i].column;
+          return import_kysely6.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)
       };
@@ -5393,29 +5435,54 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
   processSelectQuerySelections(node) {
     const selections = [];
     for (const selection of node.selections ?? []) {
+      const processedSelections = [];
       if (import_kysely6.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 (import_kysely6.ReferenceNode.is(selection.selection) || import_kysely6.ColumnNode.is(selection.selection)) {
         const transformed = this.transformNode(selection.selection);
+        const originalField = extractFieldName(selection.selection);
         if (import_kysely6.AliasNode.is(transformed)) {
-          selections.push(import_kysely6.SelectionNode.create(transformed));
+          processedSelections.push({
+            originalField,
+            selection: import_kysely6.SelectionNode.create(transformed)
+          });
         } else {
-          const origFieldName = extractFieldName(selection.selection);
           const fieldName = extractFieldName(transformed);
-          if (fieldName !== origFieldName) {
-            selections.push(import_kysely6.SelectionNode.create(this.wrapAlias(transformed, origFieldName ? import_kysely6.IdentifierNode.create(origFieldName) : void 0)));
+          if (fieldName !== originalField) {
+            processedSelections.push({
+              originalField,
+              selection: import_kysely6.SelectionNode.create(this.wrapAlias(transformed, originalField ? import_kysely6.IdentifierNode.create(originalField) : void 0))
+            });
           } else {
-            selections.push(import_kysely6.SelectionNode.create(transformed));
+            processedSelections.push({
+              originalField,
+              selection: import_kysely6.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 import_kysely6.SelectionNode.create(this.processEnumSelection(selection2.selection, originalField));
+        }
+      });
+      selections.push(...enumProcessedSelections);
     }
     return selections;
   }
@@ -5479,7 +5546,9 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     if (!import_kysely6.TableNode.is(node)) {
       return super.transformNode(node);
     }
-    return import_kysely6.TableNode.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");
@@ -5519,8 +5588,9 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       const modelName = innerNode.table.identifier.name;
       const mappedName = this.mapTableName(modelName);
       const finalAlias = alias ?? (mappedName !== modelName ? import_kysely6.IdentifierNode.create(modelName) : void 0);
+      const tableSchema = this.getTableSchema(modelName);
       return {
-        node: this.wrapAlias(import_kysely6.TableNode.create(mappedName), finalAlias),
+        node: this.wrapAlias(this.createTableNode(mappedName, tableSchema), finalAlias),
         scope: {
           alias: alias ?? import_kysely6.IdentifierNode.create(modelName),
           model: modelName,
@@ -5538,6 +5608,20 @@ var QueryNameMapper = class extends import_kysely6.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) => {
@@ -5545,9 +5629,15 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       const columnRef = import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(columnName), alias && import_kysely6.IdentifierNode.is(alias) ? import_kysely6.TableNode.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
         const aliased = import_kysely6.AliasNode.create(columnRef, import_kysely6.IdentifierNode.create(fieldDef.name));
-        return import_kysely6.SelectionNode.create(aliased);
+        return {
+          originalField: fieldDef.name,
+          selection: import_kysely6.SelectionNode.create(aliased)
+        };
       } else {
-        return import_kysely6.SelectionNode.create(columnRef);
+        return {
+          originalField: fieldDef.name,
+          selection: import_kysely6.SelectionNode.create(columnRef)
+        };
       }
     });
   }
@@ -5571,26 +5661,155 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     return result;
   }
   processSelection(node) {
-    let alias;
-    if (!import_kysely6.AliasNode.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 (!import_kysely6.AliasNode.is(result)) {
+      const addAlias = alias ?? (originalField ? import_kysely6.IdentifierNode.create(originalField) : void 0);
+      if (addAlias) {
+        result = this.wrapAlias(result, addAlias);
+      }
     }
-    const result = super.transformNode(node);
-    return this.wrapAlias(result, alias ? import_kysely6.IdentifierNode.create(alias) : void 0);
+    return result;
   }
   processSelectAll(node) {
-    const scope = this.scopes[this.scopes.length - 1];
-    (0, import_common_helpers8.invariant)(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 = import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(columnName));
-      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, import_kysely6.IdentifierNode.create(fieldDef.name)) : columnRef;
+      const enumProcessed = this.processEnumSelection(columnRef, fieldDef.name);
+      return columnName !== fieldDef.name && !import_kysely6.AliasNode.is(enumProcessed) ? this.wrapAlias(enumProcessed, import_kysely6.IdentifierNode.create(fieldDef.name)) : enumProcessed;
+    });
+  }
+  createTableNode(tableName, schemaName) {
+    return schemaName ? import_kysely6.TableNode.createWithSchema(schemaName, tableName) : import_kysely6.TableNode.create(tableName);
+  }
+  requireCurrentScope() {
+    const scope = this.scopes[this.scopes.length - 1];
+    (0, import_common_helpers8.invariant)(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 (import_kysely6.ValuesNode.is(values)) {
+      return import_kysely6.ValuesNode.create(values.values.map((valueItems) => {
+        if (import_kysely6.PrimitiveValueListNode.is(valueItems)) {
+          return import_kysely6.PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+        } else {
+          return import_kysely6.ValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+        }
+      }));
+    } else if (import_kysely6.PrimitiveValueListNode.is(values)) {
+      return import_kysely6.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) && import_kysely6.ValueNode.is(value) && typeof value.value === "string") {
+      const mappedValue = enumValueMapping[value.value];
+      if (mappedValue) {
+        return import_kysely6.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 && import_kysely6.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 = (0, import_kysely6.expressionBuilder)();
+    const caseBuilder = eb.case();
+    let caseWhen;
+    for (const [key, value] of Object.entries(enumValueMapping)) {
+      if (!caseWhen) {
+        caseWhen = caseBuilder.when(new import_kysely6.ExpressionWrapper(node), "=", value).then(key);
+      } else {
+        caseWhen = caseWhen.when(new import_kysely6.ExpressionWrapper(node), "=", value).then(key);
+      }
+    }
+    const finalExpr = caseWhen.else(eb.cast(new import_kysely6.ExpressionWrapper(node), "text")).end();
+    if (aliasName) {
+      return finalExpr.as(aliasName).toOperationNode();
+    } else {
+      return finalExpr.toOperationNode();
+    }
+  }
 };
 
 // src/client/executor/zenstack-query-executor.ts
@@ -5606,7 +5825,8 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   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);
     }
   }
@@ -6047,7 +6267,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);
+                (0, import_common_helpers11.invariant)(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();
         }
       }