@biref/scanner 0.0.2 → 0.1.1

package/dist/index.cjs

@@ -1,5 +1,1089 @@
 'use strict';
 
+// src/adapters/mysql/MySQLMeta.ts
+var MYSQL_ADAPTER_NAME = "mysql";
+var MYSQL_URL_SCHEMES = ["mysql", "mariadb"];
+
+// src/adapters/mysql/mapping/ConstraintMapper.ts
+var ConstraintMapper = class _ConstraintMapper {
+  static toConstraint(raw) {
+    return {
+      name: raw.name,
+      kind: _ConstraintMapper.toKind(raw.kind),
+      fields: raw.columns,
+      expression: raw.definition
+    };
+  }
+  static toKind(kind) {
+    switch (kind) {
+      case "UNIQUE": {
+        return "unique";
+      }
+      case "CHECK": {
+        return "check";
+      }
+      default: {
+        return "custom";
+      }
+    }
+  }
+};
+
+// src/adapters/mysql/mapping/FieldMapper.ts
+var ENUM_VALUES_RE = /^enum\((.+)\)$/i;
+var SET_VALUES_RE = /^set\((.+)\)$/i;
+var QUOTED_VALUE_RE = /'([^']*)'/g;
+var FieldMapper = class _FieldMapper {
+  static toField(col, isIdentifier) {
+    return {
+      name: col.name,
+      type: _FieldMapper.toType(col),
+      nullable: col.nullable,
+      isIdentifier,
+      defaultValue: col.default_value,
+      description: col.description
+    };
+  }
+  static toType(col) {
+    const dataType = col.data_type.toLowerCase();
+    if (dataType === "enum") {
+      return {
+        category: "enum",
+        nativeType: col.column_type,
+        enumValues: _FieldMapper.parseEnumValues(col.column_type)
+      };
+    }
+    if (dataType === "set") {
+      return {
+        category: "enum",
+        nativeType: col.column_type,
+        enumValues: _FieldMapper.parseSetValues(col.column_type)
+      };
+    }
+    if (col.column_type.toLowerCase() === "tinyint(1)") {
+      return {
+        category: "boolean",
+        nativeType: col.column_type
+      };
+    }
+    const base = {
+      category: _FieldMapper.categorize(dataType),
+      nativeType: col.column_type
+    };
+    if (col.numeric_precision !== null && (dataType === "decimal" || dataType === "numeric")) {
+      return {
+        ...base,
+        precision: col.numeric_precision,
+        scale: col.numeric_scale ?? void 0
+      };
+    }
+    if (col.character_max_length !== null) {
+      return { ...base, length: col.character_max_length };
+    }
+    return base;
+  }
+  static parseEnumValues(columnType) {
+    const match = ENUM_VALUES_RE.exec(columnType);
+    if (!match) {
+      return [];
+    }
+    return _FieldMapper.extractQuotedValues(match[1]);
+  }
+  static parseSetValues(columnType) {
+    const match = SET_VALUES_RE.exec(columnType);
+    if (!match) {
+      return [];
+    }
+    return _FieldMapper.extractQuotedValues(match[1]);
+  }
+  static extractQuotedValues(raw) {
+    return Array.from(raw.matchAll(QUOTED_VALUE_RE), (m) => m[1]);
+  }
+  static categorize(dataType) {
+    switch (dataType) {
+      case "varchar":
+      case "char":
+      case "text":
+      case "tinytext":
+      case "mediumtext":
+      case "longtext": {
+        return "string";
+      }
+      case "tinyint":
+      case "smallint":
+      case "mediumint":
+      case "int":
+      case "bigint": {
+        return "integer";
+      }
+      case "decimal":
+      case "numeric":
+      case "float":
+      case "double":
+      case "real": {
+        return "decimal";
+      }
+      case "bit": {
+        return "binary";
+      }
+      case "date":
+      case "year": {
+        return "date";
+      }
+      case "datetime":
+      case "timestamp": {
+        return "timestamp";
+      }
+      case "time": {
+        return "time";
+      }
+      case "json": {
+        return "json";
+      }
+      case "binary":
+      case "varbinary":
+      case "blob":
+      case "tinyblob":
+      case "mediumblob":
+      case "longblob": {
+        return "binary";
+      }
+      default: {
+        return "unknown";
+      }
+    }
+  }
+};
+
+// src/adapters/mysql/mysqlEnums.ts
+var MySQLReferentialAction = {
+  Restrict: "RESTRICT",
+  Cascade: "CASCADE",
+  SetNull: "SET NULL",
+  NoAction: "NO ACTION",
+  SetDefault: "SET DEFAULT"
+};
+var MySQLIndexMethod = {
+  BTree: "BTREE",
+  Hash: "HASH"};
+
+// src/adapters/mysql/mapping/IndexMapper.ts
+var IndexMapper = class _IndexMapper {
+  static toIndex(raw) {
+    return {
+      name: raw.name,
+      fields: raw.columns,
+      unique: raw.unique,
+      kind: _IndexMapper.toKind(raw.method),
+      partial: false,
+      definition: null
+    };
+  }
+  static toKind(method) {
+    switch (method.toUpperCase()) {
+      case MySQLIndexMethod.BTree: {
+        return "btree";
+      }
+      case MySQLIndexMethod.Hash: {
+        return "hash";
+      }
+      default: {
+        return "unknown";
+      }
+    }
+  }
+};
+
+// src/adapters/mysql/mapping/ReferenceMapper.ts
+var ReferenceMapper = class _ReferenceMapper {
+  static toReference(fk) {
+    return {
+      name: fk.name,
+      fromEntity: { namespace: fk.from_namespace, name: fk.from_table },
+      fromFields: fk.from_columns,
+      toEntity: { namespace: fk.to_namespace, name: fk.to_table },
+      toFields: fk.to_columns,
+      confidence: 1,
+      onUpdate: _ReferenceMapper.toAction(fk.update_action),
+      onDelete: _ReferenceMapper.toAction(fk.delete_action)
+    };
+  }
+  static toAction(rule) {
+    switch (rule) {
+      case MySQLReferentialAction.Restrict: {
+        return "restrict";
+      }
+      case MySQLReferentialAction.Cascade: {
+        return "cascade";
+      }
+      case MySQLReferentialAction.SetNull: {
+        return "set-null";
+      }
+      case MySQLReferentialAction.SetDefault: {
+        return "set-default";
+      }
+      case MySQLReferentialAction.NoAction: {
+        return "no-action";
+      }
+      default: {
+        return "no-action";
+      }
+    }
+  }
+};
+
+// src/adapters/mysql/mapping/EntityAssembler.ts
+var EntityAssembler = class _EntityAssembler {
+  static assemble(inputs) {
+    const tableKeys = new Set(
+      inputs.tables.map((t) => _EntityAssembler.qualified(t.namespace, t.name))
+    );
+    const pkByEntity = _EntityAssembler.indexPrimaryKeys(inputs.primaryKeys);
+    const colsByEntity = _EntityAssembler.indexColumns(inputs.columns);
+    const relsByEntity = _EntityAssembler.buildRelationships(
+      inputs.foreignKeys,
+      tableKeys
+    );
+    const indexesByEntity = _EntityAssembler.buildIndexes(
+      inputs.indexes,
+      tableKeys
+    );
+    const constraintsByEntity = _EntityAssembler.buildConstraints(
+      inputs.constraints,
+      tableKeys
+    );
+    return inputs.tables.map((table) => {
+      const key = _EntityAssembler.qualified(table.namespace, table.name);
+      const pkColumns = pkByEntity.get(key) ?? [];
+      const pkSet = new Set(pkColumns);
+      const rawCols = colsByEntity.get(key) ?? [];
+      const fields = rawCols.map(
+        (col) => FieldMapper.toField(col, pkSet.has(col.name))
+      );
+      return {
+        namespace: table.namespace,
+        name: table.name,
+        fields,
+        identifier: pkColumns,
+        relationships: relsByEntity.get(key) ?? [],
+        constraints: constraintsByEntity.get(key) ?? [],
+        indexes: indexesByEntity.get(key) ?? [],
+        description: table.description
+      };
+    });
+  }
+  static indexPrimaryKeys(primaryKeys) {
+    const map = /* @__PURE__ */ new Map();
+    for (const pk of primaryKeys) {
+      map.set(
+        _EntityAssembler.qualified(pk.namespace, pk.table_name),
+        pk.columns
+      );
+    }
+    return map;
+  }
+  static indexColumns(columns) {
+    const map = /* @__PURE__ */ new Map();
+    for (const col of columns) {
+      const key = _EntityAssembler.qualified(col.namespace, col.table_name);
+      const list = map.get(key);
+      if (list) {
+        list.push(col);
+      } else {
+        map.set(key, [col]);
+      }
+    }
+    return map;
+  }
+  static buildRelationships(foreignKeys, tableKeys) {
+    const map = /* @__PURE__ */ new Map();
+    for (const fk of foreignKeys) {
+      const reference = ReferenceMapper.toReference(fk);
+      const fromKey = _EntityAssembler.qualified(
+        fk.from_namespace,
+        fk.from_table
+      );
+      const toKey = _EntityAssembler.qualified(fk.to_namespace, fk.to_table);
+      if (tableKeys.has(fromKey)) {
+        _EntityAssembler.push(map, fromKey, {
+          direction: "outbound",
+          reference
+        });
+      }
+      if (tableKeys.has(toKey)) {
+        _EntityAssembler.push(map, toKey, {
+          direction: "inbound",
+          reference
+        });
+      }
+    }
+    return map;
+  }
+  static buildIndexes(indexes, tableKeys) {
+    const map = /* @__PURE__ */ new Map();
+    for (const idx of indexes) {
+      const key = _EntityAssembler.qualified(idx.namespace, idx.table_name);
+      if (!tableKeys.has(key)) {
+        continue;
+      }
+      _EntityAssembler.push(map, key, IndexMapper.toIndex(idx));
+    }
+    return map;
+  }
+  static buildConstraints(constraints, tableKeys) {
+    const map = /* @__PURE__ */ new Map();
+    for (const cn of constraints) {
+      const key = _EntityAssembler.qualified(cn.namespace, cn.table_name);
+      if (!tableKeys.has(key)) {
+        continue;
+      }
+      _EntityAssembler.push(map, key, ConstraintMapper.toConstraint(cn));
+    }
+    return map;
+  }
+  static push(map, key, value) {
+    const list = map.get(key);
+    if (list) {
+      list.push(value);
+    } else {
+      map.set(key, [value]);
+    }
+  }
+  static qualified(namespace, name) {
+    return `${namespace}.${name}`;
+  }
+};
+
+// src/adapters/mysql/queries/inPlaceholders.ts
+function inPlaceholders(count) {
+  return Array.from({ length: count }, () => "?").join(", ");
+}
+
+// src/adapters/mysql/queries/ColumnsQuery.ts
+var ColumnsQuery = class {
+  static async fetch(client, namespaces) {
+    const sql = `
+SELECT
+  c.TABLE_SCHEMA,
+  c.TABLE_NAME,
+  c.COLUMN_NAME,
+  c.DATA_TYPE,
+  c.COLUMN_TYPE,
+  c.IS_NULLABLE,
+  c.COLUMN_DEFAULT,
+  c.COLUMN_COMMENT,
+  c.CHARACTER_MAXIMUM_LENGTH,
+  c.NUMERIC_PRECISION,
+  c.NUMERIC_SCALE
+FROM information_schema.COLUMNS c
+JOIN information_schema.TABLES t
+  ON t.TABLE_SCHEMA = c.TABLE_SCHEMA
+  AND t.TABLE_NAME = c.TABLE_NAME
+WHERE t.TABLE_TYPE = 'BASE TABLE'
+  AND c.TABLE_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY c.TABLE_SCHEMA, c.TABLE_NAME, c.ORDINAL_POSITION
+`;
+    const [rows] = await client.execute(sql, [...namespaces]);
+    return rows.map((row) => ({
+      namespace: row.TABLE_SCHEMA,
+      table_name: row.TABLE_NAME,
+      name: row.COLUMN_NAME,
+      data_type: row.DATA_TYPE,
+      column_type: row.COLUMN_TYPE,
+      nullable: row.IS_NULLABLE === "YES",
+      default_value: row.COLUMN_DEFAULT,
+      description: row.COLUMN_COMMENT || null,
+      character_max_length: row.CHARACTER_MAXIMUM_LENGTH,
+      numeric_precision: row.NUMERIC_PRECISION,
+      numeric_scale: row.NUMERIC_SCALE
+    }));
+  }
+};
+
+// src/adapters/mysql/queries/ConstraintsQuery.ts
+var ConstraintsQuery = class _ConstraintsQuery {
+  static async fetch(client, namespaces) {
+    const [uniques, checks] = await Promise.all([
+      _ConstraintsQuery.fetchUniques(client, namespaces),
+      _ConstraintsQuery.fetchChecks(client, namespaces)
+    ]);
+    return [...uniques, ...checks];
+  }
+  static async fetchUniques(client, namespaces) {
+    const sql = `
+SELECT
+  kcu.TABLE_SCHEMA,
+  kcu.TABLE_NAME,
+  kcu.CONSTRAINT_NAME,
+  kcu.COLUMN_NAME
+FROM information_schema.KEY_COLUMN_USAGE kcu
+JOIN information_schema.TABLE_CONSTRAINTS tc
+  ON tc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
+  AND tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+  AND tc.TABLE_NAME = kcu.TABLE_NAME
+WHERE tc.CONSTRAINT_TYPE = 'UNIQUE'
+  AND kcu.TABLE_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY kcu.TABLE_SCHEMA, kcu.TABLE_NAME, kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION
+`;
+    const [rows] = await client.execute(sql, [...namespaces]);
+    return _ConstraintsQuery.aggregateUniques(rows);
+  }
+  static aggregateUniques(rows) {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.TABLE_SCHEMA}.${row.TABLE_NAME}.${row.CONSTRAINT_NAME}`;
+      const existing = map.get(key);
+      if (existing) {
+        existing.columns.push(row.COLUMN_NAME);
+      } else {
+        map.set(key, {
+          namespace: row.TABLE_SCHEMA,
+          table_name: row.TABLE_NAME,
+          name: row.CONSTRAINT_NAME,
+          kind: "UNIQUE",
+          definition: null,
+          columns: [row.COLUMN_NAME]
+        });
+      }
+    }
+    return [...map.values()];
+  }
+  static async fetchChecks(client, namespaces) {
+    const sql = `
+SELECT
+  cc.CONSTRAINT_SCHEMA,
+  tc.TABLE_NAME,
+  cc.CONSTRAINT_NAME,
+  cc.CHECK_CLAUSE
+FROM information_schema.CHECK_CONSTRAINTS cc
+JOIN information_schema.TABLE_CONSTRAINTS tc
+  ON tc.CONSTRAINT_SCHEMA = cc.CONSTRAINT_SCHEMA
+  AND tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+WHERE tc.CONSTRAINT_TYPE = 'CHECK'
+  AND cc.CONSTRAINT_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY cc.CONSTRAINT_SCHEMA, tc.TABLE_NAME, cc.CONSTRAINT_NAME
+`;
+    try {
+      const [rows] = await client.execute(sql, [...namespaces]);
+      return rows.map((row) => ({
+        namespace: row.CONSTRAINT_SCHEMA,
+        table_name: row.TABLE_NAME,
+        name: row.CONSTRAINT_NAME,
+        kind: "CHECK",
+        definition: row.CHECK_CLAUSE,
+        columns: []
+      }));
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/mysql/queries/ForeignKeysQuery.ts
+var ForeignKeysQuery = class _ForeignKeysQuery {
+  static async fetch(client, namespaces) {
+    const sql = `
+SELECT
+  kcu.CONSTRAINT_NAME,
+  kcu.TABLE_SCHEMA,
+  kcu.TABLE_NAME,
+  kcu.COLUMN_NAME,
+  kcu.REFERENCED_TABLE_SCHEMA,
+  kcu.REFERENCED_TABLE_NAME,
+  kcu.REFERENCED_COLUMN_NAME,
+  rc.UPDATE_RULE,
+  rc.DELETE_RULE
+FROM information_schema.KEY_COLUMN_USAGE kcu
+JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+  ON rc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
+  AND rc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+WHERE kcu.REFERENCED_TABLE_NAME IS NOT NULL
+  AND kcu.TABLE_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY kcu.TABLE_SCHEMA, kcu.TABLE_NAME, kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION
+`;
+    const [rows] = await client.execute(sql, [...namespaces]);
+    return _ForeignKeysQuery.aggregate(rows);
+  }
+  static aggregate(rows) {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.TABLE_SCHEMA}.${row.TABLE_NAME}.${row.CONSTRAINT_NAME}`;
+      const existing = map.get(key);
+      if (existing) {
+        existing.from_columns.push(row.COLUMN_NAME);
+        existing.to_columns.push(row.REFERENCED_COLUMN_NAME);
+      } else {
+        map.set(key, {
+          name: row.CONSTRAINT_NAME,
+          from_namespace: row.TABLE_SCHEMA,
+          from_table: row.TABLE_NAME,
+          from_columns: [row.COLUMN_NAME],
+          to_namespace: row.REFERENCED_TABLE_SCHEMA,
+          to_table: row.REFERENCED_TABLE_NAME,
+          to_columns: [row.REFERENCED_COLUMN_NAME],
+          update_action: row.UPDATE_RULE,
+          delete_action: row.DELETE_RULE
+        });
+      }
+    }
+    return [...map.values()];
+  }
+};
+
+// src/adapters/mysql/queries/IndexesQuery.ts
+var IndexesQuery = class _IndexesQuery {
+  static async fetch(client, namespaces) {
+    const sql = `
+SELECT
+  s.TABLE_SCHEMA,
+  s.TABLE_NAME,
+  s.INDEX_NAME,
+  s.INDEX_TYPE,
+  s.NON_UNIQUE,
+  s.COLUMN_NAME
+FROM information_schema.STATISTICS s
+WHERE s.INDEX_NAME <> 'PRIMARY'
+  AND s.TABLE_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY s.TABLE_SCHEMA, s.TABLE_NAME, s.INDEX_NAME, s.SEQ_IN_INDEX
+`;
+    const [rows] = await client.execute(sql, [...namespaces]);
+    return _IndexesQuery.aggregate(rows);
+  }
+  static aggregate(rows) {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.TABLE_SCHEMA}.${row.TABLE_NAME}.${row.INDEX_NAME}`;
+      const existing = map.get(key);
+      if (existing) {
+        existing.columns.push(row.COLUMN_NAME);
+      } else {
+        map.set(key, {
+          namespace: row.TABLE_SCHEMA,
+          table_name: row.TABLE_NAME,
+          name: row.INDEX_NAME,
+          method: row.INDEX_TYPE,
+          unique: row.NON_UNIQUE === 0,
+          partial: false,
+          definition: null,
+          columns: [row.COLUMN_NAME]
+        });
+      }
+    }
+    return [...map.values()];
+  }
+};
+
+// src/adapters/mysql/queries/PrimaryKeysQuery.ts
+var PrimaryKeysQuery = class _PrimaryKeysQuery {
+  static async fetch(client, namespaces) {
+    const sql = `
+SELECT
+  kcu.TABLE_SCHEMA,
+  kcu.TABLE_NAME,
+  kcu.COLUMN_NAME
+FROM information_schema.KEY_COLUMN_USAGE kcu
+JOIN information_schema.TABLE_CONSTRAINTS tc
+  ON tc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
+  AND tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+  AND tc.TABLE_NAME = kcu.TABLE_NAME
+WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+  AND kcu.TABLE_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY kcu.TABLE_SCHEMA, kcu.TABLE_NAME, kcu.ORDINAL_POSITION
+`;
+    const [rows] = await client.execute(sql, [...namespaces]);
+    return _PrimaryKeysQuery.aggregate(rows);
+  }
+  static aggregate(rows) {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.TABLE_SCHEMA}.${row.TABLE_NAME}`;
+      const existing = map.get(key);
+      if (existing) {
+        existing.columns.push(row.COLUMN_NAME);
+      } else {
+        map.set(key, {
+          namespace: row.TABLE_SCHEMA,
+          table_name: row.TABLE_NAME,
+          columns: [row.COLUMN_NAME]
+        });
+      }
+    }
+    return [...map.values()];
+  }
+};
+
+// src/adapters/mysql/queries/TablesQuery.ts
+var TablesQuery = class {
+  static async fetch(client, namespaces) {
+    const sql = `
+SELECT
+  t.TABLE_SCHEMA AS TABLE_SCHEMA,
+  t.TABLE_NAME AS TABLE_NAME,
+  t.TABLE_COMMENT AS TABLE_COMMENT
+FROM information_schema.TABLES t
+WHERE t.TABLE_TYPE = 'BASE TABLE'
+  AND t.TABLE_SCHEMA IN (${inPlaceholders(namespaces.length)})
+ORDER BY t.TABLE_SCHEMA, t.TABLE_NAME
+`;
+    const [rows] = await client.execute(sql, [...namespaces]);
+    return rows.map((row) => ({
+      namespace: row.TABLE_SCHEMA,
+      name: row.TABLE_NAME,
+      description: row.TABLE_COMMENT || null
+    }));
+  }
+};
+
+// src/domain/model/DataModel.ts
+var DataModel = class _DataModel {
+  constructor(kind, entities) {
+    this.kind = kind;
+    this.entities = entities;
+    this.index = new Map(
+      entities.map((e) => [_DataModel.qualifiedName(e.namespace, e.name), e])
+    );
+  }
+  kind;
+  entities;
+  index;
+  /**
+   * Build the lookup key for an entity. Exposed as a static helper so
+   * consumers can compute keys consistently when building their own
+   * indexes on top of a `DataModel`.
+   */
+  static qualifiedName(namespace, name) {
+    return `${namespace}.${name}`;
+  }
+  getEntity(namespace, name) {
+    return this.index.get(_DataModel.qualifiedName(namespace, name));
+  }
+  hasEntity(namespace, name) {
+    return this.index.has(_DataModel.qualifiedName(namespace, name));
+  }
+  /**
+   * All relationships an entity participates in, in both directions.
+   * Returns an empty array if the entity is unknown.
+   */
+  relationshipsOf(namespace, name) {
+    return this.getEntity(namespace, name)?.relationships ?? [];
+  }
+  /**
+   * Outbound relationships: this entity holds the reference.
+   * In a relational store these correspond to FOREIGN KEY constraints
+   * declared by the entity itself.
+   */
+  outboundRelationshipsOf(namespace, name) {
+    return this.relationshipsOf(namespace, name).filter(
+      (r) => r.direction === "outbound"
+    );
+  }
+  /**
+   * Inbound relationships: other entities hold references pointing here.
+   *
+   * This is the differentiating feature of the SDK. Most introspection
+   * tools only surface outbound relationships, requiring consumers to
+   * know which other entities reference theirs ahead of time.
+   */
+  inboundRelationshipsOf(namespace, name) {
+    return this.relationshipsOf(namespace, name).filter(
+      (r) => r.direction === "inbound"
+    );
+  }
+};
+
+// src/adapters/mysql/MySQLIntrospector.ts
+var MySQLIntrospector = class _MySQLIntrospector {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  name = MYSQL_ADAPTER_NAME;
+  kind = "relational";
+  async introspect(options = {}) {
+    const namespaces = await this.resolveNamespaces(options.namespaces);
+    const [tables, columns, primaryKeys, foreignKeys, indexes, constraints] = await Promise.all([
+      TablesQuery.fetch(this.client, namespaces),
+      ColumnsQuery.fetch(this.client, namespaces),
+      PrimaryKeysQuery.fetch(this.client, namespaces),
+      ForeignKeysQuery.fetch(this.client, namespaces),
+      IndexesQuery.fetch(this.client, namespaces),
+      ConstraintsQuery.fetch(this.client, namespaces)
+    ]);
+    const filteredTables = _MySQLIntrospector.applyEntityFilters(
+      tables,
+      options
+    );
+    const entities = EntityAssembler.assemble({
+      tables: filteredTables,
+      columns,
+      primaryKeys,
+      foreignKeys,
+      indexes,
+      constraints
+    });
+    return new DataModel("relational", entities);
+  }
+  async resolveNamespaces(raw) {
+    if (raw === void 0) {
+      return this.currentDatabase();
+    }
+    if (raw === "all") {
+      const [rows] = await this.client.execute(
+        _MySQLIntrospector.ALL_SCHEMAS_SQL
+      );
+      return rows.map((row) => row.SCHEMA_NAME);
+    }
+    return raw;
+  }
+  async currentDatabase() {
+    const [rows] = await this.client.execute(
+      "SELECT DATABASE() AS db"
+    );
+    const db = rows[0]?.db;
+    if (!db) {
+      throw new Error(
+        "No database selected. Pass explicit namespaces or connect to a specific database."
+      );
+    }
+    return [db];
+  }
+  static ALL_SCHEMAS_SQL = `
+SELECT s.SCHEMA_NAME
+FROM information_schema.SCHEMATA s
+WHERE s.SCHEMA_NAME NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
+ORDER BY s.SCHEMA_NAME
+`;
+  static applyEntityFilters(tables, options) {
+    const { includeEntities: allow, excludeEntities: deny } = options;
+    if (!allow && !deny) {
+      return tables;
+    }
+    return tables.filter((t) => {
+      if (allow && !allow.includes(t.name)) {
+        return false;
+      }
+      if (deny?.includes(t.name)) {
+        return false;
+      }
+      return true;
+    });
+  }
+};
+
+// src/adapters/mysql/query/SqlIdentifier.ts
+var SqlIdentifier = class _SqlIdentifier {
+  static quote(id) {
+    return `\`${id.replace(/`/g, "``")}\``;
+  }
+  static qualified(namespace, name) {
+    return `${_SqlIdentifier.quote(namespace)}.${_SqlIdentifier.quote(name)}`;
+  }
+};
+
+// src/adapters/mysql/query/FilterBuilder.ts
+var FilterBuilder = class {
+  constructor(params) {
+    this.params = params;
+  }
+  params;
+  build(filter) {
+    const col = SqlIdentifier.quote(filter.field);
+    switch (filter.operator) {
+      case "eq": {
+        return `${col} = ${this.params.add(filter.value)}`;
+      }
+      case "neq": {
+        return `${col} <> ${this.params.add(filter.value)}`;
+      }
+      case "lt": {
+        return `${col} < ${this.params.add(filter.value)}`;
+      }
+      case "lte": {
+        return `${col} <= ${this.params.add(filter.value)}`;
+      }
+      case "gt": {
+        return `${col} > ${this.params.add(filter.value)}`;
+      }
+      case "gte": {
+        return `${col} >= ${this.params.add(filter.value)}`;
+      }
+      case "like": {
+        return `${col} LIKE ${this.params.add(filter.value)}`;
+      }
+      case "ilike": {
+        return `LOWER(${col}) LIKE LOWER(${this.params.add(filter.value)})`;
+      }
+      case "is-null": {
+        return `${col} IS NULL`;
+      }
+      case "is-not-null": {
+        return `${col} IS NOT NULL`;
+      }
+      case "in": {
+        return this.buildInClause(col, filter.value, "FALSE", "IN");
+      }
+      case "not-in": {
+        return this.buildInClause(col, filter.value, "TRUE", "NOT IN");
+      }
+      case "between": {
+        return this.buildBetween(col, filter.value);
+      }
+      default: {
+        const exhaustive = filter.operator;
+        throw new Error(`Unknown filter operator: ${String(exhaustive)}`);
+      }
+    }
+  }
+  buildInClause(col, value, emptyFallback, keyword) {
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Operator '${keyword.toLowerCase()}' requires an array value.`
+      );
+    }
+    const values = value;
+    if (values.length === 0) {
+      return emptyFallback;
+    }
+    const placeholders = this.params.addAll(values);
+    return `${col} ${keyword} (${placeholders.join(", ")})`;
+  }
+  buildBetween(col, value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+      throw new Error("Operator 'between' requires a [min, max] tuple.");
+    }
+    const tuple = value;
+    const lo = this.params.add(tuple[0]);
+    const hi = this.params.add(tuple[1]);
+    return `${col} BETWEEN ${lo} AND ${hi}`;
+  }
+};
+
+// src/adapters/mysql/query/SqlParamList.ts
+var SqlParamList = class {
+  values = [];
+  /**
+   * Append a value and return a `?` placeholder.
+   */
+  add(value) {
+    this.values.push(value);
+    return "?";
+  }
+  /**
+   * Append many values and return their placeholders in order.
+   */
+  addAll(values) {
+    return values.map((v) => this.add(v));
+  }
+  /** Number of values currently bound. */
+  get size() {
+    return this.values.length;
+  }
+  /**
+   * Return a read-only copy of the bound values. The returned array
+   * is not backed by the internal storage.
+   */
+  toArray() {
+    return [...this.values];
+  }
+};
+
+// src/adapters/mysql/MySQLQueryEngine.ts
+var MySQLQueryEngine = class {
+  name = MYSQL_ADAPTER_NAME;
+  kind = "relational";
+  build(spec, model) {
+    const entity = model.getEntity(spec.namespace, spec.entity);
+    if (!entity) {
+      throw new Error(
+        `Entity "${spec.namespace}.${spec.entity}" not found in the data model.`
+      );
+    }
+    const fieldNames = new Set(entity.fields.map((f) => f.name));
+    const selectedFields = spec.select && spec.select.length > 0 ? [...spec.select] : entity.fields.map((f) => f.name);
+    for (const field of selectedFields) {
+      if (!fieldNames.has(field)) {
+        throw new Error(
+          `Field "${field}" does not exist on "${spec.namespace}.${spec.entity}".`
+        );
+      }
+    }
+    const params = new SqlParamList();
+    const filterBuilder = new FilterBuilder(params);
+    const selectClause = selectedFields.map(SqlIdentifier.quote).join(", ");
+    const fromClause = SqlIdentifier.qualified(spec.namespace, spec.entity);
+    let sql = `SELECT ${selectClause} FROM ${fromClause}`;
+    if (spec.filters && spec.filters.length > 0) {
+      const wherePieces = spec.filters.map((filter) => {
+        if (!fieldNames.has(filter.field)) {
+          throw new Error(
+            `Filter field "${filter.field}" does not exist on "${spec.namespace}.${spec.entity}".`
+          );
+        }
+        return filterBuilder.build(filter);
+      });
+      sql += ` WHERE ${wherePieces.join(" AND ")}`;
+    }
+    if (spec.orderBy && spec.orderBy.length > 0) {
+      const orderPieces = spec.orderBy.map((order) => {
+        if (!fieldNames.has(order.field)) {
+          throw new Error(
+            `Order field "${order.field}" does not exist on "${spec.namespace}.${spec.entity}".`
+          );
+        }
+        return `${SqlIdentifier.quote(order.field)} ${order.direction.toUpperCase()}`;
+      });
+      sql += ` ORDER BY ${orderPieces.join(", ")}`;
+    }
+    if (spec.limit !== void 0) {
+      sql += ` LIMIT ${Number(spec.limit)}`;
+    }
+    if (spec.offset !== void 0) {
+      sql += ` OFFSET ${Number(spec.offset)}`;
+    }
+    return {
+      command: sql,
+      params: params.toArray(),
+      metadata: {
+        engine: MYSQL_ADAPTER_NAME,
+        paramCount: params.size
+      }
+    };
+  }
+};
+
+// src/parsing/DefaultRecordParser.ts
+var DefaultRecordParser = class {
+  parse(entity, row) {
+    const result = {};
+    for (const field of entity.fields) {
+      if (field.name in row) {
+        result[field.name] = this.coerce(field, row[field.name]);
+      }
+    }
+    return result;
+  }
+  parseMany(entity, rows) {
+    return rows.map((row) => this.parse(entity, row));
+  }
+  coerce(field, raw) {
+    if (raw === null || raw === void 0) {
+      return null;
+    }
+    switch (field.type.category) {
+      case "string":
+      case "uuid":
+      case "enum": {
+        return String(raw);
+      }
+      case "integer": {
+        if (typeof raw === "bigint") {
+          return raw;
+        }
+        if (typeof raw === "number") {
+          return raw;
+        }
+        return Number(raw);
+      }
+      case "decimal": {
+        return typeof raw === "string" ? raw : String(raw);
+      }
+      case "boolean": {
+        return Boolean(raw);
+      }
+      case "date":
+      case "timestamp":
+      case "time": {
+        if (raw instanceof Date) {
+          return raw;
+        }
+        if (typeof raw === "string" || typeof raw === "number") {
+          return new Date(raw);
+        }
+        return null;
+      }
+      case "json":
+      case "binary":
+      case "reference":
+      case "unknown": {
+        return raw;
+      }
+      case "array": {
+        return Array.isArray(raw) ? raw : [];
+      }
+      default: {
+        const exhaustive = field.type.category;
+        return exhaustive;
+      }
+    }
+  }
+};
+
+// src/adapters/mysql/MySQLRecordParser.ts
+var BIGINT_NATIVE_TYPES = /* @__PURE__ */ new Set(["bigint"]);
+var MySQLRecordParser = class extends DefaultRecordParser {
+  coerce(field, raw) {
+    if (raw === null || raw === void 0) {
+      return null;
+    }
+    if (field.type.category === "integer" && BIGINT_NATIVE_TYPES.has(field.type.nativeType.toLowerCase())) {
+      if (typeof raw === "bigint") {
+        return raw;
+      }
+      if (typeof raw === "string" || typeof raw === "number") {
+        return BigInt(raw);
+      }
+      return null;
+    }
+    if (field.type.category === "boolean") {
+      if (typeof raw === "number") {
+        return raw !== 0;
+      }
+      return Boolean(raw);
+    }
+    if (field.type.category === "json" && typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    }
+    return super.coerce(field, raw);
+  }
+};
+
+// src/adapters/mysql/MySQLRawQueryRunner.ts
+var MySQLRawQueryRunner = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async run(built) {
+    const [rows] = await this.client.execute(built.command, [
+      ...built.params
+    ]);
+    return rows;
+  }
+};
+
+// src/adapters/mysql/mysqlAdapter.ts
+var mysqlAdapter = {
+  name: MYSQL_ADAPTER_NAME,
+  urlSchemes: MYSQL_URL_SCHEMES,
+  create(client) {
+    return {
+      name: MYSQL_ADAPTER_NAME,
+      introspector: new MySQLIntrospector(client),
+      engine: new MySQLQueryEngine(),
+      runner: new MySQLRawQueryRunner(client),
+      parser: new MySQLRecordParser(),
+      urlSchemes: MYSQL_URL_SCHEMES
+    };
+  }
+};
+function isMySQLAdapter(adapter) {
+  return adapter.name === MYSQL_ADAPTER_NAME;
+}
+
 // src/adapters/postgres/pgEnums.ts
 var PgTypeCategory = {
   Array: "A"};
@@ -27,7 +1111,7 @@ var PgIndexMethod = {
 };
 
 // src/adapters/postgres/mapping/ConstraintMapper.ts
-var ConstraintMapper = class _ConstraintMapper {
+var ConstraintMapper2 = class _ConstraintMapper {
   static toConstraint(raw) {
     return {
       name: raw.name,
@@ -55,7 +1139,7 @@ var ConstraintMapper = class _ConstraintMapper {
 };
 
 // src/adapters/postgres/mapping/FieldMapper.ts
-var FieldMapper = class _FieldMapper {
+var FieldMapper2 = class _FieldMapper {
   static toField(col, isIdentifier) {
     return {
       name: col.name,
@@ -159,7 +1243,7 @@ var FieldMapper = class _FieldMapper {
 };
 
 // src/adapters/postgres/mapping/IndexMapper.ts
-var IndexMapper = class _IndexMapper {
+var IndexMapper2 = class _IndexMapper {
   static toIndex(raw) {
     return {
       name: raw.name,
@@ -198,7 +1282,7 @@ var IndexMapper = class _IndexMapper {
 };
 
 // src/adapters/postgres/mapping/ReferenceMapper.ts
-var ReferenceMapper = class _ReferenceMapper {
+var ReferenceMapper2 = class _ReferenceMapper {
   static toReference(fk) {
     return {
       name: fk.name,
@@ -236,7 +1320,7 @@ var ReferenceMapper = class _ReferenceMapper {
 };
 
 // src/adapters/postgres/mapping/EntityAssembler.ts
-var EntityAssembler = class _EntityAssembler {
+var EntityAssembler2 = class _EntityAssembler {
   static assemble(inputs) {
     const tableKeys = new Set(
       inputs.tables.map((t) => _EntityAssembler.qualified(t.namespace, t.name))
@@ -261,7 +1345,7 @@ var EntityAssembler = class _EntityAssembler {
       const pkSet = new Set(pkColumns);
       const rawCols = colsByEntity.get(key) ?? [];
       const fields = rawCols.map(
-        (col) => FieldMapper.toField(col, pkSet.has(col.name))
+        (col) => FieldMapper2.toField(col, pkSet.has(col.name))
       );
       return {
         namespace: table.namespace,
@@ -301,7 +1385,7 @@ var EntityAssembler = class _EntityAssembler {
   static buildRelationships(foreignKeys, tableKeys) {
     const map = /* @__PURE__ */ new Map();
     for (const fk of foreignKeys) {
-      const reference = ReferenceMapper.toReference(fk);
+      const reference = ReferenceMapper2.toReference(fk);
       const fromKey = _EntityAssembler.qualified(
         fk.from_namespace,
         fk.from_table
@@ -329,7 +1413,7 @@ var EntityAssembler = class _EntityAssembler {
       if (!tableKeys.has(key)) {
         continue;
       }
-      _EntityAssembler.push(map, key, IndexMapper.toIndex(idx));
+      _EntityAssembler.push(map, key, IndexMapper2.toIndex(idx));
     }
     return map;
   }
@@ -340,7 +1424,7 @@ var EntityAssembler = class _EntityAssembler {
       if (!tableKeys.has(key)) {
         continue;
       }
-      _EntityAssembler.push(map, key, ConstraintMapper.toConstraint(cn));
+      _EntityAssembler.push(map, key, ConstraintMapper2.toConstraint(cn));
     }
     return map;
   }
@@ -365,7 +1449,7 @@ var POSTGRES_URL_SCHEMES = [
 ];
 
 // src/adapters/postgres/queries/ColumnsQuery.ts
-var ColumnsQuery = class _ColumnsQuery {
+var ColumnsQuery2 = class _ColumnsQuery {
   static SQL = `
 SELECT
   n.nspname AS namespace,
@@ -418,7 +1502,7 @@ ORDER BY n.nspname, c.relname, a.attnum
 };
 
 // src/adapters/postgres/queries/ConstraintsQuery.ts
-var ConstraintsQuery = class _ConstraintsQuery {
+var ConstraintsQuery2 = class _ConstraintsQuery {
   static SQL = `
 SELECT
   n.nspname AS namespace,
@@ -450,7 +1534,7 @@ ORDER BY n.nspname, cls.relname, c.conname
 };
 
 // src/adapters/postgres/queries/ForeignKeysQuery.ts
-var ForeignKeysQuery = class _ForeignKeysQuery {
+var ForeignKeysQuery2 = class _ForeignKeysQuery {
   static SQL = `
 SELECT
   c.conname AS name,
@@ -487,7 +1571,7 @@ WHERE c.contype = 'f'
 };
 
 // src/adapters/postgres/queries/IndexesQuery.ts
-var IndexesQuery = class _IndexesQuery {
+var IndexesQuery2 = class _IndexesQuery {
   static SQL = `
 SELECT
   n.nspname AS namespace,
@@ -520,7 +1604,7 @@ ORDER BY n.nspname, t.relname, i.relname
 };
 
 // src/adapters/postgres/queries/PrimaryKeysQuery.ts
-var PrimaryKeysQuery = class _PrimaryKeysQuery {
+var PrimaryKeysQuery2 = class _PrimaryKeysQuery {
   static SQL = `
 SELECT
   n.nspname AS namespace,
@@ -545,7 +1629,7 @@ WHERE c.contype = 'p'
 };
 
 // src/adapters/postgres/queries/TablesQuery.ts
-var TablesQuery = class _TablesQuery {
+var TablesQuery2 = class _TablesQuery {
   static SQL = `
 SELECT
   n.nspname AS namespace,
@@ -563,63 +1647,6 @@ ORDER BY n.nspname, c.relname
   }
 };
 
-// src/domain/model/DataModel.ts
-var DataModel = class _DataModel {
-  constructor(kind, entities) {
-    this.kind = kind;
-    this.entities = entities;
-    this.index = new Map(
-      entities.map((e) => [_DataModel.qualifiedName(e.namespace, e.name), e])
-    );
-  }
-  kind;
-  entities;
-  index;
-  /**
-   * Build the lookup key for an entity. Exposed as a static helper so
-   * consumers can compute keys consistently when building their own
-   * indexes on top of a `DataModel`.
-   */
-  static qualifiedName(namespace, name) {
-    return `${namespace}.${name}`;
-  }
-  getEntity(namespace, name) {
-    return this.index.get(_DataModel.qualifiedName(namespace, name));
-  }
-  hasEntity(namespace, name) {
-    return this.index.has(_DataModel.qualifiedName(namespace, name));
-  }
-  /**
-   * All relationships an entity participates in, in both directions.
-   * Returns an empty array if the entity is unknown.
-   */
-  relationshipsOf(namespace, name) {
-    return this.getEntity(namespace, name)?.relationships ?? [];
-  }
-  /**
-   * Outbound relationships: this entity holds the reference.
-   * In a relational store these correspond to FOREIGN KEY constraints
-   * declared by the entity itself.
-   */
-  outboundRelationshipsOf(namespace, name) {
-    return this.relationshipsOf(namespace, name).filter(
-      (r) => r.direction === "outbound"
-    );
-  }
-  /**
-   * Inbound relationships: other entities hold references pointing here.
-   *
-   * This is the differentiating feature of the SDK. Most introspection
-   * tools only surface outbound relationships, requiring consumers to
-   * know which other entities reference theirs ahead of time.
-   */
-  inboundRelationshipsOf(namespace, name) {
-    return this.relationshipsOf(namespace, name).filter(
-      (r) => r.direction === "inbound"
-    );
-  }
-};
-
 // src/adapters/postgres/PostgresIntrospector.ts
 var DEFAULT_NAMESPACES = ["public"];
 var PostgresIntrospector = class _PostgresIntrospector {
@@ -632,18 +1659,18 @@ var PostgresIntrospector = class _PostgresIntrospector {
   async introspect(options = {}) {
     const namespaces = await this.resolveNamespaces(options.namespaces);
     const [tables, columns, primaryKeys, foreignKeys, indexes, constraints] = await Promise.all([
-      TablesQuery.fetch(this.client, namespaces),
-      ColumnsQuery.fetch(this.client, namespaces),
-      PrimaryKeysQuery.fetch(this.client, namespaces),
-      ForeignKeysQuery.fetch(this.client, namespaces),
-      IndexesQuery.fetch(this.client, namespaces),
-      ConstraintsQuery.fetch(this.client, namespaces)
+      TablesQuery2.fetch(this.client, namespaces),
+      ColumnsQuery2.fetch(this.client, namespaces),
+      PrimaryKeysQuery2.fetch(this.client, namespaces),
+      ForeignKeysQuery2.fetch(this.client, namespaces),
+      IndexesQuery2.fetch(this.client, namespaces),
+      ConstraintsQuery2.fetch(this.client, namespaces)
     ]);
     const filteredTables = _PostgresIntrospector.applyEntityFilters(
       tables,
       options
     );
-    const entities = EntityAssembler.assemble({
+    const entities = EntityAssembler2.assemble({
       tables: filteredTables,
       columns,
       primaryKeys,
@@ -691,7 +1718,7 @@ ORDER BY n.nspname
 };
 
 // src/adapters/postgres/query/SqlIdentifier.ts
-var SqlIdentifier = class _SqlIdentifier {
+var SqlIdentifier2 = class _SqlIdentifier {
   static quote(id) {
     return `"${id.replace(/"/g, '""')}"`;
   }
@@ -701,13 +1728,13 @@ var SqlIdentifier = class _SqlIdentifier {
 };
 
 // src/adapters/postgres/query/FilterBuilder.ts
-var FilterBuilder = class {
+var FilterBuilder2 = class {
   constructor(params) {
     this.params = params;
   }
   params;
   build(filter) {
-    const col = SqlIdentifier.quote(filter.field);
+    const col = SqlIdentifier2.quote(filter.field);
     switch (filter.operator) {
       case "eq": {
         return `${col} = ${this.params.add(filter.value)}`;
@@ -779,7 +1806,7 @@ var FilterBuilder = class {
 };
 
 // src/adapters/postgres/query/SqlParamList.ts
-var SqlParamList = class {
+var SqlParamList2 = class {
   values = [];
   /**
    * Append a value and return its placeholder (`$N`, where N is the
@@ -828,10 +1855,10 @@ var PostgresQueryEngine = class {
         );
       }
     }
-    const params = new SqlParamList();
-    const filterBuilder = new FilterBuilder(params);
-    const selectClause = selectedFields.map(SqlIdentifier.quote).join(", ");
-    const fromClause = SqlIdentifier.qualified(spec.namespace, spec.entity);
+    const params = new SqlParamList2();
+    const filterBuilder = new FilterBuilder2(params);
+    const selectClause = selectedFields.map(SqlIdentifier2.quote).join(", ");
+    const fromClause = SqlIdentifier2.qualified(spec.namespace, spec.entity);
     let sql = `SELECT ${selectClause} FROM ${fromClause}`;
     if (spec.filters && spec.filters.length > 0) {
       const wherePieces = spec.filters.map((filter) => {
@@ -851,7 +1878,7 @@ var PostgresQueryEngine = class {
             `Order field "${order.field}" does not exist on "${spec.namespace}.${spec.entity}".`
           );
         }
-        return `${SqlIdentifier.quote(order.field)} ${order.direction.toUpperCase()}`;
+        return `${SqlIdentifier2.quote(order.field)} ${order.direction.toUpperCase()}`;
       });
       sql += ` ORDER BY ${orderPieces.join(", ")}`;
     }
@@ -872,81 +1899,14 @@ var PostgresQueryEngine = class {
   }
 };
 
-// src/parsing/DefaultRecordParser.ts
-var DefaultRecordParser = class {
-  parse(entity, row) {
-    const result = {};
-    for (const field of entity.fields) {
-      if (field.name in row) {
-        result[field.name] = this.coerce(field, row[field.name]);
-      }
-    }
-    return result;
-  }
-  parseMany(entity, rows) {
-    return rows.map((row) => this.parse(entity, row));
-  }
-  coerce(field, raw) {
-    if (raw === null || raw === void 0) {
-      return null;
-    }
-    switch (field.type.category) {
-      case "string":
-      case "uuid":
-      case "enum": {
-        return String(raw);
-      }
-      case "integer": {
-        if (typeof raw === "bigint") {
-          return raw;
-        }
-        if (typeof raw === "number") {
-          return raw;
-        }
-        return Number(raw);
-      }
-      case "decimal": {
-        return typeof raw === "string" ? raw : String(raw);
-      }
-      case "boolean": {
-        return Boolean(raw);
-      }
-      case "date":
-      case "timestamp":
-      case "time": {
-        if (raw instanceof Date) {
-          return raw;
-        }
-        if (typeof raw === "string" || typeof raw === "number") {
-          return new Date(raw);
-        }
-        return null;
-      }
-      case "json":
-      case "binary":
-      case "reference":
-      case "unknown": {
-        return raw;
-      }
-      case "array": {
-        return Array.isArray(raw) ? raw : [];
-      }
-      default: {
-        const exhaustive = field.type.category;
-        return exhaustive;
-      }
-    }
-  }
-};
-
 // src/adapters/postgres/PostgresRecordParser.ts
-var BIGINT_NATIVE_TYPES = /* @__PURE__ */ new Set(["int8", "bigint"]);
+var BIGINT_NATIVE_TYPES2 = /* @__PURE__ */ new Set(["int8", "bigint"]);
 var PostgresRecordParser = class extends DefaultRecordParser {
   coerce(field, raw) {
     if (raw === null || raw === void 0) {
       return null;
     }
-    if (field.type.category === "integer" && BIGINT_NATIVE_TYPES.has(field.type.nativeType.toLowerCase())) {
+    if (field.type.category === "integer" && BIGINT_NATIVE_TYPES2.has(field.type.nativeType.toLowerCase())) {
       if (typeof raw === "bigint") {
         return raw;
       }
@@ -2255,6 +3215,11 @@ exports.CsvFormatter = CsvFormatter;
 exports.DataModel = DataModel;
 exports.DefaultRecordParser = DefaultRecordParser;
 exports.JsonFormatter = JsonFormatter;
+exports.MYSQL_ADAPTER_NAME = MYSQL_ADAPTER_NAME;
+exports.MYSQL_URL_SCHEMES = MYSQL_URL_SCHEMES;
+exports.MySQLIntrospector = MySQLIntrospector;
+exports.MySQLQueryEngine = MySQLQueryEngine;
+exports.MySQLRecordParser = MySQLRecordParser;
 exports.POSTGRES_ADAPTER_NAME = POSTGRES_ADAPTER_NAME;
 exports.POSTGRES_URL_SCHEMES = POSTGRES_URL_SCHEMES;
 exports.PostgresIntrospector = PostgresIntrospector;
@@ -2265,7 +3230,9 @@ exports.RawFormatter = RawFormatter;
 exports.Scanner = Scanner;
 exports.generateSchema = generateSchema;
 exports.generateSchemaFiles = generateSchemaFiles;
+exports.isMySQLAdapter = isMySQLAdapter;
 exports.isPostgresAdapter = isPostgresAdapter;
+exports.mysqlAdapter = mysqlAdapter;
 exports.overridesScaffold = overridesScaffold;
 exports.postgresAdapter = postgresAdapter;
 exports.tsTypeFor = tsTypeFor;