@zenstackhq/runtime 3.0.0-alpha.30 → 3.0.0-alpha.31

package/dist/{contract-DUtKB39c.d.cts → contract-5Wcmlo5v.d.cts}

@@ -96,7 +96,7 @@ type BatchResult = {
     count: number;
 };
 type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ScalarOnly extends boolean = false, WithAggregations extends boolean = false> = {
-    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>> : PrimitiveFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
+    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations> : PrimitiveFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
 } & {
     $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
 } & {
@@ -104,12 +104,16 @@ type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Scala
     OR?: WhereInput<Schema, Model, ScalarOnly>[];
     NOT?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
 };
-type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | {
+type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | ({
     equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
     in?: (keyof GetEnum<Schema, T>)[];
     notIn?: (keyof GetEnum<Schema, T>)[];
-    not?: EnumFilter<Schema, T, Nullable>;
-};
+    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: EnumFilter<Schema, T, false, false>;
+    _max?: EnumFilter<Schema, T, false, false>;
+} : {}));
 type ArrayFilter<Schema extends SchemaDef, T extends string> = {
     equals?: MapScalarType<Schema, T>[] | null;
     has?: MapScalarType<Schema, T> | null;

package/dist/{contract-DUtKB39c.d.ts → contract-5Wcmlo5v.d.ts}

@@ -96,7 +96,7 @@ type BatchResult = {
     count: number;
 };
 type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ScalarOnly extends boolean = false, WithAggregations extends boolean = false> = {
-    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>> : PrimitiveFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
+    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations> : PrimitiveFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
 } & {
     $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
 } & {
@@ -104,12 +104,16 @@ type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Scala
     OR?: WhereInput<Schema, Model, ScalarOnly>[];
     NOT?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
 };
-type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | {
+type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | ({
     equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
     in?: (keyof GetEnum<Schema, T>)[];
     notIn?: (keyof GetEnum<Schema, T>)[];
-    not?: EnumFilter<Schema, T, Nullable>;
-};
+    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: EnumFilter<Schema, T, false, false>;
+    _max?: EnumFilter<Schema, T, false, false>;
+} : {}));
 type ArrayFilter<Schema extends SchemaDef, T extends string> = {
     equals?: MapScalarType<Schema, T>[] | null;
     has?: MapScalarType<Schema, T> | null;

package/dist/index.cjs

@@ -42,7 +42,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_common_helpers14 = require("@zenstackhq/common-helpers");
 var import_kysely16 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
@@ -5386,10 +5386,11 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod.z.enum(nonRelationFields), true) : import_zod.z.never();
     let schema = import_zod.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
-      by: this.orArray(import_zod.z.enum(nonRelationFields), true),
+      by: bySchema,
       having: this.makeHavingSchema(model).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -5666,6 +5667,7 @@ var import_nanoid2 = require("nanoid");
 var import_ts_pattern16 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely12 = require("kysely");
 var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
   static {
@@ -5674,7 +5676,7 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
   schema;
   modelToTableMap = /* @__PURE__ */ new Map();
   fieldToColumnMap = /* @__PURE__ */ new Map();
-  modelStack = [];
+  modelScopes = [];
   constructor(schema) {
     super(), this.schema = schema;
     for (const [modelName, modelDef] of Object.entries(schema.models)) {
@@ -5690,150 +5692,182 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
       }
     }
   }
