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

package/dist/index.js

@@ -80,63 +80,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) {
@@ -154,7 +201,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;
 }
@@ -168,7 +215,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];
     }
@@ -176,12 +223,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) {
@@ -193,7 +240,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;
 }
@@ -201,11 +248,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) => ({
@@ -216,17 +263,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) => ({
@@ -263,7 +310,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({
@@ -286,7 +333,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,
@@ -445,7 +492,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;
 }
@@ -500,7 +547,7 @@ __name(extractFieldName, "extractFieldName");
 // src/client/crud/operations/base.ts
 import { createId } from "@paralleldrive/cuid2";
 import { clone, enumerate as enumerate2, invariant as invariant5, isPlainObject as isPlainObject2 } from "@zenstackhq/common-helpers";
-import { expressionBuilder as expressionBuilder2, sql as sql4 } from "kysely";
+import { createQueryId, expressionBuilder as expressionBuilder2, sql as sql4 } from "kysely";
 import { nanoid } from "nanoid";
 import { match as match6 } from "ts-pattern";
 import { ulid } from "ulid";
@@ -607,7 +654,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) {
@@ -814,7 +861,7 @@ var BaseCrudDialect = class {
           break;
         }
         default: {
-          throw new InternalError(`Invalid array filter key: ${key}`);
+          throw createInvalidInputError(`Invalid array filter key: ${key}`);
         }
       }
     }
@@ -828,9 +875,9 @@ var BaseCrudDialect = class {
       return this.buildEnumFilter(fieldRef, fieldDef, payload);
     }
     return match2(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(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) {
@@ -875,7 +922,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;
         }
@@ -904,7 +951,7 @@ var BaseCrudDialect = class {
           continue;
         }
         const condition = match2(key).with("contains", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", sql.val(`%${value}%`)) : this.eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", sql.val(`${value}%`)) : this.eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", sql.val(`%${value}`)) : this.eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
-          throw new QueryError(`Invalid string filter key: ${key}`);
+          throw createInvalidInputError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
           conditions.push(condition);
@@ -984,7 +1031,7 @@ var BaseCrudDialect = class {
           invariant2(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             invariant2(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
           }
           continue;
         }
@@ -993,7 +1040,7 @@ var BaseCrudDialect = class {
             invariant2(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
               invariant2(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), this.negateSort(v, negated));
             }
             continue;
           }
@@ -1006,13 +1053,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, 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) {
               invariant2(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
@@ -1183,7 +1235,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
@@ -1414,7 +1466,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]) {
@@ -1504,7 +1556,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;
@@ -1647,10 +1701,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";
@@ -1738,16 +1792,12 @@ var BaseOperationHandler = class {
       operation: "read"
     }));
     let result = [];
-    const queryId = {
-      queryId: `zenstack-${createId()}`
-    };
-    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), queryId);
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), 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;
   }
@@ -1773,7 +1823,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);
@@ -1790,7 +1840,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;
@@ -1895,7 +1945,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);
         }
@@ -1979,7 +2029,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;
           }
@@ -1996,7 +2046,7 @@ var BaseOperationHandler = class {
           break;
         }
         default:
-          throw new QueryError(`Invalid relation action: ${action}`);
+          throw createInvalidInputError(`Invalid relation action: ${action}`);
       }
     }
     return result;
@@ -2042,7 +2092,7 @@ var BaseOperationHandler = class {
           break;
         }
         default:
-          throw new QueryError(`Invalid relation action: ${action}`);
+          throw createInvalidInputError(`Invalid relation action: ${action}`);
       }
     }
   }
@@ -2057,7 +2107,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;
     }
@@ -2100,7 +2150,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;
@@ -2198,7 +2248,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;
@@ -2260,7 +2310,7 @@ var BaseOperationHandler = class {
         select: this.makeIdSelect(model)
       });
       if (!readResult && throwIfNotFound) {
-        throw new NotFoundError(model);
+        throw createNotFoundError(model);
       }
       combinedWhere = readResult;
     }
@@ -2277,13 +2327,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;
             }
@@ -2310,7 +2360,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;
         }
@@ -2374,7 +2424,7 @@ var BaseOperationHandler = class {
     const eb = expressionBuilder2();
     const fieldRef = this.dialect.fieldRef(model, field);
     return match6(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) {
@@ -2386,7 +2436,7 @@ var BaseOperationHandler = class {
     return match6(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) {
@@ -2397,7 +2447,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 ? [] : {
@@ -2406,7 +2456,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 = {};
@@ -2560,7 +2610,7 @@ var BaseOperationHandler = class {
           break;
         }
         default: {
-          throw new Error("Not implemented yet");
+          throw createInvalidInputError(`Invalid relation update operation: ${key}`);
         }
       }
     }
@@ -2578,13 +2628,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);
@@ -2594,7 +2644,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];
@@ -2620,7 +2670,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);
         }
       }
     }
