drizzle-docs-generator 0.1.0

package/dist/generator/common.js

@@ -0,0 +1,699 @@
+import { is as m, Relation as j, getTableName as g, getTableColumns as d, One as b } from "drizzle-orm";
+import { PgTable as C, getTableConfig as v } from "drizzle-orm/pg-core";
+import { MySqlTable as T, getTableConfig as N } from "drizzle-orm/mysql-core";
+import { SQLiteTable as R, getTableConfig as K } from "drizzle-orm/sqlite-core";
+import { mkdirSync as q, writeFileSync as V } from "node:fs";
+import { resolve as O, dirname as x } from "node:path";
+import { extractComments as S } from "../parser/comments.js";
+import { extractRelations as k } from "../parser/relations.js";
+class D {
+  lines = [];
+  indentLevel = 0;
+  /**
+   * Increase the indentation level by one
+   * @returns This instance for method chaining
+   */
+  indent() {
+    return this.indentLevel++, this;
+  }
+  /**
+   * Decrease the indentation level by one (minimum 0)
+   * @returns This instance for method chaining
+   */
+  dedent() {
+    return this.indentLevel = Math.max(0, this.indentLevel - 1), this;
+  }
+  /**
+   * Add a line with the current indentation level
+   * @param content - The content to add (empty string adds a blank line)
+   * @returns This instance for method chaining
+   */
+  line(e = "") {
+    const t = "  ".repeat(this.indentLevel);
+    return this.lines.push(e ? `${t}${e}` : ""), this;
+  }
+  /**
+   * Build the final DBML string from all added lines
+   * @returns The complete DBML content as a string
+   */
+  build() {
+    return this.lines.join(`
+`);
+  }
+}
+class B {
+  schema;
+  relational;
+  generatedRefs = [];
+  comments;
+  parsedRelations;
+  source;
+  /**
+   * Create a new generator instance
+   * @param options - Configuration options including schema, relational mode, source code, and comments
+   */
+  constructor(e) {
+    this.schema = e.schema, this.relational = e.relational ?? !1, this.source = e.source, e.comments ? this.comments = e.comments : this.source && (this.comments = S(this.source)), this.relational && this.source && (this.parsedRelations = k(this.source));
+  }
+  /**
+   * Generate complete DBML output from the schema
+   *
+   * Creates DBML representation including:
+   * - Table definitions with columns, indexes, and constraints
+   * - Foreign key references (from table config or relations)
+   * - Comments for tables and columns
+   *
+   * @returns The complete DBML string
+   */
+  generate() {
+    const e = new D(), t = this.getTables(), n = this.getV0Relations(), s = this.getV1RelationEntries();
+    for (const o of t)
+      this.generateTable(e, o), e.line();
+    this.relational && (s.length > 0 ? this.generateRelationalRefsFromV1(s) : (n.length > 0 || this.parsedRelations) && this.generateRelationalRefsFromV0());
+    for (const o of this.generatedRefs)
+      this.generateRef(e, o);
+    return e.build().trim();
+  }
+  /**
+   * Get all tables from schema
+   *
+   * Extracts all Drizzle table objects from the schema by checking each value
+   * with isTable() method.
+   *
+   * @returns Array of table objects
+   */
+  getTables() {
+    const e = [];
+    for (const t of Object.values(this.schema))
+      this.isTable(t) && e.push(t);
+    return e;
+  }
+  /**
+   * Check if a value is a Drizzle table
+   *
+   * Validates whether a value is a table instance from any supported dialect
+   * (PostgreSQL, MySQL, or SQLite).
+   *
+   * @param value - The value to check
+   * @returns True if value is a Drizzle table
+   */
+  isTable(e) {
+    return m(e, C) || m(e, T) || m(e, R);
+  }
+  /**
+   * Get all v0 relations from schema (legacy relations() API)
+   *
+   * Extracts legacy relations defined using the old relations() API.
+   * These are identified by having 'table' and 'config' properties.
+   *
+   * @returns Array of legacy relation objects
+   */
+  getV0Relations() {
+    const e = [];
+    for (const t of Object.values(this.schema))
+      this.isV0Relations(t) && e.push(t);
+    return e;
+  }
+  /**
+   * Check if a value is a Drizzle v0 relations object (from relations())
+   *
+   * Validates the legacy relations() format by checking for 'table' and 'config' properties.
+   *
+   * @param value - The value to check
+   * @returns True if value is a legacy relations object
+   */
+  isV0Relations(e) {
+    return typeof e != "object" || e === null ? !1 : "table" in e && "config" in e && typeof e.config == "object";
+  }
+  /**
+   * Check if a value is a v1 relation entry (from defineRelations())
+   *
+   * Uses official Drizzle v1 types: TableRelationalConfig with Relation instances.
+   * Validates the structure has 'table', 'name', and 'relations' properties with valid types.
+   *
+   * @param value - The value to check
+   * @returns True if value is a v1 relation entry
+   */
+  isV1RelationEntry(e) {
+    if (typeof e != "object" || e === null)
+      return !1;
+    const t = e;
+    if (!("table" in t) || !("name" in t) || typeof t.name != "string" || !("relations" in t) || typeof t.relations != "object" || t.relations === null)
+      return !1;
+    const n = t.relations, s = Object.values(n);
+    return s.length > 0 ? s.some((o) => m(o, j)) : this.isTable(t.table);
+  }
+  /**
+   * Get all v1 relation entries from schema (defineRelations() API)
+   *
+   * Handles both individual entries and the full defineRelations() result object.
+   * Extracts relation configurations that use the modern v1 API with official types.
+   *
+   * @returns Array of v1 relation entries
+   */
+  getV1RelationEntries() {
+    const e = [];
+    for (const t of Object.values(this.schema))
+      if (this.isV1RelationEntry(t))
+        e.push(t);
+      else if (this.isV1DefineRelationsResult(t))
+        for (const n of Object.values(t))
+          this.isV1RelationEntry(n) && e.push(n);
+    return e;
+  }
+  /**
+   * Check if a value is a full v1 defineRelations() result object
+   *
+   * This is an object where all values are TableRelationalConfig objects.
+   * Used to detect the full result of calling defineRelations() in v1.
+   *
+   * @param value - The value to check
+   * @returns True if value is a full defineRelations() result
+   */
+  isV1DefineRelationsResult(e) {
+    if (typeof e != "object" || e === null || Array.isArray(e))
+      return !1;
+    const n = Object.values(e);
+    return n.length > 0 && n.every((s) => this.isV1RelationEntry(s));
+  }
+  /**
+   * Generate a table definition in DBML format
+   *
+   * Creates the complete table definition including columns, indexes, constraints,
+   * and table-level comments. Also collects foreign keys if not in relational mode.
+   *
+   * @param dbml - The DBML builder to add the table to
+   * @param table - The Drizzle table to generate
+   */
+  generateTable(e, t) {
+    const n = g(t), s = d(t), o = this.dialectConfig.escapeName(n);
+    e.line(`Table ${o} {`), e.indent();
+    for (const a of Object.values(s))
+      this.generateColumn(e, a, n);
+    const i = this.getTableConfig(t);
+    i && this.generateIndexesBlock(e, i);
+    const r = this.comments?.tables[n]?.comment;
+    r && (e.line(), e.line(`Note: '${$(r)}'`)), e.dedent(), e.line("}"), !this.relational && i && i.foreignKeys.length > 0 && this.collectForeignKeysFromConfig(n, i.foreignKeys);
+  }
+  /**
+   * Get table configuration from a Drizzle table
+   *
+   * Extracts indexes, primary keys, unique constraints, and foreign keys
+   * from the table using the appropriate dialect-specific config getter.
+   *
+   * @param table - The Drizzle table to get configuration from
+   * @returns Table configuration or undefined if dialect is not supported
+   */
+  getTableConfig(e) {
+    if (m(e, C)) {
+      const t = v(e);
+      return {
+        indexes: t.indexes || [],
+        primaryKeys: t.primaryKeys || [],
+        uniqueConstraints: t.uniqueConstraints || [],
+        foreignKeys: t.foreignKeys || []
+      };
+    }
+    if (m(e, T)) {
+      const t = N(e);
+      return {
+        indexes: t.indexes || [],
+        primaryKeys: t.primaryKeys || [],
+        uniqueConstraints: t.uniqueConstraints || [],
+        foreignKeys: t.foreignKeys || []
+      };
+    }
+    if (m(e, R)) {
+      const t = K(e);
+      return {
+        indexes: t.indexes || [],
+        primaryKeys: t.primaryKeys || [],
+        uniqueConstraints: t.uniqueConstraints || [],
+        foreignKeys: t.foreignKeys || []
+      };
+    }
+  }
+  /**
+   * Generate a column definition in DBML format
+   *
+   * Creates a column line with type and attributes (primary key, not null, unique, etc.)
+   * and includes column-level comments if available.
+   *
+   * @param dbml - The DBML builder to add the column to
+   * @param column - The Drizzle column to generate
+   * @param tableName - Optional table name for looking up comments
+   */
+  generateColumn(e, t, n) {
+    const s = this.dialectConfig.escapeName(t.name), o = this.getColumnType(t), i = this.getColumnAttributes(t, n), r = this.formatAttributes(i);
+    r ? e.line(`${s} ${o} [${r}]`) : e.line(`${s} ${o}`);
+  }
+  /**
+   * Get the SQL type for a column
+   *
+   * @param column - The column to get the SQL type from
+   * @returns The SQL type string (e.g., "varchar", "integer")
+   */
+  getColumnType(e) {
+    return e.getSQLType();
+  }
+  /**
+   * Get column attributes for DBML
+   *
+   * Extracts attributes like primary key, not null, unique, increment, default value,
+   * and note from the column. Uses column metadata and comments if available.
+   *
+   * @param column - The column to get attributes from
+   * @param tableName - Optional table name for looking up comments
+   * @returns Array of attribute strings for DBML format
+   */
+  getColumnAttributes(e, t) {
+    const n = [];
+    e.primary && n.push("primary key"), e.notNull && n.push("not null"), e.isUnique && n.push("unique"), this.dialectConfig.isIncrement(e) && n.push("increment");
+    const s = this.getDefaultValue(e);
+    if (s !== void 0 && n.push(`default: ${s}`), t) {
+      const o = this.comments?.tables[t]?.columns[e.name]?.comment;
+      o && n.push(`note: '${$(o)}'`);
+    }
+    return n;
+  }
+  /**
+   * Format attributes into a string
+   *
+   * @param attrs - Array of attribute strings
+   * @returns Comma-separated attribute string
+   */
+  formatAttributes(e) {
+    return e.join(", ");
+  }
+  /**
+   * Get the default value for a column
+   *
+   * Extracts and formats the default value from a column, handling SQL expressions,
+   * objects, and primitive values. Returns undefined if no default value exists.
+   *
+   * @param column - The column to get the default value from
+   * @returns Formatted default value string or undefined
+   */
+  getDefaultValue(e) {
+    if (!e.hasDefault)
+      return;
+    const t = e.default;
+    if (t === null)
+      return "null";
+    if (t !== void 0) {
+      if (typeof t == "object" && t !== null) {
+        if ("queryChunks" in t) {
+          const n = t.queryChunks, s = [];
+          for (const o of n)
+            typeof o == "string" ? s.push(o) : typeof o == "object" && o !== null && "value" in o && s.push(String(o.value));
+          return `\`${s.join("")}\``;
+        }
+        return "sql" in t ? `\`${t.sql}\`` : `'${JSON.stringify(t)}'`;
+      }
+      if (typeof t == "string")
+        return `'${t.replace(/'/g, "\\'")}'`;
+      if (typeof t == "number" || typeof t == "boolean")
+        return String(t);
+    }
+  }
+  /**
+   * Generate indexes block from table configuration
+   *
+   * Creates the indexes block containing primary keys, unique constraints,
+   * and regular indexes with their respective attributes.
+   *
+   * @param dbml - The DBML builder to add the indexes block to
+   * @param tableConfig - The table configuration containing index information
+   */
+  generateIndexesBlock(e, t) {
+    const { indexes: n, primaryKeys: s, uniqueConstraints: o } = t;
+    if (!(n.length === 0 && s.length === 0 && o.length === 0)) {
+      e.line(), e.line("indexes {"), e.indent();
+      for (const i of s) {
+        const r = this.getPrimaryKeyColumns(i);
+        if (r.length > 0) {
+          const a = r.map((l) => this.dialectConfig.escapeName(l)).join(", ");
+          e.line(`(${a}) [pk]`);
+        }
+      }
+      for (const i of o) {
+        const r = this.getUniqueConstraintColumns(i);
+        if (r.length > 0) {
+          const a = r.map((l) => this.dialectConfig.escapeName(l)).join(", ");
+          e.line(`(${a}) [unique]`);
+        }
+      }
+      for (const i of n) {
+        const r = this.getIndexColumns(i);
+        if (r.length > 0) {
+          const a = r.map((h) => this.dialectConfig.escapeName(h)).join(", "), l = [];
+          this.isUniqueIndex(i) && l.push("unique");
+          const c = l.length > 0 ? ` [${l.join(", ")}]` : "";
+          e.line(`(${a})${c}`);
+        }
+      }
+      e.dedent(), e.line("}");
+    }
+  }
+  /**
+   * Collect foreign keys from table configuration
+   *
+   * Parses all foreign key definitions from the table config and adds them
+   * to the generatedRefs collection for later output.
+   *
+   * @param tableName - The name of the source table
+   * @param foreignKeys - Array of foreign key definitions from table config
+   */
+  collectForeignKeysFromConfig(e, t) {
+    for (const n of t) {
+      const s = this.parseForeignKey(e, n);
+      s && this.generatedRefs.push(s);
+    }
+  }
+  /**
+   * Parse a foreign key into a GeneratedRef
+   *
+   * Extracts foreign key information (source/target tables and columns, actions)
+   * and converts it to a GeneratedRef object for DBML output.
+   *
+   * @param tableName - The name of the source table
+   * @param fk - The foreign key definition to parse
+   * @returns GeneratedRef object or undefined if parsing fails
+   */
+  parseForeignKey(e, t) {
+    try {
+      const n = t, s = n.reference(), o = s.columns.map((a) => a.name), i = s.foreignColumns.map((a) => a.name), r = g(s.foreignTable);
+      return {
+        fromTable: e,
+        fromColumns: o,
+        toTable: r,
+        toColumns: i,
+        type: ">",
+        onDelete: n.onDelete,
+        onUpdate: n.onUpdate
+      };
+    } catch {
+      return;
+    }
+  }
+  /**
+   * Get a mapping from variable names to table names in the schema
+   *
+   * Creates a map from TypeScript variable names (e.g., "usersTable") to
+   * actual database table names (e.g., "users").
+   *
+   * @returns Map of variable names to table names
+   */
+  getTableNameMapping() {
+    const e = /* @__PURE__ */ new Map();
+    for (const [t, n] of Object.entries(this.schema))
+      if (this.isTable(n)) {
+        const s = g(n);
+        e.set(t, s);
+      }
+    return e;
+  }
+  /**
+   * Get a mapping from TypeScript property names to database column names for a table
+   *
+   * Creates a map from TypeScript property names (e.g., "authorId") to
+   * actual database column names (e.g., "author_id").
+   *
+   * @param tableVarName - The variable name of the table in the schema
+   * @returns Map of property names to column names
+   */
+  getColumnNameMapping(e) {
+    const t = /* @__PURE__ */ new Map(), n = this.schema[e];
+    if (n && this.isTable(n)) {
+      const s = d(n);
+      for (const [o, i] of Object.entries(s))
+        t.set(o, i.name);
+    }
+    return t;
+  }
+  /**
+   * 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(e, t, n, s) {
+    if (!this.parsedRelations) return !1;
+    for (const o of this.parsedRelations.relations)
+      if (o.type === "one" && o.sourceTable === t && o.targetTable === e && o.fields.length > 0 && o.references.length > 0) {
+        const i = o.fields, r = o.references;
+        if (this.arraysEqual(i, s) && this.arraysEqual(r, n))
+          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(e, t) {
+    return e.length !== t.length ? !1 : e.every((n, s) => n === t[s]);
+  }
+  /**
+   * Generate references from v0 relations() API
+   *
+   * Uses TypeScript Compiler API to parse relations() definitions from source file
+   * and extract fields/references to generate DBML Ref lines.
+   *
+   * Detects one-to-one relationships when bidirectional one() relations exist.
+   */
+  generateRelationalRefsFromV0() {
+    if (!this.parsedRelations || this.parsedRelations.relations.length === 0)
+      return;
+    const e = this.getTableNameMapping(), t = /* @__PURE__ */ new Set();
+    for (const n of this.parsedRelations.relations) {
+      if (n.type !== "one" || n.fields.length === 0 || n.references.length === 0)
+        continue;
+      const s = e.get(n.sourceTable), o = e.get(n.targetTable);
+      if (!s || !o)
+        continue;
+      const i = this.getColumnNameMapping(n.sourceTable), r = this.getColumnNameMapping(n.targetTable), a = n.fields.map(
+        (u) => i.get(u) || u
+      ), l = n.references.map((u) => r.get(u) || u), c = `${s}.${a.join(",")}-${o}.${l.join(",")}`, h = `${o}.${l.join(",")}-${s}.${a.join(",")}`;
+      if (t.has(c) || t.has(h))
+        continue;
+      t.add(c);
+      const f = this.hasReverseOneRelation(
+        n.sourceTable,
+        n.targetTable,
+        n.fields,
+        n.references
+      ), p = {
+        fromTable: s,
+        fromColumns: a,
+        toTable: o,
+        toColumns: l,
+        type: f ? "-" : ">"
+      };
+      this.generatedRefs.push(p);
+    }
+  }
+  /**
+   * Generate references from v1 defineRelations() entries
+   *
+   * Uses official Drizzle v1 types (TableRelationalConfig, Relation, One).
+   * Processes One relations to extract foreign key information and generates
+   * DBML Ref lines. Detects one-to-one relationships with bidirectional checks.
+   *
+   * @param entries - Array of v1 relation entries from defineRelations()
+   */
+  generateRelationalRefsFromV1(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const n of e) {
+      const s = g(n.table);
+      for (const o of Object.values(n.relations)) {
+        if (!m(o, b) || o.isReversed)
+          continue;
+        const i = o, r = i.sourceColumns.map((u) => u.name), a = i.targetColumns.map((u) => u.name);
+        if (r.length === 0 || a.length === 0)
+          continue;
+        const l = g(i.targetTable), c = `${s}.${r.join(",")}->${l}.${a.join(",")}`, h = `${l}.${a.join(",")}->${s}.${r.join(",")}`;
+        if (t.has(c) || t.has(h))
+          continue;
+        t.add(c);
+        const f = this.hasV1ReverseOneRelation(
+          e,
+          l,
+          s,
+          a,
+          r
+        ), p = {
+          fromTable: s,
+          fromColumns: r,
+          toTable: l,
+          toColumns: a,
+          type: f ? "-" : ">"
+        };
+        this.generatedRefs.push(p);
+      }
+    }
+  }
+  /**
+   * 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 entries - All v1 relation entries
+   * @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
+   */
+  hasV1ReverseOneRelation(e, t, n, s, o) {
+    const i = e.find((r) => g(r.table) === t);
+    if (!i)
+      return !1;
+    for (const r of Object.values(i.relations)) {
+      if (!m(r, b))
+        continue;
+      const a = r;
+      if (g(a.targetTable) !== n)
+        continue;
+      const c = a.sourceColumns.map((f) => f.name), h = a.targetColumns.map((f) => f.name);
+      if (c.length === s.length && h.length === o.length && c.every((f, p) => f === s[p]) && h.every((f, p) => f === o[p]))
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Get unique key for a relation to avoid duplicates
+   *
+   * Creates a consistent key by sorting table names alphabetically.
+   *
+   * @param tableName - The source table name
+   * @param relation - The relation object
+   * @returns A unique key string for the relation
+   */
+  getRelationKey(e, t) {
+    const n = t, s = n.referencedTable ? g(n.referencedTable) : "unknown", o = [e, s].sort();
+    return `${o[0]}-${o[1]}`;
+  }
+  /**
+   * Parse a relation into a GeneratedRef
+   *
+   * Extracts relation information from a legacy relation object and converts
+   * it to a GeneratedRef for DBML output.
+   *
+   * @param tableName - The source table name
+   * @param relation - The relation object to parse
+   * @returns GeneratedRef object or undefined if parsing fails
+   */
+  parseRelation(e, t) {
+    try {
+      const n = t;
+      if (!n.referencedTable)
+        return;
+      const s = g(n.referencedTable), o = n.sourceColumns || [], i = n.referencedColumns || [];
+      if (o.length === 0 || i.length === 0)
+        return;
+      const r = o.map((c) => c.name), a = i.map((c) => c.name);
+      let l = ">";
+      return n.relationType === "one" && (l = "-"), {
+        fromTable: e,
+        fromColumns: r,
+        toTable: s,
+        toColumns: a,
+        type: l
+      };
+    } catch {
+      return;
+    }
+  }
+  /**
+   * Generate a reference line in DBML format
+   *
+   * Creates a Ref line showing the relationship between tables with optional
+   * onDelete and onUpdate actions.
+   *
+   * @param dbml - The DBML builder to add the reference to
+   * @param ref - The reference definition to generate
+   */
+  generateRef(e, t) {
+    const n = `${this.dialectConfig.escapeName(t.fromTable)}.${t.fromColumns.map((r) => this.dialectConfig.escapeName(r)).join(", ")}`, s = `${this.dialectConfig.escapeName(t.toTable)}.${t.toColumns.map((r) => this.dialectConfig.escapeName(r)).join(", ")}`;
+    let o = `Ref: ${n} ${t.type} ${s}`;
+    const i = [];
+    t.onDelete && t.onDelete !== "no action" && i.push(`delete: ${t.onDelete}`), t.onUpdate && t.onUpdate !== "no action" && i.push(`update: ${t.onUpdate}`), i.length > 0 && (o += ` [${i.join(", ")}]`), e.line(o);
+  }
+  // Helper methods for extracting column information from constraints
+  /**
+   * Get column names from an index definition
+   *
+   * @param idx - The index definition to extract columns from
+   * @returns Array of column names in the index
+   */
+  getIndexColumns(e) {
+    try {
+      return e.config.columns.map((n) => typeof n == "object" && n !== null && "name" in n ? n.name : "").filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Check if an index is unique
+   *
+   * @param idx - The index definition to check
+   * @returns True if the index has the unique flag
+   */
+  isUniqueIndex(e) {
+    try {
+      return e.config.unique === !0;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Get column names from a primary key constraint
+   *
+   * @param pk - The primary key definition to extract columns from
+   * @returns Array of column names in the primary key
+   */
+  getPrimaryKeyColumns(e) {
+    try {
+      return e.columns.map((n) => n.name);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get column names from a unique constraint
+   *
+   * @param uc - The unique constraint definition to extract columns from
+   * @returns Array of column names in the unique constraint
+   */
+  getUniqueConstraintColumns(e) {
+    try {
+      return e.columns.map((n) => n.name);
+    } catch {
+      return [];
+    }
+  }
+}
+function P(y, e) {
+  const t = O(y), n = x(t);
+  q(n, { recursive: !0 }), V(t, e, "utf-8");
+}
+function $(y) {
+  return y.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
+}
+export {
+  B as BaseGenerator,
+  D as DbmlBuilder,
+  P as writeDbmlFile
+};
+//# sourceMappingURL=common.js.map