drizzle-docs-generator 0.7.0 → 0.7.2

package/dist/adapter/v0-adapter.js

@@ -1,136 +1,70 @@
-import { getTableName as g, is as c, getTableColumns as h } from "drizzle-orm";
-import { PgTable as b } from "drizzle-orm/pg-core";
-import { MySqlTable as T } from "drizzle-orm/mysql-core";
-import { SQLiteTable as M } from "drizzle-orm/sqlite-core";
-class $ {
-  schema;
-  parsedRelations;
-  tableNameMapping;
-  columnNameMappings;
-  /**
-   * Create a new V0RelationAdapter
-   *
-   * @param schema - The Drizzle schema object containing tables
-   * @param parsedRelations - Parsed relation information from TypeScript source
-   */
-  constructor(t, s) {
-    this.schema = t, this.parsedRelations = s, this.tableNameMapping = this.buildTableNameMapping(), this.columnNameMappings = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Extract relations from v0 relations() definitions
-   *
-   * Processes parsed relation information to extract foreign key relationships,
-   * determining relation types (one-to-one vs many-to-one) based on bidirectional
-   * analysis.
-   *
-   * @returns Array of unified relations
-   */
-  extract() {
-    if (!this.parsedRelations || this.parsedRelations.relations.length === 0)
-      return [];
-    const t = [], s = /* @__PURE__ */ new Set();
-    for (const e of this.parsedRelations.relations) {
-      if (e.type !== "one" || e.fields.length === 0 || e.references.length === 0)
-        continue;
-      const a = this.tableNameMapping.get(e.sourceTable), n = this.tableNameMapping.get(e.targetTable);
-      if (!a || !n)
-        continue;
-      const o = this.getColumnNameMapping(e.sourceTable), r = this.getColumnNameMapping(e.targetTable), l = e.fields.map(
-        (i) => o.get(i) || i
-      ), p = e.references.map((i) => r.get(i) || i), m = `${a}.${l.join(",")}-${n}.${p.join(",")}`, u = `${n}.${p.join(",")}-${a}.${l.join(",")}`;
-      if (s.has(m) || s.has(u))
-        continue;
-      s.add(m);
-      const f = this.hasReverseOneRelation(
-        e.sourceTable,
-        e.targetTable,
-        e.fields,
-        e.references
-      );
-      t.push({
-        sourceTable: a,
-        sourceColumns: l,
-        targetTable: n,
-        targetColumns: p,
-        relationType: f ? "one-to-one" : "many-to-one"
-      });
-    }
-    return t;
-  }
-  /**
-   * Build a mapping from variable names to table names
-   *
-   * @returns Map of variable names to database table names
-   */
-  buildTableNameMapping() {
-    const t = /* @__PURE__ */ new Map();
-    for (const [s, e] of Object.entries(this.schema))
-      if (this.isTable(e)) {
-        const a = g(e);
-        t.set(s, a);
-      }
-    return t;
-  }
-  /**
-   * Check if a value is a Drizzle table
-   *
-   * @param value - The value to check
-   * @returns True if value is a table
-   */
-  isTable(t) {
-    return c(t, b) || c(t, T) || c(t, M);
-  }
-  /**
-   * Get column name mapping for a table
-   *
-   * @param tableVarName - The variable name of the table
-   * @returns Map of property names to database column names
-   */
-  getColumnNameMapping(t) {
-    if (this.columnNameMappings.has(t))
-      return this.columnNameMappings.get(t);
-    const s = /* @__PURE__ */ new Map(), e = this.schema[t];
-    if (e && this.isTable(e)) {
-      const a = h(e);
-      for (const [n, o] of Object.entries(a))
-        s.set(n, o.name);
-    }
-    return this.columnNameMappings.set(t, s), s;
-  }
-  /**
-   * Check if there's a reverse one() relation (B->A when we have A->B)
-   *
-   * Used to detect one-to-one relationships by checking if both tables
-   * have one() relations pointing to each other.
-   *
-   * @param sourceTable - The source table variable name
-   * @param targetTable - The target table variable name
-   * @param sourceFields - The source table's field names
-   * @param targetReferences - The target table's reference column names
-   * @returns True if a reverse one() relation exists
-   */
-  hasReverseOneRelation(t, s, e, a) {
-    if (!this.parsedRelations) return !1;
-    for (const n of this.parsedRelations.relations)
-      if (n.type === "one" && n.sourceTable === s && n.targetTable === t && n.fields.length > 0 && n.references.length > 0) {
-        const o = n.fields, r = n.references;
-        if (this.arraysEqual(o, a) && this.arraysEqual(r, e))
-          return !0;
-      }
-    return !1;
-  }
-  /**
-   * Helper to check if two arrays are equal
-   *
-   * @param a - First array
-   * @param b - Second array
-   * @returns True if arrays have same length and same elements in order
-   */
-  arraysEqual(t, s) {
-    return t.length !== s.length ? !1 : t.every((e, a) => e === s[a]);
-  }
-}
-export {
-  $ as V0RelationAdapter
+import { getTableColumns as e, getTableName as t, is as n } from "drizzle-orm";
+import { PgTable as r } from "drizzle-orm/pg-core";
+import { MySqlTable as i } from "drizzle-orm/mysql-core";
+import { SQLiteTable as a } from "drizzle-orm/sqlite-core";
+//#region src/adapter/v0-adapter.ts
+var o = class {
+	schema;
+	parsedRelations;
+	tableNameMapping;
+	columnNameMappings;
+	constructor(e, t) {
+		this.schema = e, this.parsedRelations = t, this.tableNameMapping = this.buildTableNameMapping(), this.columnNameMappings = /* @__PURE__ */ new Map();
+	}
+	extract() {
+		if (!this.parsedRelations || this.parsedRelations.relations.length === 0) return [];
+		let e = [], t = /* @__PURE__ */ new Set();
+		for (let n of this.parsedRelations.relations) {
+			if (n.type !== "one" || n.fields.length === 0 || n.references.length === 0) continue;
+			let r = this.tableNameMapping.get(n.sourceTable), i = this.tableNameMapping.get(n.targetTable);
+			if (!r || !i) continue;
+			let a = this.getColumnNameMapping(n.sourceTable), o = this.getColumnNameMapping(n.targetTable), s = n.fields.map((e) => a.get(e) || e), c = n.references.map((e) => o.get(e) || e), l = `${r}.${s.join(",")}-${i}.${c.join(",")}`, u = `${i}.${c.join(",")}-${r}.${s.join(",")}`;
+			if (t.has(l) || t.has(u)) continue;
+			t.add(l);
+			let d = this.hasReverseOneRelation(n.sourceTable, n.targetTable, n.fields, n.references);
+			e.push({
+				sourceTable: r,
+				sourceColumns: s,
+				targetTable: i,
+				targetColumns: c,
+				relationType: d ? "one-to-one" : "many-to-one"
+			});
+		}
+		return e;
+	}
+	buildTableNameMapping() {
+		let e = /* @__PURE__ */ new Map();
+		for (let [n, r] of Object.entries(this.schema)) if (this.isTable(r)) {
+			let i = t(r);
+			e.set(n, i);
+		}
+		return e;
+	}
+	isTable(e) {
+		return n(e, r) || n(e, i) || n(e, a);
+	}
+	getColumnNameMapping(t) {
+		if (this.columnNameMappings.has(t)) return this.columnNameMappings.get(t);
+		let n = /* @__PURE__ */ new Map(), r = this.schema[t];
+		if (r && this.isTable(r)) {
+			let t = e(r);
+			for (let [e, r] of Object.entries(t)) n.set(e, r.name);
+		}
+		return this.columnNameMappings.set(t, n), n;
+	}
+	hasReverseOneRelation(e, t, n, r) {
+		if (!this.parsedRelations) return !1;
+		for (let i of this.parsedRelations.relations) if (i.type === "one" && i.sourceTable === t && i.targetTable === e && i.fields.length > 0 && i.references.length > 0) {
+			let e = i.fields, t = i.references;
+			if (this.arraysEqual(e, r) && this.arraysEqual(t, n)) return !0;
+		}
+		return !1;
+	}
+	arraysEqual(e, t) {
+		return e.length === t.length ? e.every((e, n) => e === t[n]) : !1;
+	}
 };
-//# sourceMappingURL=v0-adapter.js.map
+//#endregion
+export { o as V0RelationAdapter };
+
+//# sourceMappingURL=v0-adapter.js.map

package/dist/adapter/v0-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"v0-adapter.js","sources":["../../src/adapter/v0-adapter.ts"],"sourcesContent":["import { type Table, getTableColumns, getTableName, is } from \"drizzle-orm\";\nimport { PgTable } from \"drizzle-orm/pg-core\";\nimport { MySqlTable } from \"drizzle-orm/mysql-core\";\nimport { SQLiteTable } from \"drizzle-orm/sqlite-core\";\nimport type { SchemaRelations } from \"../parser/relations\";\nimport type { RelationAdapter, UnifiedRelation } from \"./types\";\n\n/**\n * Adapter for extracting relations from v0 relations() API\n *\n * Handles the legacy relations() format by parsing relation definitions\n * from the TypeScript source using the schema parser.\n */\nexport class V0RelationAdapter implements RelationAdapter {\n  private schema: Record<string, unknown>;\n  private parsedRelations: SchemaRelations | undefined;\n  private tableNameMapping: Map<string, string>;\n  private columnNameMappings: Map<string, Map<string, string>>;\n\n  /**\n   * Create a new V0RelationAdapter\n   *\n   * @param schema - The Drizzle schema object containing tables\n   * @param parsedRelations - Parsed relation information from TypeScript source\n   */\n  constructor(schema: Record<string, unknown>, parsedRelations: SchemaRelations | undefined) {\n    this.schema = schema;\n    this.parsedRelations = parsedRelations;\n    this.tableNameMapping = this.buildTableNameMapping();\n    this.columnNameMappings = new Map();\n  }\n\n  /**\n   * Extract relations from v0 relations() definitions\n   *\n   * Processes parsed relation information to extract foreign key relationships,\n   * determining relation types (one-to-one vs many-to-one) based on bidirectional\n   * analysis.\n   *\n   * @returns Array of unified relations\n   */\n  extract(): UnifiedRelation[] {\n    if (!this.parsedRelations || this.parsedRelations.relations.length === 0) {\n      return [];\n    }\n\n    const relations: UnifiedRelation[] = [];\n    const processedRefs = new Set<string>();\n\n    for (const parsedRelation of this.parsedRelations.relations) {\n      // Only process one() relations with fields and references\n      // many() relations are typically the inverse and don't have field info\n      if (parsedRelation.type !== \"one\") {\n        continue;\n      }\n\n      if (parsedRelation.fields.length === 0 || parsedRelation.references.length === 0) {\n        continue;\n      }\n\n      // Map variable names to actual table names\n      const fromTableName = this.tableNameMapping.get(parsedRelation.sourceTable);\n      const toTableName = this.tableNameMapping.get(parsedRelation.targetTable);\n\n      if (!fromTableName || !toTableName) {\n        continue;\n      }\n\n      // Get column name mappings (TypeScript property names -> database column names)\n      const fromColumnMapping = this.getColumnNameMapping(parsedRelation.sourceTable);\n      const toColumnMapping = this.getColumnNameMapping(parsedRelation.targetTable);\n\n      // Map TypeScript field names to database column names\n      const fromColumns = parsedRelation.fields.map(\n        (field) => fromColumnMapping.get(field) || field,\n      );\n      const toColumns = parsedRelation.references.map((ref) => toColumnMapping.get(ref) || ref);\n\n      // Create a unique key to avoid duplicate refs (bidirectional)\n      const refKey = `${fromTableName}.${fromColumns.join(\",\")}-${toTableName}.${toColumns.join(\",\")}`;\n      const reverseRefKey = `${toTableName}.${toColumns.join(\",\")}-${fromTableName}.${fromColumns.join(\",\")}`;\n\n      if (processedRefs.has(refKey) || processedRefs.has(reverseRefKey)) {\n        continue;\n      }\n      processedRefs.add(refKey);\n\n      // Check if this is a one-to-one relationship (bidirectional one())\n      const isOneToOne = this.hasReverseOneRelation(\n        parsedRelation.sourceTable,\n        parsedRelation.targetTable,\n        parsedRelation.fields,\n        parsedRelation.references,\n      );\n\n      // Create UnifiedRelation\n      relations.push({\n        sourceTable: fromTableName,\n        sourceColumns: fromColumns,\n        targetTable: toTableName,\n        targetColumns: toColumns,\n        relationType: isOneToOne ? \"one-to-one\" : \"many-to-one\",\n      });\n    }\n\n    return relations;\n  }\n\n  /**\n   * Build a mapping from variable names to table names\n   *\n   * @returns Map of variable names to database table names\n   */\n  private buildTableNameMapping(): Map<string, string> {\n    const mapping = new Map<string, string>();\n    for (const [varName, value] of Object.entries(this.schema)) {\n      if (this.isTable(value)) {\n        const tableName = getTableName(value as Table);\n        mapping.set(varName, tableName);\n      }\n    }\n    return mapping;\n  }\n\n  /**\n   * Check if a value is a Drizzle table\n   *\n   * @param value - The value to check\n   * @returns True if value is a table\n   */\n  private isTable(value: unknown): boolean {\n    return is(value, PgTable) || is(value, MySqlTable) || is(value, SQLiteTable);\n  }\n\n  /**\n   * Get column name mapping for a table\n   *\n   * @param tableVarName - The variable name of the table\n   * @returns Map of property names to database column names\n   */\n  private getColumnNameMapping(tableVarName: string): Map<string, string> {\n    // Check cache first\n    if (this.columnNameMappings.has(tableVarName)) {\n      return this.columnNameMappings.get(tableVarName)!;\n    }\n\n    const mapping = new Map<string, string>();\n    const table = this.schema[tableVarName];\n    if (table && this.isTable(table)) {\n      const columns = getTableColumns(table as Table);\n      for (const [propName, column] of Object.entries(columns)) {\n        mapping.set(propName, column.name);\n      }\n    }\n\n    // Cache the mapping\n    this.columnNameMappings.set(tableVarName, mapping);\n    return mapping;\n  }\n\n  /**\n   * Check if there's a reverse one() relation (B->A when we have A->B)\n   *\n   * Used to detect one-to-one relationships by checking if both tables\n   * have one() relations pointing to each other.\n   *\n   * @param sourceTable - The source table variable name\n   * @param targetTable - The target table variable name\n   * @param sourceFields - The source table's field names\n   * @param targetReferences - The target table's reference column names\n   * @returns True if a reverse one() relation exists\n   */\n  private hasReverseOneRelation(\n    sourceTable: string,\n    targetTable: string,\n    sourceFields: string[],\n    targetReferences: string[],\n  ): boolean {\n    if (!this.parsedRelations) return false;\n\n    // Look for a one() relation from targetTable to sourceTable\n    for (const relation of this.parsedRelations.relations) {\n      if (\n        relation.type === \"one\" &&\n        relation.sourceTable === targetTable &&\n        relation.targetTable === sourceTable &&\n        relation.fields.length > 0 &&\n        relation.references.length > 0\n      ) {\n        // Check if the fields/references are the reverse of each other\n        // A->B: fields=[A.col], references=[B.col]\n        // B->A: fields=[B.col], references=[A.col]\n        const reverseFields = relation.fields;\n        const reverseReferences = relation.references;\n\n        // The reverse relation's fields should match our references\n        // and the reverse relation's references should match our fields\n        if (\n          this.arraysEqual(reverseFields, targetReferences) &&\n          this.arraysEqual(reverseReferences, sourceFields)\n        ) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Helper to check if two arrays are equal\n   *\n   * @param a - First array\n   * @param b - Second array\n   * @returns True if arrays have same length and same elements in order\n   */\n  private arraysEqual(a: string[], b: string[]): boolean {\n    if (a.length !== b.length) return false;\n    return a.every((val, i) => val === b[i]);\n  }\n}\n"],"names":["V0RelationAdapter","schema","parsedRelations","relations","processedRefs","parsedRelation","fromTableName","toTableName","fromColumnMapping","toColumnMapping","fromColumns","field","toColumns","ref","refKey","reverseRefKey","isOneToOne","mapping","varName","value","tableName","getTableName","is","PgTable","MySqlTable","SQLiteTable","tableVarName","table","columns","getTableColumns","propName","column","sourceTable","targetTable","sourceFields","targetReferences","relation","reverseFields","reverseReferences","a","b","val","i"],"mappings":"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"}
+{"version":3,"file":"v0-adapter.js","names":[],"sources":["../../src/adapter/v0-adapter.ts"],"sourcesContent":["import { type Table, getTableColumns, getTableName, is } from \"drizzle-orm\";\nimport { PgTable } from \"drizzle-orm/pg-core\";\nimport { MySqlTable } from \"drizzle-orm/mysql-core\";\nimport { SQLiteTable } from \"drizzle-orm/sqlite-core\";\nimport type { SchemaRelations } from \"../parser/relations\";\nimport type { RelationAdapter, UnifiedRelation } from \"./types\";\n\n/**\n * Adapter for extracting relations from v0 relations() API\n *\n * Handles the legacy relations() format by parsing relation definitions\n * from the TypeScript source using the schema parser.\n */\nexport class V0RelationAdapter implements RelationAdapter {\n  private schema: Record<string, unknown>;\n  private parsedRelations: SchemaRelations | undefined;\n  private tableNameMapping: Map<string, string>;\n  private columnNameMappings: Map<string, Map<string, string>>;\n\n  /**\n   * Create a new V0RelationAdapter\n   *\n   * @param schema - The Drizzle schema object containing tables\n   * @param parsedRelations - Parsed relation information from TypeScript source\n   */\n  constructor(schema: Record<string, unknown>, parsedRelations: SchemaRelations | undefined) {\n    this.schema = schema;\n    this.parsedRelations = parsedRelations;\n    this.tableNameMapping = this.buildTableNameMapping();\n    this.columnNameMappings = new Map();\n  }\n\n  /**\n   * Extract relations from v0 relations() definitions\n   *\n   * Processes parsed relation information to extract foreign key relationships,\n   * determining relation types (one-to-one vs many-to-one) based on bidirectional\n   * analysis.\n   *\n   * @returns Array of unified relations\n   */\n  extract(): UnifiedRelation[] {\n    if (!this.parsedRelations || this.parsedRelations.relations.length === 0) {\n      return [];\n    }\n\n    const relations: UnifiedRelation[] = [];\n    const processedRefs = new Set<string>();\n\n    for (const parsedRelation of this.parsedRelations.relations) {\n      // Only process one() relations with fields and references\n      // many() relations are typically the inverse and don't have field info\n      if (parsedRelation.type !== \"one\") {\n        continue;\n      }\n\n      if (parsedRelation.fields.length === 0 || parsedRelation.references.length === 0) {\n        continue;\n      }\n\n      // Map variable names to actual table names\n      const fromTableName = this.tableNameMapping.get(parsedRelation.sourceTable);\n      const toTableName = this.tableNameMapping.get(parsedRelation.targetTable);\n\n      if (!fromTableName || !toTableName) {\n        continue;\n      }\n\n      // Get column name mappings (TypeScript property names -> database column names)\n      const fromColumnMapping = this.getColumnNameMapping(parsedRelation.sourceTable);\n      const toColumnMapping = this.getColumnNameMapping(parsedRelation.targetTable);\n\n      // Map TypeScript field names to database column names\n      const fromColumns = parsedRelation.fields.map(\n        (field) => fromColumnMapping.get(field) || field,\n      );\n      const toColumns = parsedRelation.references.map((ref) => toColumnMapping.get(ref) || ref);\n\n      // Create a unique key to avoid duplicate refs (bidirectional)\n      const refKey = `${fromTableName}.${fromColumns.join(\",\")}-${toTableName}.${toColumns.join(\",\")}`;\n      const reverseRefKey = `${toTableName}.${toColumns.join(\",\")}-${fromTableName}.${fromColumns.join(\",\")}`;\n\n      if (processedRefs.has(refKey) || processedRefs.has(reverseRefKey)) {\n        continue;\n      }\n      processedRefs.add(refKey);\n\n      // Check if this is a one-to-one relationship (bidirectional one())\n      const isOneToOne = this.hasReverseOneRelation(\n        parsedRelation.sourceTable,\n        parsedRelation.targetTable,\n        parsedRelation.fields,\n        parsedRelation.references,\n      );\n\n      // Create UnifiedRelation\n      relations.push({\n        sourceTable: fromTableName,\n        sourceColumns: fromColumns,\n        targetTable: toTableName,\n        targetColumns: toColumns,\n        relationType: isOneToOne ? \"one-to-one\" : \"many-to-one\",\n      });\n    }\n\n    return relations;\n  }\n\n  /**\n   * Build a mapping from variable names to table names\n   *\n   * @returns Map of variable names to database table names\n   */\n  private buildTableNameMapping(): Map<string, string> {\n    const mapping = new Map<string, string>();\n    for (const [varName, value] of Object.entries(this.schema)) {\n      if (this.isTable(value)) {\n        const tableName = getTableName(value as Table);\n        mapping.set(varName, tableName);\n      }\n    }\n    return mapping;\n  }\n\n  /**\n   * Check if a value is a Drizzle table\n   *\n   * @param value - The value to check\n   * @returns True if value is a table\n   */\n  private isTable(value: unknown): boolean {\n    return is(value, PgTable) || is(value, MySqlTable) || is(value, SQLiteTable);\n  }\n\n  /**\n   * Get column name mapping for a table\n   *\n   * @param tableVarName - The variable name of the table\n   * @returns Map of property names to database column names\n   */\n  private getColumnNameMapping(tableVarName: string): Map<string, string> {\n    // Check cache first\n    if (this.columnNameMappings.has(tableVarName)) {\n      return this.columnNameMappings.get(tableVarName)!;\n    }\n\n    const mapping = new Map<string, string>();\n    const table = this.schema[tableVarName];\n    if (table && this.isTable(table)) {\n      const columns = getTableColumns(table as Table);\n      for (const [propName, column] of Object.entries(columns)) {\n        mapping.set(propName, column.name);\n      }\n    }\n\n    // Cache the mapping\n    this.columnNameMappings.set(tableVarName, mapping);\n    return mapping;\n  }\n\n  /**\n   * Check if there's a reverse one() relation (B->A when we have A->B)\n   *\n   * Used to detect one-to-one relationships by checking if both tables\n   * have one() relations pointing to each other.\n   *\n   * @param sourceTable - The source table variable name\n   * @param targetTable - The target table variable name\n   * @param sourceFields - The source table's field names\n   * @param targetReferences - The target table's reference column names\n   * @returns True if a reverse one() relation exists\n   */\n  private hasReverseOneRelation(\n    sourceTable: string,\n    targetTable: string,\n    sourceFields: string[],\n    targetReferences: string[],\n  ): boolean {\n    if (!this.parsedRelations) return false;\n\n    // Look for a one() relation from targetTable to sourceTable\n    for (const relation of this.parsedRelations.relations) {\n      if (\n        relation.type === \"one\" &&\n        relation.sourceTable === targetTable &&\n        relation.targetTable === sourceTable &&\n        relation.fields.length > 0 &&\n        relation.references.length > 0\n      ) {\n        // Check if the fields/references are the reverse of each other\n        // A->B: fields=[A.col], references=[B.col]\n        // B->A: fields=[B.col], references=[A.col]\n        const reverseFields = relation.fields;\n        const reverseReferences = relation.references;\n\n        // The reverse relation's fields should match our references\n        // and the reverse relation's references should match our fields\n        if (\n          this.arraysEqual(reverseFields, targetReferences) &&\n          this.arraysEqual(reverseReferences, sourceFields)\n        ) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Helper to check if two arrays are equal\n   *\n   * @param a - First array\n   * @param b - Second array\n   * @returns True if arrays have same length and same elements in order\n   */\n  private arraysEqual(a: string[], b: string[]): boolean {\n    if (a.length !== b.length) return false;\n    return a.every((val, i) => val === b[i]);\n  }\n}\n"],"mappings":"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"}

package/dist/adapter/v1-adapter.js

@@ -1,83 +1,47 @@
-import { getTableName as m, is as h, One as T } from "drizzle-orm";
-class v {
-  entries;
-  /**
-   * Create a new V1RelationAdapter
-   *
-   * @param entries - Array of v1 relation entries from defineRelations()
-   */
-  constructor(s) {
-    this.entries = s;
-  }
-  /**
-   * Extract relations from v1 defineRelations() entries
-   *
-   * Processes One relations to extract foreign key information and generates
-   * relation definitions. Detects one-to-one relationships with bidirectional checks.
-   *
-   * @returns Array of unified relations
-   */
-  extract() {
-    const s = [], i = /* @__PURE__ */ new Set();
-    for (const c of this.entries) {
-      const o = m(c.table);
-      for (const a of Object.values(c.relations)) {
-        if (!h(a, T) || a.isReversed)
-          continue;
-        const n = a, e = n.sourceColumns.map((g) => g.name), l = n.targetColumns.map((g) => g.name);
-        if (e.length === 0 || l.length === 0)
-          continue;
-        const r = m(n.targetTable), u = `${o}.${e.join(",")}->${r}.${l.join(",")}`, t = `${r}.${l.join(",")}->${o}.${e.join(",")}`;
-        if (i.has(u) || i.has(t))
-          continue;
-        i.add(u);
-        const f = this.hasReverseOneRelation(
-          r,
-          o,
-          l,
-          e
-        );
-        s.push({
-          sourceTable: o,
-          sourceColumns: e,
-          targetTable: r,
-          targetColumns: l,
-          relationType: f ? "one-to-one" : "many-to-one"
-        });
-      }
-    }
-    return s;
-  }
-  /**
-   * Check if there's a reverse One relation in v1 entries
-   *
-   * Detects one-to-one relationships by checking if the target table
-   * has a matching One relation pointing back to the source table.
-   *
-   * @param fromTableName - The table to search for reverse relation
-   * @param toTableName - The expected target table of the reverse relation
-   * @param fromColumns - The expected source columns of the reverse relation
-   * @param toColumns - The expected target columns of the reverse relation
-   * @returns True if a matching reverse One relation exists
-   */
-  hasReverseOneRelation(s, i, c, o) {
-    const a = this.entries.find((n) => m(n.table) === s);
-    if (!a)
-      return !1;
-    for (const n of Object.values(a.relations)) {
-      if (!h(n, T))
-        continue;
-      const e = n;
-      if (m(e.targetTable) !== i)
-        continue;
-      const r = e.sourceColumns.map((t) => t.name), u = e.targetColumns.map((t) => t.name);
-      if (r.length === c.length && u.length === o.length && r.every((t, f) => t === c[f]) && u.every((t, f) => t === o[f]))
-        return !0;
-    }
-    return !1;
-  }
-}
-export {
-  v as V1RelationAdapter
+import { One as e, getTableName as t, is as n } from "drizzle-orm";
+//#region src/adapter/v1-adapter.ts
+var r = class {
+	entries;
+	constructor(e) {
+		this.entries = e;
+	}
+	extract() {
+		let r = [], i = /* @__PURE__ */ new Set();
+		for (let a of this.entries) {
+			let o = t(a.table);
+			for (let s of Object.values(a.relations)) {
+				if (!n(s, e) || s.isReversed) continue;
+				let a = s, c = a.sourceColumns.map((e) => e.name), l = a.targetColumns.map((e) => e.name);
+				if (c.length === 0 || l.length === 0) continue;
+				let u = t(a.targetTable), d = `${o}.${c.join(",")}->${u}.${l.join(",")}`, f = `${u}.${l.join(",")}->${o}.${c.join(",")}`;
+				if (i.has(d) || i.has(f)) continue;
+				i.add(d);
+				let p = this.hasReverseOneRelation(u, o, l, c);
+				r.push({
+					sourceTable: o,
+					sourceColumns: c,
+					targetTable: u,
+					targetColumns: l,
+					relationType: p ? "one-to-one" : "many-to-one"
+				});
+			}
+		}
+		return r;
+	}
+	hasReverseOneRelation(r, i, a, o) {
+		let s = this.entries.find((e) => t(e.table) === r);
+		if (!s) return !1;
+		for (let r of Object.values(s.relations)) {
+			if (!n(r, e)) continue;
+			let s = r;
+			if (t(s.targetTable) !== i) continue;
+			let c = s.sourceColumns.map((e) => e.name), l = s.targetColumns.map((e) => e.name);
+			if (c.length === a.length && l.length === o.length && c.every((e, t) => e === a[t]) && l.every((e, t) => e === o[t])) return !0;
+		}
+		return !1;
+	}
 };
-//# sourceMappingURL=v1-adapter.js.map
+//#endregion
+export { r as V1RelationAdapter };
+
+//# sourceMappingURL=v1-adapter.js.map

package/dist/adapter/v1-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"v1-adapter.js","sources":["../../src/adapter/v1-adapter.ts"],"sourcesContent":["import { type Table, getTableName, is, One } from \"drizzle-orm\";\nimport type { AnyRelation, TableRelationalConfig } from \"drizzle-orm/relations\";\nimport type { RelationAdapter, UnifiedRelation } from \"./types\";\n\n/**\n * Adapter for extracting relations from v1 defineRelations() API\n *\n * Handles the modern v1 defineRelations() format using official Drizzle types\n * (TableRelationalConfig, AnyRelation, One).\n */\nexport class V1RelationAdapter implements RelationAdapter {\n  private entries: TableRelationalConfig[];\n\n  /**\n   * Create a new V1RelationAdapter\n   *\n   * @param entries - Array of v1 relation entries from defineRelations()\n   */\n  constructor(entries: TableRelationalConfig[]) {\n    this.entries = entries;\n  }\n\n  /**\n   * Extract relations from v1 defineRelations() entries\n   *\n   * Processes One relations to extract foreign key information and generates\n   * relation definitions. Detects one-to-one relationships with bidirectional checks.\n   *\n   * @returns Array of unified relations\n   */\n  extract(): UnifiedRelation[] {\n    const relations: UnifiedRelation[] = [];\n    const processedRefs = new Set<string>();\n\n    for (const entry of this.entries) {\n      const sourceTableName = getTableName(entry.table as Table);\n\n      for (const relation of Object.values(entry.relations)) {\n        // Only process One relations as they define the FK direction\n        // Many relations are the inverse and don't add new information\n        if (!is(relation, One)) {\n          continue;\n        }\n\n        // Skip reversed relations (they are auto-generated inverse relations)\n        if ((relation as AnyRelation).isReversed) {\n          continue;\n        }\n\n        // Get source and target column names (using official Relation properties)\n        const rel = relation as AnyRelation;\n        const sourceColumns = rel.sourceColumns.map((col) => col.name);\n        const targetColumns = rel.targetColumns.map((col) => col.name);\n\n        if (sourceColumns.length === 0 || targetColumns.length === 0) {\n          continue;\n        }\n\n        const targetTableName = getTableName(rel.targetTable as Table);\n\n        // Create a unique key to avoid duplicate refs\n        const refKey = `${sourceTableName}.${sourceColumns.join(\",\")}->${targetTableName}.${targetColumns.join(\",\")}`;\n        const reverseRefKey = `${targetTableName}.${targetColumns.join(\",\")}->${sourceTableName}.${sourceColumns.join(\",\")}`;\n\n        if (processedRefs.has(refKey) || processedRefs.has(reverseRefKey)) {\n          continue;\n        }\n        processedRefs.add(refKey);\n\n        // Check if there's a reverse one() relation (indicating one-to-one)\n        const isOneToOne = this.hasReverseOneRelation(\n          targetTableName,\n          sourceTableName,\n          targetColumns,\n          sourceColumns,\n        );\n\n        relations.push({\n          sourceTable: sourceTableName,\n          sourceColumns,\n          targetTable: targetTableName,\n          targetColumns,\n          relationType: isOneToOne ? \"one-to-one\" : \"many-to-one\",\n        });\n      }\n    }\n\n    return relations;\n  }\n\n  /**\n   * Check if there's a reverse One relation in v1 entries\n   *\n   * Detects one-to-one relationships by checking if the target table\n   * has a matching One relation pointing back to the source table.\n   *\n   * @param fromTableName - The table to search for reverse relation\n   * @param toTableName - The expected target table of the reverse relation\n   * @param fromColumns - The expected source columns of the reverse relation\n   * @param toColumns - The expected target columns of the reverse relation\n   * @returns True if a matching reverse One relation exists\n   */\n  private hasReverseOneRelation(\n    fromTableName: string,\n    toTableName: string,\n    fromColumns: string[],\n    toColumns: string[],\n  ): boolean {\n    const fromEntry = this.entries.find((e) => getTableName(e.table as Table) === fromTableName);\n    if (!fromEntry) {\n      return false;\n    }\n\n    for (const relation of Object.values(fromEntry.relations)) {\n      if (!is(relation, One)) {\n        continue;\n      }\n\n      const rel = relation as AnyRelation;\n      const relTargetName = getTableName(rel.targetTable as Table);\n      if (relTargetName !== toTableName) {\n        continue;\n      }\n\n      const relSourceCols = rel.sourceColumns.map((col) => col.name);\n      const relTargetCols = rel.targetColumns.map((col) => col.name);\n\n      // Check if columns match in reverse\n      if (\n        relSourceCols.length === fromColumns.length &&\n        relTargetCols.length === toColumns.length &&\n        relSourceCols.every((col, i) => col === fromColumns[i]) &&\n        relTargetCols.every((col, i) => col === toColumns[i])\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n"],"names":["V1RelationAdapter","entries","relations","processedRefs","entry","sourceTableName","getTableName","relation","is","One","rel","sourceColumns","col","targetColumns","targetTableName","refKey","reverseRefKey","isOneToOne","fromTableName","toTableName","fromColumns","toColumns","fromEntry","e","relSourceCols","relTargetCols","i"],"mappings":";AAUO,MAAMA,EAA6C;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOR,YAAYC,GAAkC;AAC5C,SAAK,UAAUA;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,UAA6B;AAC3B,UAAMC,IAA+B,CAAA,GAC/BC,wBAAoB,IAAA;AAE1B,eAAWC,KAAS,KAAK,SAAS;AAChC,YAAMC,IAAkBC,EAAaF,EAAM,KAAc;AAEzD,iBAAWG,KAAY,OAAO,OAAOH,EAAM,SAAS,GAAG;AAQrD,YALI,CAACI,EAAGD,GAAUE,CAAG,KAKhBF,EAAyB;AAC5B;AAIF,cAAMG,IAAMH,GACNI,IAAgBD,EAAI,cAAc,IAAI,CAACE,MAAQA,EAAI,IAAI,GACvDC,IAAgBH,EAAI,cAAc,IAAI,CAACE,MAAQA,EAAI,IAAI;AAE7D,YAAID,EAAc,WAAW,KAAKE,EAAc,WAAW;AACzD;AAGF,cAAMC,IAAkBR,EAAaI,EAAI,WAAoB,GAGvDK,IAAS,GAAGV,CAAe,IAAIM,EAAc,KAAK,GAAG,CAAC,KAAKG,CAAe,IAAID,EAAc,KAAK,GAAG,CAAC,IACrGG,IAAgB,GAAGF,CAAe,IAAID,EAAc,KAAK,GAAG,CAAC,KAAKR,CAAe,IAAIM,EAAc,KAAK,GAAG,CAAC;AAElH,YAAIR,EAAc,IAAIY,CAAM,KAAKZ,EAAc,IAAIa,CAAa;AAC9D;AAEF,QAAAb,EAAc,IAAIY,CAAM;AAGxB,cAAME,IAAa,KAAK;AAAA,UACtBH;AAAA,UACAT;AAAA,UACAQ;AAAA,UACAF;AAAA,QAAA;AAGF,QAAAT,EAAU,KAAK;AAAA,UACb,aAAaG;AAAA,UACb,eAAAM;AAAA,UACA,aAAaG;AAAA,UACb,eAAAD;AAAA,UACA,cAAcI,IAAa,eAAe;AAAA,QAAA,CAC3C;AAAA,MACH;AAAA,IACF;AAEA,WAAOf;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcQ,sBACNgB,GACAC,GACAC,GACAC,GACS;AACT,UAAMC,IAAY,KAAK,QAAQ,KAAK,CAACC,MAAMjB,EAAaiB,EAAE,KAAc,MAAML,CAAa;AAC3F,QAAI,CAACI;AACH,aAAO;AAGT,eAAWf,KAAY,OAAO,OAAOe,EAAU,SAAS,GAAG;AACzD,UAAI,CAACd,EAAGD,GAAUE,CAAG;AACnB;AAGF,YAAMC,IAAMH;AAEZ,UADsBD,EAAaI,EAAI,WAAoB,MACrCS;AACpB;AAGF,YAAMK,IAAgBd,EAAI,cAAc,IAAI,CAACE,MAAQA,EAAI,IAAI,GACvDa,IAAgBf,EAAI,cAAc,IAAI,CAACE,MAAQA,EAAI,IAAI;AAG7D,UACEY,EAAc,WAAWJ,EAAY,UACrCK,EAAc,WAAWJ,EAAU,UACnCG,EAAc,MAAM,CAACZ,GAAKc,MAAMd,MAAQQ,EAAYM,CAAC,CAAC,KACtDD,EAAc,MAAM,CAACb,GAAKc,MAAMd,MAAQS,EAAUK,CAAC,CAAC;AAEpD,eAAO;AAAA,IAEX;AAEA,WAAO;AAAA,EACT;AACF;"}
+{"version":3,"file":"v1-adapter.js","names":[],"sources":["../../src/adapter/v1-adapter.ts"],"sourcesContent":["import { type Table, getTableName, is, One } from \"drizzle-orm\";\nimport type { AnyRelation, TableRelationalConfig } from \"drizzle-orm/relations\";\nimport type { RelationAdapter, UnifiedRelation } from \"./types\";\n\n/**\n * Adapter for extracting relations from v1 defineRelations() API\n *\n * Handles the modern v1 defineRelations() format using official Drizzle types\n * (TableRelationalConfig, AnyRelation, One).\n */\nexport class V1RelationAdapter implements RelationAdapter {\n  private entries: TableRelationalConfig[];\n\n  /**\n   * Create a new V1RelationAdapter\n   *\n   * @param entries - Array of v1 relation entries from defineRelations()\n   */\n  constructor(entries: TableRelationalConfig[]) {\n    this.entries = entries;\n  }\n\n  /**\n   * Extract relations from v1 defineRelations() entries\n   *\n   * Processes One relations to extract foreign key information and generates\n   * relation definitions. Detects one-to-one relationships with bidirectional checks.\n   *\n   * @returns Array of unified relations\n   */\n  extract(): UnifiedRelation[] {\n    const relations: UnifiedRelation[] = [];\n    const processedRefs = new Set<string>();\n\n    for (const entry of this.entries) {\n      const sourceTableName = getTableName(entry.table as Table);\n\n      for (const relation of Object.values(entry.relations)) {\n        // Only process One relations as they define the FK direction\n        // Many relations are the inverse and don't add new information\n        if (!is(relation, One)) {\n          continue;\n        }\n\n        // Skip reversed relations (they are auto-generated inverse relations)\n        if ((relation as AnyRelation).isReversed) {\n          continue;\n        }\n\n        // Get source and target column names (using official Relation properties)\n        const rel = relation as AnyRelation;\n        const sourceColumns = rel.sourceColumns.map((col) => col.name);\n        const targetColumns = rel.targetColumns.map((col) => col.name);\n\n        if (sourceColumns.length === 0 || targetColumns.length === 0) {\n          continue;\n        }\n\n        const targetTableName = getTableName(rel.targetTable as Table);\n\n        // Create a unique key to avoid duplicate refs\n        const refKey = `${sourceTableName}.${sourceColumns.join(\",\")}->${targetTableName}.${targetColumns.join(\",\")}`;\n        const reverseRefKey = `${targetTableName}.${targetColumns.join(\",\")}->${sourceTableName}.${sourceColumns.join(\",\")}`;\n\n        if (processedRefs.has(refKey) || processedRefs.has(reverseRefKey)) {\n          continue;\n        }\n        processedRefs.add(refKey);\n\n        // Check if there's a reverse one() relation (indicating one-to-one)\n        const isOneToOne = this.hasReverseOneRelation(\n          targetTableName,\n          sourceTableName,\n          targetColumns,\n          sourceColumns,\n        );\n\n        relations.push({\n          sourceTable: sourceTableName,\n          sourceColumns,\n          targetTable: targetTableName,\n          targetColumns,\n          relationType: isOneToOne ? \"one-to-one\" : \"many-to-one\",\n        });\n      }\n    }\n\n    return relations;\n  }\n\n  /**\n   * Check if there's a reverse One relation in v1 entries\n   *\n   * Detects one-to-one relationships by checking if the target table\n   * has a matching One relation pointing back to the source table.\n   *\n   * @param fromTableName - The table to search for reverse relation\n   * @param toTableName - The expected target table of the reverse relation\n   * @param fromColumns - The expected source columns of the reverse relation\n   * @param toColumns - The expected target columns of the reverse relation\n   * @returns True if a matching reverse One relation exists\n   */\n  private hasReverseOneRelation(\n    fromTableName: string,\n    toTableName: string,\n    fromColumns: string[],\n    toColumns: string[],\n  ): boolean {\n    const fromEntry = this.entries.find((e) => getTableName(e.table as Table) === fromTableName);\n    if (!fromEntry) {\n      return false;\n    }\n\n    for (const relation of Object.values(fromEntry.relations)) {\n      if (!is(relation, One)) {\n        continue;\n      }\n\n      const rel = relation as AnyRelation;\n      const relTargetName = getTableName(rel.targetTable as Table);\n      if (relTargetName !== toTableName) {\n        continue;\n      }\n\n      const relSourceCols = rel.sourceColumns.map((col) => col.name);\n      const relTargetCols = rel.targetColumns.map((col) => col.name);\n\n      // Check if columns match in reverse\n      if (\n        relSourceCols.length === fromColumns.length &&\n        relTargetCols.length === toColumns.length &&\n        relSourceCols.every((col, i) => col === fromColumns[i]) &&\n        relTargetCols.every((col, i) => col === toColumns[i])\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n"],"mappings":";;AAUA,IAAa,IAAb,MAA0D;CACxD;CAOA,YAAY,GAAkC;AAC5C,OAAK,UAAU;;CAWjB,UAA6B;EAC3B,IAAM,IAA+B,EAAE,EACjC,oBAAgB,IAAI,KAAa;AAEvC,OAAK,IAAM,KAAS,KAAK,SAAS;GAChC,IAAM,IAAkB,EAAa,EAAM,MAAe;AAE1D,QAAK,IAAM,KAAY,OAAO,OAAO,EAAM,UAAU,EAAE;AAQrD,QALI,CAAC,EAAG,GAAU,EAAI,IAKjB,EAAyB,WAC5B;IAIF,IAAM,IAAM,GACN,IAAgB,EAAI,cAAc,KAAK,MAAQ,EAAI,KAAK,EACxD,IAAgB,EAAI,cAAc,KAAK,MAAQ,EAAI,KAAK;AAE9D,QAAI,EAAc,WAAW,KAAK,EAAc,WAAW,EACzD;IAGF,IAAM,IAAkB,EAAa,EAAI,YAAqB,EAGxD,IAAS,GAAG,EAAgB,GAAG,EAAc,KAAK,IAAI,CAAC,IAAI,EAAgB,GAAG,EAAc,KAAK,IAAI,IACrG,IAAgB,GAAG,EAAgB,GAAG,EAAc,KAAK,IAAI,CAAC,IAAI,EAAgB,GAAG,EAAc,KAAK,IAAI;AAElH,QAAI,EAAc,IAAI,EAAO,IAAI,EAAc,IAAI,EAAc,CAC/D;AAEF,MAAc,IAAI,EAAO;IAGzB,IAAM,IAAa,KAAK,sBACtB,GACA,GACA,GACA,EACD;AAED,MAAU,KAAK;KACb,aAAa;KACb;KACA,aAAa;KACb;KACA,cAAc,IAAa,eAAe;KAC3C,CAAC;;;AAIN,SAAO;;CAeT,sBACE,GACA,GACA,GACA,GACS;EACT,IAAM,IAAY,KAAK,QAAQ,MAAM,MAAM,EAAa,EAAE,MAAe,KAAK,EAAc;AAC5F,MAAI,CAAC,EACH,QAAO;AAGT,OAAK,IAAM,KAAY,OAAO,OAAO,EAAU,UAAU,EAAE;AACzD,OAAI,CAAC,EAAG,GAAU,EAAI,CACpB;GAGF,IAAM,IAAM;AAEZ,OADsB,EAAa,EAAI,YAAqB,KACtC,EACpB;GAGF,IAAM,IAAgB,EAAI,cAAc,KAAK,MAAQ,EAAI,KAAK,EACxD,IAAgB,EAAI,cAAc,KAAK,MAAQ,EAAI,KAAK;AAG9D,OACE,EAAc,WAAW,EAAY,UACrC,EAAc,WAAW,EAAU,UACnC,EAAc,OAAO,GAAK,MAAM,MAAQ,EAAY,GAAG,IACvD,EAAc,OAAO,GAAK,MAAM,MAAQ,EAAU,GAAG,CAErD,QAAO;;AAIX,SAAO"}