@@ -2736,17 +2786,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,
@@ -2775,7 +2825,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);
         }
       }
     }
@@ -2826,7 +2876,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);
         invariant5(fieldDef.relation?.opposite);
@@ -2858,7 +2908,7 @@ var BaseOperationHandler = class {
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.rows.length) {
-      throw new NotFoundError(deleteFromModel);
+      throw createNotFoundError(deleteFromModel);
     }
   }
   normalizeRelationManipulationInput(model, data) {
@@ -2870,7 +2920,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);
     }
@@ -2904,7 +2954,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
@@ -2982,22 +3032,17 @@ var BaseOperationHandler = class {
       }
     }
   }
-  makeQueryId(operation) {
-    return {
-      queryId: `${operation}-${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];
   }
@@ -3218,7 +3263,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;
   }
@@ -3276,12 +3321,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;
   }
@@ -3450,7 +3495,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;
       }
@@ -3490,7 +3535,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;
   }
@@ -3513,7 +3558,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;
   }
@@ -3910,7 +3955,7 @@ function evalCall(data, expr) {
     invariant6(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");
@@ -4001,7 +4046,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;
   }
@@ -4039,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(),
@@ -4055,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",
@@ -4065,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();
@@ -4079,7 +4143,7 @@ var InputValidator = class {
         field,
         fieldSchema
       ];
-    }))).passthrough();
+    })));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4116,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) {
@@ -4138,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();
@@ -4163,7 +4227,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({
@@ -4178,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",
@@ -5166,12 +5230,12 @@ __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
 import { invariant as invariant9 } from "@zenstackhq/common-helpers";
-import { AndNode, DefaultQueryExecutor, DeleteQueryNode, InsertQueryNode, ReturningNode, SelectionNode as SelectionNode2, SingleConnectionProvider, TableNode as TableNode3, UpdateQueryNode, WhereNode } from "kysely";
+import { AndNode, createQueryId as createQueryId2, DefaultQueryExecutor, DeleteQueryNode, InsertQueryNode, ReturningNode, SelectionNode as SelectionNode2, SingleConnectionProvider, TableNode as TableNode3, UpdateQueryNode, WhereNode } from "kysely";
 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");
@@ -5226,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 {
@@ -5255,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;
     }
@@ -5276,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)
       };
@@ -5316,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;
   }
@@ -5402,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");
@@ -5442,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,
@@ -5461,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) => {
@@ -5468,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)
+        };
       }
     });
   }
@@ -5494,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
@@ -5529,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);
     }
   }
@@ -5548,7 +5815,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   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;
@@ -5559,7 +5826,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
           });
           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);
         }
@@ -5568,11 +5835,10 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
         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);
         }
       }
     });
@@ -5623,7 +5889,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
     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,
@@ -5641,7 +5907,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       };
     }
     const finalQuery = this.processNameMapping(query);
-    compiled = this.compileQuery(finalQuery);
+    compiled = this.compileQuery(finalQuery, queryId);
     if (parameters) {
       compiled = {
         ...compiled,
@@ -5730,7 +5996,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       invariant9(TableNode3.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) {
@@ -5795,7 +6061,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       ...selectQueryNode,
       where: this.andNodes(selectQueryNode.where, where)
     };
-    const compiled = this.compileQuery(selectQueryNode);
+    const compiled = this.compileQuery(selectQueryNode, createQueryId2());
     const result = await connection.executeQuery(compiled);
     return result.rows;
   }
@@ -5826,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) => {
@@ -5935,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".`);
   });
@@ -5947,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");
@@ -5971,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();
         }
       }
@@ -6450,7 +6731,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") {
@@ -6581,7 +6862,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) {
@@ -6976,6 +7257,18 @@ var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
   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
@@ -7038,18 +7331,14 @@ export {
   BaseCrudDialect,
   CRUD,
   CRUD_EXT,
-  InputValidationError,
-  InternalError,
   kysely_utils_exports as KyselyUtils,
-  NotFoundError,
-  QueryError,
+  ORMError,
+  ORMErrorReason,
   query_utils_exports as QueryUtils,
-  RejectedByPolicyError,
   RejectedByPolicyReason,
   schema_utils_exports as SchemaUtils,
   TransactionIsolationLevel,
   ZenStackClient,
-  ZenStackError,
   definePlugin,
   getCrudDialect
 };