-  get currentModel() {
-    return this.modelStack[this.modelStack.length - 1];
-  }
-  transformCreateTable(node) {
-    try {
-      this.modelStack.push(node.table.table.identifier.name);
-      return super.transformCreateTable(node);
-    } finally {
-      this.modelStack.pop();
+  // #region overrides
+  transformSelectQuery(node) {
+    if (!node.from?.froms) {
+      return super.transformSelectQuery(node);
     }
+    const scopes = this.createScopesFromFroms(node.from, true);
+    return this.withScopes(scopes, () => {
+      return {
+        ...super.transformSelectQuery(node),
+        // convert "from" to nested query as needed
+        from: this.processFrom(node.from)
+      };
+    });
   }
   transformInsertQuery(node) {
-    try {
-      if (node.into?.table.identifier.name) {
-        this.modelStack.push(node.into.table.identifier.name);
-      }
+    if (!node.into) {
       return super.transformInsertQuery(node);
-    } finally {
-      if (node.into?.table.identifier.name) {
-        this.modelStack.pop();
-      }
     }
+    return this.withScope({
+      model: node.into.table.identifier.name
+    }, () => ({
+      ...super.transformInsertQuery(node),
+      // map table name
+      into: this.processTableRef(node.into)
+    }));
   }
   transformReturning(node) {
-    return import_kysely12.ReturningNode.create(this.transformSelections(node.selections, node));
+    return {
+      kind: node.kind,
+      // map column names in returning selections (include returningAll)
+      selections: this.processSelections(node.selections)
+    };
   }
-  transformUpdateQuery(node) {
-    let pushed = false;
-    if (node.table && import_kysely12.TableNode.is(node.table)) {
-      this.modelStack.push(node.table.table.identifier.name);
-      pushed = true;
-    }
-    try {
-      return super.transformUpdateQuery(node);
-    } finally {
-      if (pushed) {
-        this.modelStack.pop();
+  transformJoin(node) {
+    const { alias, node: innerNode } = this.stripAlias(node.table);
+    if (import_kysely12.TableNode.is(innerNode)) {
+      const modelName = innerNode.table.identifier.name;
+      if (this.hasMappedColumns(modelName)) {
+        const select = this.createSelectAll(modelName);
+        return {
+          ...super.transformJoin(node),
+          table: this.wrapAlias(select, alias ?? modelName)
+        };
       }
     }
+    return super.transformJoin(node);
   }
-  transformDeleteQuery(node) {
-    let pushed = false;
-    if (node.from?.froms && node.from.froms.length === 1 && node.from.froms[0]) {
-      const from = node.from.froms[0];
-      if (import_kysely12.TableNode.is(from)) {
-        this.modelStack.push(from.table.identifier.name);
-        pushed = true;
-      } else if (import_kysely12.AliasNode.is(from) && import_kysely12.TableNode.is(from.node)) {
-        this.modelStack.push(from.node.table.identifier.name);
-        pushed = true;
-      }
+  transformReference(node) {
+    if (!import_kysely12.ColumnNode.is(node.column)) {
+      return super.transformReference(node);
     }
-    try {
-      return super.transformDeleteQuery(node);
-    } finally {
-      if (pushed) {
-        this.modelStack.pop();
+    const { fieldDef, modelDef, scope } = this.resolveFieldFromScopes(node.column.column.name, node.table?.table.identifier.name);
+    if (fieldDef && !scope.namesMapped) {
+      const mappedFieldName = this.mapFieldName(modelDef.name, fieldDef.name);
+      let mappedTableName = node.table?.table.identifier.name;
+      if (mappedTableName) {
+        if (scope.alias === mappedTableName) {
+        } else if (scope.model === mappedTableName) {
+          mappedTableName = this.mapTableName(scope.model);
+        }
       }
+      return import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(mappedFieldName), mappedTableName ? import_kysely12.TableNode.create(mappedTableName) : void 0);
+    } else {
+      return super.transformReference(node);
     }
   }
-  transformSelectQuery(node) {
-    if (!node.from?.froms || node.from.froms.length === 0) {
-      return super.transformSelectQuery(node);
-    }
-    if (node.from.froms.length > 1) {
-      throw new InternalError(`SelectQueryNode must have a single table in from clause`);
+  transformColumn(node) {
+    const { modelDef, fieldDef, scope } = this.resolveFieldFromScopes(node.column.name);
+    if (!fieldDef || scope.namesMapped) {
+      return super.transformColumn(node);
     }
-    let pushed = false;
-    const from = node.from.froms[0];
-    if (import_kysely12.TableNode.is(from)) {
-      this.modelStack.push(from.table.identifier.name);
-      pushed = true;
-    } else if (import_kysely12.AliasNode.is(from) && import_kysely12.TableNode.is(from.node)) {
-      this.modelStack.push(from.node.table.identifier.name);
-      pushed = true;
+    const mappedName = this.mapFieldName(modelDef.name, fieldDef.name);
+    return import_kysely12.ColumnNode.create(mappedName);
+  }
+  transformUpdateQuery(node) {
+    const { alias, node: innerTable } = this.stripAlias(node.table);
+    if (!innerTable || !import_kysely12.TableNode.is(innerTable)) {
+      return super.transformUpdateQuery(node);
     }
-    const selections = node.selections ? this.transformSelections(node.selections, node) : node.selections;
-    try {
+    return this.withScope({
+      model: innerTable.table.identifier.name,
+      alias
+    }, () => {
       return {
-        ...super.transformSelectQuery(node),
-        selections
+        ...super.transformUpdateQuery(node),
+        // map table name
+        table: this.wrapAlias(this.processTableRef(innerTable), alias)
       };
-    } finally {
-      if (pushed) {
-        this.modelStack.pop();
+    });
+  }
+  transformDeleteQuery(node) {
+    const scopes = this.createScopesFromFroms(node.from, false);
+    const froms = node.from.froms.map((from) => {
+      const { alias, node: innerNode } = this.stripAlias(from);
+      if (import_kysely12.TableNode.is(innerNode)) {
+        return this.wrapAlias(this.processTableRef(innerNode), alias);
+      } else {
+        return super.transformNode(from);
       }
-    }
+    });
+    return this.withScopes(scopes, () => {
+      return {
+        ...super.transformDeleteQuery(node),
+        from: import_kysely12.FromNode.create(froms)
+      };
+    });
   }
-  transformSelections(selections, contextNode) {
-    const result = [];
-    for (const selection of selections) {
-      let selectAllFromModel = void 0;
-      let isSelectAll = false;
-      if (import_kysely12.SelectAllNode.is(selection.selection)) {
-        selectAllFromModel = this.currentModel;
-        isSelectAll = true;
-      } else if (import_kysely12.ReferenceNode.is(selection.selection) && import_kysely12.SelectAllNode.is(selection.selection.column)) {
-        selectAllFromModel = selection.selection.table?.table.identifier.name ?? this.currentModel;
-        isSelectAll = true;
-      }
-      if (isSelectAll) {
-        if (!selectAllFromModel) {
-          continue;
+  // #endregion
+  // #region utils
+  resolveFieldFromScopes(name, qualifier) {
+    for (const scope of this.modelScopes.toReversed()) {
+      if (qualifier) {
+        if (scope.alias) {
+          if (qualifier !== scope.alias) {
+            continue;
+          }
         } else {
-          const scalarFields = this.getModelScalarFields(contextNode, selectAllFromModel);
-          const fromModelDef = requireModel(this.schema, selectAllFromModel);
-          const mappedTableName = this.getMappedName(fromModelDef) ?? selectAllFromModel;
-          result.push(...scalarFields.map((fieldName) => {
-            const fieldRef = import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(this.mapFieldName(fieldName)), import_kysely12.TableNode.create(mappedTableName));
-            return import_kysely12.SelectionNode.create(this.fieldHasMappedName(fieldName) ? import_kysely12.AliasNode.create(fieldRef, import_kysely12.IdentifierNode.create(fieldName)) : fieldRef);
-          }));
+          if (qualifier !== scope.model) {
+            continue;
+          }
         }
-      } else {
-        result.push(this.transformSelectionWithAlias(selection));
+      }
+      const modelDef = getModel(this.schema, scope.model);
+      if (!modelDef) {
+        continue;
+      }
+      if (modelDef.fields[name]) {
+        return {
+          modelDef,
+          fieldDef: modelDef.fields[name],
+          scope
+        };
       }
     }
-    return result;
+    return {
+      modelDef: void 0,
+      fieldDef: void 0,
+      scope: void 0
+    };
   }
-  transformSelectionWithAlias(node) {
-    if (import_kysely12.ColumnNode.is(node.selection) && this.fieldHasMappedName(node.selection.column.name)) {
-      return import_kysely12.SelectionNode.create(import_kysely12.AliasNode.create(this.transformColumn(node.selection), import_kysely12.IdentifierNode.create(node.selection.column.name)));
-    } else if (import_kysely12.ReferenceNode.is(node.selection) && this.fieldHasMappedName(node.selection.column.column.name)) {
-      return import_kysely12.SelectionNode.create(import_kysely12.AliasNode.create(this.transformReference(node.selection), import_kysely12.IdentifierNode.create(node.selection.column.column.name)));
-    } else {
-      return this.transformSelection(node);
+  pushScope(scope) {
+    this.modelScopes.push(scope);
+  }
+  withScope(scope, fn) {
+    this.pushScope(scope);
+    try {
+      return fn();
+    } finally {
+      this.modelScopes.pop();
     }
   }
-  fieldHasMappedName(name) {
-    if (!this.currentModel) {
-      return false;
+  withScopes(scopes, fn) {
+    scopes.forEach((s) => this.pushScope(s));
+    try {
+      return fn();
+    } finally {
+      scopes.forEach(() => this.modelScopes.pop());
     }
-    return this.fieldToColumnMap.has(`${this.currentModel}.${name}`);
   }
-  transformTable(node) {
-    const tableName = node.table.identifier.name;
-    const mappedName = this.modelToTableMap.get(tableName);
-    if (mappedName) {
-      return import_kysely12.TableNode.create(mappedName);
-    } else {
+  wrapAlias(node, alias) {
+    return alias ? import_kysely12.AliasNode.create(node, import_kysely12.IdentifierNode.create(alias)) : node;
+  }
+  ensureAlias(node, alias, fallbackName) {
+    if (!node) {
       return node;
     }
+    return alias ? import_kysely12.AliasNode.create(node, import_kysely12.IdentifierNode.create(alias)) : import_kysely12.AliasNode.create(node, import_kysely12.IdentifierNode.create(fallbackName));
   }
-  transformColumn(node) {
-    return import_kysely12.ColumnNode.create(this.mapFieldName(node.column.name));
+  processTableRef(node) {
+    if (!node) {
+      return node;
+    }
+    if (!import_kysely12.TableNode.is(node)) {
+      return super.transformNode(node);
+    }
+    return import_kysely12.TableNode.create(this.mapTableName(node.table.identifier.name));
   }
   getMappedName(def) {
     const mapAttr = def.attributes?.find((attr) => attr.name === "@@map" || attr.name === "@map");
@@ -5845,28 +5879,151 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     }
     return void 0;
   }
-  mapFieldName(fieldName) {
-    if (!this.currentModel) {
-      return fieldName;
+  mapFieldName(model, field) {
+    const mappedName = this.fieldToColumnMap.get(`${model}.${field}`);
+    if (mappedName) {
+      return mappedName;
+    } else {
+      return field;
     }
-    const mappedName = this.fieldToColumnMap.get(`${this.currentModel}.${fieldName}`);
+  }
+  mapTableName(tableName) {
+    const mappedName = this.modelToTableMap.get(tableName);
     if (mappedName) {
       return mappedName;
     } else {
-      return fieldName;
+      return tableName;
     }
   }
-  requireCurrentModel(node) {
-    if (!this.currentModel) {
-      throw new InternalError(`Missing model context for "${node}"`);
+  stripAlias(node) {
+    if (!node) {
+      return {
+        alias: void 0,
+        node
+      };
+    }
+    if (import_kysely12.AliasNode.is(node)) {
+      (0, import_common_helpers10.invariant)(import_kysely12.IdentifierNode.is(node.alias), "Expected identifier as alias");
+      return {
+        alias: node.alias.name,
+        node: node.node
+      };
+    }
+    return {
+      alias: void 0,
+      node
+    };
+  }
+  hasMappedColumns(modelName) {
+    return [
+      ...this.fieldToColumnMap.keys()
+    ].some((key) => key.startsWith(modelName + "."));
+  }
+  createScopesFromFroms(node, namesMapped) {
+    if (!node) {
+      return [];
     }
+    return node.froms.map((from) => {
+      const { alias, node: innerNode } = this.stripAlias(from);
+      if (innerNode && import_kysely12.TableNode.is(innerNode)) {
+        return {
+          model: innerNode.table.identifier.name,
+          alias,
+          namesMapped
+        };
+      } else {
+        return void 0;
+      }
+    }).filter((s) => !!s);
   }
-  getModelScalarFields(contextNode, model) {
-    this.requireCurrentModel(contextNode);
-    model = model ?? this.currentModel;
+  // convert a "from" node to a nested query if there are columns with name mapping
+  processFrom(node) {
+    return {
+      ...super.transformFrom(node),
+      froms: node.froms.map((from) => {
+        const { alias, node: innerNode } = this.stripAlias(from);
+        if (!innerNode) {
+          return super.transformNode(from);
+        }
+        if (import_kysely12.TableNode.is(innerNode)) {
+          if (this.hasMappedColumns(innerNode.table.identifier.name)) {
+            const selectAll = this.createSelectAll(innerNode.table.identifier.name);
+            return this.ensureAlias(selectAll, alias, innerNode.table.identifier.name);
+          }
+        }
+        return this.transformNode(from);
+      })
+    };
+  }
+  // create a `SelectQueryNode` for the given model with all columns mapped
+  createSelectAll(model) {
     const modelDef = requireModel(this.schema, model);
-    const scalarFields = Object.entries(modelDef.fields).filter(([, fieldDef]) => !fieldDef.relation && !fieldDef.computed && !fieldDef.originModel).map(([fieldName]) => fieldName);
-    return scalarFields;
+    const tableName = this.mapTableName(model);
+    return {
+      kind: "SelectQueryNode",
+      from: import_kysely12.FromNode.create([
+        import_kysely12.TableNode.create(tableName)
+      ]),
+      selections: this.getModelFields(modelDef).map((fieldDef) => {
+        const columnName = this.mapFieldName(model, fieldDef.name);
+        const columnRef = import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(columnName), import_kysely12.TableNode.create(tableName));
+        if (columnName !== fieldDef.name) {
+          const aliased = import_kysely12.AliasNode.create(columnRef, import_kysely12.IdentifierNode.create(fieldDef.name));
+          return import_kysely12.SelectionNode.create(aliased);
+        } else {
+          return import_kysely12.SelectionNode.create(columnRef);
+        }
+      })
+    };
+  }
+  getModelFields(modelDef) {
+    return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
+  }
+  processSelections(selections) {
+    const result = [];
+    selections.forEach((selection) => {
+      if (import_kysely12.SelectAllNode.is(selection.selection)) {
+        const processed = this.processSelectAll(selection.selection);
+        if (Array.isArray(processed)) {
+          result.push(...processed.map((s) => import_kysely12.SelectionNode.create(s)));
+        } else {
+          result.push(import_kysely12.SelectionNode.create(processed));
+        }
+      } else {
+        result.push(import_kysely12.SelectionNode.create(this.processSelection(selection.selection)));
+      }
+    });
+    return result;
+  }
+  processSelection(node) {
+    let alias;
+    if (!import_kysely12.AliasNode.is(node)) {
+      alias = this.extractFieldName(node);
+    }
+    const result = super.transformNode(node);
+    return this.wrapAlias(result, alias);
+  }
+  processSelectAll(node) {
+    const scope = this.modelScopes[this.modelScopes.length - 1];
+    (0, import_common_helpers10.invariant)(scope);
+    if (!this.hasMappedColumns(scope.model)) {
+      return super.transformSelectAll(node);
+    }
+    const modelDef = requireModel(this.schema, scope.model);
+    return this.getModelFields(modelDef).map((fieldDef) => {
+      const columnName = this.mapFieldName(scope.model, fieldDef.name);
+      const columnRef = import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(columnName));
+      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, fieldDef.name) : columnRef;
+    });
+  }
+  extractFieldName(node) {
+    if (import_kysely12.ReferenceNode.is(node) && import_kysely12.ColumnNode.is(node.column)) {
+      return node.column.column.name;
+    } else if (import_kysely12.ColumnNode.is(node)) {
+      return node.column.name;
+    } else {
+      return void 0;
+    }
   }
 };
 
@@ -6167,7 +6324,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely14 = require("kysely");
 var import_ts_pattern17 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
@@ -6274,8 +6431,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers10.invariant)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers10.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers10.lowerCaseFirst)(result)).otherwise(() => {
+  (0, import_common_helpers11.invariant)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers11.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers11.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -6283,7 +6440,7 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern18 = require("ts-pattern");
@@ -6379,7 +6536,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers11.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers12.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -6447,7 +6604,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers11.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers12.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -6502,7 +6659,7 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern19 = require("ts-pattern");
 var ResultProcessor = class {
@@ -6602,14 +6759,14 @@ var ResultProcessor = class {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_common_helpers12.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers13.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers12.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers13.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -6653,7 +6810,7 @@ var ResultProcessor = class {
   }
   transformJson(value) {
     return (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => {
-      (0, import_common_helpers12.invariant)(typeof value === "string", "Expected string, got " + typeof value);
+      (0, import_common_helpers13.invariant)(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
   }
@@ -6730,7 +6887,7 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    (0, import_common_helpers13.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    (0, import_common_helpers14.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
     if (typeof input === "function") {
       return this.interactiveTransaction(input, options);
     } else {