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

package/dist/index.cjs

@@ -35,18 +35,14 @@ __export(src_exports, {
   BaseCrudDialect: () => BaseCrudDialect,
   CRUD: () => CRUD,
   CRUD_EXT: () => CRUD_EXT,
-  InputValidationError: () => InputValidationError,
-  InternalError: () => InternalError,
   KyselyUtils: () => kysely_utils_exports,
-  NotFoundError: () => NotFoundError,
-  QueryError: () => QueryError,
+  ORMError: () => ORMError,
+  ORMErrorReason: () => ORMErrorReason,
   QueryUtils: () => query_utils_exports,
-  RejectedByPolicyError: () => RejectedByPolicyError,
   RejectedByPolicyReason: () => RejectedByPolicyReason,
   SchemaUtils: () => schema_utils_exports,
   TransactionIsolationLevel: () => TransactionIsolationLevel,
   ZenStackClient: () => ZenStackClient,
-  ZenStackError: () => ZenStackError,
   definePlugin: () => definePlugin,
   getCrudDialect: () => getCrudDialect
 });
@@ -114,63 +110,110 @@ function fieldsToSelectObject(fields) {
 }
 __name(fieldsToSelectObject, "fieldsToSelectObject");
 
-// src/client/errors.ts
-var ZenStackError = class extends Error {
-  static {
-    __name(this, "ZenStackError");
-  }
-};
-var InputValidationError = class extends ZenStackError {
-  static {
-    __name(this, "InputValidationError");
-  }
-  model;
-  constructor(model, message, cause) {
-    super(message, {
-      cause
-    }), this.model = model;
-  }
-};
-var QueryError = class extends ZenStackError {
-  static {
-    __name(this, "QueryError");
-  }
-  constructor(message, cause) {
-    super(message, {
-      cause
-    });
-  }
-};
-var InternalError = class extends ZenStackError {
-  static {
-    __name(this, "InternalError");
-  }
-};
-var NotFoundError = class extends ZenStackError {
-  static {
-    __name(this, "NotFoundError");
-  }
-  model;
-  constructor(model, details) {
-    super(`Entity not found for model "${model}"${details ? `: ${details}` : ""}`), this.model = model;
+// src/client/executor/error-processor.ts
+function getDbErrorCode(error) {
+  if (error instanceof Error && "code" in error) {
+    return error.code;
+  } else {
+    return void 0;
   }
-};
+}
+__name(getDbErrorCode, "getDbErrorCode");
+
+// src/client/errors.ts
+var ORMErrorReason = /* @__PURE__ */ function(ORMErrorReason2) {
+  ORMErrorReason2["CONFIG_ERROR"] = "config-error";
+  ORMErrorReason2["INVALID_INPUT"] = "invalid-input";
+  ORMErrorReason2["NOT_FOUND"] = "not-found";
+  ORMErrorReason2["REJECTED_BY_POLICY"] = "rejected-by-policy";
+  ORMErrorReason2["DB_QUERY_ERROR"] = "db-query-error";
+  ORMErrorReason2["NOT_SUPPORTED"] = "not-supported";
+  ORMErrorReason2["INTERNAL_ERROR"] = "internal-error";
+  return ORMErrorReason2;
+}({});
 var RejectedByPolicyReason = /* @__PURE__ */ function(RejectedByPolicyReason2) {
   RejectedByPolicyReason2["NO_ACCESS"] = "no-access";
   RejectedByPolicyReason2["CANNOT_READ_BACK"] = "cannot-read-back";
   RejectedByPolicyReason2["OTHER"] = "other";
   return RejectedByPolicyReason2;
 }({});
-var RejectedByPolicyError = class extends ZenStackError {
+var ORMError = class extends Error {
   static {
-    __name(this, "RejectedByPolicyError");
+    __name(this, "ORMError");
   }
-  model;
   reason;
-  constructor(model, reason = "no-access", message) {
-    super(message ?? `Operation rejected by policy${model ? ": " + model : ""}`), this.model = model, this.reason = reason;
+  constructor(reason, message, options) {
+    super(message, options), this.reason = reason;
   }
+  /**
+   * The name of the model that the error pertains to.
+   */
+  model;
+  /**
+   * The error code given by the underlying database driver.
+   */
+  dbErrorCode;
+  /**
+   * The error message given by the underlying database driver.
+   */
+  dbErrorMessage;
+  /**
+   * The reason code for policy rejection. Only available when `reason` is `REJECTED_BY_POLICY`.
+   */
+  rejectedByPolicyReason;
+  /**
+   * The SQL query that was executed. Only available when `reason` is `DB_QUERY_ERROR`.
+   */
+  sql;
+  /**
+   * The parameters used in the SQL query. Only available when `reason` is `DB_QUERY_ERROR`.
+   */
+  sqlParams;
 };
+function createConfigError(message, options) {
+  return new ORMError("config-error", message, options);
+}
+__name(createConfigError, "createConfigError");
+function createNotFoundError(model, message, options) {
+  const error = new ORMError("not-found", message ?? "Record not found", options);
+  error.model = model;
+  return error;
+}
+__name(createNotFoundError, "createNotFoundError");
+function createInvalidInputError(message, model, options) {
+  const error = new ORMError("invalid-input", message, options);
+  error.model = model;
+  return error;
+}
+__name(createInvalidInputError, "createInvalidInputError");
+function createDBQueryError(message, dbError, sql8, parameters) {
+  const error = new ORMError("db-query-error", message, {
+    cause: dbError
+  });
+  error.dbErrorCode = getDbErrorCode(dbError);
+  error.dbErrorMessage = dbError instanceof Error ? dbError.message : void 0;
+  error.sql = sql8;
+  error.sqlParams = parameters;
+  return error;
+}
+__name(createDBQueryError, "createDBQueryError");
+function createRejectedByPolicyError(model, reason, message, options) {
+  const error = new ORMError("rejected-by-policy", message, options);
+  error.model = model;
+  error.rejectedByPolicyReason = reason;
+  return error;
+}
+__name(createRejectedByPolicyError, "createRejectedByPolicyError");
+function createNotSupportedError(message, options) {
+  return new ORMError("not-supported", message, options);
+}
+__name(createNotSupportedError, "createNotSupportedError");
+function createInternalError(message, model, options) {
+  const error = new ORMError("internal-error", message, options);
+  error.model = model;
+  return error;
+}
+__name(createInternalError, "createInternalError");
 
 // src/client/query-utils.ts
 function hasModel(schema, model) {
@@ -188,7 +231,7 @@ __name(getTypeDef, "getTypeDef");
 function requireModel(schema, model) {
   const modelDef = getModel(schema, model);
   if (!modelDef) {
-    throw new QueryError(`Model "${model}" not found in schema`);
+    throw createInternalError(`Model "${model}" not found in schema`, model);
   }
   return modelDef;
 }
@@ -202,7 +245,7 @@ function requireField(schema, modelOrType, field) {
   const modelDef = getModel(schema, modelOrType);
   if (modelDef) {
     if (!modelDef.fields[field]) {
-      throw new QueryError(`Field "${field}" not found in model "${modelOrType}"`);
+      throw createInternalError(`Field "${field}" not found in model "${modelOrType}"`, modelOrType);
     } else {
       return modelDef.fields[field];
     }
@@ -210,12 +253,12 @@ function requireField(schema, modelOrType, field) {
   const typeDef = getTypeDef(schema, modelOrType);
   if (typeDef) {
     if (!typeDef.fields[field]) {
-      throw new QueryError(`Field "${field}" not found in type "${modelOrType}"`);
+      throw createInternalError(`Field "${field}" not found in type "${modelOrType}"`, modelOrType);
     } else {
       return typeDef.fields[field];
     }
   }
-  throw new QueryError(`Model or type "${modelOrType}" not found in schema`);
+  throw createInternalError(`Model or type "${modelOrType}" not found in schema`, modelOrType);
 }
 __name(requireField, "requireField");
 function getIdFields(schema, model) {
@@ -227,7 +270,7 @@ function requireIdFields(schema, model) {
   const modelDef = requireModel(schema, model);
   const result = modelDef?.idFields;
   if (!result) {
-    throw new InternalError(`Model "${model}" does not have ID field(s)`);
+    throw createInternalError(`Model "${model}" does not have ID field(s)`, model);
   }
   return result;
 }
@@ -235,11 +278,11 @@ __name(requireIdFields, "requireIdFields");
 function getRelationForeignKeyFieldPairs(schema, model, relationField) {
   const fieldDef = requireField(schema, model, relationField);
   if (!fieldDef?.relation) {
-    throw new InternalError(`Field "${relationField}" is not a relation`);
+    throw createInternalError(`Field "${relationField}" is not a relation`, model);
   }
   if (fieldDef.relation.fields) {
     if (!fieldDef.relation.references) {
-      throw new InternalError(`Relation references not defined for field "${relationField}"`);
+      throw createInternalError(`Relation references not defined for field "${relationField}"`, model);
     }
     return {
       keyPairs: fieldDef.relation.fields.map((f, i) => ({
@@ -250,17 +293,17 @@ function getRelationForeignKeyFieldPairs(schema, model, relationField) {
     };
   } else {
     if (!fieldDef.relation.opposite) {
-      throw new InternalError(`Opposite relation not defined for field "${relationField}"`);
+      throw createInternalError(`Opposite relation not defined for field "${relationField}"`, model);
     }
     const oppositeField = requireField(schema, fieldDef.type, fieldDef.relation.opposite);
     if (!oppositeField.relation) {
-      throw new InternalError(`Field "${fieldDef.relation.opposite}" is not a relation`);
+      throw createInternalError(`Field "${fieldDef.relation.opposite}" is not a relation`, model);
     }
     if (!oppositeField.relation.fields) {
-      throw new InternalError(`Relation fields not defined for field "${relationField}"`);
+      throw createInternalError(`Relation fields not defined for field "${relationField}"`, model);
     }
     if (!oppositeField.relation.references) {
-      throw new InternalError(`Relation references not defined for field "${relationField}"`);
+      throw createInternalError(`Relation references not defined for field "${relationField}"`, model);
     }
     return {
       keyPairs: oppositeField.relation.fields.map((f, i) => ({
@@ -297,7 +340,7 @@ function getUniqueFields(schema, model) {
   const result = [];
   for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
     if (typeof value !== "object") {
-      throw new InternalError(`Invalid unique field definition for "${key}"`);
+      throw createInternalError(`Invalid unique field definition for "${key}"`, model);
     }
     if (typeof value.type === "string") {
       result.push({
@@ -320,7 +363,7 @@ __name(getUniqueFields, "getUniqueFields");
 function getIdValues(schema, model, data) {
   const idFields = getIdFields(schema, model);
   if (!idFields) {
-    throw new InternalError(`ID fields not defined for model "${model}"`);
+    throw createInternalError(`ID fields not defined for model "${model}"`, model);
   }
   return idFields.reduce((acc, field) => ({
     ...acc,
@@ -479,7 +522,7 @@ function getDiscriminatorField(schema, model) {
   }
   const discriminator = delegateAttr.args?.find((arg) => arg.name === "discriminator");
   if (!discriminator || !schema_exports.ExpressionUtils.isField(discriminator.value)) {
-    throw new InternalError(`Discriminator field not defined for model "${model}"`);
+    throw createInternalError(`Discriminator field not defined for model "${model}"`, model);
   }
   return discriminator.value.field;
 }
@@ -641,7 +684,7 @@ var BaseCrudDialect = class {
       if (this.supportsDistinctOn) {
         result = result.distinctOn(distinct.map((f) => this.eb.ref(`${modelAlias}.${f}`)));
       } else {
-        throw new QueryError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
+        throw createNotSupportedError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
       }
     }
     if (args.cursor) {
@@ -848,7 +891,7 @@ var BaseCrudDialect = class {
           break;
         }
         default: {
-          throw new InternalError(`Invalid array filter key: ${key}`);
+          throw createInvalidInputError(`Invalid array filter key: ${key}`);
         }
       }
     }
@@ -862,9 +905,9 @@ var BaseCrudDialect = class {
       return this.buildEnumFilter(fieldRef, fieldDef, payload);
     }
     return (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(import_ts_pattern2.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => {
-      throw new InternalError("JSON filters are not supported yet");
+      throw createNotSupportedError("JSON filters are not supported yet");
     }).with("Unsupported", () => {
-      throw new QueryError(`Unsupported field cannot be used in filters`);
+      throw createInvalidInputError(`Unsupported field cannot be used in filters`);
     }).exhaustive();
   }
   buildLiteralFilter(lhs, type, rhs) {
@@ -909,7 +952,7 @@ var BaseCrudDialect = class {
         return this.and(...innerResult.conditions);
       }).otherwise(() => {
         if (throwIfInvalid) {
-          throw new QueryError(`Invalid filter key: ${op}`);
+          throw createInvalidInputError(`Invalid filter key: ${op}`);
         } else {
           return void 0;
         }
@@ -938,7 +981,7 @@ var BaseCrudDialect = class {
           continue;
         }
         const condition = (0, import_ts_pattern2.match)(key).with("contains", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", import_kysely2.sql.val(`%${value}%`)) : this.eb(fieldRef, "like", import_kysely2.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", import_kysely2.sql.val(`${value}%`)) : this.eb(fieldRef, "like", import_kysely2.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", import_kysely2.sql.val(`%${value}`)) : this.eb(fieldRef, "like", import_kysely2.sql.val(`%${value}`))).otherwise(() => {
-          throw new QueryError(`Invalid string filter key: ${key}`);
+          throw createInvalidInputError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
           conditions.push(condition);
@@ -1018,7 +1061,7 @@ var BaseCrudDialect = class {
           (0, import_common_helpers2.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             (0, import_common_helpers2.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), import_kysely2.sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
           }
           continue;
         }
@@ -1027,7 +1070,7 @@ var BaseCrudDialect = class {
             (0, import_common_helpers2.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
               (0, import_common_helpers2.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), import_kysely2.sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), this.negateSort(v, negated));
             }
             continue;
           }
@@ -1040,13 +1083,18 @@ var BaseCrudDialect = class {
           if (value === "asc" || value === "desc") {
             result = result.orderBy(fieldRef, this.negateSort(value, negated));
           } else if (value && typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
-            result = result.orderBy(fieldRef, import_kysely2.sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
+            result = result.orderBy(fieldRef, (ob) => {
+              const dir = this.negateSort(value.sort, negated);
+              ob = dir === "asc" ? ob.asc() : ob.desc();
+              ob = value.nulls === "first" ? ob.nullsFirst() : ob.nullsLast();
+              return ob;
+            });
           }
         } else {
           const relationModel = fieldDef.type;
           if (fieldDef.array) {
             if (typeof value !== "object") {
-              throw new QueryError(`invalid orderBy value for field "${field}"`);
+              throw createInvalidInputError(`invalid orderBy value for field "${field}"`);
             }
             if ("_count" in value) {
               (0, import_common_helpers2.invariant)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
@@ -1217,7 +1265,7 @@ var BaseCrudDialect = class {
         computer = computedFields?.[fieldDef.originModel ?? model]?.[field];
       }
       if (!computer) {
-        throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
+        throw createConfigError(`Computed field "${field}" implementation not provided for model "${model}"`);
       }
       return computer(this.eb, {
         modelAlias
@@ -1448,7 +1496,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   }
   getFieldSqlType(fieldDef) {
     if (fieldDef.relation) {
-      throw new QueryError("Cannot get SQL type of a relation field");
+      throw createInternalError("Cannot get SQL type of a relation field");
     }
     let result;
     if (this.schema.enums?.[fieldDef.type]) {
@@ -1538,7 +1586,9 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       try {
         return JSON.parse(value);
       } catch (e) {
-        throw new QueryError("Invalid JSON returned", e);
+        throw createInternalError("Invalid JSON returned", void 0, {
+          cause: e
+        });
       }
     }
     return value;
@@ -1681,10 +1731,10 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   }
   getFieldSqlType(fieldDef) {
     if (fieldDef.relation) {
-      throw new QueryError("Cannot get SQL type of a relation field");
+      throw createInternalError("Cannot get SQL type of a relation field");
     }
     if (fieldDef.array) {
-      throw new QueryError("SQLite does not support scalar list type");
+      throw createInternalError("SQLite does not support scalar list type");
     }
     if (this.schema.enums?.[fieldDef.type]) {
       return "text";
@@ -1772,16 +1822,12 @@ var BaseOperationHandler = class {
       operation: "read"
     }));
     let result = [];
-    const queryId = {
-      queryId: `zenstack-${(0, import_cuid2.createId)()}`
-    };
-    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), queryId);
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), (0, import_kysely5.createQueryId)());
     try {
-      const r = await kysely.getExecutor().executeQuery(compiled, queryId);
+      const r = await kysely.getExecutor().executeQuery(compiled);
       result = r.rows;
     } catch (err) {
-      const message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
-      throw new QueryError(message, err);
+      throw createDBQueryError("Failed to execute query", err, compiled.sql, compiled.parameters);
     }
     return result;
   }
@@ -1807,7 +1853,7 @@ var BaseOperationHandler = class {
         result = this.dialect.buildSelectField(result, model, parentAlias, field);
       } else {
         if (!fieldDef.array && !fieldDef.optional && payload.where) {
-          throw new QueryError(`Field "${field}" doesn't support filtering`);
+          throw createInternalError(`Field "${field}" does not support filtering`, model);
         }
         if (fieldDef.originModel) {
           result = this.dialect.buildRelationSelection(result, fieldDef.originModel, field, fieldDef.originModel, payload);
@@ -1824,7 +1870,7 @@ var BaseOperationHandler = class {
   async create(kysely, model, data, fromRelation, creatingForDelegate = false, returnFields) {
     const modelDef = this.requireModel(model);
     if (modelDef.isDelegate && !creatingForDelegate) {
-      throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
+      throw createNotSupportedError(`Model "${model}" is a delegate and cannot be created directly.`);
     }
     let createFields = {};
     let updateParent = void 0;
@@ -1929,7 +1975,7 @@ var BaseOperationHandler = class {
           }
         });
         if (!extraRead) {
-          throw new QueryError(`Field "${pair.pk}" not found in parent created data`);
+          throw createInternalError(`Field "${pair.pk}" not found in parent created data`, model);
         } else {
           Object.assign(entity, extraRead);
         }
@@ -2013,7 +2059,7 @@ var BaseOperationHandler = class {
               select: fieldsToSelectObject(referencedPkFields)
             });
             if (!relationEntity) {
-              throw new NotFoundError(relationModel, `Could not find the entity to connect for the relation "${relationField.name}"`);
+              throw createNotFoundError(relationModel, `Could not find the entity to connect for the relation "${relationField.name}"`);
             }
             result = relationEntity;
           }
@@ -2030,7 +2076,7 @@ var BaseOperationHandler = class {
           break;
         }
         default:
-          throw new QueryError(`Invalid relation action: ${action}`);
+          throw createInvalidInputError(`Invalid relation action: ${action}`);
       }
     }
     return result;
@@ -2076,7 +2122,7 @@ var BaseOperationHandler = class {
           break;
         }
         default:
-          throw new QueryError(`Invalid relation action: ${action}`);
+          throw createInvalidInputError(`Invalid relation action: ${action}`);
       }
     }
   }
@@ -2091,7 +2137,7 @@ var BaseOperationHandler = class {
     if (fromRelation) {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
-        throw new QueryError("incorrect relation hierarchy for createMany");
+        throw createInvalidInputError("incorrect relation hierarchy for createMany", model);
       }
       relationKeyPairs = keyPairs;
     }
@@ -2134,7 +2180,7 @@ var BaseOperationHandler = class {
     }
     if (modelDef.baseModel) {
       if (input.skipDuplicates) {
-        throw new QueryError('"skipDuplicates" options is not supported for polymorphic models');
+        throw createNotSupportedError('"skipDuplicates" options is not supported for polymorphic models');
       }
       const baseCreateResult = await this.processBaseModelCreateMany(kysely, modelDef.baseModel, createData, !!input.skipDuplicates, model);
       createData = baseCreateResult.remainingFieldRows;
@@ -2232,7 +2278,7 @@ var BaseOperationHandler = class {
   }
   async update(kysely, model, where, data, fromRelation, allowRelationUpdate = true, throwIfNotFound = true, fieldsToReturn) {
     if (!data || typeof data !== "object") {
-      throw new InternalError("data must be an object");
+      throw createInvalidInputError("data must be an object");
     }
     const parentWhere = {};
     let m2m = void 0;
@@ -2294,7 +2340,7 @@ var BaseOperationHandler = class {
         select: this.makeIdSelect(model)
       });
       if (!readResult && throwIfNotFound) {
-        throw new NotFoundError(model);
+        throw createNotFoundError(model);
       }
       combinedWhere = readResult;
     }
@@ -2311,13 +2357,13 @@ var BaseOperationHandler = class {
         updateFields[field] = this.processScalarFieldUpdateData(model, field, finalData);
       } else {
         if (!allowRelationUpdate) {
-          throw new QueryError(`Relation update not allowed for field "${field}"`);
+          throw createNotSupportedError(`Relation update not allowed for field "${field}"`);
         }
         if (!thisEntity) {
           thisEntity = await this.getEntityIds(kysely, model, combinedWhere);
           if (!thisEntity) {
             if (throwIfNotFound) {
-              throw new NotFoundError(model);
+              throw createNotFoundError(model);
             } else {
               return null;
             }
@@ -2344,7 +2390,7 @@ var BaseOperationHandler = class {
       const updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
       if (!updatedEntity) {
         if (throwIfNotFound) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         } else {
           return null;
         }
@@ -2408,7 +2454,7 @@ var BaseOperationHandler = class {
     const eb = (0, import_kysely5.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field);
     return (0, import_ts_pattern6.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
-      throw new InternalError(`Invalid incremental update operation: ${key}`);
+      throw createInvalidInputError(`Invalid incremental update operation: ${key}`);
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
@@ -2420,7 +2466,7 @@ var BaseOperationHandler = class {
     return (0, import_ts_pattern6.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
-      throw new InternalError(`Invalid array update operation: ${key}`);
+      throw createInvalidInputError(`Invalid array update operation: ${key}`);
     });
   }
   isNumericField(fieldDef) {
@@ -2431,7 +2477,7 @@ var BaseOperationHandler = class {
   }
   async updateMany(kysely, model, where, data, limit, returnData, filterModel, fieldsToReturn) {
     if (typeof data !== "object") {
-      throw new InternalError("data must be an object");
+      throw createInvalidInputError("data must be an object");
     }
     if (Object.keys(data).length === 0) {
       return returnData ? [] : {
@@ -2440,7 +2486,7 @@ var BaseOperationHandler = class {
     }
     const modelDef = this.requireModel(model);
     if (modelDef.baseModel && limit !== void 0) {
-      throw new QueryError("Updating with a limit is not supported for polymorphic models");
+      throw createNotSupportedError("Updating with a limit is not supported for polymorphic models");
     }
     filterModel ??= model;
     let updateFields = {};
@@ -2594,7 +2640,7 @@ var BaseOperationHandler = class {
           break;
         }
         default: {
-          throw new Error("Not implemented yet");
+          throw createInvalidInputError(`Invalid relation update operation: ${key}`);
         }
       }
     }
@@ -2612,13 +2658,13 @@ var BaseOperationHandler = class {
       for (const d of _data) {
         const ids = await this.getEntityIds(kysely, model, d);
         if (!ids) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         }
         const r = await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, ids, m2m.joinTable);
         results.push(r);
       }
       if (_data.length > results.filter((r) => !!r).length) {
-        throw new NotFoundError(model);
+        throw createNotFoundError(model);
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
@@ -2628,7 +2674,7 @@ var BaseOperationHandler = class {
           where: _data[0]
         });
         if (!target) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         }
         for (const { fk, pk } of keyPairs) {
           fromRelation.parentUpdates[fk] = target[pk];
@@ -2654,7 +2700,7 @@ var BaseOperationHandler = class {
         }));
         const updateResult = await this.executeQuery(kysely, query, "connect");
         if (!updateResult.numAffectedRows || _data.length > updateResult.numAffectedRows) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         }
       }
     }
@@ -2770,17 +2816,17 @@ var BaseOperationHandler = class {
       for (const d of _data) {
         const ids = await this.getEntityIds(kysely, model, d);
         if (!ids) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         }
         results.push(await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, ids, m2m.joinTable));
       }
       if (_data.length > results.filter((r) => !!r).length) {
-        throw new NotFoundError(model);
+        throw createNotFoundError(model);
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
-        throw new InternalError("relation can only be set from the non-owning side");
+        throw createInternalError("relation can only be set from the non-owning side", fromRelation.model);
       }
       const fkConditions = keyPairs.reduce((acc, { fk, pk }) => ({
         ...acc,
@@ -2809,7 +2855,7 @@ var BaseOperationHandler = class {
         }));
         const r = await this.executeQuery(kysely, query2, "connect");
         if (!r.numAffectedRows || _data.length > r.numAffectedRows) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         }
       }
     }
@@ -2860,7 +2906,7 @@ var BaseOperationHandler = class {
           where: fromRelation.ids
         });
         if (!fromEntity) {
-          throw new NotFoundError(fromRelation.model);
+          throw createNotFoundError(fromRelation.model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
         (0, import_common_helpers5.invariant)(fieldDef.relation?.opposite);
@@ -2892,7 +2938,7 @@ var BaseOperationHandler = class {
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.rows.length) {
-      throw new NotFoundError(deleteFromModel);
+      throw createNotFoundError(deleteFromModel);
     }
   }
   normalizeRelationManipulationInput(model, data) {
@@ -2904,7 +2950,7 @@ var BaseOperationHandler = class {
     const modelDef = this.requireModel(model);
     if (modelDef.baseModel) {
       if (limit !== void 0) {
-        throw new QueryError("Deleting with a limit is not supported for polymorphic models");
+        throw createNotSupportedError("Deleting with a limit is not supported for polymorphic models");
       }
       return this.processBaseModelDelete(kysely, modelDef.baseModel, where, limit, filterModel);
     }
@@ -2938,7 +2984,7 @@ var BaseOperationHandler = class {
         const oppositeRelation = this.requireField(fieldDef.type, fieldDef.relation.opposite);
         if (oppositeModelDef.baseModel && oppositeRelation.relation?.onDelete === "Cascade") {
           if (limit !== void 0) {
-            throw new QueryError("Deleting with a limit is not supported for polymorphic models");
+            throw createNotSupportedError("Deleting with a limit is not supported for polymorphic models");
           }
           await this.delete(kysely, fieldDef.type, {
             [fieldDef.relation.opposite]: where
@@ -3016,22 +3062,17 @@ var BaseOperationHandler = class {
       }
     }
   }
-  makeQueryId(operation) {
-    return {
-      queryId: `${operation}-${(0, import_cuid2.createId)()}`
-    };
-  }
-  executeQuery(kysely, query, operation) {
-    return kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+  executeQuery(kysely, query, _operation) {
+    return kysely.executeQuery(query.compile());
   }
-  async executeQueryTakeFirst(kysely, query, operation) {
-    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+  async executeQueryTakeFirst(kysely, query, _operation) {
+    const result = await kysely.executeQuery(query.compile());
     return result.rows[0];
   }
-  async executeQueryTakeFirstOrThrow(kysely, query, operation) {
-    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+  async executeQueryTakeFirstOrThrow(kysely, query, _operation) {
+    const result = await kysely.executeQuery(query.compile());
     if (result.rows.length === 0) {
-      throw new QueryError("No rows found");
+      throw new ORMError(ORMErrorReason.NOT_FOUND, "No rows found");
     }
     return result.rows[0];
   }
@@ -3252,7 +3293,7 @@ var CreateOperationHandler = class extends BaseOperationHandler {
       }
     });
     if (!result && this.hasPolicyEnabled) {
-      throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, `result is not allowed to be read back`);
+      throw createRejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, `result is not allowed to be read back`);
     }
     return result;
   }
@@ -3310,12 +3351,12 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
       }
       const deleteResult = await this.delete(tx, this.model, args.where, void 0, void 0, selectedFields);
       if (deleteResult.rows.length === 0) {
-        throw new NotFoundError(this.model);
+        throw createNotFoundError(this.model);
       }
       return needReadBack ? preDeleteRead : deleteResult.rows[0];
     });
     if (!result && this.hasPolicyEnabled) {
-      throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
+      throw createRejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
     }
     return result;
   }
@@ -3484,7 +3525,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     });
     if (!result) {
       if (this.hasPolicyEnabled) {
-        throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
+        throw createRejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
       } else {
         return null;
       }
@@ -3524,7 +3565,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
       }
     });
     if (readBackResult.length < updateResult.length && this.hasPolicyEnabled) {
-      throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
+      throw createRejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
     }
     return readBackResult;
   }
@@ -3547,7 +3588,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
       }
     });
     if (!result && this.hasPolicyEnabled) {
-      throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
+      throw createRejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
     }
     return result;
   }
@@ -3944,7 +3985,7 @@ function evalCall(data, expr) {
     (0, import_common_helpers6.invariant)(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
     return fieldArg.length === 0;
   }).otherwise(() => {
-    throw new QueryError(`Unknown function "${expr.function}"`);
+    throw createNotSupportedError(`Unsupported function "${expr.function}"`);
   });
 }
 __name(evalCall, "evalCall");
@@ -4035,7 +4076,9 @@ var InputValidator = class {
     }
     const { error, data } = schema.safeParse(args);
     if (error) {
-      throw new InputValidationError(model, `Invalid ${operation} args for model "${model}": ${formatError(error)}`, error);
+      throw createInvalidInputError(`Invalid ${operation} args for model "${model}": ${formatError(error)}`, model, {
+        cause: error
+      });
     }
     return data;
   }
@@ -4073,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(),
@@ -4089,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",
@@ -4099,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();
@@ -4113,7 +4173,7 @@ var InputValidator = class {
         field,
         fieldSchema
       ];
-    }))).passthrough();
+    })));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4150,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) {
@@ -4172,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();
@@ -4197,7 +4257,7 @@ var InputValidator = class {
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
       if (uniqueFields.length === 0) {
-        throw new InternalError(`Model "${model}" has no unique fields`);
+        throw createInternalError(`Model "${model}" has no unique fields`);
       }
       if (uniqueFields.length === 1) {
         result = baseWhere.required({
@@ -4212,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",
@@ -5260,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 {
@@ -5289,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;
     }
@@ -5310,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)
       };
@@ -5350,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;
   }
@@ -5436,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");
@@ -5476,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,
@@ -5495,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) => {
@@ -5502,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)
+        };
       }
     });
   }
