metal-orm 1.0.8 → 1.0.9

package/dist/index.js

@@ -0,0 +1,4131 @@
+// src/schema/table.ts
+var defineTable = (name, columns, relations = {}, hooks) => {
+  const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
+    acc[key] = { ...def, name: key, table: name };
+    return acc;
+  }, {});
+  return { name, columns: colsWithNames, relations, hooks };
+};
+
+// src/schema/column.ts
+var col = {
+  /**
+   * Creates an integer column definition
+   * @returns ColumnDef with INT type
+   */
+  int: () => ({ name: "", type: "INT" }),
+  /**
+   * Creates a variable character column definition
+   * @param length - Maximum length of the string
+   * @returns ColumnDef with VARCHAR type
+   */
+  varchar: (length) => ({ name: "", type: "VARCHAR", args: [length] }),
+  /**
+   * Creates a JSON column definition
+   * @returns ColumnDef with JSON type
+   */
+  json: () => ({ name: "", type: "JSON" }),
+  /**
+   * Creates a boolean column definition
+   * @returns ColumnDef with BOOLEAN type
+   */
+  boolean: () => ({ name: "", type: "BOOLEAN" }),
+  /**
+   * Marks a column definition as a primary key
+   * @param def - Column definition to modify
+   * @returns Modified ColumnDef with primary: true
+   */
+  primaryKey: (def) => ({ ...def, primary: true })
+};
+
+// src/schema/relation.ts
+var RelationKinds = {
+  /** One-to-many relationship */
+  HasMany: "HAS_MANY",
+  /** Many-to-one relationship */
+  BelongsTo: "BELONGS_TO",
+  /** Many-to-many relationship with pivot metadata */
+  BelongsToMany: "BELONGS_TO_MANY"
+};
+var hasMany = (target, foreignKey, localKey, cascade) => ({
+  type: RelationKinds.HasMany,
+  target,
+  foreignKey,
+  localKey,
+  cascade
+});
+var belongsTo = (target, foreignKey, localKey, cascade) => ({
+  type: RelationKinds.BelongsTo,
+  target,
+  foreignKey,
+  localKey,
+  cascade
+});
+var belongsToMany = (target, pivotTable, options) => ({
+  type: RelationKinds.BelongsToMany,
+  target,
+  pivotTable,
+  pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
+  pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
+  localKey: options.localKey,
+  targetKey: options.targetKey,
+  pivotPrimaryKey: options.pivotPrimaryKey,
+  defaultPivotColumns: options.defaultPivotColumns,
+  cascade: options.cascade
+});
+
+// src/core/ast/expression-nodes.ts
+var operandTypes = /* @__PURE__ */ new Set([
+  "Column",
+  "Literal",
+  "Function",
+  "JsonPath",
+  "ScalarSubquery",
+  "CaseExpression",
+  "WindowFunction"
+]);
+var isOperandNode = (node) => node && operandTypes.has(node.type);
+var isFunctionNode = (node) => node?.type === "Function";
+var isCaseExpressionNode = (node) => node?.type === "CaseExpression";
+var isWindowFunctionNode = (node) => node?.type === "WindowFunction";
+var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
+
+// src/core/ast/expression-builders.ts
+var valueToOperand = (value) => {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return { type: "Literal", value: value === void 0 ? null : value };
+  }
+  return value;
+};
+var toNode = (col2) => {
+  if (isOperandNode(col2)) return col2;
+  const def = col2;
+  return { type: "Column", table: def.table || "unknown", name: def.name };
+};
+var toLiteralNode = (value) => ({
+  type: "Literal",
+  value
+});
+var toOperand = (val) => {
+  if (val === null) return { type: "Literal", value: null };
+  if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+    return { type: "Literal", value: val };
+  }
+  return toNode(val);
+};
+var columnOperand = (col2) => toNode(col2);
+var createBinaryExpression = (operator, left, right, escape) => {
+  const node = {
+    type: "BinaryExpression",
+    left: toNode(left),
+    operator,
+    right: toOperand(right)
+  };
+  if (escape !== void 0) {
+    node.escape = toLiteralNode(escape);
+  }
+  return node;
+};
+var eq = (left, right) => createBinaryExpression("=", left, right);
+var neq = (left, right) => createBinaryExpression("!=", left, right);
+var gt = (left, right) => createBinaryExpression(">", left, right);
+var gte = (left, right) => createBinaryExpression(">=", left, right);
+var lt = (left, right) => createBinaryExpression("<", left, right);
+var lte = (left, right) => createBinaryExpression("<=", left, right);
+var like = (left, pattern, escape) => createBinaryExpression("LIKE", left, pattern, escape);
+var notLike = (left, pattern, escape) => createBinaryExpression("NOT LIKE", left, pattern, escape);
+var and = (...operands) => ({
+  type: "LogicalExpression",
+  operator: "AND",
+  operands
+});
+var or = (...operands) => ({
+  type: "LogicalExpression",
+  operator: "OR",
+  operands
+});
+var isNull = (left) => ({
+  type: "NullExpression",
+  left: toNode(left),
+  operator: "IS NULL"
+});
+var isNotNull = (left) => ({
+  type: "NullExpression",
+  left: toNode(left),
+  operator: "IS NOT NULL"
+});
+var createInExpression = (operator, left, values) => ({
+  type: "InExpression",
+  left: toNode(left),
+  operator,
+  right: values.map((v) => toOperand(v))
+});
+var inList = (left, values) => createInExpression("IN", left, values);
+var notInList = (left, values) => createInExpression("NOT IN", left, values);
+var createBetweenExpression = (operator, left, lower, upper) => ({
+  type: "BetweenExpression",
+  left: toNode(left),
+  operator,
+  lower: toOperand(lower),
+  upper: toOperand(upper)
+});
+var between = (left, lower, upper) => createBetweenExpression("BETWEEN", left, lower, upper);
+var notBetween = (left, lower, upper) => createBetweenExpression("NOT BETWEEN", left, lower, upper);
+var jsonPath = (col2, path) => ({
+  type: "JsonPath",
+  column: columnOperand(col2),
+  path
+});
+var caseWhen = (conditions, elseValue) => ({
+  type: "CaseExpression",
+  conditions: conditions.map((c) => ({
+    when: c.when,
+    then: toOperand(c.then)
+  })),
+  else: elseValue !== void 0 ? toOperand(elseValue) : void 0
+});
+var exists = (subquery) => ({
+  type: "ExistsExpression",
+  operator: "EXISTS",
+  subquery
+});
+var notExists = (subquery) => ({
+  type: "ExistsExpression",
+  operator: "NOT EXISTS",
+  subquery
+});
+
+// src/core/ast/window-functions.ts
+var buildWindowFunction = (name, args = [], partitionBy, orderBy) => {
+  const node = {
+    type: "WindowFunction",
+    name,
+    args
+  };
+  if (partitionBy && partitionBy.length) {
+    node.partitionBy = partitionBy;
+  }
+  if (orderBy && orderBy.length) {
+    node.orderBy = orderBy;
+  }
+  return node;
+};
+var rowNumber = () => buildWindowFunction("ROW_NUMBER");
+var rank = () => buildWindowFunction("RANK");
+var denseRank = () => buildWindowFunction("DENSE_RANK");
+var ntile = (n) => buildWindowFunction("NTILE", [{ type: "Literal", value: n }]);
+var lag = (col2, offset = 1, defaultValue) => {
+  const args = [
+    columnOperand(col2),
+    { type: "Literal", value: offset }
+  ];
+  if (defaultValue !== void 0) {
+    args.push({ type: "Literal", value: defaultValue });
+  }
+  return buildWindowFunction("LAG", args);
+};
+var lead = (col2, offset = 1, defaultValue) => {
+  const args = [
+    columnOperand(col2),
+    { type: "Literal", value: offset }
+  ];
+  if (defaultValue !== void 0) {
+    args.push({ type: "Literal", value: defaultValue });
+  }
+  return buildWindowFunction("LEAD", args);
+};
+var firstValue = (col2) => buildWindowFunction("FIRST_VALUE", [columnOperand(col2)]);
+var lastValue = (col2) => buildWindowFunction("LAST_VALUE", [columnOperand(col2)]);
+var windowFunction = (name, args = [], partitionBy, orderBy) => {
+  const nodeArgs = args.map((arg) => {
+    if (typeof arg.value !== "undefined") {
+      return arg;
+    }
+    if ("path" in arg) {
+      return arg;
+    }
+    return columnOperand(arg);
+  });
+  const partitionNodes = partitionBy?.map((col2) => columnOperand(col2)) ?? void 0;
+  const orderNodes = orderBy?.map((o) => ({
+    type: "OrderBy",
+    column: columnOperand(o.column),
+    direction: o.direction
+  }));
+  return buildWindowFunction(name, nodeArgs, partitionNodes, orderNodes);
+};
+
+// src/core/ast/aggregate-functions.ts
+var buildAggregate = (name) => (col2) => ({
+  type: "Function",
+  name,
+  args: [columnOperand(col2)]
+});
+var count = buildAggregate("COUNT");
+var sum = buildAggregate("SUM");
+var avg = buildAggregate("AVG");
+
+// src/core/ast/expression-visitor.ts
+var unsupportedExpression = (node) => {
+  throw new Error(`Unsupported expression type "${node?.type ?? "unknown"}"`);
+};
+var unsupportedOperand = (node) => {
+  throw new Error(`Unsupported operand type "${node?.type ?? "unknown"}"`);
+};
+var visitExpression = (node, visitor) => {
+  switch (node.type) {
+    case "BinaryExpression":
+      return visitor.visitBinaryExpression(node);
+    case "LogicalExpression":
+      return visitor.visitLogicalExpression(node);
+    case "NullExpression":
+      return visitor.visitNullExpression(node);
+    case "InExpression":
+      return visitor.visitInExpression(node);
+    case "ExistsExpression":
+      return visitor.visitExistsExpression(node);
+    case "BetweenExpression":
+      return visitor.visitBetweenExpression(node);
+    default:
+      return unsupportedExpression(node);
+  }
+};
+var visitOperand = (node, visitor) => {
+  switch (node.type) {
+    case "Column":
+      return visitor.visitColumn(node);
+    case "Literal":
+      return visitor.visitLiteral(node);
+    case "Function":
+      return visitor.visitFunction(node);
+    case "JsonPath":
+      return visitor.visitJsonPath(node);
+    case "ScalarSubquery":
+      return visitor.visitScalarSubquery(node);
+    case "CaseExpression":
+      return visitor.visitCaseExpression(node);
+    case "WindowFunction":
+      return visitor.visitWindowFunction(node);
+    default:
+      return unsupportedOperand(node);
+  }
+};
+
+// src/query-builder/select-query-state.ts
+var SelectQueryState = class _SelectQueryState {
+  /**
+   * Creates a new SelectQueryState instance
+   * @param table - Table definition
+   * @param ast - Optional existing AST
+   */
+  constructor(table, ast) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: "SelectQuery",
+      from: { type: "Table", name: table.name },
+      columns: [],
+      joins: []
+    };
+  }
+  /**
+   * Creates a new SelectQueryState with updated AST
+   * @param nextAst - Updated AST
+   * @returns New SelectQueryState instance
+   */
+  clone(nextAst) {
+    return new _SelectQueryState(this.table, nextAst);
+  }
+  /**
+   * Adds columns to the query
+   * @param newCols - Columns to add
+   * @returns New SelectQueryState with added columns
+   */
+  withColumns(newCols) {
+    return this.clone({
+      ...this.ast,
+      columns: [...this.ast.columns ?? [], ...newCols]
+    });
+  }
+  /**
+   * Adds a join to the query
+   * @param join - Join node to add
+   * @returns New SelectQueryState with added join
+   */
+  withJoin(join) {
+    return this.clone({
+      ...this.ast,
+      joins: [...this.ast.joins ?? [], join]
+    });
+  }
+  /**
+   * Adds a WHERE clause to the query
+   * @param predicate - WHERE predicate expression
+   * @returns New SelectQueryState with WHERE clause
+   */
+  withWhere(predicate) {
+    return this.clone({
+      ...this.ast,
+      where: predicate
+    });
+  }
+  /**
+   * Adds a HAVING clause to the query
+   * @param predicate - HAVING predicate expression
+   * @returns New SelectQueryState with HAVING clause
+   */
+  withHaving(predicate) {
+    return this.clone({
+      ...this.ast,
+      having: predicate
+    });
+  }
+  /**
+   * Adds GROUP BY columns to the query
+   * @param columns - Columns to group by
+   * @returns New SelectQueryState with GROUP BY clause
+   */
+  withGroupBy(columns) {
+    return this.clone({
+      ...this.ast,
+      groupBy: [...this.ast.groupBy ?? [], ...columns]
+    });
+  }
+  /**
+   * Adds ORDER BY clauses to the query
+   * @param orderBy - ORDER BY nodes
+   * @returns New SelectQueryState with ORDER BY clause
+   */
+  withOrderBy(orderBy) {
+    return this.clone({
+      ...this.ast,
+      orderBy: [...this.ast.orderBy ?? [], ...orderBy]
+    });
+  }
+  /**
+   * Adds DISTINCT columns to the query
+   * @param columns - Columns to make distinct
+   * @returns New SelectQueryState with DISTINCT clause
+   */
+  withDistinct(columns) {
+    return this.clone({
+      ...this.ast,
+      distinct: [...this.ast.distinct ?? [], ...columns]
+    });
+  }
+  /**
+   * Adds a LIMIT clause to the query
+   * @param limit - Maximum number of rows to return
+   * @returns New SelectQueryState with LIMIT clause
+   */
+  withLimit(limit) {
+    return this.clone({
+      ...this.ast,
+      limit
+    });
+  }
+  /**
+   * Adds an OFFSET clause to the query
+   * @param offset - Number of rows to skip
+   * @returns New SelectQueryState with OFFSET clause
+   */
+  withOffset(offset) {
+    return this.clone({
+      ...this.ast,
+      offset
+    });
+  }
+  /**
+   * Adds a Common Table Expression (CTE) to the query
+   * @param cte - CTE node to add
+   * @returns New SelectQueryState with CTE
+   */
+  withCte(cte) {
+    return this.clone({
+      ...this.ast,
+      ctes: [...this.ast.ctes ?? [], cte]
+    });
+  }
+};
+
+// src/query-builder/hydration-manager.ts
+var HydrationManager = class _HydrationManager {
+  /**
+   * Creates a new HydrationManager instance
+   * @param table - Table definition
+   * @param planner - Hydration planner
+   */
+  constructor(table, planner) {
+    this.table = table;
+    this.planner = planner;
+  }
+  /**
+   * Creates a new HydrationManager with updated planner
+   * @param nextPlanner - Updated hydration planner
+   * @returns New HydrationManager instance
+   */
+  clone(nextPlanner) {
+    return new _HydrationManager(this.table, nextPlanner);
+  }
+  /**
+   * Handles column selection for hydration planning
+   * @param state - Current query state
+   * @param newColumns - Newly selected columns
+   * @returns Updated HydrationManager with captured columns
+   */
+  onColumnsSelected(state, newColumns) {
+    const updated = this.planner.captureRootColumns(newColumns);
+    return this.clone(updated);
+  }
+  /**
+   * Handles relation inclusion for hydration planning
+   * @param state - Current query state
+   * @param relation - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for the relation
+   * @param targetColumns - Target columns to include
+   * @returns Updated HydrationManager with included relation
+   */
+  onRelationIncluded(state, relation, relationName, aliasPrefix, targetColumns, pivot) {
+    const withRoots = this.planner.captureRootColumns(state.ast.columns);
+    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
+    return this.clone(next);
+  }
+  /**
+   * Applies hydration plan to the AST
+   * @param ast - Query AST to modify
+   * @returns AST with hydration metadata
+   */
+  applyToAst(ast) {
+    const plan = this.planner.getPlan();
+    if (!plan) return ast;
+    return {
+      ...ast,
+      meta: {
+        ...ast.meta || {},
+        hydration: plan
+      }
+    };
+  }
+  /**
+   * Gets the current hydration plan
+   * @returns Hydration plan or undefined if none exists
+   */
+  getPlan() {
+    return this.planner.getPlan();
+  }
+};
+
+// src/query-builder/relation-alias.ts
+var RELATION_SEPARATOR = "__";
+var makeRelationAlias = (relationName, columnName) => `${relationName}${RELATION_SEPARATOR}${columnName}`;
+var isRelationAlias = (alias) => !!alias && alias.includes(RELATION_SEPARATOR);
+
+// src/query-builder/relation-utils.ts
+var buildDefaultPivotColumns = (rel, pivotPk) => {
+  const excluded = /* @__PURE__ */ new Set([pivotPk, rel.pivotForeignKeyToRoot, rel.pivotForeignKeyToTarget]);
+  return Object.keys(rel.pivotTable.columns).filter((col2) => !excluded.has(col2));
+};
+
+// src/query-builder/hydration-planner.ts
+var findPrimaryKey = (table) => {
+  const pk = Object.values(table.columns).find((c) => c.primary);
+  return pk?.name || "id";
+};
+var HydrationPlanner = class _HydrationPlanner {
+  /**
+   * Creates a new HydrationPlanner instance
+   * @param table - Table definition
+   * @param plan - Optional existing hydration plan
+   */
+  constructor(table, plan) {
+    this.table = table;
+    this.plan = plan;
+  }
+  /**
+   * Captures root table columns for hydration planning
+   * @param columns - Columns to capture
+   * @returns Updated HydrationPlanner with captured columns
+   */
+  captureRootColumns(columns) {
+    const currentPlan = this.getPlanOrDefault();
+    const rootCols = new Set(currentPlan.rootColumns);
+    let changed = false;
+    columns.forEach((node) => {
+      if (node.type !== "Column") return;
+      if (node.table !== this.table.name) return;
+      const alias = node.alias || node.name;
+      if (isRelationAlias(alias)) return;
+      if (!rootCols.has(alias)) {
+        rootCols.add(alias);
+        changed = true;
+      }
+    });
+    if (!changed) return this;
+    return new _HydrationPlanner(this.table, {
+      ...currentPlan,
+      rootColumns: Array.from(rootCols)
+    });
+  }
+  /**
+   * Includes a relation in the hydration plan
+   * @param rel - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for relation columns
+   * @param columns - Columns to include from the relation
+   * @returns Updated HydrationPlanner with included relation
+   */
+  includeRelation(rel, relationName, aliasPrefix, columns, pivot) {
+    const currentPlan = this.getPlanOrDefault();
+    const relations = currentPlan.relations.filter((r) => r.name !== relationName);
+    relations.push(this.buildRelationPlan(rel, relationName, aliasPrefix, columns, pivot));
+    return new _HydrationPlanner(this.table, {
+      ...currentPlan,
+      relations
+    });
+  }
+  /**
+   * Gets the current hydration plan
+   * @returns Current hydration plan or undefined
+   */
+  getPlan() {
+    return this.plan;
+  }
+  /**
+   * Gets the current hydration plan or creates a default one
+   * @returns Current hydration plan or default plan
+   */
+  getPlanOrDefault() {
+    return this.plan ?? buildDefaultHydrationPlan(this.table);
+  }
+  /**
+   * Builds a relation plan for hydration
+   * @param rel - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for relation columns
+   * @param columns - Columns to include from the relation
+   * @returns Hydration relation plan
+   */
+  buildRelationPlan(rel, relationName, aliasPrefix, columns, pivot) {
+    switch (rel.type) {
+      case RelationKinds.HasMany: {
+        const localKey = rel.localKey || findPrimaryKey(this.table);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: rel.target.name,
+          targetPrimaryKey: findPrimaryKey(rel.target),
+          foreignKey: rel.foreignKey,
+          localKey,
+          columns
+        };
+      }
+      case RelationKinds.BelongsTo: {
+        const localKey = rel.localKey || findPrimaryKey(rel.target);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: rel.target.name,
+          targetPrimaryKey: findPrimaryKey(rel.target),
+          foreignKey: rel.foreignKey,
+          localKey,
+          columns
+        };
+      }
+      case RelationKinds.BelongsToMany: {
+        const many = rel;
+        const localKey = many.localKey || findPrimaryKey(this.table);
+        const targetPk = many.targetKey || findPrimaryKey(many.target);
+        const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
+        const pivotAliasPrefix = pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
+        const pivotColumns = pivot?.columns ?? many.defaultPivotColumns ?? buildDefaultPivotColumns(many, pivotPk);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: many.target.name,
+          targetPrimaryKey: targetPk,
+          foreignKey: many.pivotForeignKeyToRoot,
+          localKey,
+          columns,
+          pivot: {
+            table: many.pivotTable.name,
+            primaryKey: pivotPk,
+            aliasPrefix: pivotAliasPrefix,
+            columns: pivotColumns
+          }
+        };
+      }
+    }
+  }
+};
+var buildDefaultHydrationPlan = (table) => ({
+  rootTable: table.name,
+  rootPrimaryKey: findPrimaryKey(table),
+  rootColumns: [],
+  relations: []
+});
+
+// src/core/ast/builders.ts
+var buildColumnNode = (table, column) => {
+  if (column.type === "Column") {
+    return column;
+  }
+  const def = column;
+  return {
+    type: "Column",
+    table: def.table || table.name,
+    name: def.name
+  };
+};
+var buildColumnNodes = (table, names) => names.map((name) => ({
+  type: "Column",
+  table: table.name,
+  name
+}));
+var createTableNode = (table) => ({
+  type: "Table",
+  name: table.name
+});
+
+// src/query-builder/raw-column-parser.ts
+var parseRawColumn = (col2, tableName, ctes) => {
+  if (col2.includes("(")) {
+    const [fn, rest] = col2.split("(");
+    const colName = rest.replace(")", "");
+    const [table, name] = colName.includes(".") ? colName.split(".") : [tableName, colName];
+    return { type: "Column", table, name, alias: col2 };
+  }
+  if (col2.includes(".")) {
+    const [potentialCteName, columnName] = col2.split(".");
+    const hasCte = ctes?.some((cte) => cte.name === potentialCteName);
+    if (hasCte) {
+      return { type: "Column", table: tableName, name: col2 };
+    }
+    return { type: "Column", table: potentialCteName, name: columnName };
+  }
+  return { type: "Column", table: tableName, name: col2 };
+};
+
+// src/query-builder/query-ast-service.ts
+var QueryAstService = class {
+  /**
+   * Creates a new QueryAstService instance
+   * @param table - Table definition
+   * @param state - Current query state
+   */
+  constructor(table, state) {
+    this.table = table;
+    this.state = state;
+  }
+  /**
+   * Selects columns for the query
+   * @param columns - Columns to select (key: alias, value: column definition or expression)
+   * @returns Column selection result with updated state and added columns
+   */
+  select(columns) {
+    const existingAliases = new Set(
+      this.state.ast.columns.map((c) => c.alias || c.name)
+    );
+    const newCols = Object.entries(columns).reduce((acc, [alias, val]) => {
+      if (existingAliases.has(alias)) return acc;
+      if (isExpressionSelectionNode(val)) {
+        acc.push({ ...val, alias });
+        return acc;
+      }
+      const colDef = val;
+      acc.push({
+        type: "Column",
+        table: colDef.table || this.table.name,
+        name: colDef.name,
+        alias
+      });
+      return acc;
+    }, []);
+    const nextState = this.state.withColumns(newCols);
+    return { state: nextState, addedColumns: newCols };
+  }
+  /**
+   * Selects raw column expressions (best-effort parser for simple references/functions)
+   * @param cols - Raw column expressions
+   * @returns Column selection result with updated state and added columns
+   */
+  selectRaw(cols) {
+    const newCols = cols.map((col2) => parseRawColumn(col2, this.table.name, this.state.ast.ctes));
+    const nextState = this.state.withColumns(newCols);
+    return { state: nextState, addedColumns: newCols };
+  }
+  /**
+   * Adds a Common Table Expression (CTE) to the query
+   * @param name - Name of the CTE
+   * @param query - Query for the CTE
+   * @param columns - Optional column names for the CTE
+   * @param recursive - Whether the CTE is recursive
+   * @returns Updated query state with CTE
+   */
+  withCte(name, query, columns, recursive = false) {
+    const cte = {
+      type: "CommonTableExpression",
+      name,
+      query,
+      columns,
+      recursive
+    };
+    return this.state.withCte(cte);
+  }
+  /**
+   * Selects a subquery as a column
+   * @param alias - Alias for the subquery
+   * @param query - Subquery to select
+   * @returns Updated query state with subquery selection
+   */
+  selectSubquery(alias, query) {
+    const node = { type: "ScalarSubquery", query, alias };
+    return this.state.withColumns([node]);
+  }
+  /**
+   * Adds a JOIN clause to the query
+   * @param join - Join node to add
+   * @returns Updated query state with JOIN
+   */
+  withJoin(join) {
+    return this.state.withJoin(join);
+  }
+  /**
+   * Adds a WHERE clause to the query
+   * @param expr - Expression for the WHERE clause
+   * @returns Updated query state with WHERE clause
+   */
+  withWhere(expr) {
+    const combined = this.combineExpressions(this.state.ast.where, expr);
+    return this.state.withWhere(combined);
+  }
+  /**
+   * Adds a GROUP BY clause to the query
+   * @param col - Column to group by
+   * @returns Updated query state with GROUP BY clause
+   */
+  withGroupBy(col2) {
+    const node = buildColumnNode(this.table, col2);
+    return this.state.withGroupBy([node]);
+  }
+  /**
+   * Adds a HAVING clause to the query
+   * @param expr - Expression for the HAVING clause
+   * @returns Updated query state with HAVING clause
+   */
+  withHaving(expr) {
+    const combined = this.combineExpressions(this.state.ast.having, expr);
+    return this.state.withHaving(combined);
+  }
+  /**
+   * Adds an ORDER BY clause to the query
+   * @param col - Column to order by
+   * @param direction - Order direction (ASC/DESC)
+   * @returns Updated query state with ORDER BY clause
+   */
+  withOrderBy(col2, direction) {
+    const node = buildColumnNode(this.table, col2);
+    return this.state.withOrderBy([{ type: "OrderBy", column: node, direction }]);
+  }
+  /**
+   * Adds a DISTINCT clause to the query
+   * @param cols - Columns to make distinct
+   * @returns Updated query state with DISTINCT clause
+   */
+  withDistinct(cols) {
+    return this.state.withDistinct(cols);
+  }
+  /**
+   * Adds a LIMIT clause to the query
+   * @param limit - Maximum number of rows to return
+   * @returns Updated query state with LIMIT clause
+   */
+  withLimit(limit) {
+    return this.state.withLimit(limit);
+  }
+  /**
+   * Adds an OFFSET clause to the query
+   * @param offset - Number of rows to skip
+   * @returns Updated query state with OFFSET clause
+   */
+  withOffset(offset) {
+    return this.state.withOffset(offset);
+  }
+  /**
+   * Combines expressions with AND operator
+   * @param existing - Existing expression
+   * @param next - New expression to combine
+   * @returns Combined expression
+   */
+  combineExpressions(existing, next) {
+    return existing ? and(existing, next) : next;
+  }
+};
+
+// src/query-builder/relation-projection-helper.ts
+var RelationProjectionHelper = class {
+  /**
+   * Creates a new RelationProjectionHelper instance
+   * @param table - Table definition
+   * @param selectColumns - Callback for selecting columns
+   */
+  constructor(table, selectColumns) {
+    this.table = table;
+    this.selectColumns = selectColumns;
+  }
+  /**
+   * Ensures base projection is included in the query
+   * @param state - Current query state
+   * @param hydration - Hydration manager
+   * @returns Relation result with updated state and hydration
+   */
+  ensureBaseProjection(state, hydration) {
+    const primaryKey = findPrimaryKey(this.table);
+    if (!this.hasBaseProjection(state)) {
+      return this.selectColumns(state, hydration, this.getBaseColumns());
+    }
+    if (primaryKey && !this.hasPrimarySelected(state, primaryKey) && this.table.columns[primaryKey]) {
+      return this.selectColumns(state, hydration, {
+        [primaryKey]: this.table.columns[primaryKey]
+      });
+    }
+    return { state, hydration };
+  }
+  /**
+   * Checks if base projection exists in the query
+   * @param state - Current query state
+   * @returns True if base projection exists
+   */
+  hasBaseProjection(state) {
+    return state.ast.columns.some((col2) => !isRelationAlias(col2.alias));
+  }
+  /**
+   * Checks if primary key is selected in the query
+   * @param state - Current query state
+   * @param primaryKey - Primary key name
+   * @returns True if primary key is selected
+   */
+  hasPrimarySelected(state, primaryKey) {
+    return state.ast.columns.some((col2) => {
+      const alias = col2.alias;
+      const name = alias || col2.name;
+      return !isRelationAlias(alias) && name === primaryKey;
+    });
+  }
+  /**
+   * Gets all base columns for the table
+   * @returns Record of all table columns
+   */
+  getBaseColumns() {
+    return Object.keys(this.table.columns).reduce((acc, key) => {
+      acc[key] = this.table.columns[key];
+      return acc;
+    }, {});
+  }
+};
+
+// src/core/ast/join-node.ts
+var createJoinNode = (kind, tableName, condition, relationName) => ({
+  type: "Join",
+  kind,
+  table: { type: "Table", name: tableName },
+  condition,
+  relationName
+});
+
+// src/query-builder/relation-conditions.ts
+var assertNever = (value) => {
+  throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
+};
+var baseRelationCondition = (root, relation) => {
+  const defaultLocalKey = relation.type === RelationKinds.HasMany ? findPrimaryKey(root) : findPrimaryKey(relation.target);
+  const localKey = relation.localKey || defaultLocalKey;
+  switch (relation.type) {
+    case RelationKinds.HasMany:
+      return eq(
+        { type: "Column", table: relation.target.name, name: relation.foreignKey },
+        { type: "Column", table: root.name, name: localKey }
+      );
+    case RelationKinds.BelongsTo:
+      return eq(
+        { type: "Column", table: relation.target.name, name: localKey },
+        { type: "Column", table: root.name, name: relation.foreignKey }
+      );
+    case RelationKinds.BelongsToMany:
+      throw new Error("BelongsToMany relations do not support the standard join condition builder");
+    default:
+      return assertNever(relation);
+  }
+};
+var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra) => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const pivotCondition = eq(
+    { type: "Column", table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: "Column", table: root.name, name: rootKey }
+  );
+  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
+  let targetCondition = eq(
+    { type: "Column", table: relation.target.name, name: targetKey },
+    { type: "Column", table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
+  );
+  if (extra) {
+    targetCondition = and(targetCondition, extra);
+  }
+  const targetJoin = createJoinNode(
+    joinKind,
+    relation.target.name,
+    targetCondition,
+    relationName
+  );
+  return [pivotJoin, targetJoin];
+};
+var buildRelationJoinCondition = (root, relation, extra) => {
+  const base = baseRelationCondition(root, relation);
+  return extra ? and(base, extra) : base;
+};
+var buildRelationCorrelation = (root, relation) => {
+  return baseRelationCondition(root, relation);
+};
+
+// src/core/sql/sql.ts
+var SQL_OPERATORS = {
+  /** Equality operator */
+  EQUALS: "=",
+  /** Not equals operator */
+  NOT_EQUALS: "!=",
+  /** Greater than operator */
+  GREATER_THAN: ">",
+  /** Greater than or equal operator */
+  GREATER_OR_EQUAL: ">=",
+  /** Less than operator */
+  LESS_THAN: "<",
+  /** Less than or equal operator */
+  LESS_OR_EQUAL: "<=",
+  /** LIKE pattern matching operator */
+  LIKE: "LIKE",
+  /** NOT LIKE pattern matching operator */
+  NOT_LIKE: "NOT LIKE",
+  /** IN membership operator */
+  IN: "IN",
+  /** NOT IN membership operator */
+  NOT_IN: "NOT IN",
+  /** BETWEEN range operator */
+  BETWEEN: "BETWEEN",
+  /** NOT BETWEEN range operator */
+  NOT_BETWEEN: "NOT BETWEEN",
+  /** IS NULL null check operator */
+  IS_NULL: "IS NULL",
+  /** IS NOT NULL null check operator */
+  IS_NOT_NULL: "IS NOT NULL",
+  /** Logical AND operator */
+  AND: "AND",
+  /** Logical OR operator */
+  OR: "OR",
+  /** EXISTS operator */
+  EXISTS: "EXISTS",
+  /** NOT EXISTS operator */
+  NOT_EXISTS: "NOT EXISTS"
+};
+var JOIN_KINDS = {
+  /** INNER JOIN type */
+  INNER: "INNER",
+  /** LEFT JOIN type */
+  LEFT: "LEFT",
+  /** RIGHT JOIN type */
+  RIGHT: "RIGHT",
+  /** CROSS JOIN type */
+  CROSS: "CROSS"
+};
+var ORDER_DIRECTIONS = {
+  /** Ascending order */
+  ASC: "ASC",
+  /** Descending order */
+  DESC: "DESC"
+};
+
+// src/query-builder/relation-service.ts
+var RelationService = class {
+  /**
+   * Creates a new RelationService instance
+   * @param table - Table definition
+   * @param state - Current query state
+   * @param hydration - Hydration manager
+   */
+  constructor(table, state, hydration, createQueryAstService) {
+    this.table = table;
+    this.state = state;
+    this.hydration = hydration;
+    this.createQueryAstService = createQueryAstService;
+    this.projectionHelper = new RelationProjectionHelper(
+      table,
+      (state2, hydration2, columns) => this.selectColumns(state2, hydration2, columns)
+    );
+  }
+  /**
+   * Joins a relation to the query
+   * @param relationName - Name of the relation to join
+   * @param joinKind - Type of join to use
+   * @param extraCondition - Additional join condition
+   * @returns Relation result with updated state and hydration
+   */
+  joinRelation(relationName, joinKind, extraCondition) {
+    const nextState = this.withJoin(this.state, relationName, joinKind, extraCondition);
+    return { state: nextState, hydration: this.hydration };
+  }
+  /**
+   * Matches records based on a relation with an optional predicate
+   * @param relationName - Name of the relation to match
+   * @param predicate - Optional predicate expression
+   * @returns Relation result with updated state and hydration
+   */
+  match(relationName, predicate) {
+    const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
+    const pk = findPrimaryKey(this.table);
+    const distinctCols = [{ type: "Column", table: this.table.name, name: pk }];
+    const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
+    const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
+    return { state: nextState, hydration: joined.hydration };
+  }
+  /**
+   * Includes a relation in the query result
+   * @param relationName - Name of the relation to include
+   * @param options - Options for relation inclusion
+   * @returns Relation result with updated state and hydration
+   */
+  include(relationName, options) {
+    let state = this.state;
+    let hydration = this.hydration;
+    const relation = this.getRelation(relationName);
+    const aliasPrefix = options?.aliasPrefix ?? relationName;
+    const alreadyJoined = state.ast.joins.some((j) => j.relationName === relationName);
+    if (!alreadyJoined) {
+      const joined = this.joinRelation(relationName, options?.joinKind ?? JOIN_KINDS.LEFT, options?.filter);
+      state = joined.state;
+    }
+    const projectionResult = this.projectionHelper.ensureBaseProjection(state, hydration);
+    state = projectionResult.state;
+    hydration = projectionResult.hydration;
+    const targetColumns = options?.columns?.length ? options.columns : Object.keys(relation.target.columns);
+    const buildTypedSelection = (columns, prefix, keys, missingMsg) => {
+      return keys.reduce((acc, key) => {
+        const def = columns[key];
+        if (!def) {
+          throw new Error(missingMsg(key));
+        }
+        acc[makeRelationAlias(prefix, key)] = def;
+        return acc;
+      }, {});
+    };
+    const targetSelection = buildTypedSelection(
+      relation.target.columns,
+      aliasPrefix,
+      targetColumns,
+      (key) => `Column '${key}' not found on relation '${relationName}'`
+    );
+    if (relation.type !== RelationKinds.BelongsToMany) {
+      const relationSelectionResult2 = this.selectColumns(state, hydration, targetSelection);
+      state = relationSelectionResult2.state;
+      hydration = relationSelectionResult2.hydration;
+      hydration = hydration.onRelationIncluded(
+        state,
+        relation,
+        relationName,
+        aliasPrefix,
+        targetColumns
+      );
+      return { state, hydration };
+    }
+    const many = relation;
+    const pivotAliasPrefix = options?.pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
+    const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
+    const pivotColumns = options?.pivot?.columns ?? many.defaultPivotColumns ?? buildDefaultPivotColumns(many, pivotPk);
+    const pivotSelection = buildTypedSelection(
+      many.pivotTable.columns,
+      pivotAliasPrefix,
+      pivotColumns,
+      (key) => `Column '${key}' not found on pivot table '${many.pivotTable.name}'`
+    );
+    const combinedSelection = {
+      ...targetSelection,
+      ...pivotSelection
+    };
+    const relationSelectionResult = this.selectColumns(state, hydration, combinedSelection);
+    state = relationSelectionResult.state;
+    hydration = relationSelectionResult.hydration;
+    hydration = hydration.onRelationIncluded(
+      state,
+      relation,
+      relationName,
+      aliasPrefix,
+      targetColumns,
+      { aliasPrefix: pivotAliasPrefix, columns: pivotColumns }
+    );
+    return { state, hydration };
+  }
+  /**
+   * Applies relation correlation to a query AST
+   * @param relationName - Name of the relation
+   * @param ast - Query AST to modify
+   * @returns Modified query AST with relation correlation
+   */
+  applyRelationCorrelation(relationName, ast) {
+    const relation = this.getRelation(relationName);
+    const correlation = buildRelationCorrelation(this.table, relation);
+    const whereInSubquery = ast.where ? and(correlation, ast.where) : correlation;
+    return {
+      ...ast,
+      where: whereInSubquery
+    };
+  }
+  /**
+   * Creates a join node for a relation
+   * @param state - Current query state
+   * @param relationName - Name of the relation
+   * @param joinKind - Type of join to use
+   * @param extraCondition - Additional join condition
+   * @returns Updated query state with join
+   */
+  withJoin(state, relationName, joinKind, extraCondition) {
+    const relation = this.getRelation(relationName);
+    if (relation.type === RelationKinds.BelongsToMany) {
+      const joins = buildBelongsToManyJoins(
+        this.table,
+        relationName,
+        relation,
+        joinKind,
+        extraCondition
+      );
+      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
+    }
+    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
+    const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
+    return this.astService(state).withJoin(joinNode);
+  }
+  /**
+   * Selects columns for a relation
+   * @param state - Current query state
+   * @param hydration - Hydration manager
+   * @param columns - Columns to select
+   * @returns Relation result with updated state and hydration
+   */
+  selectColumns(state, hydration, columns) {
+    const { state: nextState, addedColumns } = this.astService(state).select(columns);
+    return {
+      state: nextState,
+      hydration: hydration.onColumnsSelected(nextState, addedColumns)
+    };
+  }
+  /**
+   * Gets a relation definition by name
+   * @param relationName - Name of the relation
+   * @returns Relation definition
+   * @throws Error if relation is not found
+   */
+  getRelation(relationName) {
+    const relation = this.table.relations[relationName];
+    if (!relation) {
+      throw new Error(`Relation '${relationName}' not found on table '${this.table.name}'`);
+    }
+    return relation;
+  }
+  /**
+   * Creates a QueryAstService instance
+   * @param state - Current query state
+   * @returns QueryAstService instance
+   */
+  astService(state = this.state) {
+    return this.createQueryAstService(this.table, state);
+  }
+};
+
+// src/query-builder/select-query-builder-deps.ts
+var defaultCreateQueryAstService = (table, state) => new QueryAstService(table, state);
+var defaultCreateHydrationPlanner = (table) => new HydrationPlanner(table);
+var defaultCreateHydration = (table, plannerFactory) => new HydrationManager(table, plannerFactory(table));
+var resolveSelectQueryBuilderDependencies = (overrides = {}) => {
+  const createQueryAstService = overrides.createQueryAstService ?? defaultCreateQueryAstService;
+  const createHydrationPlanner = overrides.createHydrationPlanner ?? defaultCreateHydrationPlanner;
+  const createHydration = overrides.createHydration ?? ((table) => defaultCreateHydration(table, createHydrationPlanner));
+  const createRelationService = overrides.createRelationService ?? ((table, state, hydration) => new RelationService(table, state, hydration, createQueryAstService));
+  return {
+    createState: overrides.createState ?? ((table) => new SelectQueryState(table)),
+    createHydration,
+    createHydrationPlanner,
+    createQueryAstService,
+    createRelationService
+  };
+};
+var defaultSelectQueryBuilderDependencies = resolveSelectQueryBuilderDependencies();
+
+// src/query-builder/column-selector.ts
+var ColumnSelector = class {
+  /**
+   * Creates a new ColumnSelector instance
+   * @param env - Query builder environment
+   */
+  constructor(env) {
+    this.env = env;
+  }
+  /**
+   * Selects columns for the query
+   * @param context - Current query context
+   * @param columns - Columns to select
+   * @returns Updated query context with selected columns
+   */
+  select(context, columns) {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const { state: nextState, addedColumns } = astService.select(columns);
+    return {
+      state: nextState,
+      hydration: context.hydration.onColumnsSelected(nextState, addedColumns)
+    };
+  }
+  /**
+   * Selects raw column expressions
+   * @param context - Current query context
+   * @param columns - Raw column expressions
+   * @returns Updated query context with raw column selections
+   */
+  selectRaw(context, columns) {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.selectRaw(columns).state;
+    return { state: nextState, hydration: context.hydration };
+  }
+  /**
+   * Selects a subquery as a column
+   * @param context - Current query context
+   * @param alias - Alias for the subquery
+   * @param query - Subquery to select
+   * @returns Updated query context with subquery selection
+   */
+  selectSubquery(context, alias, query) {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.selectSubquery(alias, query);
+    return { state: nextState, hydration: context.hydration };
+  }
+  /**
+   * Adds DISTINCT clause to the query
+   * @param context - Current query context
+   * @param columns - Columns to make distinct
+   * @returns Updated query context with DISTINCT clause
+   */
+  distinct(context, columns) {
+    const nodes = columns.map((col2) => buildColumnNode(this.env.table, col2));
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.withDistinct(nodes);
+    return { state: nextState, hydration: context.hydration };
+  }
+};
+
+// src/query-builder/relation-manager.ts
+var RelationManager = class {
+  /**
+   * Creates a new RelationManager instance
+   * @param env - Query builder environment
+   */
+  constructor(env) {
+    this.env = env;
+  }
+  /**
+   * Matches records based on a relation with an optional predicate
+   * @param context - Current query context
+   * @param relationName - Name of the relation to match
+   * @param predicate - Optional predicate expression
+   * @returns Updated query context with relation match
+   */
+  match(context, relationName, predicate) {
+    const result = this.createService(context).match(relationName, predicate);
+    return { state: result.state, hydration: result.hydration };
+  }
+  /**
+   * Joins a relation to the query
+   * @param context - Current query context
+   * @param relationName - Name of the relation to join
+   * @param joinKind - Type of join to use
+   * @param extraCondition - Additional join condition
+   * @returns Updated query context with relation join
+   */
+  joinRelation(context, relationName, joinKind, extraCondition) {
+    const result = this.createService(context).joinRelation(relationName, joinKind, extraCondition);
+    return { state: result.state, hydration: result.hydration };
+  }
+  /**
+   * Includes a relation in the query result
+   * @param context - Current query context
+   * @param relationName - Name of the relation to include
+   * @param options - Options for relation inclusion
+   * @returns Updated query context with included relation
+   */
+  include(context, relationName, options) {
+    const result = this.createService(context).include(relationName, options);
+    return { state: result.state, hydration: result.hydration };
+  }
+  /**
+   * Applies relation correlation to a query AST
+   * @param context - Current query context
+   * @param relationName - Name of the relation
+   * @param ast - Query AST to modify
+   * @returns Modified query AST with relation correlation
+   */
+  applyRelationCorrelation(context, relationName, ast) {
+    return this.createService(context).applyRelationCorrelation(relationName, ast);
+  }
+  /**
+   * Creates a relation service instance
+   * @param context - Current query context
+   * @returns Relation service instance
+   */
+  createService(context) {
+    return this.env.deps.createRelationService(this.env.table, context.state, context.hydration);
+  }
+};
+
+// src/orm/hydration.ts
+var hydrateRows = (rows, plan) => {
+  if (!plan || !rows.length) return rows;
+  const rootMap = /* @__PURE__ */ new Map();
+  const relationIndex = /* @__PURE__ */ new Map();
+  const getOrCreateParent = (row) => {
+    const rootId = row[plan.rootPrimaryKey];
+    if (rootId === void 0) return void 0;
+    if (!rootMap.has(rootId)) {
+      rootMap.set(rootId, createBaseRow(row, plan));
+    }
+    return rootMap.get(rootId);
+  };
+  const getRelationSeenSet = (rootId, relationName) => {
+    let byRelation = relationIndex.get(rootId);
+    if (!byRelation) {
+      byRelation = {};
+      relationIndex.set(rootId, byRelation);
+    }
+    let seen = byRelation[relationName];
+    if (!seen) {
+      seen = /* @__PURE__ */ new Set();
+      byRelation[relationName] = seen;
+    }
+    return seen;
+  };
+  for (const row of rows) {
+    const rootId = row[plan.rootPrimaryKey];
+    if (rootId === void 0) continue;
+    const parent = getOrCreateParent(row);
+    if (!parent) continue;
+    for (const rel of plan.relations) {
+      const childPkKey = makeRelationAlias(rel.aliasPrefix, rel.targetPrimaryKey);
+      const childPk = row[childPkKey];
+      if (childPk === null || childPk === void 0) continue;
+      const seen = getRelationSeenSet(rootId, rel.name);
+      if (seen.has(childPk)) continue;
+      seen.add(childPk);
+      const bucket = parent[rel.name];
+      bucket.push(buildChild(row, rel));
+    }
+  }
+  return Array.from(rootMap.values());
+};
+var createBaseRow = (row, plan) => {
+  const base = {};
+  const baseKeys = plan.rootColumns.length ? plan.rootColumns : Object.keys(row).filter((k) => !isRelationAlias(k));
+  for (const key of baseKeys) {
+    base[key] = row[key];
+  }
+  for (const rel of plan.relations) {
+    base[rel.name] = [];
+  }
+  return base;
+};
+var buildChild = (row, rel) => {
+  const child = {};
+  for (const col2 of rel.columns) {
+    const key = makeRelationAlias(rel.aliasPrefix, col2);
+    child[col2] = row[key];
+  }
+  const pivot = buildPivot(row, rel);
+  if (pivot) {
+    child._pivot = pivot;
+  }
+  return child;
+};
+var buildPivot = (row, rel) => {
+  if (!rel.pivot) return void 0;
+  const pivot = {};
+  for (const col2 of rel.pivot.columns) {
+    const key = makeRelationAlias(rel.pivot.aliasPrefix, col2);
+    pivot[col2] = row[key];
+  }
+  const hasValue = Object.values(pivot).some((v) => v !== null && v !== void 0);
+  return hasValue ? pivot : void 0;
+};
+
+// src/orm/entity-meta.ts
+var ENTITY_META = Symbol("EntityMeta");
+var toKey = (value) => value === null || value === void 0 ? "" : String(value);
+var getHydrationRows = (meta, relationName, key) => {
+  const map = meta.relationHydration.get(relationName);
+  if (!map) return void 0;
+  const rows = map.get(toKey(key));
+  if (!rows) return void 0;
+  return Array.isArray(rows) ? rows : void 0;
+};
+var getHydrationRecord = (meta, relationName, key) => {
+  const map = meta.relationHydration.get(relationName);
+  if (!map) return void 0;
+  const value = map.get(toKey(key));
+  if (!value) return void 0;
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+};
+var getEntityMeta = (entity) => {
+  if (!entity || typeof entity !== "object") return void 0;
+  return entity[ENTITY_META];
+};
+var hasEntityMeta = (entity) => {
+  return Boolean(getEntityMeta(entity));
+};
+
+// src/orm/relations/has-many.ts
+var toKey2 = (value) => value === null || value === void 0 ? "" : String(value);
+var DefaultHasManyCollection = class {
+  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
+    this.ctx = ctx;
+    this.meta = meta;
+    this.root = root;
+    this.relationName = relationName;
+    this.relation = relation;
+    this.rootTable = rootTable;
+    this.loader = loader;
+    this.createEntity = createEntity;
+    this.localKey = localKey;
+    this.loaded = false;
+    this.items = [];
+    this.added = /* @__PURE__ */ new Set();
+    this.removed = /* @__PURE__ */ new Set();
+    this.hydrateFromCache();
+  }
+  async load() {
+    if (this.loaded) return this.items;
+    const map = await this.loader();
+    const key = toKey2(this.root[this.localKey]);
+    const rows = map.get(key) ?? [];
+    this.items = rows.map((row) => this.createEntity(row));
+    this.loaded = true;
+    return this.items;
+  }
+  getItems() {
+    return this.items;
+  }
+  add(data) {
+    const keyValue = this.root[this.localKey];
+    const childRow = {
+      ...data,
+      [this.relation.foreignKey]: keyValue
+    };
+    const entity = this.createEntity(childRow);
+    this.added.add(entity);
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "add", entity }
+    );
+    return entity;
+  }
+  attach(entity) {
+    const keyValue = this.root[this.localKey];
+    entity[this.relation.foreignKey] = keyValue;
+    this.ctx.markDirty(entity);
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "attach", entity }
+    );
+  }
+  remove(entity) {
+    this.items = this.items.filter((item) => item !== entity);
+    this.removed.add(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "remove", entity }
+    );
+  }
+  clear() {
+    for (const entity of [...this.items]) {
+      this.remove(entity);
+    }
+  }
+  get relationKey() {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+  hydrateFromCache() {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === void 0 || keyValue === null) return;
+    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
+    if (!rows?.length) return;
+    this.items = rows.map((row) => this.createEntity(row));
+    this.loaded = true;
+  }
+};
+
+// src/orm/relations/belongs-to.ts
+var toKey3 = (value) => value === null || value === void 0 ? "" : String(value);
+var DefaultBelongsToReference = class {
+  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, targetKey) {
+    this.ctx = ctx;
+    this.meta = meta;
+    this.root = root;
+    this.relationName = relationName;
+    this.relation = relation;
+    this.rootTable = rootTable;
+    this.loader = loader;
+    this.createEntity = createEntity;
+    this.targetKey = targetKey;
+    this.loaded = false;
+    this.current = null;
+    this.populateFromHydrationCache();
+  }
+  async load() {
+    if (this.loaded) return this.current;
+    const map = await this.loader();
+    const fkValue = this.root[this.relation.foreignKey];
+    if (fkValue === null || fkValue === void 0) {
+      this.current = null;
+    } else {
+      const row = map.get(toKey3(fkValue));
+      this.current = row ? this.createEntity(row) : null;
+    }
+    this.loaded = true;
+    return this.current;
+  }
+  get() {
+    return this.current;
+  }
+  set(data) {
+    if (data === null) {
+      const previous = this.current;
+      this.root[this.relation.foreignKey] = null;
+      this.current = null;
+      this.ctx.registerRelationChange(
+        this.root,
+        this.relationKey,
+        this.rootTable,
+        this.relationName,
+        this.relation,
+        { kind: "remove", entity: previous }
+      );
+      return null;
+    }
+    const entity = hasEntityMeta(data) ? data : this.createEntity(data);
+    const pkValue = entity[this.targetKey];
+    if (pkValue !== void 0) {
+      this.root[this.relation.foreignKey] = pkValue;
+    }
+    this.current = entity;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "attach", entity }
+    );
+    return entity;
+  }
+  get relationKey() {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+  populateFromHydrationCache() {
+    const fkValue = this.root[this.relation.foreignKey];
+    if (fkValue === void 0 || fkValue === null) return;
+    const row = getHydrationRecord(this.meta, this.relationName, fkValue);
+    if (!row) return;
+    this.current = this.createEntity(row);
+    this.loaded = true;
+  }
+};
+
+// src/orm/relations/many-to-many.ts
+var toKey4 = (value) => value === null || value === void 0 ? "" : String(value);
+var DefaultManyToManyCollection = class {
+  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
+    this.ctx = ctx;
+    this.meta = meta;
+    this.root = root;
+    this.relationName = relationName;
+    this.relation = relation;
+    this.rootTable = rootTable;
+    this.loader = loader;
+    this.createEntity = createEntity;
+    this.localKey = localKey;
+    this.loaded = false;
+    this.items = [];
+    this.hydrateFromCache();
+  }
+  async load() {
+    if (this.loaded) return this.items;
+    const map = await this.loader();
+    const key = toKey4(this.root[this.localKey]);
+    const rows = map.get(key) ?? [];
+    this.items = rows.map((row) => {
+      const entity = this.createEntity(row);
+      if (row._pivot) {
+        entity._pivot = row._pivot;
+      }
+      return entity;
+    });
+    this.loaded = true;
+    return this.items;
+  }
+  getItems() {
+    return this.items;
+  }
+  attach(target) {
+    const entity = this.ensureEntity(target);
+    const id = this.extractId(entity);
+    if (id == null) return;
+    if (this.items.some((item) => this.extractId(item) === id)) {
+      return;
+    }
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "attach", entity }
+    );
+  }
+  detach(target) {
+    const id = typeof target === "number" || typeof target === "string" ? target : this.extractId(target);
+    if (id == null) return;
+    const existing = this.items.find((item) => this.extractId(item) === id);
+    if (!existing) return;
+    this.items = this.items.filter((item) => this.extractId(item) !== id);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "detach", entity: existing }
+    );
+  }
+  async syncByIds(ids) {
+    await this.load();
+    const targetKey = this.relation.targetKey || findPrimaryKey(this.relation.target);
+    const normalized = new Set(ids.map((id) => toKey4(id)));
+    const currentIds = new Set(this.items.map((item) => toKey4(this.extractId(item))));
+    for (const id of normalized) {
+      if (!currentIds.has(id)) {
+        this.attach(id);
+      }
+    }
+    for (const item of [...this.items]) {
+      const itemId = toKey4(this.extractId(item));
+      if (!normalized.has(itemId)) {
+        this.detach(item);
+      }
+    }
+  }
+  ensureEntity(target) {
+    if (typeof target === "number" || typeof target === "string") {
+      const stub = {
+        [this.targetKey]: target
+      };
+      return this.createEntity(stub);
+    }
+    return target;
+  }
+  extractId(entity) {
+    if (entity === null || entity === void 0) return null;
+    if (typeof entity === "number" || typeof entity === "string") {
+      return entity;
+    }
+    return entity[this.targetKey] ?? null;
+  }
+  get relationKey() {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+  get targetKey() {
+    return this.relation.targetKey || findPrimaryKey(this.relation.target);
+  }
+  hydrateFromCache() {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === void 0 || keyValue === null) return;
+    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
+    if (!rows?.length) return;
+    this.items = rows.map((row) => {
+      const entity = this.createEntity(row);
+      if (row._pivot) {
+        entity._pivot = row._pivot;
+      }
+      return entity;
+    });
+    this.loaded = true;
+  }
+};
+
+// src/orm/lazy-batch.ts
+var selectAllColumns = (table) => Object.entries(table.columns).reduce((acc, [name, def]) => {
+  acc[name] = def;
+  return acc;
+}, {});
+var rowsFromResults = (results) => {
+  const rows = [];
+  for (const result of results) {
+    const { columns, values } = result;
+    for (const valueRow of values) {
+      const row = {};
+      columns.forEach((column, idx) => {
+        row[column] = valueRow[idx];
+      });
+      rows.push(row);
+    }
+  }
+  return rows;
+};
+var executeQuery = async (ctx, qb) => {
+  const compiled = ctx.dialect.compileSelect(qb.getAST());
+  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
+  return rowsFromResults(results);
+};
+var toKey5 = (value) => value === null || value === void 0 ? "" : String(value);
+var loadHasManyRelation = async (ctx, rootTable, _relationName, relation) => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = /* @__PURE__ */ new Set();
+  for (const tracked of roots) {
+    const value = tracked.entity[localKey];
+    if (value !== null && value !== void 0) {
+      keys.add(value);
+    }
+  }
+  if (!keys.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const selectMap = selectAllColumns(relation.target);
+  const fb = new SelectQueryBuilder(relation.target).select(selectMap);
+  const fkColumn = relation.target.columns[relation.foreignKey];
+  if (!fkColumn) return /* @__PURE__ */ new Map();
+  fb.where(inList(fkColumn, Array.from(keys)));
+  const rows = await executeQuery(ctx, fb);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const fkValue = row[relation.foreignKey];
+    if (fkValue === null || fkValue === void 0) continue;
+    const key = toKey5(fkValue);
+    const bucket = grouped.get(key) ?? [];
+    bucket.push(row);
+    grouped.set(key, bucket);
+  }
+  return grouped;
+};
+var loadBelongsToRelation = async (ctx, rootTable, _relationName, relation) => {
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const foreignKeys = /* @__PURE__ */ new Set();
+  for (const tracked of roots) {
+    const value = tracked.entity[relation.foreignKey];
+    if (value !== null && value !== void 0) {
+      foreignKeys.add(value);
+    }
+  }
+  if (!foreignKeys.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const selectMap = selectAllColumns(relation.target);
+  const qb = new SelectQueryBuilder(relation.target).select(selectMap);
+  const targetKey = relation.localKey || findPrimaryKey(relation.target);
+  const pkColumn = relation.target.columns[targetKey];
+  if (!pkColumn) return /* @__PURE__ */ new Map();
+  qb.where(inList(pkColumn, Array.from(foreignKeys)));
+  const rows = await executeQuery(ctx, qb);
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const keyValue = row[targetKey];
+    if (keyValue === null || keyValue === void 0) continue;
+    map.set(toKey5(keyValue), row);
+  }
+  return map;
+};
+var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation) => {
+  const rootKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const rootIds = /* @__PURE__ */ new Set();
+  for (const tracked of roots) {
+    const value = tracked.entity[rootKey];
+    if (value !== null && value !== void 0) {
+      rootIds.add(value);
+    }
+  }
+  if (!rootIds.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const pivotSelect = selectAllColumns(relation.pivotTable);
+  const pivotQb = new SelectQueryBuilder(relation.pivotTable).select(pivotSelect);
+  const pivotFkCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+  if (!pivotFkCol) return /* @__PURE__ */ new Map();
+  pivotQb.where(inList(pivotFkCol, Array.from(rootIds)));
+  const pivotRows = await executeQuery(ctx, pivotQb);
+  const rootLookup = /* @__PURE__ */ new Map();
+  const targetIds = /* @__PURE__ */ new Set();
+  for (const pivot of pivotRows) {
+    const rootValue = pivot[relation.pivotForeignKeyToRoot];
+    const targetValue = pivot[relation.pivotForeignKeyToTarget];
+    if (rootValue === null || rootValue === void 0 || targetValue === null || targetValue === void 0) {
+      continue;
+    }
+    const bucket = rootLookup.get(toKey5(rootValue)) ?? [];
+    bucket.push({
+      targetId: targetValue,
+      pivot: { ...pivot }
+    });
+    rootLookup.set(toKey5(rootValue), bucket);
+    targetIds.add(targetValue);
+  }
+  if (!targetIds.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const targetSelect = selectAllColumns(relation.target);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const targetPkColumn = relation.target.columns[targetKey];
+  if (!targetPkColumn) return /* @__PURE__ */ new Map();
+  const targetQb = new SelectQueryBuilder(relation.target).select(targetSelect);
+  targetQb.where(inList(targetPkColumn, Array.from(targetIds)));
+  const targetRows = await executeQuery(ctx, targetQb);
+  const targetMap = /* @__PURE__ */ new Map();
+  for (const row of targetRows) {
+    const pkValue = row[targetKey];
+    if (pkValue === null || pkValue === void 0) continue;
+    targetMap.set(toKey5(pkValue), row);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [rootId, entries] of rootLookup.entries()) {
+    const bucket = [];
+    for (const entry of entries) {
+      const targetRow = targetMap.get(toKey5(entry.targetId));
+      if (!targetRow) continue;
+      bucket.push({
+        ...targetRow,
+        _pivot: entry.pivot
+      });
+    }
+    result.set(rootId, bucket);
+  }
+  return result;
+};
+
+// src/orm/entity.ts
+var relationLoaderCache = (meta, relationName, factory) => {
+  if (meta.relationCache.has(relationName)) {
+    return meta.relationCache.get(relationName);
+  }
+  const promise = factory().then((value) => {
+    for (const tracked of meta.ctx.getEntitiesForTable(meta.table)) {
+      const otherMeta = getEntityMeta(tracked.entity);
+      if (!otherMeta) continue;
+      otherMeta.relationHydration.set(relationName, value);
+    }
+    return value;
+  });
+  meta.relationCache.set(relationName, promise);
+  for (const tracked of meta.ctx.getEntitiesForTable(meta.table)) {
+    const otherMeta = getEntityMeta(tracked.entity);
+    if (!otherMeta) continue;
+    otherMeta.relationCache.set(relationName, promise);
+  }
+  return promise;
+};
+var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
+  const target = { ...row };
+  const meta = {
+    ctx,
+    table,
+    lazyRelations: [...lazyRelations],
+    relationCache: /* @__PURE__ */ new Map(),
+    relationHydration: /* @__PURE__ */ new Map(),
+    relationWrappers: /* @__PURE__ */ new Map()
+  };
+  Object.defineProperty(target, ENTITY_META, {
+    value: meta,
+    enumerable: false,
+    writable: false
+  });
+  let proxy;
+  const handler = {
+    get(targetObj, prop, receiver) {
+      if (prop === ENTITY_META) {
+        return meta;
+      }
+      if (prop === "$load") {
+        return async (relationName) => {
+          const wrapper = getRelationWrapper(meta, relationName, proxy);
+          if (wrapper && typeof wrapper.load === "function") {
+            return wrapper.load();
+          }
+          return void 0;
+        };
+      }
+      if (typeof prop === "string" && table.relations[prop]) {
+        return getRelationWrapper(meta, prop, proxy);
+      }
+      return Reflect.get(targetObj, prop, receiver);
+    },
+    set(targetObj, prop, value, receiver) {
+      const result = Reflect.set(targetObj, prop, value, receiver);
+      if (typeof prop === "string" && table.columns[prop]) {
+        ctx.markDirty(proxy);
+      }
+      return result;
+    }
+  };
+  proxy = new Proxy(target, handler);
+  populateHydrationCache(proxy, row, meta);
+  return proxy;
+};
+var createEntityFromRow = (ctx, table, row, lazyRelations = []) => {
+  const pkName = findPrimaryKey(table);
+  const pkValue = row[pkName];
+  if (pkValue !== void 0 && pkValue !== null) {
+    const tracked = ctx.getEntity(table, pkValue);
+    if (tracked) return tracked;
+  }
+  const entity = createEntityProxy(ctx, table, row, lazyRelations);
+  if (pkValue !== void 0 && pkValue !== null) {
+    ctx.trackManaged(table, pkValue, entity);
+  } else {
+    ctx.trackNew(table, entity);
+  }
+  return entity;
+};
+var toKey6 = (value) => value === null || value === void 0 ? "" : String(value);
+var populateHydrationCache = (entity, row, meta) => {
+  for (const relationName of Object.keys(meta.table.relations)) {
+    const relation = meta.table.relations[relationName];
+    const data = row[relationName];
+    if (!Array.isArray(data)) continue;
+    if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
+      const localKey = relation.localKey || findPrimaryKey(meta.table);
+      const rootValue = entity[localKey];
+      if (rootValue === void 0 || rootValue === null) continue;
+      const cache = /* @__PURE__ */ new Map();
+      cache.set(toKey6(rootValue), data);
+      meta.relationHydration.set(relationName, cache);
+      meta.relationCache.set(relationName, Promise.resolve(cache));
+      continue;
+    }
+    if (relation.type === RelationKinds.BelongsTo) {
+      const targetKey = relation.localKey || findPrimaryKey(relation.target);
+      const cache = /* @__PURE__ */ new Map();
+      for (const item of data) {
+        const pkValue = item[targetKey];
+        if (pkValue === void 0 || pkValue === null) continue;
+        cache.set(toKey6(pkValue), item);
+      }
+      if (cache.size) {
+        meta.relationHydration.set(relationName, cache);
+        meta.relationCache.set(relationName, Promise.resolve(cache));
+      }
+    }
+  }
+};
+var getRelationWrapper = (meta, relationName, owner) => {
+  if (meta.relationWrappers.has(relationName)) {
+    return meta.relationWrappers.get(relationName);
+  }
+  const relation = meta.table.relations[relationName];
+  if (!relation) return void 0;
+  const wrapper = instantiateWrapper(meta, relationName, relation, owner);
+  if (wrapper) {
+    meta.relationWrappers.set(relationName, wrapper);
+  }
+  return wrapper;
+};
+var instantiateWrapper = (meta, relationName, relation, owner) => {
+  switch (relation.type) {
+    case RelationKinds.HasMany: {
+      const hasMany2 = relation;
+      const localKey = hasMany2.localKey || findPrimaryKey(meta.table);
+      const loader = () => relationLoaderCache(
+        meta,
+        relationName,
+        () => loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany2)
+      );
+      return new DefaultHasManyCollection(
+        meta.ctx,
+        meta,
+        owner,
+        relationName,
+        hasMany2,
+        meta.table,
+        loader,
+        (row) => createEntityFromRow(meta.ctx, relation.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.BelongsTo: {
+      const belongsTo2 = relation;
+      const targetKey = belongsTo2.localKey || findPrimaryKey(belongsTo2.target);
+      const loader = () => relationLoaderCache(
+        meta,
+        relationName,
+        () => loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo2)
+      );
+      return new DefaultBelongsToReference(
+        meta.ctx,
+        meta,
+        owner,
+        relationName,
+        belongsTo2,
+        meta.table,
+        loader,
+        (row) => createEntityFromRow(meta.ctx, relation.target, row),
+        targetKey
+      );
+    }
+    case RelationKinds.BelongsToMany: {
+      const many = relation;
+      const localKey = many.localKey || findPrimaryKey(meta.table);
+      const loader = () => relationLoaderCache(
+        meta,
+        relationName,
+        () => loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many)
+      );
+      return new DefaultManyToManyCollection(
+        meta.ctx,
+        meta,
+        owner,
+        relationName,
+        many,
+        meta.table,
+        loader,
+        (row) => createEntityFromRow(meta.ctx, relation.target, row),
+        localKey
+      );
+    }
+    default:
+      return void 0;
+  }
+};
+
+// src/orm/execute.ts
+var flattenResults = (results) => {
+  const rows = [];
+  for (const result of results) {
+    const { columns, values } = result;
+    for (const valueRow of values) {
+      const row = {};
+      columns.forEach((column, idx) => {
+        row[column] = valueRow[idx];
+      });
+      rows.push(row);
+    }
+  }
+  return rows;
+};
+async function executeHydrated(ctx, qb) {
+  const compiled = ctx.dialect.compileSelect(qb.getAST());
+  const executed = await ctx.executor.executeSql(compiled.sql, compiled.params);
+  const rows = flattenResults(executed);
+  const hydrated = hydrateRows(rows, qb.getHydrationPlan());
+  return hydrated.map(
+    (row) => createEntityFromRow(ctx, qb.getTable(), row, qb.getLazyRelations())
+  );
+}
+
+// src/query-builder/select.ts
+var SelectQueryBuilder = class _SelectQueryBuilder {
+  /**
+   * Creates a new SelectQueryBuilder instance
+   * @param table - Table definition to query
+   * @param state - Optional initial query state
+   * @param hydration - Optional hydration manager
+   * @param dependencies - Optional query builder dependencies
+   */
+  constructor(table, state, hydration, dependencies, lazyRelations) {
+    const deps = resolveSelectQueryBuilderDependencies(dependencies);
+    this.env = { table, deps };
+    const initialState = state ?? deps.createState(table);
+    const initialHydration = hydration ?? deps.createHydration(table);
+    this.context = {
+      state: initialState,
+      hydration: initialHydration
+    };
+    this.lazyRelations = new Set(lazyRelations ?? []);
+    this.columnSelector = new ColumnSelector(this.env);
+    this.relationManager = new RelationManager(this.env);
+  }
+  clone(context = this.context, lazyRelations = new Set(this.lazyRelations)) {
+    return new _SelectQueryBuilder(this.env.table, context.state, context.hydration, this.env.deps, lazyRelations);
+  }
+  resolveQueryNode(query) {
+    return typeof query.getAST === "function" ? query.getAST() : query;
+  }
+  createChildBuilder(table) {
+    return new _SelectQueryBuilder(table, void 0, void 0, this.env.deps);
+  }
+  applyAst(context, mutator) {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = mutator(astService);
+    return { state: nextState, hydration: context.hydration };
+  }
+  applyJoin(context, table, condition, kind) {
+    const joinNode = createJoinNode(kind, table.name, condition);
+    return this.applyAst(context, (service) => service.withJoin(joinNode));
+  }
+  /**
+   * Selects specific columns for the query
+   * @param columns - Record of column definitions, function nodes, case expressions, or window functions
+   * @returns New query builder instance with selected columns
+   */
+  select(columns) {
+    return this.clone(this.columnSelector.select(this.context, columns));
+  }
+  /**
+   * Selects raw column expressions
+   * @param cols - Column expressions as strings
+   * @returns New query builder instance with raw column selections
+   */
+  selectRaw(...cols) {
+    return this.clone(this.columnSelector.selectRaw(this.context, cols));
+  }
+  /**
+   * Adds a Common Table Expression (CTE) to the query
+   * @param name - Name of the CTE
+   * @param query - Query builder or query node for the CTE
+   * @param columns - Optional column names for the CTE
+   * @returns New query builder instance with the CTE
+   */
+  with(name, query, columns) {
+    const subAst = this.resolveQueryNode(query);
+    const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, false));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a recursive Common Table Expression (CTE) to the query
+   * @param name - Name of the CTE
+   * @param query - Query builder or query node for the CTE
+   * @param columns - Optional column names for the CTE
+   * @returns New query builder instance with the recursive CTE
+   */
+  withRecursive(name, query, columns) {
+    const subAst = this.resolveQueryNode(query);
+    const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, true));
+    return this.clone(nextContext);
+  }
+  /**
+   * Selects a subquery as a column
+   * @param alias - Alias for the subquery column
+   * @param sub - Query builder or query node for the subquery
+   * @returns New query builder instance with the subquery selection
+   */
+  selectSubquery(alias, sub) {
+    const query = this.resolveQueryNode(sub);
+    return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
+  }
+  /**
+   * Adds an INNER JOIN to the query
+   * @param table - Table to join
+   * @param condition - Join condition expression
+   * @returns New query builder instance with the INNER JOIN
+   */
+  innerJoin(table, condition) {
+    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.INNER);
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a LEFT JOIN to the query
+   * @param table - Table to join
+   * @param condition - Join condition expression
+   * @returns New query builder instance with the LEFT JOIN
+   */
+  leftJoin(table, condition) {
+    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.LEFT);
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a RIGHT JOIN to the query
+   * @param table - Table to join
+   * @param condition - Join condition expression
+   * @returns New query builder instance with the RIGHT JOIN
+   */
+  rightJoin(table, condition) {
+    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.RIGHT);
+    return this.clone(nextContext);
+  }
+  /**
+   * Matches records based on a relationship
+   * @param relationName - Name of the relationship to match
+   * @param predicate - Optional predicate expression
+   * @returns New query builder instance with the relationship match
+   */
+  match(relationName, predicate) {
+    const nextContext = this.relationManager.match(this.context, relationName, predicate);
+    return this.clone(nextContext);
+  }
+  /**
+   * Joins a related table
+   * @param relationName - Name of the relationship to join
+   * @param joinKind - Type of join (defaults to INNER)
+   * @param extraCondition - Optional additional join condition
+   * @returns New query builder instance with the relationship join
+   */
+  joinRelation(relationName, joinKind = JOIN_KINDS.INNER, extraCondition) {
+    const nextContext = this.relationManager.joinRelation(this.context, relationName, joinKind, extraCondition);
+    return this.clone(nextContext);
+  }
+  /**
+   * Includes related data in the query results
+   * @param relationName - Name of the relationship to include
+   * @param options - Optional include options
+   * @returns New query builder instance with the relationship inclusion
+   */
+  include(relationName, options) {
+    const nextContext = this.relationManager.include(this.context, relationName, options);
+    return this.clone(nextContext);
+  }
+  includeLazy(relationName) {
+    const nextLazy = new Set(this.lazyRelations);
+    nextLazy.add(relationName);
+    return this.clone(this.context, nextLazy);
+  }
+  getLazyRelations() {
+    return Array.from(this.lazyRelations);
+  }
+  getTable() {
+    return this.env.table;
+  }
+  async execute(ctx) {
+    return executeHydrated(ctx, this);
+  }
+  /**
+   * Adds a WHERE condition to the query
+   * @param expr - Expression for the WHERE clause
+   * @returns New query builder instance with the WHERE condition
+   */
+  where(expr) {
+    const nextContext = this.applyAst(this.context, (service) => service.withWhere(expr));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a GROUP BY clause to the query
+   * @param col - Column definition or column node to group by
+   * @returns New query builder instance with the GROUP BY clause
+   */
+  groupBy(col2) {
+    const nextContext = this.applyAst(this.context, (service) => service.withGroupBy(col2));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a HAVING condition to the query
+   * @param expr - Expression for the HAVING clause
+   * @returns New query builder instance with the HAVING condition
+   */
+  having(expr) {
+    const nextContext = this.applyAst(this.context, (service) => service.withHaving(expr));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds an ORDER BY clause to the query
+   * @param col - Column definition or column node to order by
+   * @param direction - Order direction (defaults to ASC)
+   * @returns New query builder instance with the ORDER BY clause
+   */
+  orderBy(col2, direction = ORDER_DIRECTIONS.ASC) {
+    const nextContext = this.applyAst(this.context, (service) => service.withOrderBy(col2, direction));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a DISTINCT clause to the query
+   * @param cols - Columns to make distinct
+   * @returns New query builder instance with the DISTINCT clause
+   */
+  distinct(...cols) {
+    return this.clone(this.columnSelector.distinct(this.context, cols));
+  }
+  /**
+   * Adds a LIMIT clause to the query
+   * @param n - Maximum number of rows to return
+   * @returns New query builder instance with the LIMIT clause
+   */
+  limit(n) {
+    const nextContext = this.applyAst(this.context, (service) => service.withLimit(n));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds an OFFSET clause to the query
+   * @param n - Number of rows to skip
+   * @returns New query builder instance with the OFFSET clause
+   */
+  offset(n) {
+    const nextContext = this.applyAst(this.context, (service) => service.withOffset(n));
+    return this.clone(nextContext);
+  }
+  /**
+   * Adds a WHERE EXISTS condition to the query
+   * @param subquery - Subquery to check for existence
+   * @returns New query builder instance with the WHERE EXISTS condition
+   */
+  whereExists(subquery) {
+    const subAst = this.resolveQueryNode(subquery);
+    return this.where(exists(subAst));
+  }
+  /**
+   * Adds a WHERE NOT EXISTS condition to the query
+   * @param subquery - Subquery to check for non-existence
+   * @returns New query builder instance with the WHERE NOT EXISTS condition
+   */
+  whereNotExists(subquery) {
+    const subAst = this.resolveQueryNode(subquery);
+    return this.where(notExists(subAst));
+  }
+  /**
+   * Adds a WHERE EXISTS condition based on a relationship
+   * @param relationName - Name of the relationship to check
+   * @param callback - Optional callback to modify the relationship query
+   * @returns New query builder instance with the relationship existence check
+   */
+  whereHas(relationName, callback) {
+    const relation = this.env.table.relations[relationName];
+    if (!relation) {
+      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
+    }
+    let subQb = this.createChildBuilder(relation.target);
+    if (callback) {
+      subQb = callback(subQb);
+    }
+    const subAst = subQb.getAST();
+    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst);
+    return this.where(exists(finalSubAst));
+  }
+  /**
+   * Adds a WHERE NOT EXISTS condition based on a relationship
+   * @param relationName - Name of the relationship to check
+   * @param callback - Optional callback to modify the relationship query
+   * @returns New query builder instance with the relationship non-existence check
+   */
+  whereHasNot(relationName, callback) {
+    const relation = this.env.table.relations[relationName];
+    if (!relation) {
+      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
+    }
+    let subQb = this.createChildBuilder(relation.target);
+    if (callback) {
+      subQb = callback(subQb);
+    }
+    const subAst = subQb.getAST();
+    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst);
+    return this.where(notExists(finalSubAst));
+  }
+  /**
+   * Compiles the query to SQL for a specific dialect
+   * @param dialect - Database dialect to compile for
+   * @returns Compiled query with SQL and parameters
+   */
+  compile(dialect) {
+    return dialect.compileSelect(this.context.state.ast);
+  }
+  /**
+   * Converts the query to SQL string for a specific dialect
+   * @param dialect - Database dialect to generate SQL for
+   * @returns SQL string representation of the query
+   */
+  toSql(dialect) {
+    return this.compile(dialect).sql;
+  }
+  /**
+   * Gets the hydration plan for the query
+   * @returns Hydration plan or undefined if none exists
+   */
+  getHydrationPlan() {
+    return this.context.hydration.getPlan();
+  }
+  /**
+   * Gets the Abstract Syntax Tree (AST) representation of the query
+   * @returns Query AST with hydration applied
+   */
+  getAST() {
+    return this.context.hydration.applyToAst(this.context.state.ast);
+  }
+};
+var createColumn = (table, name) => ({ type: "Column", table, name });
+var createLiteral = (val) => ({ type: "Literal", value: val });
+
+// src/query-builder/insert-query-state.ts
+var InsertQueryState = class _InsertQueryState {
+  constructor(table, ast) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: "InsertQuery",
+      into: createTableNode(table),
+      columns: [],
+      values: []
+    };
+  }
+  clone(nextAst) {
+    return new _InsertQueryState(this.table, nextAst);
+  }
+  withValues(rows) {
+    if (!rows.length) return this;
+    const definedColumns = this.ast.columns.length ? this.ast.columns : buildColumnNodes(this.table, Object.keys(rows[0]));
+    const newRows = rows.map(
+      (row) => definedColumns.map((column) => valueToOperand(row[column.name]))
+    );
+    return this.clone({
+      ...this.ast,
+      columns: definedColumns,
+      values: [...this.ast.values, ...newRows]
+    });
+  }
+  withReturning(columns) {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+};
+
+// src/query-builder/insert.ts
+var InsertQueryBuilder = class _InsertQueryBuilder {
+  constructor(table, state) {
+    this.table = table;
+    this.state = state ?? new InsertQueryState(table);
+  }
+  clone(state) {
+    return new _InsertQueryBuilder(this.table, state);
+  }
+  values(rowOrRows) {
+    const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
+    if (!rows.length) return this;
+    return this.clone(this.state.withValues(rows));
+  }
+  returning(...columns) {
+    if (!columns.length) return this;
+    const nodes = columns.map((column) => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+  compile(compiler) {
+    return compiler.compileInsert(this.state.ast);
+  }
+  toSql(compiler) {
+    return this.compile(compiler).sql;
+  }
+  getAST() {
+    return this.state.ast;
+  }
+};
+
+// src/query-builder/update-query-state.ts
+var UpdateQueryState = class _UpdateQueryState {
+  constructor(table, ast) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: "UpdateQuery",
+      table: createTableNode(table),
+      set: []
+    };
+  }
+  clone(nextAst) {
+    return new _UpdateQueryState(this.table, nextAst);
+  }
+  withSet(values) {
+    const assignments = Object.entries(values).map(([column, value]) => ({
+      column: {
+        type: "Column",
+        table: this.table.name,
+        name: column
+      },
+      value: valueToOperand(value)
+    }));
+    return this.clone({
+      ...this.ast,
+      set: assignments
+    });
+  }
+  withWhere(expr) {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+  withReturning(columns) {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+};
+
+// src/query-builder/update.ts
+var UpdateQueryBuilder = class _UpdateQueryBuilder {
+  constructor(table, state) {
+    this.table = table;
+    this.state = state ?? new UpdateQueryState(table);
+  }
+  clone(state) {
+    return new _UpdateQueryBuilder(this.table, state);
+  }
+  set(values) {
+    return this.clone(this.state.withSet(values));
+  }
+  where(expr) {
+    return this.clone(this.state.withWhere(expr));
+  }
+  returning(...columns) {
+    if (!columns.length) return this;
+    const nodes = columns.map((column) => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+  compile(compiler) {
+    return compiler.compileUpdate(this.state.ast);
+  }
+  toSql(compiler) {
+    return this.compile(compiler).sql;
+  }
+  getAST() {
+    return this.state.ast;
+  }
+};
+
+// src/query-builder/delete-query-state.ts
+var DeleteQueryState = class _DeleteQueryState {
+  constructor(table, ast) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: "DeleteQuery",
+      from: createTableNode(table)
+    };
+  }
+  clone(nextAst) {
+    return new _DeleteQueryState(this.table, nextAst);
+  }
+  withWhere(expr) {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+  withReturning(columns) {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+};
+
+// src/query-builder/delete.ts
+var DeleteQueryBuilder = class _DeleteQueryBuilder {
+  constructor(table, state) {
+    this.table = table;
+    this.state = state ?? new DeleteQueryState(table);
+  }
+  clone(state) {
+    return new _DeleteQueryBuilder(this.table, state);
+  }
+  where(expr) {
+    return this.clone(this.state.withWhere(expr));
+  }
+  returning(...columns) {
+    if (!columns.length) return this;
+    const nodes = columns.map((column) => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+  compile(compiler) {
+    return compiler.compileDelete(this.state.ast);
+  }
+  toSql(compiler) {
+    return this.compile(compiler).sql;
+  }
+  getAST() {
+    return this.state.ast;
+  }
+};
+
+// src/core/dialect/abstract.ts
+var Dialect = class {
+  /**
+   * Compiles a SELECT query AST to SQL
+   * @param ast - Query AST to compile
+   * @returns Compiled query with SQL and parameters
+   */
+  compileSelect(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileSelectAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+  compileInsert(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileInsertAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+  compileUpdate(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileUpdateAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+  compileDelete(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileDeleteAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+  /**
+   * Compiles a WHERE clause
+   * @param where - WHERE expression
+   * @param ctx - Compiler context
+   * @returns SQL WHERE clause or empty string
+   */
+  compileWhere(where, ctx) {
+    if (!where) return "";
+    return ` WHERE ${this.compileExpression(where, ctx)}`;
+  }
+  compileReturning(returning, ctx) {
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  /**
+   * Generates subquery for EXISTS expressions
+   * Rule: Always forces SELECT 1, ignoring column list
+   * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
+   * Does not add ';' at the end
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns SQL for EXISTS subquery
+   */
+  compileSelectForExists(ast, ctx) {
+    const full = this.compileSelectAst(ast, ctx).trim().replace(/;$/, "");
+    const upper = full.toUpperCase();
+    const fromIndex = upper.indexOf(" FROM ");
+    if (fromIndex === -1) {
+      return full;
+    }
+    const tail = full.slice(fromIndex);
+    return `SELECT 1${tail}`;
+  }
+  /**
+   * Creates a new compiler context
+   * @returns Compiler context with parameter management
+   */
+  createCompilerContext() {
+    const params = [];
+    let counter = 0;
+    return {
+      params,
+      addParameter: (value) => {
+        counter += 1;
+        params.push(value);
+        return this.formatPlaceholder(counter);
+      }
+    };
+  }
+  /**
+   * Formats a parameter placeholder
+   * @param index - Parameter index
+   * @returns Formatted placeholder string
+   */
+  formatPlaceholder(index) {
+    return "?";
+  }
+  constructor() {
+    this.expressionCompilers = /* @__PURE__ */ new Map();
+    this.operandCompilers = /* @__PURE__ */ new Map();
+    this.registerDefaultOperandCompilers();
+    this.registerDefaultExpressionCompilers();
+  }
+  /**
+   * Registers an expression compiler for a specific node type
+   * @param type - Expression node type
+   * @param compiler - Compiler function
+   */
+  registerExpressionCompiler(type, compiler) {
+    this.expressionCompilers.set(type, compiler);
+  }
+  /**
+   * Registers an operand compiler for a specific node type
+   * @param type - Operand node type
+   * @param compiler - Compiler function
+   */
+  registerOperandCompiler(type, compiler) {
+    this.operandCompilers.set(type, compiler);
+  }
+  /**
+   * Compiles an expression node
+   * @param node - Expression node to compile
+   * @param ctx - Compiler context
+   * @returns Compiled SQL expression
+   */
+  compileExpression(node, ctx) {
+    const compiler = this.expressionCompilers.get(node.type);
+    if (!compiler) {
+      throw new Error(`Unsupported expression node type "${node.type}" for ${this.constructor.name}`);
+    }
+    return compiler(node, ctx);
+  }
+  /**
+   * Compiles an operand node
+   * @param node - Operand node to compile
+   * @param ctx - Compiler context
+   * @returns Compiled SQL operand
+   */
+  compileOperand(node, ctx) {
+    const compiler = this.operandCompilers.get(node.type);
+    if (!compiler) {
+      throw new Error(`Unsupported operand node type "${node.type}" for ${this.constructor.name}`);
+    }
+    return compiler(node, ctx);
+  }
+  registerDefaultExpressionCompilers() {
+    this.registerExpressionCompiler("BinaryExpression", (binary, ctx) => {
+      const left = this.compileOperand(binary.left, ctx);
+      const right = this.compileOperand(binary.right, ctx);
+      const base = `${left} ${binary.operator} ${right}`;
+      if (binary.escape) {
+        const escapeOperand = this.compileOperand(binary.escape, ctx);
+        return `${base} ESCAPE ${escapeOperand}`;
+      }
+      return base;
+    });
+    this.registerExpressionCompiler("LogicalExpression", (logical, ctx) => {
+      if (logical.operands.length === 0) return "";
+      const parts = logical.operands.map((op) => {
+        const compiled = this.compileExpression(op, ctx);
+        return op.type === "LogicalExpression" ? `(${compiled})` : compiled;
+      });
+      return parts.join(` ${logical.operator} `);
+    });
+    this.registerExpressionCompiler("NullExpression", (nullExpr, ctx) => {
+      const left = this.compileOperand(nullExpr.left, ctx);
+      return `${left} ${nullExpr.operator}`;
+    });
+    this.registerExpressionCompiler("InExpression", (inExpr, ctx) => {
+      const left = this.compileOperand(inExpr.left, ctx);
+      const values = inExpr.right.map((v) => this.compileOperand(v, ctx)).join(", ");
+      return `${left} ${inExpr.operator} (${values})`;
+    });
+    this.registerExpressionCompiler("ExistsExpression", (existsExpr, ctx) => {
+      const subquerySql = this.compileSelectForExists(existsExpr.subquery, ctx);
+      return `${existsExpr.operator} (${subquerySql})`;
+    });
+    this.registerExpressionCompiler("BetweenExpression", (betweenExpr, ctx) => {
+      const left = this.compileOperand(betweenExpr.left, ctx);
+      const lower = this.compileOperand(betweenExpr.lower, ctx);
+      const upper = this.compileOperand(betweenExpr.upper, ctx);
+      return `${left} ${betweenExpr.operator} ${lower} AND ${upper}`;
+    });
+  }
+  registerDefaultOperandCompilers() {
+    this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
+    this.registerOperandCompiler("Column", (column, _ctx) => {
+      return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
+    });
+    this.registerOperandCompiler("Function", (fnNode, ctx) => {
+      const args = fnNode.args.map((arg) => this.compileOperand(arg, ctx)).join(", ");
+      return `${fnNode.name}(${args})`;
+    });
+    this.registerOperandCompiler("JsonPath", (path, _ctx) => this.compileJsonPath(path));
+    this.registerOperandCompiler("ScalarSubquery", (node, ctx) => {
+      const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
+      return `(${sql})`;
+    });
+    this.registerOperandCompiler("CaseExpression", (node, ctx) => {
+      const parts = ["CASE"];
+      for (const { when, then } of node.conditions) {
+        parts.push(`WHEN ${this.compileExpression(when, ctx)} THEN ${this.compileOperand(then, ctx)}`);
+      }
+      if (node.else) {
+        parts.push(`ELSE ${this.compileOperand(node.else, ctx)}`);
+      }
+      parts.push("END");
+      return parts.join(" ");
+    });
+    this.registerOperandCompiler("WindowFunction", (node, ctx) => {
+      let result = `${node.name}(`;
+      if (node.args.length > 0) {
+        result += node.args.map((arg) => this.compileOperand(arg, ctx)).join(", ");
+      }
+      result += ") OVER (";
+      const parts = [];
+      if (node.partitionBy && node.partitionBy.length > 0) {
+        const partitionClause = "PARTITION BY " + node.partitionBy.map(
+          (col2) => `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`
+        ).join(", ");
+        parts.push(partitionClause);
+      }
+      if (node.orderBy && node.orderBy.length > 0) {
+        const orderClause = "ORDER BY " + node.orderBy.map(
+          (o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`
+        ).join(", ");
+        parts.push(orderClause);
+      }
+      result += parts.join(" ");
+      result += ")";
+      return result;
+    });
+  }
+  // Default fallback, should be overridden by dialects if supported
+  compileJsonPath(node) {
+    throw new Error("JSON Path not supported by this dialect");
+  }
+};
+
+// src/core/dialect/mysql/index.ts
+var MySqlDialect = class extends Dialect {
+  /**
+   * Creates a new MySqlDialect instance
+   */
+  constructor() {
+    super();
+  }
+  /**
+   * Quotes an identifier using MySQL backtick syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id) {
+    return `\`${id}\``;
+  }
+  /**
+   * Compiles JSON path expression using MySQL syntax
+   * @param node - JSON path node
+   * @returns MySQL JSON path expression
+   */
+  compileJsonPath(node) {
+    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${col2}->'${node.path}'`;
+  }
+  /**
+   * Compiles SELECT query AST to MySQL SQL
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns MySQL SQL string
+   */
+  compileSelectAst(ast, ctx) {
+    const columns = ast.columns.map((c) => {
+      let expr = "";
+      if (c.type === "Function") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "Column") {
+        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
+      } else if (c.type === "ScalarSubquery") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "WindowFunction") {
+        expr = this.compileOperand(c, ctx);
+      }
+      if (c.alias) {
+        if (c.alias.includes("(")) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(", ");
+    const distinct = ast.distinct ? "DISTINCT " : "";
+    const from = `${this.quoteIdentifier(ast.from.name)}`;
+    const joins = ast.joins.map((j) => {
+      const table = this.quoteIdentifier(j.table.name);
+      const cond = this.compileExpression(j.condition, ctx);
+      return `${j.kind} JOIN ${table} ON ${cond}`;
+    }).join(" ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
+    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
+    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
+    const limit = ast.limit ? ` LIMIT ${ast.limit}` : "";
+    const offset = ast.offset ? ` OFFSET ${ast.offset}` : "";
+    const ctes = ast.ctes && ast.ctes.length > 0 ? (() => {
+      const hasRecursive = ast.ctes.some((cte) => cte.recursive);
+      const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
+      const cteDefs = ast.ctes.map((cte) => {
+        const name = this.quoteIdentifier(cte.name);
+        const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+        const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
+        return `${name}${cols} AS (${query})`;
+      }).join(", ");
+      return prefix + cteDefs + " ";
+    })() : "";
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+  compileInsertAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+  compileUpdateAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map((assignment) => {
+      const col2 = assignment.column;
+      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+  compileDeleteAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
+};
+
+// src/core/dialect/mssql/index.ts
+var SqlServerDialect = class extends Dialect {
+  /**
+   * Creates a new SqlServerDialect instance
+   */
+  constructor() {
+    super();
+  }
+  /**
+   * Quotes an identifier using SQL Server bracket syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id) {
+    return `[${id}]`;
+  }
+  /**
+   * Compiles JSON path expression using SQL Server syntax
+   * @param node - JSON path node
+   * @returns SQL Server JSON path expression
+   */
+  compileJsonPath(node) {
+    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `JSON_VALUE(${col2}, '${node.path}')`;
+  }
+  /**
+   * Formats parameter placeholders using SQL Server named parameter syntax
+   * @param index - Parameter index
+   * @returns Named parameter placeholder
+   */
+  formatPlaceholder(index) {
+    return `@p${index}`;
+  }
+  /**
+   * Compiles SELECT query AST to SQL Server SQL
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns SQL Server SQL string
+   */
+  compileSelectAst(ast, ctx) {
+    const columns = ast.columns.map((c) => {
+      let expr = "";
+      if (c.type === "Function") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "Column") {
+        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
+      } else if (c.type === "ScalarSubquery") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "WindowFunction") {
+        expr = this.compileOperand(c, ctx);
+      }
+      if (c.alias) {
+        if (c.alias.includes("(")) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(", ");
+    const distinct = ast.distinct ? "DISTINCT " : "";
+    const from = `${this.quoteIdentifier(ast.from.name)}`;
+    const joins = ast.joins.map((j) => {
+      const table = this.quoteIdentifier(j.table.name);
+      const cond = this.compileExpression(j.condition, ctx);
+      return `${j.kind} JOIN ${table} ON ${cond}`;
+    }).join(" ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
+    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
+    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
+    let pagination = "";
+    if (ast.limit || ast.offset) {
+      const off = ast.offset || 0;
+      const orderClause = orderBy || " ORDER BY (SELECT NULL)";
+      pagination = `${orderClause} OFFSET ${off} ROWS`;
+      if (ast.limit) {
+        pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
+      }
+      return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${pagination};`;
+    }
+    const ctes = ast.ctes && ast.ctes.length > 0 ? "WITH " + ast.ctes.map((cte) => {
+      const name = this.quoteIdentifier(cte.name);
+      const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+      const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
+      return `${name}${cols} AS (${query})`;
+    }).join(", ") + " " : "";
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy};`;
+  }
+  compileInsertAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+  compileUpdateAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map((assignment) => {
+      const col2 = assignment.column;
+      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+  compileDeleteAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
+};
+
+// src/core/dialect/sqlite/index.ts
+var SqliteDialect = class extends Dialect {
+  /**
+   * Creates a new SqliteDialect instance
+   */
+  constructor() {
+    super();
+  }
+  /**
+   * Quotes an identifier using SQLite double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id) {
+    return `"${id}"`;
+  }
+  /**
+   * Compiles JSON path expression using SQLite syntax
+   * @param node - JSON path node
+   * @returns SQLite JSON path expression
+   */
+  compileJsonPath(node) {
+    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `json_extract(${col2}, '${node.path}')`;
+  }
+  /**
+   * Compiles SELECT query AST to SQLite SQL
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns SQLite SQL string
+   */
+  compileSelectAst(ast, ctx) {
+    const columns = ast.columns.map((c) => {
+      let expr = "";
+      if (c.type === "Function") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "Column") {
+        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
+      } else if (c.type === "ScalarSubquery") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "CaseExpression") {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === "WindowFunction") {
+        expr = this.compileOperand(c, ctx);
+      }
+      if (c.alias) {
+        if (c.alias.includes("(")) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(", ");
+    const distinct = ast.distinct ? "DISTINCT " : "";
+    const from = `${this.quoteIdentifier(ast.from.name)}`;
+    const joins = ast.joins.map((j) => {
+      const table = this.quoteIdentifier(j.table.name);
+      const cond = this.compileExpression(j.condition, ctx);
+      return `${j.kind} JOIN ${table} ON ${cond}`;
+    }).join(" ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
+    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
+    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
+    const limit = ast.limit ? ` LIMIT ${ast.limit}` : "";
+    const offset = ast.offset ? ` OFFSET ${ast.offset}` : "";
+    const ctes = ast.ctes && ast.ctes.length > 0 ? (() => {
+      const hasRecursive = ast.ctes.some((cte) => cte.recursive);
+      const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
+      const cteDefs = ast.ctes.map((cte) => {
+        const name = this.quoteIdentifier(cte.name);
+        const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+        const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
+        return `${name}${cols} AS (${query})`;
+      }).join(", ");
+      return prefix + cteDefs + " ";
+    })() : "";
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+  compileInsertAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+  }
+  compileUpdateAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map((assignment) => {
+      const col2 = assignment.column;
+      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  }
+  compileDeleteAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning};`;
+  }
+  compileReturning(returning, ctx) {
+    if (!returning || returning.length === 0) return "";
+    const columns = returning.map((column) => {
+      const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : "";
+      return `${tablePart}${this.quoteIdentifier(column.name)}`;
+    }).join(", ");
+    return ` RETURNING ${columns}`;
+  }
+};
+
+// src/orm/als.ts
+var AsyncLocalStorage = class {
+  /**
+   * Executes a callback with the specified store value
+   * @param store - Value to store during callback execution
+   * @param callback - Function to execute with the store value
+   * @returns Result of the callback function
+   */
+  run(store, callback) {
+    this.store = store;
+    try {
+      return callback();
+    } finally {
+      this.store = void 0;
+    }
+  }
+  /**
+   * Gets the currently stored value
+   * @returns Current store value or undefined if none exists
+   */
+  getStore() {
+    return this.store;
+  }
+};
+
+// src/core/sql/sql-operator-config.ts
+var SQL_OPERATOR_REGISTRY = {
+  [SQL_OPERATORS.EQUALS]: { sql: SQL_OPERATORS.EQUALS, tsName: "eq" },
+  [SQL_OPERATORS.NOT_EQUALS]: { sql: SQL_OPERATORS.NOT_EQUALS, tsName: "neq" },
+  [SQL_OPERATORS.GREATER_THAN]: { sql: SQL_OPERATORS.GREATER_THAN, tsName: "gt" },
+  [SQL_OPERATORS.GREATER_OR_EQUAL]: { sql: SQL_OPERATORS.GREATER_OR_EQUAL, tsName: "gte" },
+  [SQL_OPERATORS.LESS_THAN]: { sql: SQL_OPERATORS.LESS_THAN, tsName: "lt" },
+  [SQL_OPERATORS.LESS_OR_EQUAL]: { sql: SQL_OPERATORS.LESS_OR_EQUAL, tsName: "lte" },
+  [SQL_OPERATORS.LIKE]: { sql: SQL_OPERATORS.LIKE, tsName: "like" },
+  [SQL_OPERATORS.NOT_LIKE]: { sql: SQL_OPERATORS.NOT_LIKE, tsName: "notLike" },
+  [SQL_OPERATORS.IN]: { sql: SQL_OPERATORS.IN, tsName: "inList" },
+  [SQL_OPERATORS.NOT_IN]: { sql: SQL_OPERATORS.NOT_IN, tsName: "notInList" },
+  [SQL_OPERATORS.IS_NULL]: { sql: SQL_OPERATORS.IS_NULL, tsName: "isNull" },
+  [SQL_OPERATORS.IS_NOT_NULL]: { sql: SQL_OPERATORS.IS_NOT_NULL, tsName: "isNotNull" },
+  [SQL_OPERATORS.AND]: { sql: SQL_OPERATORS.AND, tsName: "and" },
+  [SQL_OPERATORS.OR]: { sql: SQL_OPERATORS.OR, tsName: "or" },
+  [SQL_OPERATORS.BETWEEN]: { sql: SQL_OPERATORS.BETWEEN, tsName: "between" },
+  [SQL_OPERATORS.NOT_BETWEEN]: { sql: SQL_OPERATORS.NOT_BETWEEN, tsName: "notBetween" },
+  [SQL_OPERATORS.EXISTS]: { sql: SQL_OPERATORS.EXISTS, tsName: "exists" },
+  [SQL_OPERATORS.NOT_EXISTS]: { sql: SQL_OPERATORS.NOT_EXISTS, tsName: "notExists" }
+};
+
+// src/codegen/typescript.ts
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var assertNever2 = (value) => {
+  throw new Error(`Unhandled SQL operator: ${value}`);
+};
+var TypeScriptGenerator = class {
+  /**
+   * Generates TypeScript code from a query AST
+   * @param ast - Query AST to generate code from
+   * @returns Generated TypeScript code
+   */
+  generate(ast) {
+    const chainLines = this.buildSelectLines(ast);
+    const lines = chainLines.map((line, index) => index === 0 ? `const query = ${line}` : line);
+    lines.push(";", "", "await query.execute();");
+    return lines.join("\n");
+  }
+  /**
+   * Builds TypeScript method chain lines from query AST
+   * @param ast - Query AST
+   * @returns Array of TypeScript method chain lines
+   */
+  buildSelectLines(ast) {
+    const lines = [];
+    const hydration = ast.meta?.hydration;
+    const hydratedRelations = new Set(hydration?.relations?.map((r) => r.name) ?? []);
+    const selections = ast.columns.filter((col2) => !(hydration && isRelationAlias(col2.alias))).map((col2) => {
+      const key = col2.alias || col2.name;
+      const operand = col2;
+      return `${key}: ${this.printOperand(operand)}`;
+    });
+    lines.push(`db.select({`);
+    selections.forEach((sel, index) => {
+      lines.push(`  ${sel}${index < selections.length - 1 ? "," : ""}`);
+    });
+    lines.push(`})`);
+    lines.push(`.from(${capitalize(ast.from.name)})`);
+    if (ast.distinct && ast.distinct.length) {
+      const cols = ast.distinct.map((c) => `${capitalize(c.table)}.${c.name}`).join(", ");
+      lines.push(`.distinct(${cols})`);
+    }
+    ast.joins.forEach((join) => {
+      if (join.relationName && hydratedRelations.has(join.relationName)) {
+        return;
+      }
+      if (join.relationName) {
+        if (join.kind === "INNER") {
+          lines.push(`.joinRelation('${join.relationName}')`);
+        } else {
+          lines.push(`.joinRelation('${join.relationName}', '${join.kind}')`);
+        }
+      } else {
+        const table = capitalize(join.table.name);
+        const cond = this.printExpression(join.condition);
+        let method = "innerJoin";
+        if (join.kind === "LEFT") method = "leftJoin";
+        if (join.kind === "RIGHT") method = "rightJoin";
+        lines.push(`.${method}(${table}, ${cond})`);
+      }
+    });
+    if (hydration?.relations?.length) {
+      hydration.relations.forEach((rel) => {
+        const options = [];
+        if (rel.columns.length) options.push(`columns: [${rel.columns.map((c) => `'${c}'`).join(", ")}]`);
+        if (rel.aliasPrefix !== rel.name) options.push(`aliasPrefix: '${rel.aliasPrefix}'`);
+        const opts = options.length ? `, { ${options.join(", ")} }` : "";
+        lines.push(`.include('${rel.name}'${opts})`);
+      });
+    }
+    if (ast.where) {
+      lines.push(`.where(${this.printExpression(ast.where)})`);
+    }
+    if (ast.groupBy && ast.groupBy.length) {
+      const cols = ast.groupBy.map((c) => `${capitalize(c.table)}.${c.name}`).join(", ");
+      lines.push(`.groupBy(${cols})`);
+    }
+    if (ast.having) {
+      lines.push(`.having(${this.printExpression(ast.having)})`);
+    }
+    if (ast.orderBy && ast.orderBy.length) {
+      ast.orderBy.forEach((o) => {
+        lines.push(`.orderBy(${capitalize(o.column.table)}.${o.column.name}, '${o.direction}')`);
+      });
+    }
+    if (ast.limit) lines.push(`.limit(${ast.limit})`);
+    if (ast.offset) lines.push(`.offset(${ast.offset})`);
+    return lines;
+  }
+  /**
+   * Prints an expression node to TypeScript code
+   * @param expr - Expression node to print
+   * @returns TypeScript code representation
+   */
+  printExpression(expr) {
+    return visitExpression(expr, this);
+  }
+  /**
+   * Prints an operand node to TypeScript code
+   * @param node - Operand node to print
+   * @returns TypeScript code representation
+   */
+  printOperand(node) {
+    return visitOperand(node, this);
+  }
+  visitBinaryExpression(binary) {
+    return this.printBinaryExpression(binary);
+  }
+  visitLogicalExpression(logical) {
+    return this.printLogicalExpression(logical);
+  }
+  visitNullExpression(nullExpr) {
+    return this.printNullExpression(nullExpr);
+  }
+  visitInExpression(inExpr) {
+    return this.printInExpression(inExpr);
+  }
+  visitExistsExpression(existsExpr) {
+    return this.printExistsExpression(existsExpr);
+  }
+  visitBetweenExpression(betweenExpr) {
+    return this.printBetweenExpression(betweenExpr);
+  }
+  visitColumn(node) {
+    return this.printColumnOperand(node);
+  }
+  visitLiteral(node) {
+    return this.printLiteralOperand(node);
+  }
+  visitFunction(node) {
+    return this.printFunctionOperand(node);
+  }
+  visitJsonPath(node) {
+    return this.printJsonPathOperand(node);
+  }
+  visitScalarSubquery(node) {
+    return this.printScalarSubqueryOperand(node);
+  }
+  visitCaseExpression(node) {
+    return this.printCaseExpressionOperand(node);
+  }
+  visitWindowFunction(node) {
+    return this.printWindowFunctionOperand(node);
+  }
+  /**
+   * Prints a binary expression to TypeScript code
+   * @param binary - Binary expression node
+   * @returns TypeScript code representation
+   */
+  printBinaryExpression(binary) {
+    const left = this.printOperand(binary.left);
+    const right = this.printOperand(binary.right);
+    const fn = this.mapOp(binary.operator);
+    const args = [left, right];
+    if (binary.escape) {
+      args.push(this.printOperand(binary.escape));
+    }
+    return `${fn}(${args.join(", ")})`;
+  }
+  /**
+   * Prints a logical expression to TypeScript code
+   * @param logical - Logical expression node
+   * @returns TypeScript code representation
+   */
+  printLogicalExpression(logical) {
+    if (logical.operands.length === 0) return "";
+    const parts = logical.operands.map((op) => {
+      const compiled = this.printExpression(op);
+      return op.type === "LogicalExpression" ? `(${compiled})` : compiled;
+    });
+    return `${this.mapOp(logical.operator)}(
+    ${parts.join(",\n    ")}
+  )`;
+  }
+  /**
+   * Prints an IN expression to TypeScript code
+   * @param inExpr - IN expression node
+   * @returns TypeScript code representation
+   */
+  printInExpression(inExpr) {
+    const left = this.printOperand(inExpr.left);
+    const values = inExpr.right.map((v) => this.printOperand(v)).join(", ");
+    const fn = this.mapOp(inExpr.operator);
+    return `${fn}(${left}, [${values}])`;
+  }
+  /**
+   * Prints a null expression to TypeScript code
+   * @param nullExpr - Null expression node
+   * @returns TypeScript code representation
+   */
+  printNullExpression(nullExpr) {
+    const left = this.printOperand(nullExpr.left);
+    const fn = this.mapOp(nullExpr.operator);
+    return `${fn}(${left})`;
+  }
+  /**
+   * Prints a BETWEEN expression to TypeScript code
+   * @param betweenExpr - BETWEEN expression node
+   * @returns TypeScript code representation
+   */
+  printBetweenExpression(betweenExpr) {
+    const left = this.printOperand(betweenExpr.left);
+    const lower = this.printOperand(betweenExpr.lower);
+    const upper = this.printOperand(betweenExpr.upper);
+    return `${this.mapOp(betweenExpr.operator)}(${left}, ${lower}, ${upper})`;
+  }
+  /**
+   * Prints an EXISTS expression to TypeScript code
+   * @param existsExpr - EXISTS expression node
+   * @returns TypeScript code representation
+   */
+  printExistsExpression(existsExpr) {
+    const subquery = this.inlineChain(this.buildSelectLines(existsExpr.subquery));
+    return `${this.mapOp(existsExpr.operator)}(${subquery})`;
+  }
+  /**
+   * Prints a column operand to TypeScript code
+   * @param column - Column node
+   * @returns TypeScript code representation
+   */
+  printColumnOperand(column) {
+    return `${capitalize(column.table)}.${column.name}`;
+  }
+  /**
+   * Prints a literal operand to TypeScript code
+   * @param literal - Literal node
+   * @returns TypeScript code representation
+   */
+  printLiteralOperand(literal) {
+    if (literal.value === null) return "null";
+    return typeof literal.value === "string" ? `'${literal.value}'` : String(literal.value);
+  }
+  /**
+   * Prints a function operand to TypeScript code
+   * @param fn - Function node
+   * @returns TypeScript code representation
+   */
+  printFunctionOperand(fn) {
+    const args = fn.args.map((a) => this.printOperand(a)).join(", ");
+    return `${fn.name.toLowerCase()}(${args})`;
+  }
+  /**
+   * Prints a JSON path operand to TypeScript code
+   * @param json - JSON path node
+   * @returns TypeScript code representation
+   */
+  printJsonPathOperand(json) {
+    return `jsonPath(${capitalize(json.column.table)}.${json.column.name}, '${json.path}')`;
+  }
+  /**
+   * Prints a scalar subquery operand to TypeScript code
+   * @param node - Scalar subquery node
+   * @returns TypeScript code representation
+   */
+  printScalarSubqueryOperand(node) {
+    const subquery = this.inlineChain(this.buildSelectLines(node.query));
+    return `(${subquery})`;
+  }
+  /**
+   * Prints a CASE expression operand to TypeScript code
+   * @param node - CASE expression node
+   * @returns TypeScript code representation
+   */
+  printCaseExpressionOperand(node) {
+    const clauses = node.conditions.map(
+      (condition) => `{ when: ${this.printExpression(condition.when)}, then: ${this.printOperand(condition.then)} }`
+    );
+    const elseValue = node.else ? `, ${this.printOperand(node.else)}` : "";
+    return `caseWhen([${clauses.join(", ")}]${elseValue})`;
+  }
+  /**
+   * Prints a window function operand to TypeScript code
+   * @param node - Window function node
+   * @returns TypeScript code representation
+   */
+  printWindowFunctionOperand(node) {
+    let result = `${node.name}(`;
+    if (node.args.length > 0) {
+      result += node.args.map((arg) => this.printOperand(arg)).join(", ");
+    }
+    result += ") OVER (";
+    const parts = [];
+    if (node.partitionBy && node.partitionBy.length > 0) {
+      const partitionClause = "PARTITION BY " + node.partitionBy.map((col2) => `${capitalize(col2.table)}.${col2.name}`).join(", ");
+      parts.push(partitionClause);
+    }
+    if (node.orderBy && node.orderBy.length > 0) {
+      const orderClause = "ORDER BY " + node.orderBy.map((o) => `${capitalize(o.column.table)}.${o.column.name} ${o.direction}`).join(", ");
+      parts.push(orderClause);
+    }
+    result += parts.join(" ");
+    result += ")";
+    return result;
+  }
+  /**
+   * Converts method chain lines to inline format
+   * @param lines - Method chain lines
+   * @returns Inline method chain string
+   */
+  inlineChain(lines) {
+    return lines.map((line) => line.trim()).filter((line) => line.length > 0).join(" ");
+  }
+  /**
+   * Maps SQL operators to TypeScript function names
+   * @param op - SQL operator
+   * @returns TypeScript function name
+   */
+  mapOp(op) {
+    const config = SQL_OPERATOR_REGISTRY[op];
+    if (!config) {
+      return assertNever2(op);
+    }
+    return config.tsName;
+  }
+};
+
+// src/orm/domain-event-bus.ts
+var DomainEventBus = class {
+  constructor(initialHandlers) {
+    this.handlers = /* @__PURE__ */ new Map();
+    const handlers = initialHandlers ?? {};
+    Object.entries(handlers).forEach(([name, list]) => {
+      this.handlers.set(name, [...list]);
+    });
+  }
+  register(name, handler) {
+    const existing = this.handlers.get(name) ?? [];
+    existing.push(handler);
+    this.handlers.set(name, existing);
+  }
+  async dispatch(trackedEntities, ctx) {
+    for (const tracked of trackedEntities) {
+      const entity = tracked.entity;
+      if (!entity.domainEvents || !entity.domainEvents.length) continue;
+      for (const event of entity.domainEvents) {
+        const eventName = this.getEventName(event);
+        const handlers = this.handlers.get(eventName);
+        if (!handlers) continue;
+        for (const handler of handlers) {
+          await handler(event, ctx);
+        }
+      }
+      entity.domainEvents = [];
+    }
+  }
+  getEventName(event) {
+    if (!event) return "Unknown";
+    if (typeof event === "string") return event;
+    return event.constructor?.name ?? "Unknown";
+  }
+};
+var addDomainEvent = (entity, event) => {
+  if (!entity.domainEvents) {
+    entity.domainEvents = [];
+  }
+  entity.domainEvents.push(event);
+};
+
+// src/orm/identity-map.ts
+var IdentityMap = class {
+  constructor() {
+    this.buckets = /* @__PURE__ */ new Map();
+  }
+  get bucketsMap() {
+    return this.buckets;
+  }
+  getEntity(table, pk) {
+    const bucket = this.buckets.get(table.name);
+    return bucket?.get(this.toIdentityKey(pk))?.entity;
+  }
+  register(tracked) {
+    if (tracked.pk == null) return;
+    const bucket = this.buckets.get(tracked.table.name) ?? /* @__PURE__ */ new Map();
+    bucket.set(this.toIdentityKey(tracked.pk), tracked);
+    this.buckets.set(tracked.table.name, bucket);
+  }
+  remove(tracked) {
+    if (tracked.pk == null) return;
+    const bucket = this.buckets.get(tracked.table.name);
+    bucket?.delete(this.toIdentityKey(tracked.pk));
+  }
+  getEntitiesForTable(table) {
+    const bucket = this.buckets.get(table.name);
+    return bucket ? Array.from(bucket.values()) : [];
+  }
+  toIdentityKey(pk) {
+    return String(pk);
+  }
+};
+
+// src/orm/relation-change-processor.ts
+var RelationChangeProcessor = class {
+  constructor(unitOfWork, dialect, executor) {
+    this.unitOfWork = unitOfWork;
+    this.dialect = dialect;
+    this.executor = executor;
+    this.relationChanges = [];
+  }
+  registerChange(entry) {
+    this.relationChanges.push(entry);
+  }
+  async process() {
+    if (!this.relationChanges.length) return;
+    const entries = [...this.relationChanges];
+    this.relationChanges.length = 0;
+    for (const entry of entries) {
+      switch (entry.relation.type) {
+        case RelationKinds.HasMany:
+          await this.handleHasManyChange(entry);
+          break;
+        case RelationKinds.BelongsToMany:
+          await this.handleBelongsToManyChange(entry);
+          break;
+        case RelationKinds.BelongsTo:
+          await this.handleBelongsToChange(entry);
+          break;
+      }
+    }
+  }
+  async handleHasManyChange(entry) {
+    const relation = entry.relation;
+    const target = entry.change.entity;
+    if (!target) return;
+    const tracked = this.unitOfWork.findTracked(target);
+    if (!tracked) return;
+    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootValue = entry.root[localKey];
+    if (rootValue === void 0 || rootValue === null) return;
+    if (entry.change.kind === "add" || entry.change.kind === "attach") {
+      this.assignHasManyForeignKey(tracked.entity, relation, rootValue);
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+    if (entry.change.kind === "remove") {
+      this.detachHasManyChild(tracked.entity, relation);
+    }
+  }
+  async handleBelongsToChange(_entry) {
+  }
+  async handleBelongsToManyChange(entry) {
+    const relation = entry.relation;
+    const rootKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootId = entry.root[rootKey];
+    if (rootId === void 0 || rootId === null) return;
+    const targetId = this.resolvePrimaryKeyValue(entry.change.entity, relation.target);
+    if (targetId === null) return;
+    if (entry.change.kind === "attach" || entry.change.kind === "add") {
+      await this.insertPivotRow(relation, rootId, targetId);
+      return;
+    }
+    if (entry.change.kind === "detach" || entry.change.kind === "remove") {
+      await this.deletePivotRow(relation, rootId, targetId);
+      if (relation.cascade === "all" || relation.cascade === "remove") {
+        this.unitOfWork.markRemoved(entry.change.entity);
+      }
+    }
+  }
+  assignHasManyForeignKey(child, relation, rootValue) {
+    const current = child[relation.foreignKey];
+    if (current === rootValue) return;
+    child[relation.foreignKey] = rootValue;
+  }
+  detachHasManyChild(child, relation) {
+    if (relation.cascade === "all" || relation.cascade === "remove") {
+      this.unitOfWork.markRemoved(child);
+      return;
+    }
+    child[relation.foreignKey] = null;
+    this.unitOfWork.markDirty(child);
+  }
+  async insertPivotRow(relation, rootId, targetId) {
+    const payload = {
+      [relation.pivotForeignKeyToRoot]: rootId,
+      [relation.pivotForeignKeyToTarget]: targetId
+    };
+    const builder = new InsertQueryBuilder(relation.pivotTable).values(payload);
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+  async deletePivotRow(relation, rootId, targetId) {
+    const rootCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+    const targetCol = relation.pivotTable.columns[relation.pivotForeignKeyToTarget];
+    if (!rootCol || !targetCol) return;
+    const builder = new DeleteQueryBuilder(relation.pivotTable).where(
+      and(eq(rootCol, rootId), eq(targetCol, targetId))
+    );
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+  resolvePrimaryKeyValue(entity, table) {
+    if (!entity) return null;
+    const key = findPrimaryKey(table);
+    const value = entity[key];
+    if (value === void 0 || value === null) return null;
+    return value;
+  }
+};
+
+// src/orm/transaction-runner.ts
+var runInTransaction = async (executor, action) => {
+  if (!executor.beginTransaction) {
+    await action();
+    return;
+  }
+  await executor.beginTransaction();
+  try {
+    await action();
+    await executor.commitTransaction?.();
+  } catch (error) {
+    await executor.rollbackTransaction?.();
+    throw error;
+  }
+};
+
+// src/orm/runtime-types.ts
+var EntityStatus = /* @__PURE__ */ ((EntityStatus2) => {
+  EntityStatus2["New"] = "new";
+  EntityStatus2["Managed"] = "managed";
+  EntityStatus2["Dirty"] = "dirty";
+  EntityStatus2["Removed"] = "removed";
+  EntityStatus2["Detached"] = "detached";
+  return EntityStatus2;
+})(EntityStatus || {});
+
+// src/orm/unit-of-work.ts
+var UnitOfWork = class {
+  constructor(dialect, executor, identityMap, hookContext) {
+    this.dialect = dialect;
+    this.executor = executor;
+    this.identityMap = identityMap;
+    this.hookContext = hookContext;
+    this.trackedEntities = /* @__PURE__ */ new Map();
+  }
+  get identityBuckets() {
+    return this.identityMap.bucketsMap;
+  }
+  getTracked() {
+    return Array.from(this.trackedEntities.values());
+  }
+  getEntity(table, pk) {
+    return this.identityMap.getEntity(table, pk);
+  }
+  getEntitiesForTable(table) {
+    return this.identityMap.getEntitiesForTable(table);
+  }
+  findTracked(entity) {
+    return this.trackedEntities.get(entity);
+  }
+  setEntity(table, pk, entity) {
+    if (pk === null || pk === void 0) return;
+    let tracked = this.trackedEntities.get(entity);
+    if (!tracked) {
+      tracked = {
+        table,
+        entity,
+        pk,
+        status: "managed" /* Managed */,
+        original: this.createSnapshot(table, entity)
+      };
+      this.trackedEntities.set(entity, tracked);
+    } else {
+      tracked.pk = pk;
+    }
+    this.registerIdentity(tracked);
+  }
+  trackNew(table, entity, pk) {
+    const tracked = {
+      table,
+      entity,
+      pk: pk ?? null,
+      status: "new" /* New */,
+      original: null
+    };
+    this.trackedEntities.set(entity, tracked);
+    if (pk != null) {
+      this.registerIdentity(tracked);
+    }
+  }
+  trackManaged(table, pk, entity) {
+    const tracked = {
+      table,
+      entity,
+      pk,
+      status: "managed" /* Managed */,
+      original: this.createSnapshot(table, entity)
+    };
+    this.trackedEntities.set(entity, tracked);
+    this.registerIdentity(tracked);
+  }
+  markDirty(entity) {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    if (tracked.status === "new" /* New */ || tracked.status === "removed" /* Removed */) return;
+    tracked.status = "dirty" /* Dirty */;
+  }
+  markRemoved(entity) {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    tracked.status = "removed" /* Removed */;
+  }
+  async flush() {
+    const toFlush = Array.from(this.trackedEntities.values());
+    for (const tracked of toFlush) {
+      switch (tracked.status) {
+        case "new" /* New */:
+          await this.flushInsert(tracked);
+          break;
+        case "dirty" /* Dirty */:
+          await this.flushUpdate(tracked);
+          break;
+        case "removed" /* Removed */:
+          await this.flushDelete(tracked);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  async flushInsert(tracked) {
+    await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
+    const payload = this.extractColumns(tracked.table, tracked.entity);
+    const builder = new InsertQueryBuilder(tracked.table).values(payload);
+    const compiled = builder.compile(this.dialect);
+    await this.executeCompiled(compiled);
+    tracked.status = "managed" /* Managed */;
+    tracked.original = this.createSnapshot(tracked.table, tracked.entity);
+    tracked.pk = this.getPrimaryKeyValue(tracked);
+    this.registerIdentity(tracked);
+    await this.runHook(tracked.table.hooks?.afterInsert, tracked);
+  }
+  async flushUpdate(tracked) {
+    if (tracked.pk == null) return;
+    const changes = this.computeChanges(tracked);
+    if (!Object.keys(changes).length) {
+      tracked.status = "managed" /* Managed */;
+      return;
+    }
+    await this.runHook(tracked.table.hooks?.beforeUpdate, tracked);
+    const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
+    if (!pkColumn) return;
+    const builder = new UpdateQueryBuilder(tracked.table).set(changes).where(eq(pkColumn, tracked.pk));
+    const compiled = builder.compile(this.dialect);
+    await this.executeCompiled(compiled);
+    tracked.status = "managed" /* Managed */;
+    tracked.original = this.createSnapshot(tracked.table, tracked.entity);
+    this.registerIdentity(tracked);
+    await this.runHook(tracked.table.hooks?.afterUpdate, tracked);
+  }
+  async flushDelete(tracked) {
+    if (tracked.pk == null) return;
+    await this.runHook(tracked.table.hooks?.beforeDelete, tracked);
+    const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
+    if (!pkColumn) return;
+    const builder = new DeleteQueryBuilder(tracked.table).where(eq(pkColumn, tracked.pk));
+    const compiled = builder.compile(this.dialect);
+    await this.executeCompiled(compiled);
+    tracked.status = "detached" /* Detached */;
+    this.trackedEntities.delete(tracked.entity);
+    this.identityMap.remove(tracked);
+    await this.runHook(tracked.table.hooks?.afterDelete, tracked);
+  }
+  async runHook(hook, tracked) {
+    if (!hook) return;
+    await hook(this.hookContext(), tracked.entity);
+  }
+  computeChanges(tracked) {
+    const snapshot = tracked.original ?? {};
+    const changes = {};
+    for (const column of Object.keys(tracked.table.columns)) {
+      const current = tracked.entity[column];
+      if (snapshot[column] !== current) {
+        changes[column] = current;
+      }
+    }
+    return changes;
+  }
+  extractColumns(table, entity) {
+    const payload = {};
+    for (const column of Object.keys(table.columns)) {
+      payload[column] = entity[column];
+    }
+    return payload;
+  }
+  async executeCompiled(compiled) {
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+  registerIdentity(tracked) {
+    if (tracked.pk == null) return;
+    this.identityMap.register(tracked);
+  }
+  createSnapshot(table, entity) {
+    const snapshot = {};
+    for (const column of Object.keys(table.columns)) {
+      snapshot[column] = entity[column];
+    }
+    return snapshot;
+  }
+  getPrimaryKeyValue(tracked) {
+    const key = findPrimaryKey(tracked.table);
+    const val = tracked.entity[key];
+    if (val === void 0 || val === null) return null;
+    return val;
+  }
+};
+
+// src/orm/orm-context.ts
+var OrmContext = class {
+  constructor(options) {
+    this.options = options;
+    this.identityMap = new IdentityMap();
+    this.interceptors = [...options.interceptors ?? []];
+    this.unitOfWork = new UnitOfWork(
+      options.dialect,
+      options.executor,
+      this.identityMap,
+      () => this
+    );
+    this.relationChanges = new RelationChangeProcessor(
+      this.unitOfWork,
+      options.dialect,
+      options.executor
+    );
+    this.domainEvents = new DomainEventBus(options.domainEventHandlers);
+  }
+  get dialect() {
+    return this.options.dialect;
+  }
+  get executor() {
+    return this.options.executor;
+  }
+  get identityBuckets() {
+    return this.unitOfWork.identityBuckets;
+  }
+  get tracked() {
+    return this.unitOfWork.getTracked();
+  }
+  getEntity(table, pk) {
+    return this.unitOfWork.getEntity(table, pk);
+  }
+  setEntity(table, pk, entity) {
+    this.unitOfWork.setEntity(table, pk, entity);
+  }
+  trackNew(table, entity, pk) {
+    this.unitOfWork.trackNew(table, entity, pk);
+  }
+  trackManaged(table, pk, entity) {
+    this.unitOfWork.trackManaged(table, pk, entity);
+  }
+  markDirty(entity) {
+    this.unitOfWork.markDirty(entity);
+  }
+  markRemoved(entity) {
+    this.unitOfWork.markRemoved(entity);
+  }
+  registerRelationChange(root, relationKey, rootTable, relationName, relation, change) {
+    const entry = {
+      root,
+      relationKey,
+      rootTable,
+      relationName,
+      relation,
+      change
+    };
+    this.relationChanges.registerChange(entry);
+  }
+  registerInterceptor(interceptor) {
+    this.interceptors.push(interceptor);
+  }
+  registerDomainEventHandler(name, handler) {
+    this.domainEvents.register(name, handler);
+  }
+  async saveChanges() {
+    await runInTransaction(this.executor, async () => {
+      for (const interceptor of this.interceptors) {
+        await interceptor.beforeFlush?.(this);
+      }
+      await this.unitOfWork.flush();
+      await this.relationChanges.process();
+      await this.unitOfWork.flush();
+      for (const interceptor of this.interceptors) {
+        await interceptor.afterFlush?.(this);
+      }
+    });
+    await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
+  }
+  getEntitiesForTable(table) {
+    return this.unitOfWork.getEntitiesForTable(table);
+  }
+};
+export {
+  AsyncLocalStorage,
+  DefaultBelongsToReference,
+  DefaultHasManyCollection,
+  DefaultManyToManyCollection,
+  DeleteQueryBuilder,
+  EntityStatus,
+  InsertQueryBuilder,
+  MySqlDialect,
+  OrmContext,
+  RelationKinds,
+  SelectQueryBuilder,
+  SqlServerDialect,
+  SqliteDialect,
+  TypeScriptGenerator,
+  UpdateQueryBuilder,
+  addDomainEvent,
+  and,
+  avg,
+  belongsTo,
+  belongsToMany,
+  between,
+  caseWhen,
+  col,
+  columnOperand,
+  count,
+  createColumn,
+  createEntityFromRow,
+  createEntityProxy,
+  createLiteral,
+  defineTable,
+  denseRank,
+  eq,
+  executeHydrated,
+  exists,
+  firstValue,
+  gt,
+  gte,
+  hasMany,
+  hydrateRows,
+  inList,
+  isCaseExpressionNode,
+  isExpressionSelectionNode,
+  isFunctionNode,
+  isNotNull,
+  isNull,
+  isOperandNode,
+  isWindowFunctionNode,
+  jsonPath,
+  lag,
+  lastValue,
+  lead,
+  like,
+  loadBelongsToManyRelation,
+  loadBelongsToRelation,
+  loadHasManyRelation,
+  lt,
+  lte,
+  neq,
+  notBetween,
+  notExists,
+  notInList,
+  notLike,
+  ntile,
+  or,
+  rank,
+  rowNumber,
+  sum,
+  valueToOperand,
+  visitExpression,
+  visitOperand,
+  windowFunction
+};
+//# sourceMappingURL=index.js.map