metal-orm 1.0.113 → 1.0.115

package/dist/index.cjs

@@ -48,6 +48,7 @@ __export(index_exports, {
   BelongsTo: () => BelongsTo,
   BelongsToMany: () => BelongsToMany,
   BigIntTypeStrategy: () => BigIntTypeStrategy,
+  BinaryTypeStrategy: () => BinaryTypeStrategy,
   BooleanTypeStrategy: () => BooleanTypeStrategy,
   CEP: () => CEP,
   CNPJ: () => CNPJ,
@@ -217,6 +218,7 @@ __export(index_exports, {
   generateRelationComponents: () => generateRelationComponents,
   generateSchemaSql: () => generateSchemaSql,
   generateSchemaSqlFor: () => generateSchemaSqlFor,
+  generateTreeComponents: () => generateTreeComponents,
   getColumn: () => getColumn,
   getColumnMap: () => getColumnMap,
   getColumnType: () => getColumnType,
@@ -380,6 +382,7 @@ __export(index_exports, {
   tableRef: () => tableRef,
   tan: () => tan,
   threadResults: () => threadResults,
+  threadedNodeToOpenApiSchema: () => threadedNodeToOpenApiSchema,
   toColumnRef: () => toColumnRef,
   toPagedResponse: () => toPagedResponse,
   toPagedResponseBuilder: () => toPagedResponseBuilder,
@@ -388,6 +391,9 @@ __export(index_exports, {
   toResponseBuilder: () => toResponseBuilder,
   toTableRef: () => toTableRef,
   treeEntityRegistry: () => treeEntityRegistry,
+  treeListEntryToOpenApiSchema: () => treeListEntryToOpenApiSchema,
+  treeNodeResultToOpenApiSchema: () => treeNodeResultToOpenApiSchema,
+  treeNodeToOpenApiSchema: () => treeNodeToOpenApiSchema,
   treeQuery: () => treeQuery,
   trim: () => trim,
   trunc: () => trunc,
@@ -15073,6 +15079,18 @@ var UuidTypeStrategy = class {
     return "uuid";
   }
 };
+var BinaryTypeStrategy = class {
+  types = ["BLOB", "BINARY", "VARBINARY", "BYTEA"];
+  supports(type) {
+    return this.types.includes(type.toUpperCase());
+  }
+  getOpenApiType() {
+    return "string";
+  }
+  getFormat() {
+    return "byte";
+  }
+};
 var DateTimeTypeStrategy = class {
   types = ["DATE", "DATETIME", "TIMESTAMP", "TIMESTAMPTZ"];
   supports(type) {
@@ -15091,9 +15109,6 @@ var StringTypeStrategy = class {
     "TEXT",
     "VARCHAR",
     "CHAR",
-    "BINARY",
-    "VARBINARY",
-    "BLOB",
     "ENUM"
   ];
   supports(type) {
@@ -15127,6 +15142,7 @@ var TypeMappingService = class {
       new BooleanTypeStrategy(),
       new DateTimeTypeStrategy(),
       new UuidTypeStrategy(),
+      new BinaryTypeStrategy(),
       new StringTypeStrategy(),
       new DefaultTypeStrategy()
     ];
@@ -15955,6 +15971,406 @@ 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;
+  const nodeSchema = entityToOpenApiSchema(target, options);
+  const treeNodeSchema = {
+    type: "object",
+    properties: {
+      node: nodeSchema,
+      children: {
+        type: "array",
+        items: componentName ? { $ref: `#/components/schemas/${componentName}` } : {},
+        description: "Child nodes in the tree hierarchy"
+      }
+    },
+    required: ["node", "children"],
+    description: "A node in a threaded tree structure with nested children"
+  };
+  return treeNodeSchema;
+}
+function treeNodeToOpenApiSchema(target, options) {
+  const includeMetadata = options?.includeTreeMetadata ?? true;
+  const entitySchema = entityToOpenApiSchema(target, options);
+  const properties = {
+    entity: entitySchema,
+    lft: {
+      type: "integer",
+      description: "Left boundary value (nested set)"
+    },
+    rght: {
+      type: "integer",
+      description: "Right boundary value (nested set)"
+    },
+    isLeaf: {
+      type: "boolean",
+      description: "Whether this node has no children"
+    },
+    isRoot: {
+      type: "boolean",
+      description: "Whether this node has no parent"
+    },
+    childCount: {
+      type: "integer",
+      minimum: 0,
+      description: "Number of descendants"
+    }
+  };
+  if (includeMetadata) {
+    properties.depth = {
+      type: "integer",
+      minimum: 0,
+      description: "Depth level (0 = root)"
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required: ["entity", "lft", "rght", "isLeaf", "isRoot", "childCount"],
+    description: "A tree node with nested set boundaries and metadata"
+  };
+}
+function treeNodeResultToOpenApiSchema(target, options) {
+  const includeMetadata = options?.includeTreeMetadata ?? true;
+  const entitySchema = entityToOpenApiSchema(target, options);
+  const parentKey = resolveParentKey(target, options);
+  const parentSchema = resolveParentSchema(target, parentKey, options?.dialect);
+  const parentIdSchema = {
+    ...parentSchema,
+    description: parentSchema.description ?? "Parent identifier (null for roots)"
+  };
+  const properties = {
+    data: entitySchema,
+    lft: {
+      type: "integer",
+      description: "Left boundary value (nested set)"
+    },
+    rght: {
+      type: "integer",
+      description: "Right boundary value (nested set)"
+    },
+    parentId: parentIdSchema,
+    isLeaf: {
+      type: "boolean",
+      description: "Whether this node has no children"
+    },
+    isRoot: {
+      type: "boolean",
+      description: "Whether this node has no parent"
+    }
+  };
+  if (includeMetadata) {
+    properties.depth = {
+      type: "integer",
+      minimum: 0,
+      description: "Depth level (0 = root)"
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required: ["data", "lft", "rght", "parentId", "isLeaf", "isRoot"],
+    description: "A tree node result with nested set boundaries and metadata"
+  };
+}
+function treeListEntryToOpenApiSchema(options) {
+  const keyType = options?.keyType ?? "integer";
+  const valueType = options?.valueType ?? "string";
+  return {
+    type: "object",
+    properties: {
+      key: {
+        type: keyType,
+        description: "The key (usually primary key)"
+      },
+      value: {
+        type: valueType,
+        description: "The display value with depth prefix"
+      },
+      depth: {
+        type: "integer",
+        minimum: 0,
+        description: "The depth level"
+      }
+    },
+    required: ["key", "value", "depth"],
+    description: "A tree list entry for dropdown/select rendering"
+  };
+}
+function generateTreeComponents(target, baseName, options) {
+  const threadedNodeName = `${baseName}TreeNode`;
+  return {
+    [baseName]: entityToOpenApiSchema(target, options),
+    [`${baseName}Node`]: treeNodeToOpenApiSchema(target, options),
+    [`${baseName}NodeResult`]: treeNodeResultToOpenApiSchema(target, options),
+    [threadedNodeName]: threadedNodeToOpenApiSchema(target, {
+      ...options,
+      componentName: threadedNodeName
+    }),
+    [`${baseName}TreeList`]: {
+      type: "array",
+      items: treeListEntryToOpenApiSchema(),
+      description: `Flat list of ${baseName} tree entries for dropdown/select`
+    },
+    [`${baseName}ThreadedTree`]: {
+      type: "array",
+      items: { $ref: `#/components/schemas/${threadedNodeName}` },
+      description: `Threaded tree structure of ${baseName} nodes`
+    }
+  };
+}
+function entityToOpenApiSchema(target, options) {
+  const columns = getColumnMap(target);
+  const properties = {};
+  const required = [];
+  const dialect = options?.dialect ?? "openapi-3.1";
+  for (const [key, col2] of Object.entries(columns)) {
+    if (options?.exclude?.includes(key)) {
+      continue;
+    }
+    if (options?.include && !options.include.includes(key)) {
+      continue;
+    }
+    properties[key] = columnToOpenApiSchema(col2, dialect);
+    if (col2.notNull || col2.primary) {
+      required.push(key);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 && { required }
+  };
+}
+function resolveParentSchema(target, parentKey, dialect = "openapi-3.1") {
+  const columns = getColumnMap(target);
+  const parentColumn = columns[parentKey] ?? findColumnByName(columns, parentKey);
+  if (parentColumn) {
+    return columnToOpenApiSchema(parentColumn, dialect);
+  }
+  return {
+    type: ["string", "null"]
+  };
+}
+function resolveParentKey(target, options) {
+  if (options?.parentKey) {
+    return options.parentKey;
+  }
+  if (!isTableDef2(target)) {
+    const config = getTreeConfig(target);
+    if (config?.parentKey) {
+      return config.parentKey;
+    }
+  }
+  return "parentId";
+}
+function findColumnByName(columns, columnName) {
+  return Object.values(columns).find((col2) => col2.name === columnName);
+}
+
 // src/dto/openapi/generators/pagination.ts
 var paginationParamsSchema = {
   type: "object",
@@ -16055,82 +16471,6 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   };
 }
 
-// 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/nested-set-strategy.ts
 var NestedSetStrategy = class {
   /**
@@ -17196,132 +17536,6 @@ function queryResultsToRows(results) {
   }
   return rows;
 }
-
-// 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;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Alphanumeric,
@@ -17329,6 +17543,7 @@ function setTreeParentId(entity, config, parentId) {
   BelongsTo,
   BelongsToMany,
   BigIntTypeStrategy,
+  BinaryTypeStrategy,
   BooleanTypeStrategy,
   CEP,
   CNPJ,
@@ -17498,6 +17713,7 @@ function setTreeParentId(entity, config, parentId) {
   generateRelationComponents,
   generateSchemaSql,
   generateSchemaSqlFor,
+  generateTreeComponents,
   getColumn,
   getColumnMap,
   getColumnType,
@@ -17661,6 +17877,7 @@ function setTreeParentId(entity, config, parentId) {
   tableRef,
   tan,
   threadResults,
+  threadedNodeToOpenApiSchema,
   toColumnRef,
   toPagedResponse,
   toPagedResponseBuilder,
@@ -17669,6 +17886,9 @@ function setTreeParentId(entity, config, parentId) {
   toResponseBuilder,
   toTableRef,
   treeEntityRegistry,
+  treeListEntryToOpenApiSchema,
+  treeNodeResultToOpenApiSchema,
+  treeNodeToOpenApiSchema,
   treeQuery,
   trim,
   trunc,