@@ -5528,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
@@ -5563,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);
     }
   }
@@ -5582,7 +5845,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   get options() {
     return this.client.$options;
   }
-  executeQuery(compiledQuery, queryId) {
+  executeQuery(compiledQuery) {
     const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
     return this.provideConnection(async (connection) => {
       let startedTx = false;
@@ -5593,7 +5856,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
           });
           startedTx = true;
         }
-        const result = await this.proceedQueryWithKyselyInterceptors(connection, compiledQuery.query, queryParams, queryId.queryId);
+        const result = await this.proceedQueryWithKyselyInterceptors(connection, compiledQuery.query, queryParams, compiledQuery.queryId);
         if (startedTx) {
           await this.driver.commitTransaction(connection);
         }
@@ -5602,11 +5865,10 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
         if (startedTx) {
           await this.driver.rollbackTransaction(connection);
         }
-        if (err instanceof ZenStackError) {
+        if (err instanceof ORMError) {
           throw err;
         } else {
-          const message = `Failed to execute query: ${err}, sql: ${compiledQuery?.sql}`;
-          throw new QueryError(message, err);
+          throw createDBQueryError("Failed to execute query", err, compiledQuery.sql, compiledQuery.parameters);
         }
       }
     });
@@ -5657,7 +5919,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
     let compiled;
     if (this.suppressMutationHooks || !this.isMutationNode(query) || !this.hasEntityMutationPlugins) {
       const finalQuery2 = this.processNameMapping(query);
-      compiled = this.compileQuery(finalQuery2);
+      compiled = this.compileQuery(finalQuery2, queryId);
       if (parameters) {
         compiled = {
           ...compiled,
@@ -5675,7 +5937,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
       };
     }
     const finalQuery = this.processNameMapping(query);
-    compiled = this.compileQuery(finalQuery);
+    compiled = this.compileQuery(finalQuery, queryId);
     if (parameters) {
       compiled = {
         ...compiled,
@@ -5764,7 +6026,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
       (0, import_common_helpers9.invariant)(import_kysely7.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
-      throw new InternalError(`Invalid query node: ${node}`);
+      throw createInternalError(`Invalid query node: ${node}`);
     });
   }
   async callBeforeMutationHooks(queryNode, mutationInfo, loadBeforeMutationEntities, client, queryId) {
@@ -5829,7 +6091,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
       ...selectQueryNode,
       where: this.andNodes(selectQueryNode.where, where)
     };
-    const compiled = this.compileQuery(selectQueryNode);
+    const compiled = this.compileQuery(selectQueryNode, (0, import_kysely7.createQueryId)());
     const result = await connection.executeQuery(compiled);
     return result.rows;
   }
