metal-orm 1.1.7 → 1.1.9

package/dist/index.cjs

@@ -395,6 +395,7 @@ __export(index_exports, {
   sub: () => sub,
   substr: () => substr,
   sum: () => sum,
+  syncTreeEntityMetadata: () => syncTreeEntityMetadata,
   synchronizeSchema: () => synchronizeSchema,
   tableRef: () => tableRef,
   tan: () => tan,
@@ -7713,6 +7714,193 @@ function buildWhereHasPredicate(env, context, relationFacet, createChildBuilder,
   return negate ? notExists(finalSubAst) : exists(finalSubAst);
 }
 
+// src/query-builder/select/cursor-pagination.ts
+function encodeCursor(payload) {
+  return Buffer.from(JSON.stringify(payload)).toString("base64url");
+}
+function decodeCursor(cursor) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("executeCursor: invalid cursor format");
+  }
+  if (typeof parsed !== "object" || parsed === null || parsed.v !== 2 || !Array.isArray(parsed.values) || typeof parsed.orderSig !== "string") {
+    throw new Error("executeCursor: invalid cursor payload");
+  }
+  return parsed;
+}
+function buildOrderSignature(specs) {
+  return specs.map((s) => `${s.table}.${s.column}:${s.direction}`).join(",");
+}
+function extractOrderSpecs(ast) {
+  if (!ast.orderBy || ast.orderBy.length === 0) {
+    throw new Error("executeCursor: ORDER BY is required for cursor pagination");
+  }
+  return ast.orderBy.map((ob) => {
+    if (ob.nulls) {
+      throw new Error("executeCursor: NULLS FIRST/LAST is not supported for cursor pagination");
+    }
+    const term = ob.term;
+    if (!term || term.type !== "Column") {
+      throw new Error(
+        "executeCursor: only column references are supported in ORDER BY for cursor pagination"
+      );
+    }
+    const col2 = term;
+    return {
+      table: col2.table,
+      column: col2.name,
+      valueKey: resolveOrderValueKey(ast, col2),
+      direction: ob.direction
+    };
+  });
+}
+function resolveOrderValueKey(ast, col2) {
+  const projectedColumn = ast.columns.find(
+    (candidate) => candidate.type === "Column" && candidate.table === col2.table && candidate.name === col2.name
+  );
+  return projectedColumn?.alias ?? projectedColumn?.name ?? col2.alias ?? col2.name;
+}
+function buildKeysetPredicate(specs, values, mode) {
+  if (values.length !== specs.length) {
+    throw new Error("executeCursor: invalid cursor payload");
+  }
+  const branches = [];
+  for (let i = 0; i < specs.length; i++) {
+    const spec = specs[i];
+    const colNode = { type: "Column", table: spec.table, name: spec.column };
+    const value = values[i];
+    if (value === null || value === void 0) {
+      throw new Error("executeCursor: invalid cursor payload");
+    }
+    const literal = { type: "Literal", value };
+    let operator;
+    if (mode === "after") {
+      operator = spec.direction === "ASC" ? ">" : "<";
+    } else {
+      operator = spec.direction === "ASC" ? "<" : ">";
+    }
+    const eqParts = [];
+    for (let j = 0; j < i; j++) {
+      const prevSpec = specs[j];
+      const prevCol = { type: "Column", table: prevSpec.table, name: prevSpec.column };
+      const prevValue = values[j];
+      if (prevValue === null || prevValue === void 0) {
+        throw new Error("executeCursor: invalid cursor payload");
+      }
+      const prevVal = { type: "Literal", value: prevValue };
+      eqParts.push({
+        type: "BinaryExpression",
+        left: prevCol,
+        operator: "=",
+        right: prevVal
+      });
+    }
+    const breakExpr = {
+      type: "BinaryExpression",
+      left: colNode,
+      operator,
+      right: literal
+    };
+    if (eqParts.length === 0) {
+      branches.push(breakExpr);
+    } else {
+      branches.push(and(...eqParts, breakExpr));
+    }
+  }
+  return branches.length === 1 ? branches[0] : or(...branches);
+}
+function buildCursorFromRow(row, specs) {
+  const values = specs.map((spec) => {
+    const value = row[spec.valueKey];
+    if (value === null || value === void 0) {
+      throw new Error("executeCursor: cursor pagination requires non-null ORDER BY values");
+    }
+    return value;
+  });
+  return encodeCursor({ v: 2, values, orderSig: buildOrderSignature(specs) });
+}
+function reverseDirection(direction) {
+  return direction === "ASC" ? "DESC" : "ASC";
+}
+function createExecutionBuilder(builder, options) {
+  const internals = builder.getInternals();
+  const baseAst = internals.context.state.ast;
+  const orderBy = options.reverseOrder && baseAst.orderBy ? baseAst.orderBy.map((order) => ({
+    ...order,
+    direction: reverseDirection(order.direction)
+  })) : baseAst.orderBy;
+  const nextAst = {
+    ...baseAst,
+    where: options.predicate ? baseAst.where ? and(baseAst.where, options.predicate) : options.predicate : baseAst.where,
+    orderBy,
+    limit: options.limit
+  };
+  const nextContext = {
+    ...internals.context,
+    state: new SelectQueryState(builder.getTable(), nextAst)
+  };
+  return internals.clone(nextContext, internals.includeTree);
+}
+async function executeCursorQuery(builder, session, options) {
+  const { first, after, last, before } = options;
+  if (first != null && last != null) {
+    throw new Error('executeCursor: "first" and "last" cannot be used together');
+  }
+  if (after != null && before != null) {
+    throw new Error('executeCursor: "after" and "before" cannot be used together');
+  }
+  if (first == null && last == null) {
+    throw new Error('executeCursor: either "first" or "last" must be provided');
+  }
+  const limit = first ?? last;
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error(`executeCursor: "${first != null ? "first" : "last"}" must be an integer >= 1`);
+  }
+  const isBackward = last != null;
+  const cursor = after ?? before;
+  const ast = builder.getInternals().context.state.ast;
+  const specs = extractOrderSpecs(ast);
+  let predicate;
+  if (cursor) {
+    const decoded = decodeCursor(cursor);
+    const expectedSig = buildOrderSignature(specs);
+    if (decoded.orderSig !== expectedSig) {
+      throw new Error(
+        "executeCursor: cursor ORDER BY signature does not match the current query. The ORDER BY clause must remain the same between paginated requests."
+      );
+    }
+    predicate = buildKeysetPredicate(specs, decoded.values, isBackward ? "before" : "after");
+  }
+  const executionBuilder = createExecutionBuilder(builder, {
+    predicate,
+    limit: limit + 1,
+    reverseOrder: isBackward
+  });
+  const rows = await executionBuilder.execute(session);
+  const hasExtraItem = rows.length > limit;
+  if (hasExtraItem) {
+    rows.pop();
+  }
+  const orderedRows = isBackward ? rows.reverse() : rows;
+  const items = orderedRows;
+  const hasItems = items.length > 0;
+  const hasNextPage2 = hasItems ? isBackward ? before != null : hasExtraItem : false;
+  const hasPreviousPage = hasItems ? isBackward ? hasExtraItem : after != null : false;
+  const startCursor = hasItems ? buildCursorFromRow(items[0], specs) : null;
+  const endCursor = hasItems ? buildCursorFromRow(items[items.length - 1], specs) : null;
+  return {
+    items,
+    pageInfo: {
+      hasNextPage: hasNextPage2,
+      hasPreviousPage,
+      startCursor,
+      endCursor
+    }
+  };
+}
+
 // src/query-builder/select/from-facet.ts
 var SelectFromFacet = class {
   /**
@@ -8739,7 +8927,38 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return executePagedQuery(builder, session, options, (sess) => builder.count(sess));
   }
   /**
-   * Executes the query and returns an array of values for a single column.
+   * Executes the query using cursor-based (keyset) pagination.
+   * Requires a stable ORDER BY on selected, non-null columns.
+   * Cursor pagination currently supports simple column references only and
+   * the cursor token is opaque: it must be reused with the same ORDER BY signature.
+   *
+   * @param session - ORM session context
+   * @param options - Cursor pagination options (`first`/`after` or `last`/`before`)
+   * @returns Promise of cursor-paginated result with items and pageInfo
+   * @example
+   * const page1 = await selectFrom(users)
+   *   .orderBy(users.columns.createdAt, 'DESC')
+   *   .orderBy(users.columns.id, 'DESC')
+   *   .executeCursor(session, { first: 20 });
+   *
+   * // Next page
+   * const page2 = await selectFrom(users)
+   *   .orderBy(users.columns.createdAt, 'DESC')
+   *   .orderBy(users.columns.id, 'DESC')
+   *   .executeCursor(session, { first: 20, after: page1.pageInfo.endCursor });
+   *
+   * // Previous page from a known cursor
+   * const prevPage = await selectFrom(users)
+   *   .orderBy(users.columns.createdAt, 'DESC')
+   *   .orderBy(users.columns.id, 'DESC')
+   *   .executeCursor(session, { last: 20, before: page2.pageInfo.startCursor });
+   */
+  async executeCursor(session, options) {
+    const builder = this.ensureDefaultSelection();
+    return executeCursorQuery(builder, session, options);
+  }
+  /**
+    * Executes the query and returns an array of values for a single column.
    * This is a convenience method to avoid manual `.map(r => r.column)`.
    *
    * @param column - The column name to extract
@@ -14969,6 +15188,265 @@ var jsonify = (value) => {
   return result;
 };
 
+// src/tree/tree-types.ts
+var DEFAULT_TREE_CONFIG = {
+  parentKey: "parentId",
+  leftKey: "lft",
+  rightKey: "rght",
+  cascadeCallbacks: false
+};
+function isTreeConfig(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return typeof obj.parentKey === "string" && typeof obj.leftKey === "string" && typeof obj.rightKey === "string";
+}
+function resolveTreeConfig(partial) {
+  return {
+    parentKey: partial.parentKey ?? DEFAULT_TREE_CONFIG.parentKey,
+    leftKey: partial.leftKey ?? DEFAULT_TREE_CONFIG.leftKey,
+    rightKey: partial.rightKey ?? DEFAULT_TREE_CONFIG.rightKey,
+    depthKey: partial.depthKey,
+    scope: partial.scope,
+    cascadeCallbacks: partial.cascadeCallbacks ?? DEFAULT_TREE_CONFIG.cascadeCallbacks,
+    recoverOrder: partial.recoverOrder
+  };
+}
+function validateTreeTable(table, config) {
+  const missingColumns = [];
+  const warnings = [];
+  const requiredColumns = [config.parentKey, config.leftKey, config.rightKey];
+  for (const col2 of requiredColumns) {
+    if (!(col2 in table.columns)) {
+      missingColumns.push(col2);
+    }
+  }
+  if (config.depthKey && !(config.depthKey in table.columns)) {
+    warnings.push(`Optional depth column '${config.depthKey}' not found in table '${table.name}'`);
+  }
+  if (config.scope) {
+    for (const scopeCol of config.scope) {
+      if (!(scopeCol in table.columns)) {
+        missingColumns.push(scopeCol);
+      }
+    }
+  }
+  const leftCol = table.columns[config.leftKey];
+  const rightCol = table.columns[config.rightKey];
+  if (leftCol && leftCol.type !== "int" && leftCol.type !== "integer") {
+    warnings.push(`Left column '${config.leftKey}' should be an integer type`);
+  }
+  if (rightCol && rightCol.type !== "int" && rightCol.type !== "integer") {
+    warnings.push(`Right column '${config.rightKey}' should be an integer type`);
+  }
+  return {
+    valid: missingColumns.length === 0,
+    missingColumns,
+    warnings
+  };
+}
+function getTreeColumns(table, config) {
+  const parentColumn = table.columns[config.parentKey];
+  const leftColumn = table.columns[config.leftKey];
+  const rightColumn = table.columns[config.rightKey];
+  const depthColumn = config.depthKey ? table.columns[config.depthKey] : void 0;
+  const scopeColumns = (config.scope ?? []).map((s) => table.columns[s]).filter(Boolean);
+  if (!parentColumn || !leftColumn || !rightColumn) {
+    throw new Error(
+      `Table '${table.name}' is missing required tree columns. Required: ${config.parentKey}, ${config.leftKey}, ${config.rightKey}`
+    );
+  }
+  return {
+    parentColumn,
+    leftColumn,
+    rightColumn,
+    depthColumn,
+    scopeColumns
+  };
+}
+
+// src/tree/tree-decorator.ts
+var TREE_METADATA_KEY = /* @__PURE__ */ Symbol("metal-orm:tree");
+function Tree(options = {}) {
+  return function(target, context) {
+    const config = resolveTreeConfig(options);
+    const metadataBag = readMetadataBag(context) ?? readMetadataBagFromConstructor(target);
+    const metadata = {
+      config,
+      parentProperty: metadataBag?.tree?.parentProperty,
+      childrenProperty: metadataBag?.tree?.childrenProperty
+    };
+    setTreeMetadataOnClass(target, metadata);
+    registerTreeRelations(target, metadata);
+    return target;
+  };
+}
+function TreeParent() {
+  return function(_value, context) {
+    if (!context.name) {
+      throw new Error("TreeParent decorator requires a property name");
+    }
+    if (context.private) {
+      throw new Error("TreeParent decorator does not support private fields");
+    }
+    const propertyName = String(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    bag.tree = { ...bag.tree, parentProperty: propertyName };
+  };
+}
+function TreeChildren() {
+  return function(_value, context) {
+    if (!context.name) {
+      throw new Error("TreeChildren decorator requires a property name");
+    }
+    if (context.private) {
+      throw new Error("TreeChildren decorator does not support private fields");
+    }
+    const propertyName = String(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    bag.tree = { ...bag.tree, childrenProperty: propertyName };
+  };
+}
+function syncTreeEntityMetadata(ctor, treeMetadata) {
+  const current = getTreeMetadata(ctor);
+  if (!current) return;
+  const metadataBag = readMetadataBagFromConstructor(ctor);
+  const nextParentProperty = treeMetadata?.parentProperty ?? metadataBag?.tree?.parentProperty ?? current.parentProperty;
+  const nextChildrenProperty = treeMetadata?.childrenProperty ?? metadataBag?.tree?.childrenProperty ?? current.childrenProperty;
+  if (nextParentProperty !== current.parentProperty || nextChildrenProperty !== current.childrenProperty) {
+    setTreeMetadata(ctor, {
+      ...current,
+      parentProperty: nextParentProperty,
+      childrenProperty: nextChildrenProperty
+    });
+  }
+  registerTreeRelations(ctor, {
+    ...current,
+    parentProperty: nextParentProperty,
+    childrenProperty: nextChildrenProperty
+  });
+}
+function getTreeMetadata(target) {
+  return target[TREE_METADATA_KEY];
+}
+function setTreeMetadata(target, metadata) {
+  target[TREE_METADATA_KEY] = metadata;
+}
+var registerTreeRelations = (target, metadata) => {
+  const entityMeta = getEntityMetadata(target);
+  if (!entityMeta) return;
+  if (metadata.parentProperty && !entityMeta.relations[metadata.parentProperty]) {
+    addRelationMetadata(target, metadata.parentProperty, {
+      kind: RelationKinds.BelongsTo,
+      propertyKey: metadata.parentProperty,
+      target: () => target,
+      foreignKey: metadata.config.parentKey
+    });
+    if (entityMeta.table && !entityMeta.table.relations[metadata.parentProperty]) {
+      entityMeta.table.relations[metadata.parentProperty] = belongsTo(
+        entityMeta.table,
+        metadata.config.parentKey
+      );
+    }
+  }
+  if (metadata.childrenProperty && !entityMeta.relations[metadata.childrenProperty]) {
+    addRelationMetadata(target, metadata.childrenProperty, {
+      kind: RelationKinds.HasMany,
+      propertyKey: metadata.childrenProperty,
+      target: () => target,
+      foreignKey: metadata.config.parentKey
+    });
+    if (entityMeta.table && !entityMeta.table.relations[metadata.childrenProperty]) {
+      entityMeta.table.relations[metadata.childrenProperty] = hasMany(
+        entityMeta.table,
+        metadata.config.parentKey
+      );
+    }
+  }
+};
+function setTreeMetadataOnClass(target, metadata) {
+  target[TREE_METADATA_KEY] = metadata;
+}
+function hasTreeBehavior(target) {
+  return getTreeMetadata(target) !== void 0;
+}
+function getTreeConfig(target) {
+  return getTreeMetadata(target)?.config;
+}
+var TreeEntityRegistry = class {
+  entities = /* @__PURE__ */ new Map();
+  tableNames = /* @__PURE__ */ new Map();
+  /**
+   * Registers an entity class with its table name.
+   */
+  register(entityClass, tableName) {
+    this.entities.set(tableName, entityClass);
+    this.tableNames.set(entityClass, tableName);
+  }
+  /**
+   * Gets the entity class for a table name.
+   */
+  getByTableName(tableName) {
+    return this.entities.get(tableName);
+  }
+  /**
+   * Gets the table name for an entity class.
+   */
+  getTableName(entityClass) {
+    return this.tableNames.get(entityClass);
+  }
+  /**
+   * Checks if a table has tree behavior.
+   */
+  isTreeTable(tableName) {
+    const entity = this.entities.get(tableName);
+    return entity ? hasTreeBehavior(entity) : false;
+  }
+  /**
+   * Gets all registered tree entities.
+   */
+  getAll() {
+    const result = [];
+    for (const [tableName, entityClass] of this.entities) {
+      const metadata = getTreeMetadata(entityClass);
+      if (metadata) {
+        result.push({ entityClass, tableName, metadata });
+      }
+    }
+    return result;
+  }
+  /**
+   * Clears the registry.
+   */
+  clear() {
+    this.entities.clear();
+    this.tableNames.clear();
+  }
+};
+var treeEntityRegistry = new TreeEntityRegistry();
+function getTreeBounds(entity, config) {
+  const data = entity;
+  const lft = data[config.leftKey];
+  const rght = data[config.rightKey];
+  if (typeof lft !== "number" || typeof rght !== "number") {
+    return null;
+  }
+  return { lft, rght };
+}
+function getTreeParentId(entity, config) {
+  return entity[config.parentKey];
+}
+function setTreeBounds(entity, config, lft, rght, depth) {
+  const data = entity;
+  data[config.leftKey] = lft;
+  data[config.rightKey] = rght;
+  if (config.depthKey && depth !== void 0) {
+    data[config.depthKey] = depth;
+  }
+}
+function setTreeParentId(entity, config, parentId) {
+  entity[config.parentKey] = parentId;
+}
+
 // src/decorators/entity.ts
 var toSnakeCase2 = (value) => {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_]+/gi, "_").replace(/__+/g, "_").replace(/^_|_$/g, "").toLowerCase();
@@ -15012,6 +15490,7 @@ function Entity(options = {}) {
         addRelationMetadata(ctor, entry.propertyName, relationCopy);
       }
     }
+    syncTreeEntityMetadata(ctor, bag?.tree);
     return ctor;
   };
 }
