metal-orm 1.0.7 → 1.0.9

package/dist/decorators/index.js

@@ -0,0 +1,2530 @@
+// 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/orm/entity-metadata.ts
+var metadataMap = /* @__PURE__ */ new Map();
+var ensureEntityMetadata = (target) => {
+  let meta = metadataMap.get(target);
+  if (!meta) {
+    meta = {
+      target,
+      tableName: target.name || "unknown",
+      columns: {},
+      relations: {}
+    };
+    metadataMap.set(target, meta);
+  }
+  return meta;
+};
+var getEntityMetadata = (target) => {
+  return metadataMap.get(target);
+};
+var getAllEntityMetadata = () => {
+  return Array.from(metadataMap.values());
+};
+var addColumnMetadata = (target, propertyKey, column) => {
+  const meta = ensureEntityMetadata(target);
+  meta.columns[propertyKey] = { ...column };
+};
+var addRelationMetadata = (target, propertyKey, relation) => {
+  const meta = ensureEntityMetadata(target);
+  meta.relations[propertyKey] = relation;
+};
+var setEntityTableName = (target, tableName, hooks) => {
+  const meta = ensureEntityMetadata(target);
+  if (tableName && tableName.length > 0) {
+    meta.tableName = tableName;
+  }
+  if (hooks) {
+    meta.hooks = hooks;
+  }
+};
+var buildTableDef = (meta) => {
+  if (meta.table) {
+    return meta.table;
+  }
+  const columns = Object.entries(meta.columns).reduce((acc, [key, def]) => {
+    acc[key] = {
+      ...def,
+      name: key,
+      table: meta.tableName
+    };
+    return acc;
+  }, {});
+  const table = defineTable(meta.tableName, columns, {}, meta.hooks);
+  meta.table = table;
+  return table;
+};
+
+// src/decorators/entity.ts
+var toSnakeCase = (value) => {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_]+/gi, "_").replace(/__+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+};
+var deriveTableNameFromConstructor = (ctor) => {
+  const fallback = "unknown";
+  const rawName = ctor.name || fallback;
+  const strippedName = rawName.replace(/Entity$/i, "");
+  const normalized = toSnakeCase(strippedName || rawName);
+  if (!normalized) {
+    return fallback;
+  }
+  return normalized.endsWith("s") ? normalized : `${normalized}s`;
+};
+function Entity(options = {}) {
+  const decorator = (value) => {
+    const tableName = options.tableName ?? deriveTableNameFromConstructor(value);
+    setEntityTableName(value, tableName, options.hooks);
+    return value;
+  };
+  return decorator;
+}
+
+// src/decorators/column.ts
+var normalizeColumnInput = (input) => {
+  const column = {
+    type: input.type ?? input.type,
+    args: input.args ?? input.args,
+    notNull: input.notNull ?? input.notNull,
+    primary: input.primary ?? input.primary
+  };
+  if (!column.type) {
+    throw new Error("Column decorator requires a column type");
+  }
+  return column;
+};
+var normalizePropertyName = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+var resolveConstructor = (target) => {
+  if (typeof target === "function") {
+    return target;
+  }
+  if (target && typeof target.constructor === "function") {
+    return target.constructor;
+  }
+  return void 0;
+};
+var registerColumn = (ctor, propertyName, column) => {
+  const meta = ensureEntityMetadata(ctor);
+  if (meta.columns[propertyName]) {
+    return;
+  }
+  addColumnMetadata(ctor, propertyName, column);
+};
+function Column(definition) {
+  const normalized = normalizeColumnInput(definition);
+  const decorator = (target, propertyKey) => {
+    const propertyName = normalizePropertyName(propertyKey);
+    const ctor = resolveConstructor(target);
+    if (!ctor) {
+      throw new Error("Unable to resolve constructor when registering column metadata");
+    }
+    registerColumn(ctor, propertyName, { ...normalized });
+  };
+  return decorator;
+}
+function PrimaryKey(definition) {
+  const normalized = normalizeColumnInput(definition);
+  normalized.primary = true;
+  return Column(normalized);
+}
+
+// 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/decorators/relations.ts
+var normalizePropertyName2 = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+var resolveConstructor2 = (instanceOrCtor) => {
+  if (typeof instanceOrCtor === "function") {
+    return instanceOrCtor;
+  }
+  if (instanceOrCtor && typeof instanceOrCtor.constructor === "function") {
+    return instanceOrCtor.constructor;
+  }
+  return void 0;
+};
+var registerRelation = (ctor, propertyName, metadata) => {
+  addRelationMetadata(ctor, propertyName, metadata);
+};
+var createFieldDecorator = (metadataFactory) => {
+  const decorator = (target, propertyKey) => {
+    const propertyName = normalizePropertyName2(propertyKey);
+    const ctor = resolveConstructor2(target);
+    if (!ctor) {
+      throw new Error("Unable to resolve constructor when registering relation metadata");
+    }
+    registerRelation(ctor, propertyName, metadataFactory(propertyName));
+  };
+  return decorator;
+};
+function HasMany(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.HasMany,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+function BelongsTo(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.BelongsTo,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+function BelongsToMany(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.BelongsToMany,
+    propertyKey: propertyName,
+    target: options.target,
+    pivotTable: options.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 toNode = (col) => {
+  if (isOperandNode(col)) return col;
+  const def = col;
+  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 = (col) => toNode(col);
+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 and = (...operands) => ({
+  type: "LogicalExpression",
+  operator: "AND",
+  operands
+});
+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 exists = (subquery) => ({
+  type: "ExistsExpression",
+  operator: "EXISTS",
+  subquery
+});
+var notExists = (subquery) => ({
+  type: "ExistsExpression",
+  operator: "NOT EXISTS",
+  subquery
+});
+
+// src/core/ast/aggregate-functions.ts
+var buildAggregate = (name) => (col) => ({
+  type: "Function",
+  name,
+  args: [columnOperand(col)]
+});
+var count = buildAggregate("COUNT");
+var sum = buildAggregate("SUM");
+var avg = buildAggregate("AVG");
+
+// 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((col) => !excluded.has(col));
+};
+
+// 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
+  };
+};
+
+// src/query-builder/raw-column-parser.ts
+var parseRawColumn = (col, tableName, ctes) => {
+  if (col.includes("(")) {
+    const [fn, rest] = col.split("(");
+    const colName = rest.replace(")", "");
+    const [table, name] = colName.includes(".") ? colName.split(".") : [tableName, colName];
+    return { type: "Column", table, name, alias: col };
+  }
+  if (col.includes(".")) {
+    const [potentialCteName, columnName] = col.split(".");
+    const hasCte = ctes?.some((cte) => cte.name === potentialCteName);
+    if (hasCte) {
+      return { type: "Column", table: tableName, name: col };
+    }
+    return { type: "Column", table: potentialCteName, name: columnName };
+  }
+  return { type: "Column", table: tableName, name: col };
+};
+
+// 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((col) => parseRawColumn(col, 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(col) {
+    const node = buildColumnNode(this.table, col);
+    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(col, direction) {
+    const node = buildColumnNode(this.table, col);
+    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((col) => !isRelationAlias(col.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((col) => {
+      const alias = col.alias;
+      const name = alias || col.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 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((col) => buildColumnNode(this.env.table, col));
+    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 col of rel.columns) {
+    const key = makeRelationAlias(rel.aliasPrefix, col);
+    child[col] = 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 col of rel.pivot.columns) {
+    const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
+    pivot[col] = 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(col) {
+    const nextContext = this.applyAst(this.context, (service) => service.withGroupBy(col));
+    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(col, direction = ORDER_DIRECTIONS.ASC) {
+    const nextContext = this.applyAst(this.context, (service) => service.withOrderBy(col, 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);
+  }
+};
+
+// src/decorators/bootstrap.ts
+var isTableDef = (value) => {
+  return typeof value === "object" && value !== null && "columns" in value;
+};
+var unwrapTarget = (target) => {
+  if (typeof target === "function" && target.prototype === void 0) {
+    return target();
+  }
+  return target;
+};
+var resolveTableTarget = (target, tableMap) => {
+  const resolved = unwrapTarget(target);
+  if (isTableDef(resolved)) {
+    return resolved;
+  }
+  const table = tableMap.get(resolved);
+  if (!table) {
+    throw new Error(`Entity '${resolved.name}' is not registered with decorators`);
+  }
+  return table;
+};
+var buildRelationDefinitions = (meta, tableMap) => {
+  const relations = {};
+  for (const [name, relation] of Object.entries(meta.relations)) {
+    switch (relation.kind) {
+      case RelationKinds.HasMany: {
+        relations[name] = hasMany(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.BelongsTo: {
+        relations[name] = belongsTo(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.BelongsToMany: {
+        relations[name] = belongsToMany(
+          resolveTableTarget(relation.target, tableMap),
+          resolveTableTarget(relation.pivotTable, tableMap),
+          {
+            pivotForeignKeyToRoot: relation.pivotForeignKeyToRoot,
+            pivotForeignKeyToTarget: relation.pivotForeignKeyToTarget,
+            localKey: relation.localKey,
+            targetKey: relation.targetKey,
+            pivotPrimaryKey: relation.pivotPrimaryKey,
+            defaultPivotColumns: relation.defaultPivotColumns,
+            cascade: relation.cascade
+          }
+        );
+        break;
+      }
+    }
+  }
+  return relations;
+};
+var bootstrapEntities = () => {
+  const metas = getAllEntityMetadata();
+  const tableMap = /* @__PURE__ */ new Map();
+  for (const meta of metas) {
+    const table = buildTableDef(meta);
+    tableMap.set(meta.target, table);
+  }
+  for (const meta of metas) {
+    const table = meta.table;
+    const relations = buildRelationDefinitions(meta, tableMap);
+    table.relations = relations;
+  }
+  return metas.map((meta) => meta.table);
+};
+var getTableDefFromEntity = (ctor) => {
+  const meta = getEntityMetadata(ctor);
+  if (!meta) return void 0;
+  return meta.table;
+};
+var selectFromEntity = (ctor) => {
+  const table = getTableDefFromEntity(ctor);
+  if (!table) {
+    throw new Error("Entity metadata has not been bootstrapped");
+  }
+  return new SelectQueryBuilder(table);
+};
+export {
+  BelongsTo,
+  BelongsToMany,
+  Column,
+  Entity,
+  HasMany,
+  PrimaryKey,
+  bootstrapEntities,
+  getTableDefFromEntity,
+  selectFromEntity
+};
+//# sourceMappingURL=index.js.map