@@ -6005,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();
         }
       }
@@ -6484,7 +6761,7 @@ var ClientImpl = class _ClientImpl {
   }
   async handleProc(name, args) {
     if (!("procedures" in this.$options) || !this.$options || typeof this.$options.procedures !== "object") {
-      throw new QueryError("Procedures are not configured for the client.");
+      throw createConfigError("Procedures are not configured for the client.");
     }
     const procOptions = this.$options.procedures;
     if (!procOptions[name] || typeof procOptions[name] !== "function") {
@@ -6615,7 +6892,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
         const _handler = txClient ? handler.withClient(txClient) : handler;
         const r = await _handler.handle(operation, _args);
         if (!r && throwIfNoResult) {
-          throw new NotFoundError(model);
+          throw createNotFoundError(model);
         }
         let result;
         if (r && postProcess) {
@@ -7010,6 +7287,18 @@ var DefaultOperationNodeVisitor = class extends import_kysely11.OperationNodeVis
   visitOutput(node) {
     this.defaultVisit(node);
   }
+  visitRenameConstraint(node) {
+    this.defaultVisit(node);
+  }
+  visitRefreshMaterializedView(node) {
+    this.defaultVisit(node);
+  }
+  visitOrAction(node) {
+    this.defaultVisit(node);
+  }
+  visitCollate(node) {
+    this.defaultVisit(node);
+  }
 };
 
 // src/utils/schema-utils.ts
@@ -7073,18 +7362,14 @@ var ExpressionVisitor = class {
   BaseCrudDialect,
   CRUD,
   CRUD_EXT,
-  InputValidationError,
-  InternalError,
   KyselyUtils,
-  NotFoundError,
-  QueryError,
+  ORMError,
+  ORMErrorReason,
   QueryUtils,
-  RejectedByPolicyError,
   RejectedByPolicyReason,
   SchemaUtils,
   TransactionIsolationLevel,
   ZenStackClient,
-  ZenStackError,
   definePlugin,
   getCrudDialect
 });