@danielhritcu/zenstack-orm 3.5.20 → 3.5.22

package/dist/index.cjs

@@ -69,7 +69,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
 var import_common_helpers15 = require("@zenstackhq/common-helpers");
-var import_kysely12 = require("kysely");
+var import_kysely13 = require("kysely");
 var import_zod3 = __toESM(require("zod"), 1);
 
 // src/utils/zod-utils.ts
@@ -7986,7 +7986,7 @@ __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
 var import_common_helpers12 = require("@zenstackhq/common-helpers");
-var import_kysely9 = require("kysely");
+var import_kysely10 = require("kysely");
 var import_ts_pattern12 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
@@ -8569,9 +8569,35 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   }
 };
 
-// src/client/executor/temp-alias-transformer.ts
+// src/client/executor/rls.ts
 var import_kysely8 = require("kysely");
-var TempAliasTransformer = class extends import_kysely8.OperationNodeTransformer {
+function buildRlsSetConfigSql(rlsDef, rlsValues) {
+  const parts = [];
+  for (const [name, keyDef] of Object.entries(rlsDef.keys)) {
+    const rawValue = rlsValues[name];
+    const resolved = keyDef.resolve(rawValue);
+    const escaped = String(resolved).replace(/'/g, "''");
+    parts.push(`set_config('${keyDef.set}', '${escaped}', true)`);
+  }
+  return `SELECT ${parts.join(", ")}`;
+}
+__name(buildRlsSetConfigSql, "buildRlsSetConfigSql");
+async function applyRlsContext(connection, rlsDef, rlsValues) {
+  const sql9 = buildRlsSetConfigSql(rlsDef, rlsValues);
+  await connection.executeQuery({
+    sql: sql9,
+    parameters: [],
+    query: {
+      kind: "RawNode"
+    },
+    queryId: (0, import_kysely8.createQueryId)()
+  });
+}
+__name(applyRlsContext, "applyRlsContext");
+
+// src/client/executor/temp-alias-transformer.ts
+var import_kysely9 = require("kysely");
+var TempAliasTransformer = class extends import_kysely9.OperationNodeTransformer {
   static {
     __name(this, "TempAliasTransformer");
   }
@@ -8611,7 +8637,7 @@ var TempAliasTransformer = class extends import_kysely8.OperationNodeTransformer
         mapped = `$$t${this.aliasMap.size + 1}`;
         this.aliasMap.set(node.name, mapped);
       }
-      return import_kysely8.IdentifierNode.create(mapped);
+      return import_kysely9.IdentifierNode.create(mapped);
     } else {
       return super.transformIdentifier(node, queryId);
     }
@@ -8620,7 +8646,7 @@ var TempAliasTransformer = class extends import_kysely8.OperationNodeTransformer
 
 // src/client/executor/zenstack-query-executor.ts
 var DEFAULT_MAX_SLOW_RECORDS = 100;
-var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.DefaultQueryExecutor {
+var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely10.DefaultQueryExecutor {
   static {
     __name(this, "ZenStackQueryExecutor");
   }
@@ -8632,6 +8658,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.
   // #region constructor, fields and props
   nameMapper;
   dialect;
+  rlsInitializedConnections = /* @__PURE__ */ new WeakSet();
   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 (client.$schema.provider.type === "postgresql" || // postgres queries need to be schema-qualified
@@ -8726,17 +8753,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.
     }
     let preUpdateIds;
     const mutationModel = this.getMutationModel(query);
-    const needLoadAfterMutationEntities = (import_kysely9.InsertQueryNode.is(query) || import_kysely9.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks;
+    const needLoadAfterMutationEntities = (import_kysely10.InsertQueryNode.is(query) || import_kysely10.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks;
     if (needLoadAfterMutationEntities) {
       if (this.dialect.supportsReturning) {
         query = {
           ...query,
-          returning: import_kysely9.ReturningNode.create([
-            import_kysely9.SelectionNode.createSelectAll()
+          returning: import_kysely10.ReturningNode.create([
+            import_kysely10.SelectionNode.createSelectAll()
           ])
         };
       } else {
-        if (import_kysely9.UpdateQueryNode.is(query)) {
+        if (import_kysely10.UpdateQueryNode.is(query)) {
           preUpdateIds = await this.getPreUpdateIds(mutationModel, query, connection);
         }
       }
@@ -8746,7 +8773,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.
     const mutationInfo = this.getMutationInfo(query);
     let beforeMutationEntities;
     const loadBeforeMutationEntities = /* @__PURE__ */ __name(async () => {
-      if (beforeMutationEntities === void 0 && (import_kysely9.UpdateQueryNode.is(query) || import_kysely9.DeleteQueryNode.is(query))) {
+      if (beforeMutationEntities === void 0 && (import_kysely10.UpdateQueryNode.is(query) || import_kysely10.DeleteQueryNode.is(query))) {
         beforeMutationEntities = await this.loadEntities(mutationInfo.model, mutationInfo.where, connection, void 0);
       }
       return beforeMutationEntities;
@@ -8850,10 +8877,10 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.
     if (this.dialect.supportsReturning) {
       return queryResult.rows;
     } else {
-      const mutatedIds = import_kysely9.InsertQueryNode.is(queryNode) ? this.getInsertIds(mutationInfo.model, queryNode, queryResult) : preUpdateIds;
+      const mutatedIds = import_kysely10.InsertQueryNode.is(queryNode) ? this.getInsertIds(mutationInfo.model, queryNode, queryResult) : preUpdateIds;
       if (mutatedIds) {
         const idFields = requireIdFields(this.client.$schema, mutationInfo.model);
-        const eb = (0, import_kysely9.expressionBuilder)();
+        const eb = (0, import_kysely10.expressionBuilder)();
         const filter = eb(
           // @ts-ignore
           eb.refTuple(...idFields),
@@ -8862,7 +8889,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.
             ...idFields.map((idField) => eb.val(idObj[idField]))
           ))
         );
-        const entities = await this.loadEntities(mutationInfo.model, import_kysely9.WhereNode.create(filter.toOperationNode()), connection, void 0);
+        const entities = await this.loadEntities(mutationInfo.model, import_kysely10.WhereNode.create(filter.toOperationNode()), connection, void 0);
         return entities;
       } else {
         console.warn(`Unable to load after-mutation entities for hooks: model "${mutationInfo.model}", operation "${mutationInfo.action}".
@@ -8883,9 +8910,9 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     const idFields = requireIdFields(this.client.$schema, mutationModel);
     if (query.updates) {
       for (const update of query.updates) {
-        if (import_kysely9.ColumnUpdateNode.is(update)) {
+        if (import_kysely10.ColumnUpdateNode.is(update)) {
           const columnNode = update.column;
-          if (import_kysely9.ColumnNode.is(columnNode)) {
+          if (import_kysely10.ColumnNode.is(columnNode)) {
             const columnName = columnNode.column.name;
             if (idFields.includes(columnName)) {
               return void 0;
@@ -8898,7 +8925,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   }
   getInsertIds(mutationModel, query, queryResult) {
     const idFields = requireIdFields(this.client.$schema, mutationModel);
-    if (import_kysely9.InsertQueryNode.is(query) && queryResult.numAffectedRows === 1n && queryResult.insertId && idFields.length === 1) {
+    if (import_kysely10.InsertQueryNode.is(query) && queryResult.numAffectedRows === 1n && queryResult.insertId && idFields.length === 1) {
       return [
         {
           [idFields[0]]: queryResult.insertId
@@ -8910,13 +8937,13 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
       return void 0;
     }
     const values = query.values;
-    if (!values || !import_kysely9.ValuesNode.is(values)) {
+    if (!values || !import_kysely10.ValuesNode.is(values)) {
       return void 0;
     }
     const allIds = [];
     for (const valuesItem of values.values) {
       const rowIds = {};
-      if (import_kysely9.PrimitiveValueListNode.is(valuesItem)) {
+      if (import_kysely10.PrimitiveValueListNode.is(valuesItem)) {
         (0, import_common_helpers12.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
         for (const idField of idFields) {
           const colIndex = columns.findIndex((col) => col.column.name === idField);
@@ -8933,7 +8960,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
             return void 0;
           }
           const valueNode = valuesItem.values[colIndex];
-          if (!valueNode || !import_kysely9.ValueNode.is(valueNode)) {
+          if (!valueNode || !import_kysely10.ValueNode.is(valueNode)) {
             return void 0;
           }
           rowIds[idField] = valueNode.value;
@@ -8962,13 +8989,13 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   // #region utilities
   getMutationInfo(queryNode) {
     const model = this.getMutationModel(queryNode);
-    const { action, where } = (0, import_ts_pattern12.match)(queryNode).when(import_kysely9.InsertQueryNode.is, () => ({
+    const { action, where } = (0, import_ts_pattern12.match)(queryNode).when(import_kysely10.InsertQueryNode.is, () => ({
       action: "create",
       where: void 0
-    })).when(import_kysely9.UpdateQueryNode.is, (node) => ({
+    })).when(import_kysely10.UpdateQueryNode.is, (node) => ({
       action: "update",
       where: node.where
-    })).when(import_kysely9.DeleteQueryNode.is, (node) => ({
+    })).when(import_kysely10.DeleteQueryNode.is, (node) => ({
       action: "delete",
       where: node.where
     })).exhaustive();
@@ -8979,21 +9006,21 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     };
   }
   isMutationNode(queryNode) {
-    return import_kysely9.InsertQueryNode.is(queryNode) || import_kysely9.UpdateQueryNode.is(queryNode) || import_kysely9.DeleteQueryNode.is(queryNode);
+    return import_kysely10.InsertQueryNode.is(queryNode) || import_kysely10.UpdateQueryNode.is(queryNode) || import_kysely10.DeleteQueryNode.is(queryNode);
   }
   getMutationModel(queryNode) {
-    return (0, import_ts_pattern12.match)(queryNode).when(import_kysely9.InsertQueryNode.is, (node) => {
+    return (0, import_ts_pattern12.match)(queryNode).when(import_kysely10.InsertQueryNode.is, (node) => {
       (0, import_common_helpers12.invariant)(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
-    }).when(import_kysely9.UpdateQueryNode.is, (node) => {
+    }).when(import_kysely10.UpdateQueryNode.is, (node) => {
       (0, import_common_helpers12.invariant)(node.table, "UpdateQueryNode must have a table");
       const { node: tableNode } = stripAlias(node.table);
-      (0, import_common_helpers12.invariant)(import_kysely9.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
+      (0, import_common_helpers12.invariant)(import_kysely10.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
-    }).when(import_kysely9.DeleteQueryNode.is, (node) => {
+    }).when(import_kysely10.DeleteQueryNode.is, (node) => {
       (0, import_common_helpers12.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
       const { node: tableNode } = stripAlias(node.from.froms[0]);
-      (0, import_common_helpers12.invariant)(import_kysely9.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
+      (0, import_common_helpers12.invariant)(import_kysely10.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw createInternalError(`Invalid query node: ${node}`);
@@ -9014,7 +9041,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     }).run(query);
   }
   createClientForConnection(connection, inTx) {
-    const innerExecutor = this.withConnectionProvider(new import_kysely9.SingleConnectionProvider(connection));
+    const innerExecutor = this.withConnectionProvider(new import_kysely10.SingleConnectionProvider(connection));
     innerExecutor.suppressMutationHooks = true;
     const innerClient = this.client.withExecutor(innerExecutor);
     if (inTx) {
@@ -9024,32 +9051,76 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   }
   andNodes(condition1, condition2) {
     if (condition1 && condition2) {
-      return import_kysely9.WhereNode.create(import_kysely9.AndNode.create(condition1, condition2));
+      return import_kysely10.WhereNode.create(import_kysely10.AndNode.create(condition1, condition2));
     } else if (condition1) {
-      return import_kysely9.WhereNode.create(condition1);
+      return import_kysely10.WhereNode.create(condition1);
     } else {
       return condition2;
     }
   }
   async internalExecuteQuery(query, connection, queryId, parameters) {
     const finalQuery = this.processQueryNode(query);
-    let compiledQuery = this.compileQuery(finalQuery, queryId ?? (0, import_kysely9.createQueryId)());
+    let compiledQuery = this.compileQuery(finalQuery, queryId ?? (0, import_kysely10.createQueryId)());
     if (parameters) {
       compiledQuery = {
         ...compiledQuery,
         parameters
       };
     }
+    const rlsDef = this.client.$schema.rls;
+    const rlsValues = this.client.$options.rls;
+    const isTransaction = this.driver.isTransactionConnection(connection);
+    const needsRls = rlsDef && rlsValues;
+    const needsRlsInit = needsRls && (!isTransaction || !this.rlsInitializedConnections.has(connection));
     const trackSlowQuery = this.options.diagnostics !== void 0;
     const startTimestamp = trackSlowQuery ? performance.now() : void 0;
     const startedAt = trackSlowQuery ? /* @__PURE__ */ new Date() : void 0;
     try {
+      if (needsRlsInit) {
+        if (!isTransaction) {
+          await connection.executeQuery({
+            sql: "BEGIN",
+            parameters: [],
+            query: {
+              kind: "RawNode"
+            },
+            queryId: (0, import_kysely10.createQueryId)()
+          });
+        }
+        await applyRlsContext(connection, rlsDef, rlsValues);
+        if (isTransaction) {
+          this.rlsInitializedConnections.add(connection);
+        }
+      }
       const result = await connection.executeQuery(compiledQuery);
+      if (needsRlsInit && !isTransaction) {
+        await connection.executeQuery({
+          sql: "COMMIT",
+          parameters: [],
+          query: {
+            kind: "RawNode"
+          },
+          queryId: (0, import_kysely10.createQueryId)()
+        });
+      }
       if (startTimestamp !== void 0) {
         this.trackSlowQuery(compiledQuery, startTimestamp, startedAt);
       }
       return this.ensureProperQueryResult(compiledQuery.query, result);
     } catch (err) {
+      if (needsRlsInit && !isTransaction) {
+        try {
+          await connection.executeQuery({
+            sql: "ROLLBACK",
+            parameters: [],
+            query: {
+              kind: "RawNode"
+            },
+            queryId: (0, import_kysely10.createQueryId)()
+          });
+        } catch {
+        }
+      }
       throw createDBQueryError(`Failed to execute query: ${err}`, err, compiledQuery.sql, compiledQuery.parameters);
     }
   }
@@ -9139,7 +9210,7 @@ __export(functions_exports, {
   startsWith: () => startsWith
 });
 var import_common_helpers13 = require("@zenstackhq/common-helpers");
-var import_kysely10 = require("kysely");
+var import_kysely11 = require("kysely");
 var import_ts_pattern13 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
 var search = /* @__PURE__ */ __name((_eb, _args) => {
@@ -9177,20 +9248,20 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   } else {
     op = "like";
   }
-  searchExpr = eb.fn.coalesce(searchExpr, import_kysely10.sql.lit(""));
-  const escapedSearch = import_kysely10.sql`REPLACE(REPLACE(REPLACE(${dialect.castText(searchExpr)}, ${import_kysely10.sql.val("\\")}, ${import_kysely10.sql.val("\\\\")}), ${import_kysely10.sql.val("%")}, ${import_kysely10.sql.val("\\%")}), ${import_kysely10.sql.val("_")}, ${import_kysely10.sql.val("\\_")})`;
+  searchExpr = eb.fn.coalesce(searchExpr, import_kysely11.sql.lit(""));
+  const escapedSearch = import_kysely11.sql`REPLACE(REPLACE(REPLACE(${dialect.castText(searchExpr)}, ${import_kysely11.sql.val("\\")}, ${import_kysely11.sql.val("\\\\")}), ${import_kysely11.sql.val("%")}, ${import_kysely11.sql.val("\\%")}), ${import_kysely11.sql.val("_")}, ${import_kysely11.sql.val("\\_")})`;
   searchExpr = (0, import_ts_pattern13.match)(method).with("contains", () => eb.fn("CONCAT", [
-    import_kysely10.sql.lit("%"),
+    import_kysely11.sql.lit("%"),
     escapedSearch,
-    import_kysely10.sql.lit("%")
+    import_kysely11.sql.lit("%")
   ])).with("startsWith", () => eb.fn("CONCAT", [
     escapedSearch,
-    import_kysely10.sql.lit("%")
+    import_kysely11.sql.lit("%")
   ])).with("endsWith", () => eb.fn("CONCAT", [
-    import_kysely10.sql.lit("%"),
+    import_kysely11.sql.lit("%"),
     escapedSearch
   ])).exhaustive();
-  return import_kysely10.sql`${fieldExpr} ${import_kysely10.sql.raw(op)} ${searchExpr} escape ${import_kysely10.sql.val("\\")}`;
+  return import_kysely11.sql`${fieldExpr} ${import_kysely11.sql.raw(op)} ${searchExpr} escape ${import_kysely11.sql.val("\\")}`;
 }, "textMatch");
 var has = /* @__PURE__ */ __name((_eb, args, context) => {
   const [field, search2] = args;
@@ -9227,16 +9298,16 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   if (!field) {
     throw new Error('"field" parameter is required');
   }
-  return eb(dialect.buildArrayLength(field), "=", import_kysely10.sql.lit(0));
+  return eb(dialect.buildArrayLength(field), "=", import_kysely11.sql.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name((_eb, _args, context) => (0, import_ts_pattern13.match)(context.dialect.provider).with("sqlite", () => import_kysely10.sql.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => import_kysely10.sql.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => import_kysely10.sql.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
+var now = /* @__PURE__ */ __name((_eb, _args, context) => (0, import_ts_pattern13.match)(context.dialect.provider).with("sqlite", () => import_kysely11.sql.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => import_kysely11.sql.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => import_kysely11.sql.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
   const [casing] = args;
   if (casing) {
     result = processCasing(casing, result, model);
   }
-  return import_kysely10.sql.lit(result);
+  return import_kysely11.sql.lit(result);
 }, "currentModel");
 var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   let result = operation;
@@ -9244,11 +9315,11 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   if (casing) {
     result = processCasing(casing, result, operation);
   }
-  return import_kysely10.sql.lit(result);
+  return import_kysely11.sql.lit(result);
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers13.invariant)(import_kysely10.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  (0, import_common_helpers13.invariant)(import_kysely11.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
   result = (0, import_ts_pattern13.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers13.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers13.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
@@ -9260,14 +9331,14 @@ function readBoolean(expr, defaultValue) {
     return defaultValue;
   }
   const opNode = expr.toOperationNode();
-  (0, import_common_helpers13.invariant)(import_kysely10.ValueNode.is(opNode), "expression must be a literal value");
+  (0, import_common_helpers13.invariant)(import_kysely11.ValueNode.is(opNode), "expression must be a literal value");
   return !!opNode.value;
 }
 __name(readBoolean, "readBoolean");
 
 // src/client/helpers/schema-db-pusher.ts
 var import_common_helpers14 = require("@zenstackhq/common-helpers");
-var import_kysely11 = require("kysely");
+var import_kysely12 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern14 = require("ts-pattern");
 var SchemaDbPusher = class {
@@ -9451,7 +9522,7 @@ var SchemaDbPusher = class {
       if (fieldDef.default !== void 0 && this.isDefaultValueSupportedForType(fieldDef.type)) {
         if (typeof fieldDef.default === "object" && "kind" in fieldDef.default) {
           if (schema_exports.ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "now") {
-            col = this.schema.provider.type === "mysql" ? col.defaultTo(import_kysely11.sql`CURRENT_TIMESTAMP(3)`) : col.defaultTo(import_kysely11.sql`CURRENT_TIMESTAMP`);
+            col = this.schema.provider.type === "mysql" ? col.defaultTo(import_kysely12.sql`CURRENT_TIMESTAMP(3)`) : col.defaultTo(import_kysely12.sql`CURRENT_TIMESTAMP`);
           }
         } else {
           if (this.schema.provider.type === "mysql" && fieldDef.type === "DateTime" && typeof fieldDef.default === "string") {
@@ -9483,7 +9554,7 @@ var SchemaDbPusher = class {
   mapFieldType(fieldDef) {
     if (this.schema.enums?.[fieldDef.type]) {
       if (this.schema.provider.type === "postgresql") {
-        return import_kysely11.sql.ref(fieldDef.type);
+        return import_kysely12.sql.ref(fieldDef.type);
       } else if (this.schema.provider.type === "mysql") {
         const enumDef = this.schema.enums[fieldDef.type];
         let enumValues;
@@ -9501,7 +9572,7 @@ var SchemaDbPusher = class {
         } else {
           enumValues = Object.values(enumDef.values);
         }
-        return import_kysely11.sql.raw(`enum(${enumValues.map((v) => `'${v}'`).join(", ")})`);
+        return import_kysely12.sql.raw(`enum(${enumValues.map((v) => `'${v}'`).join(", ")})`);
       } else {
         return "text";
       }
@@ -9517,7 +9588,7 @@ var SchemaDbPusher = class {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
-      return import_kysely11.sql.raw(`${result}[]`);
+      return import_kysely12.sql.raw(`${result}[]`);
     } else {
       return result;
     }
@@ -9563,25 +9634,25 @@ var SchemaDbPusher = class {
     return (0, import_ts_pattern14.match)(this.schema.provider.type).with("postgresql", () => "bytea").with("mysql", () => "blob").otherwise(() => "blob");
   }
   get stringType() {
-    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("varchar(255)")).otherwise(() => "text");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely12.sql.raw("varchar(255)")).otherwise(() => "text");
   }
   get booleanType() {
-    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("tinyint(1)")).otherwise(() => "boolean");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely12.sql.raw("tinyint(1)")).otherwise(() => "boolean");
   }
   get intType() {
     return "integer";
   }
   get floatType() {
-    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => import_kysely11.sql.raw("double")).otherwise(() => "real");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => import_kysely12.sql.raw("double")).otherwise(() => "real");
   }
   get bigIntType() {
     return "bigint";
   }
   get decimalType() {
-    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("decimal(65, 30)")).otherwise(() => "decimal");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely12.sql.raw("decimal(65, 30)")).otherwise(() => "decimal");
   }
   get dateTimeType() {
-    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("datetime(3)")).otherwise(() => "timestamp");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely12.sql.raw("datetime(3)")).otherwise(() => "timestamp");
   }
   columnSupportsAutoIncrement() {
     return [
@@ -9799,16 +9870,16 @@ var ClientImpl = class _ClientImpl {
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
-        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely12.DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely13.DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
       this.auth = baseClient.auth;
       this.slowQueries = baseClient.slowQueries;
     } else {
-      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely12.Log(this.$options.log ?? []));
+      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely13.Log(this.$options.log ?? []));
       const compiler = options.dialect.createQueryCompiler();
       const adapter = options.dialect.createAdapter();
-      const connectionProvider = new import_kysely12.DefaultConnectionProvider(driver);
+      const connectionProvider = new import_kysely13.DefaultConnectionProvider(driver);
       this.kyselyProps = {
         config: {
           dialect: options.dialect,
@@ -9819,15 +9890,15 @@ var ClientImpl = class _ClientImpl {
         driver,
         executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
-      this.kyselyRaw = new import_kysely12.Kysely({
+      this.kyselyRaw = new import_kysely13.Kysely({
         ...this.kyselyProps,
-        executor: new import_kysely12.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
+        executor: new import_kysely13.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
       });
     }
     if (baseClient?.isTransaction && !executor) {
       this.kysely = baseClient.$qb;
     } else {
-      this.kysely = new import_kysely12.Kysely(this.kyselyProps);
+      this.kysely = new import_kysely13.Kysely(this.kyselyProps);
     }
     this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this, {
       enabled: this.$options.validateInput !== false
@@ -9898,7 +9969,7 @@ var ClientImpl = class _ClientImpl {
   }
   forceTransaction() {
     if (!this.kysely.isTransaction) {
-      this.kysely = new import_kysely12.Transaction(this.kyselyProps);
+      this.kysely = new import_kysely13.Transaction(this.kyselyProps);
     }
   }
   async interactiveTransaction(callback, options) {
@@ -9989,7 +10060,7 @@ var ClientImpl = class _ClientImpl {
   }
   async $connect() {
     await this.kysely.connection().execute(async (conn) => {
-      await conn.executeQuery(import_kysely12.sql`select 1`.compile(this.kysely));
+      await conn.executeQuery(import_kysely13.sql`select 1`.compile(this.kysely));
     });
   }
   async $disconnect() {
@@ -10076,7 +10147,7 @@ var ClientImpl = class _ClientImpl {
   }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely12.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely13.sql)(query, ...values).execute(this.kysely);
       return Number(result.numAffectedRows ?? 0);
     });
   }
@@ -10089,7 +10160,7 @@ var ClientImpl = class _ClientImpl {
   }
   $queryRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely12.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely13.sql)(query, ...values).execute(this.kysely);
       return result.rows;
     });
   }
@@ -10101,7 +10172,7 @@ var ClientImpl = class _ClientImpl {
     });
   }
   createRawCompiledQuery(query, values) {
-    const q = import_kysely12.CompiledQuery.raw(query, values);
+    const q = import_kysely13.CompiledQuery.raw(query, values);
     return {
       ...q,
       $raw: true
@@ -10837,8 +10908,8 @@ var kysely_utils_exports = {};
 __export(kysely_utils_exports, {
   DefaultOperationNodeVisitor: () => DefaultOperationNodeVisitor
 });
-var import_kysely13 = require("kysely");
-var DefaultOperationNodeVisitor = class extends import_kysely13.OperationNodeVisitor {
+var import_kysely14 = require("kysely");
+var DefaultOperationNodeVisitor = class extends import_kysely14.OperationNodeVisitor {
   static {
     __name(this, "DefaultOperationNodeVisitor");
   }