@@ -17938,208 +18417,6 @@ function extractReusableSchemas(schema, existing = {}, prefix = "") {
   return existing;
 }
 
-// src/tree/tree-types.ts
-var DEFAULT_TREE_CONFIG = {
-  parentKey: "parentId",
-  leftKey: "lft",
-  rightKey: "rght",
-  cascadeCallbacks: false
-};
-function isTreeConfig(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  return typeof obj.parentKey === "string" && typeof obj.leftKey === "string" && typeof obj.rightKey === "string";
-}
-function resolveTreeConfig(partial) {
-  return {
-    parentKey: partial.parentKey ?? DEFAULT_TREE_CONFIG.parentKey,
-    leftKey: partial.leftKey ?? DEFAULT_TREE_CONFIG.leftKey,
-    rightKey: partial.rightKey ?? DEFAULT_TREE_CONFIG.rightKey,
-    depthKey: partial.depthKey,
-    scope: partial.scope,
-    cascadeCallbacks: partial.cascadeCallbacks ?? DEFAULT_TREE_CONFIG.cascadeCallbacks,
-    recoverOrder: partial.recoverOrder
-  };
-}
-function validateTreeTable(table, config) {
-  const missingColumns = [];
-  const warnings = [];
-  const requiredColumns = [config.parentKey, config.leftKey, config.rightKey];
-  for (const col2 of requiredColumns) {
-    if (!(col2 in table.columns)) {
-      missingColumns.push(col2);
-    }
-  }
-  if (config.depthKey && !(config.depthKey in table.columns)) {
-    warnings.push(`Optional depth column '${config.depthKey}' not found in table '${table.name}'`);
-  }
-  if (config.scope) {
-    for (const scopeCol of config.scope) {
-      if (!(scopeCol in table.columns)) {
-        missingColumns.push(scopeCol);
-      }
-    }
-  }
-  const leftCol = table.columns[config.leftKey];
-  const rightCol = table.columns[config.rightKey];
-  if (leftCol && leftCol.type !== "int" && leftCol.type !== "integer") {
-    warnings.push(`Left column '${config.leftKey}' should be an integer type`);
-  }
-  if (rightCol && rightCol.type !== "int" && rightCol.type !== "integer") {
-    warnings.push(`Right column '${config.rightKey}' should be an integer type`);
-  }
-  return {
-    valid: missingColumns.length === 0,
-    missingColumns,
-    warnings
-  };
-}
-function getTreeColumns(table, config) {
-  const parentColumn = table.columns[config.parentKey];
-  const leftColumn = table.columns[config.leftKey];
-  const rightColumn = table.columns[config.rightKey];
-  const depthColumn = config.depthKey ? table.columns[config.depthKey] : void 0;
-  const scopeColumns = (config.scope ?? []).map((s) => table.columns[s]).filter(Boolean);
-  if (!parentColumn || !leftColumn || !rightColumn) {
-    throw new Error(
-      `Table '${table.name}' is missing required tree columns. Required: ${config.parentKey}, ${config.leftKey}, ${config.rightKey}`
-    );
-  }
-  return {
-    parentColumn,
-    leftColumn,
-    rightColumn,
-    depthColumn,
-    scopeColumns
-  };
-}
-
-// src/tree/tree-decorator.ts
-var TREE_METADATA_KEY = /* @__PURE__ */ Symbol("metal-orm:tree");
-function Tree(options = {}) {
-  return function(target) {
-    const config = resolveTreeConfig(options);
-    const metadata = { config };
-    setTreeMetadataOnClass(target, metadata);
-    return target;
-  };
-}
-function TreeParent() {
-  return function(_value, context) {
-    const propertyName = String(context.name);
-    context.addInitializer(function() {
-      const constructor = this.constructor;
-      const metadata = getTreeMetadata(constructor);
-      if (metadata) {
-        metadata.parentProperty = propertyName;
-        setTreeMetadata(constructor, metadata);
-      }
-    });
-  };
-}
-function TreeChildren() {
-  return function(_value, context) {
-    const propertyName = String(context.name);
-    context.addInitializer(function() {
-      const constructor = this.constructor;
-      const metadata = getTreeMetadata(constructor);
-      if (metadata) {
-        metadata.childrenProperty = propertyName;
-        setTreeMetadata(constructor, metadata);
-      }
-    });
-  };
-}
-function getTreeMetadata(target) {
-  return target[TREE_METADATA_KEY];
-}
-function setTreeMetadata(target, metadata) {
-  target[TREE_METADATA_KEY] = metadata;
-}
-function setTreeMetadataOnClass(target, metadata) {
-  target[TREE_METADATA_KEY] = metadata;
-}
-function hasTreeBehavior(target) {
-  return getTreeMetadata(target) !== void 0;
-}
-function getTreeConfig(target) {
-  return getTreeMetadata(target)?.config;
-}
-var TreeEntityRegistry = class {
-  entities = /* @__PURE__ */ new Map();
-  tableNames = /* @__PURE__ */ new Map();
-  /**
-   * Registers an entity class with its table name.
-   */
-  register(entityClass, tableName) {
-    this.entities.set(tableName, entityClass);
-    this.tableNames.set(entityClass, tableName);
-  }
-  /**
-   * Gets the entity class for a table name.
-   */
-  getByTableName(tableName) {
-    return this.entities.get(tableName);
-  }
-  /**
-   * Gets the table name for an entity class.
-   */
-  getTableName(entityClass) {
-    return this.tableNames.get(entityClass);
-  }
-  /**
-   * Checks if a table has tree behavior.
-   */
-  isTreeTable(tableName) {
-    const entity = this.entities.get(tableName);
-    return entity ? hasTreeBehavior(entity) : false;
-  }
-  /**
-   * Gets all registered tree entities.
-   */
-  getAll() {
-    const result = [];
-    for (const [tableName, entityClass] of this.entities) {
-      const metadata = getTreeMetadata(entityClass);
-      if (metadata) {
-        result.push({ entityClass, tableName, metadata });
-      }
-    }
-    return result;
-  }
-  /**
-   * Clears the registry.
-   */
-  clear() {
-    this.entities.clear();
-    this.tableNames.clear();
-  }
-};
-var treeEntityRegistry = new TreeEntityRegistry();
-function getTreeBounds(entity, config) {
-  const data = entity;
-  const lft = data[config.leftKey];
-  const rght = data[config.rightKey];
-  if (typeof lft !== "number" || typeof rght !== "number") {
-    return null;
-  }
-  return { lft, rght };
-}
-function getTreeParentId(entity, config) {
-  return entity[config.parentKey];
-}
-function setTreeBounds(entity, config, lft, rght, depth) {
-  const data = entity;
-  data[config.leftKey] = lft;
-  data[config.rightKey] = rght;
-  if (config.depthKey && depth !== void 0) {
-    data[config.depthKey] = depth;
-  }
-}
-function setTreeParentId(entity, config, parentId) {
-  entity[config.parentKey] = parentId;
-}
-
 // src/dto/openapi/generators/tree.ts
 function threadedNodeToOpenApiSchema(target, options) {
   const componentName = options?.componentName;
@@ -20164,6 +20441,7 @@ var TagIndex = class {
   sub,
   substr,
   sum,
+  syncTreeEntityMetadata,
   synchronizeSchema,
   tableRef,
   tan,