@nextlyhq/adapter-drizzle 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1137 @@
+'use strict';
+
+var drizzleOrm = require('drizzle-orm');
+
+// src/adapter.ts
+function buildDrizzleWhere(table, where) {
+  const columns = drizzleOrm.getTableColumns(table);
+  return processWhereClause(columns, where);
+}
+function processWhereClause(columns, where) {
+  const parts = [];
+  if (where.and?.length) {
+    const andParts = where.and.map((item) => {
+      if (isWhereCondition(item)) {
+        return buildCondition(columns, item);
+      }
+      return processWhereClause(columns, item);
+    }).filter((p) => p !== void 0);
+    if (andParts.length) {
+      parts.push(drizzleOrm.and(...andParts));
+    }
+  }
+  if (where.or?.length) {
+    const orParts = where.or.map((item) => {
+      if (isWhereCondition(item)) {
+        return buildCondition(columns, item);
+      }
+      return processWhereClause(columns, item);
+    }).filter((p) => p !== void 0);
+    if (orParts.length) {
+      parts.push(drizzleOrm.or(...orParts));
+    }
+  }
+  if (where.not) {
+    const notItem = where.not;
+    const notCondition = isWhereCondition(notItem) ? buildCondition(columns, notItem) : processWhereClause(columns, notItem);
+    if (notCondition) {
+      parts.push(drizzleOrm.not(notCondition));
+    }
+  }
+  if (parts.length === 0) return void 0;
+  if (parts.length === 1) return parts[0];
+  return drizzleOrm.and(...parts);
+}
+function isWhereCondition(item) {
+  return "column" in item && "op" in item;
+}
+function buildCondition(columns, cond) {
+  const column = columns[cond.column];
+  if (!column) {
+    throw new Error(
+      `Column "${cond.column}" not found in table. Available: ${Object.keys(columns).join(", ")}`
+    );
+  }
+  const col = column;
+  switch (cond.op) {
+    case "=":
+      return drizzleOrm.eq(col, cond.value);
+    case "!=":
+      return drizzleOrm.ne(col, cond.value);
+    case ">":
+      return drizzleOrm.gt(col, cond.value);
+    case "<":
+      return drizzleOrm.lt(col, cond.value);
+    case ">=":
+      return drizzleOrm.gte(col, cond.value);
+    case "<=":
+      return drizzleOrm.lte(col, cond.value);
+    case "LIKE":
+      return drizzleOrm.like(col, cond.value);
+    case "ILIKE":
+      return drizzleOrm.ilike(col, cond.value);
+    case "IN":
+      return drizzleOrm.inArray(col, cond.value);
+    case "NOT IN":
+      return drizzleOrm.notInArray(col, cond.value);
+    case "IS NULL":
+      return drizzleOrm.isNull(col);
+    case "IS NOT NULL":
+      return drizzleOrm.isNotNull(col);
+    case "BETWEEN":
+      return drizzleOrm.between(col, cond.value, cond.valueTo);
+    case "NOT BETWEEN":
+      return drizzleOrm.notBetween(col, cond.value, cond.valueTo);
+    case "CONTAINS":
+      return drizzleOrm.like(col, `%${String(cond.value)}%`);
+    default:
+      throw new Error(`Unsupported operator: ${cond.op}`);
+  }
+}
+
+// src/types/error.ts
+function isDatabaseError(error) {
+  return typeof error === "object" && error !== null && "kind" in error && typeof error.kind === "string";
+}
+function createDatabaseError(options) {
+  const error = new Error(options.message);
+  error.name = "DatabaseError";
+  error.kind = options.kind;
+  if (options.code !== void 0) error.code = options.code;
+  if (options.constraint !== void 0) error.constraint = options.constraint;
+  if (options.table !== void 0) error.table = options.table;
+  if (options.column !== void 0) error.column = options.column;
+  if (options.detail !== void 0) error.detail = options.detail;
+  if (options.hint !== void 0) error.hint = options.hint;
+  if (options.cause !== void 0) error.cause = options.cause;
+  return error;
+}
+
+// src/adapter.ts
+var DrizzleAdapter = class {
+  // ============================================================
+  // Drizzle Query API Support
+  // ============================================================
+  /**
+   * Table resolver for looking up Drizzle table objects by name.
+   * When set, CRUD methods use Drizzle's query API instead of raw SQL.
+   * Set via setTableResolver() after boot-time schema loading.
+   */
+  tableResolver = null;
+  /**
+   * Set the table resolver for Drizzle query API support.
+   * When a resolver is set, CRUD methods (select, insert, update, delete, upsert)
+   * will use Drizzle's query API (db.select().from(), etc.) instead of raw SQL
+   * string building. Falls back to raw SQL if the resolver doesn't have the table.
+   *
+   * @param resolver - TableResolver implementation (e.g. SchemaRegistry)
+   */
+  setTableResolver(resolver) {
+    this.tableResolver = resolver;
+  }
+  /**
+   * Get a Drizzle table object by name from the resolver.
+   * Returns null if no resolver is set or table is not found.
+   */
+  getTableObject(tableName) {
+    return this.tableResolver?.getTable(tableName) ?? null;
+  }
+  /**
+   * Map data keys from SQL column names (snake_case) to Drizzle JS property names (camelCase).
+   * Drizzle schemas define columns as e.g. `createdAt: timestamp("created_at")` — the JS
+   * property is `createdAt` but the SQL column is `created_at`. Services pass snake_case keys
+   * because they match the DB column names. This method maps them to the JS names Drizzle expects.
+   */
+  mapDataToColumnNames(tableObj, data) {
+    if (!tableObj || typeof tableObj !== "object") return data;
+    const sqlToJs = /* @__PURE__ */ new Map();
+    const jsonColumns = /* @__PURE__ */ new Set();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!colDef || typeof colDef !== "object" || !("name" in colDef) || typeof colDef.name !== "string")
+        continue;
+      const sqlName = colDef.name;
+      sqlToJs.set(sqlName, jsName);
+      const dataType = colDef.dataType;
+      const columnType = colDef.columnType;
+      if (dataType === "json" || columnType === "PgJsonb" || columnType === "PgJson" || columnType === "MySqlJson" || columnType === "SQLiteTextJson") {
+        jsonColumns.add(jsName);
+      }
+    }
+    if (sqlToJs.size === 0) return data;
+    const mapped = {};
+    for (const [key, value] of Object.entries(data)) {
+      const jsKey = sqlToJs.get(key) ?? key;
+      if (jsonColumns.has(jsKey) && typeof value === "string") {
+        try {
+          mapped[jsKey] = JSON.parse(value);
+        } catch {
+          mapped[jsKey] = value;
+        }
+      } else {
+        mapped[jsKey] = value;
+      }
+    }
+    return mapped;
+  }
+  // ============================================================
+  // Connection Status (Default implementations, can override)
+  // ============================================================
+  /**
+   * Check if the adapter is currently connected.
+   *
+   * @remarks
+   * Default implementation returns false. Subclasses should override
+   * to provide accurate connection status.
+   *
+   * @returns True if connected, false otherwise
+   */
+  isConnected() {
+    return false;
+  }
+  /**
+   * Get connection pool statistics.
+   *
+   * @remarks
+   * Returns null by default. Subclasses with connection pooling
+   * should override to provide pool statistics.
+   *
+   * @returns Pool statistics or null if not applicable
+   */
+  getPoolStats() {
+    return null;
+  }
+  // ============================================================
+  // Timeout Utilities
+  // ============================================================
+  /**
+   * Default query timeout in milliseconds.
+   *
+   * @remarks
+   * This value is used by executeWithTimeout() when no explicit timeout
+   * is provided. Subclasses should set this from their config.
+   *
+   * @default 15000 (15 seconds)
+   *
+   * @protected
+   */
+  defaultQueryTimeoutMs = 15e3;
+  /**
+   * Execute an async operation with a timeout.
+   *
+   * @remarks
+   * Wraps an async operation with a timeout that aborts if the operation
+   * exceeds the specified duration. Uses Promise.race for clean timeout
+   * handling without memory leaks.
+   *
+   * When the timeout is reached, a DatabaseError with kind 'timeout' is thrown.
+   * Note that this does NOT cancel the underlying database query - it only
+   * prevents the calling code from waiting indefinitely. For true query
+   * cancellation, use database-level statement timeouts (PostgreSQL) or
+   * similar mechanisms.
+   *
+   * @param operation - Async operation to execute
+   * @param timeoutMs - Timeout in milliseconds (defaults to defaultQueryTimeoutMs)
+   * @returns Result of the operation
+   *
+   * @throws {DatabaseError} With kind 'timeout' if operation exceeds timeout
+   *
+   * @example
+   * ```typescript
+   * // Use default timeout
+   * const result = await adapter.executeWithTimeout(
+   *   () => adapter.select('users', { limit: 1000 })
+   * );
+   *
+   * // Use custom timeout for specific operation
+   * const result = await adapter.executeWithTimeout(
+   *   () => adapter.select('large_table'),
+   *   60000 // 60 seconds for large queries
+   * );
+   * ```
+   *
+   * @public
+   */
+  async executeWithTimeout(operation, timeoutMs) {
+    const timeout = timeoutMs ?? this.defaultQueryTimeoutMs;
+    if (timeout <= 0) {
+      return operation();
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(
+          this.createDatabaseError(
+            "timeout",
+            `Query execution timed out after ${timeout}ms`
+          )
+        );
+      }, timeout);
+    });
+    try {
+      const result = await Promise.race([operation(), timeoutPromise]);
+      return result;
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+   * Set the default query timeout.
+   *
+   * @remarks
+   * This method allows runtime configuration of the default timeout.
+   * Subclasses should call this in their constructor or connect() method
+   * based on their configuration.
+   *
+   * @param timeoutMs - Timeout in milliseconds (0 to disable)
+   *
+   * @protected
+   */
+  setDefaultQueryTimeout(timeoutMs) {
+    this.defaultQueryTimeoutMs = timeoutMs;
+  }
+  /**
+   * Get the current default query timeout.
+   *
+   * @returns Current default timeout in milliseconds
+   *
+   * @public
+   */
+  getDefaultQueryTimeout() {
+    return this.defaultQueryTimeoutMs;
+  }
+  // ============================================================
+  // CRUD Operations (Default implementations, can override)
+  // ============================================================
+  /**
+   * Select multiple records from a table.
+   *
+   * @remarks
+   * Default implementation builds a SELECT query and executes it.
+   * Subclasses can override for optimization or dialect-specific features.
+   *
+   * @param table - Table name
+   * @param options - Select options (filtering, sorting, pagination)
+   * @returns Array of matching records
+   *
+   * @throws {DatabaseError} If query fails
+   *
+   * @example
+   * ```typescript
+   * const users = await adapter.select('users', {
+   *   where: { and: [{ column: 'role', op: '=', value: 'admin' }] },
+   *   orderBy: [{ column: 'created_at', direction: 'desc' }],
+   *   limit: 10
+   * });
+   * ```
+   */
+  async select(table, options) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const db = this.getDrizzle();
+        let query = db.select().from(tableObj);
+        if (options?.where) {
+          const whereCondition = buildDrizzleWhere(
+            tableObj,
+            options.where
+          );
+          if (whereCondition) {
+            query = query.where(whereCondition);
+          }
+        }
+        if (options?.orderBy?.length) {
+          const columns = drizzleOrm.getTableColumns(tableObj);
+          const orderClauses = options.orderBy.map((o) => {
+            const col = columns[o.column];
+            if (!col) return void 0;
+            return o.direction === "desc" ? drizzleOrm.desc(col) : drizzleOrm.asc(col);
+          }).filter(Boolean);
+          if (orderClauses.length) {
+            query = query.orderBy(...orderClauses);
+          }
+        }
+        if (options?.limit !== void 0) {
+          query = query.limit(options.limit);
+        }
+        if (options?.offset !== void 0) {
+          query = query.offset(options.offset);
+        }
+        return await query;
+      } catch (error) {
+        throw this.handleQueryError(error, "select", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
+  /**
+   * Select a single record from a table.
+   *
+   * @remarks
+   * Default implementation uses `select()` with limit 1 and returns first result.
+   * Returns null if no matching record is found.
+   *
+   * @param table - Table name
+   * @param options - Select options
+   * @returns First matching record or null
+   *
+   * @throws {DatabaseError} If query fails
+   *
+   * @example
+   * ```typescript
+   * const user = await adapter.selectOne('users', {
+   *   where: { and: [{ column: 'email', op: '=', value: 'user@example.com' }] }
+   * });
+   * ```
+   */
+  async selectOne(table, options) {
+    const results = await this.select(table, { ...options, limit: 1 });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Insert a single record into a table.
+   *
+   * @remarks
+   * Default implementation handles databases with and without RETURNING support.
+   * For databases without RETURNING (MySQL), performs INSERT followed by SELECT.
+   *
+   * @param table - Table name
+   * @param data - Record data to insert
+   * @param options - Insert options
+   * @returns Inserted record (with RETURNING columns if specified)
+   *
+   * @throws {DatabaseError} If insert fails
+   *
+   * @example
+   * ```typescript
+   * const user = await adapter.insert('users', {
+   *   email: 'user@example.com',
+   *   name: 'John Doe'
+   * }, { returning: ['id', 'email', 'created_at'] });
+   * ```
+   */
+  async insert(table, data, options) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const mappedData = this.mapDataToColumnNames(tableObj, data);
+        const db = this.getDrizzle();
+        const caps = this.getCapabilities();
+        if (caps.supportsReturning && options?.returning) {
+          const result2 = await db.insert(tableObj).values(mappedData).returning();
+          return Array.isArray(result2) ? result2[0] : result2;
+        }
+        const result = await db.insert(tableObj).values(mappedData);
+        if (!caps.supportsReturning && options?.returning) {
+          if (data.id !== void 0) {
+            return await this.selectOne(table, {
+              where: {
+                and: [{ column: "id", op: "=", value: data.id }]
+              }
+            });
+          }
+        }
+        return Array.isArray(result) ? result[0] : result;
+      } catch (error) {
+        throw this.handleQueryError(error, "insert", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
+  /**
+   * Insert multiple records into a table.
+   *
+   * @remarks
+   * Default implementation performs individual inserts in sequence.
+   * Subclasses can override for bulk insert optimization (e.g., COPY in PostgreSQL).
+   *
+   * @param table - Table name
+   * @param data - Array of records to insert
+   * @param options - Insert options
+   * @returns Inserted records (with RETURNING columns if specified)
+   *
+   * @throws {DatabaseError} If insert fails
+   *
+   * @example
+   * ```typescript
+   * const users = await adapter.insertMany('users', [
+   *   { email: 'user1@example.com', name: 'User 1' },
+   *   { email: 'user2@example.com', name: 'User 2' }
+   * ], { returning: ['id'] });
+   * ```
+   */
+  async insertMany(table, data, options) {
+    if (data.length === 0) {
+      return [];
+    }
+    const results = [];
+    for (const record of data) {
+      const result = await this.insert(table, record, options);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Update records in a table.
+   *
+   * @remarks
+   * Default implementation builds an UPDATE query with WHERE clause.
+   * Returns updated records if RETURNING is supported and requested.
+   *
+   * @param table - Table name
+   * @param data - Data to update
+   * @param where - Conditions for records to update
+   * @param options - Update options
+   * @returns Updated records (with RETURNING columns if specified)
+   *
+   * @throws {DatabaseError} If update fails
+   *
+   * @example
+   * ```typescript
+   * const updated = await adapter.update('users',
+   *   { status: 'active' },
+   *   { and: [{ column: 'id', op: '=', value: userId }] },
+   *   { returning: ['id', 'status', 'updated_at'] }
+   * );
+   * ```
+   */
+  async update(table, data, where, options) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const db = this.getDrizzle();
+        const caps = this.getCapabilities();
+        const mappedData = this.mapDataToColumnNames(tableObj, data);
+        let query = db.update(tableObj).set(mappedData);
+        const whereCondition = buildDrizzleWhere(tableObj, where);
+        if (whereCondition) {
+          query = query.where(whereCondition);
+        }
+        if (caps.supportsReturning && options?.returning) {
+          return await query.returning();
+        }
+        await query;
+        if (!caps.supportsReturning && options?.returning) {
+          return await this.select(table, { where });
+        }
+        return [];
+      } catch (error) {
+        throw this.handleQueryError(error, "update", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
+  /**
+   * Delete records from a table.
+   *
+   * @remarks
+   * Default implementation builds a DELETE query with WHERE clause.
+   * Returns the number of deleted records.
+   *
+   * @param table - Table name
+   * @param where - Conditions for records to delete
+   * @param options - Delete options
+   * @returns Number of deleted records
+   *
+   * @throws {DatabaseError} If delete fails
+   *
+   * @example
+   * ```typescript
+   * const count = await adapter.delete('users', {
+   *   and: [{ column: 'status', op: '=', value: 'inactive' }]
+   * });
+   * console.log(`Deleted ${count} users`);
+   * ```
+   */
+  async delete(table, where, _options) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const db = this.getDrizzle();
+        let query = db.delete(tableObj);
+        const whereCondition = buildDrizzleWhere(tableObj, where);
+        if (whereCondition) {
+          query = query.where(whereCondition);
+        }
+        const result = await query;
+        return Array.isArray(result) ? result.length : result?.rowCount ?? result?.changes ?? 0;
+      } catch (error) {
+        throw this.handleQueryError(error, "delete", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
+  /**
+   * Upsert (INSERT or UPDATE) a record.
+   *
+   * @remarks
+   * Default implementation uses dialect-specific ON CONFLICT syntax.
+   * PostgreSQL/SQLite: ON CONFLICT ... DO UPDATE
+   * MySQL: ON DUPLICATE KEY UPDATE
+   *
+   * @param table - Table name
+   * @param data - Record data
+   * @param options - Upsert options (must specify conflict columns)
+   * @returns Upserted record (with RETURNING columns if specified)
+   *
+   * @throws {DatabaseError} If upsert fails
+   *
+   * @example
+   * ```typescript
+   * const user = await adapter.upsert('users', {
+   *   email: 'user@example.com',
+   *   name: 'Updated Name'
+   * }, {
+   *   conflictColumns: ['email'],
+   *   updateColumns: ['name'],
+   *   returning: ['id', 'email', 'name']
+   * });
+   * ```
+   */
+  async upsert(table, data, options) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const db = this.getDrizzle();
+        const caps = this.getCapabilities();
+        const columns = drizzleOrm.getTableColumns(tableObj);
+        const conflictTarget = options.conflictColumns.map((col) => columns[col]).filter(Boolean);
+        const conflictSet = new Set(options.conflictColumns);
+        const updateData = {};
+        const updateColumns = options.updateColumns ?? Object.keys(data);
+        for (const key of updateColumns) {
+          if (!conflictSet.has(key) && key in data) {
+            updateData[key] = data[key];
+          }
+        }
+        let query;
+        if (caps.supportsOnConflict) {
+          query = db.insert(tableObj).values(data).onConflictDoUpdate({
+            target: conflictTarget,
+            set: updateData
+          });
+        } else {
+          query = db.insert(tableObj).values(data);
+        }
+        if (caps.supportsReturning) {
+          const result = await query.returning();
+          return Array.isArray(result) ? result[0] : result;
+        }
+        await query;
+        if (options.conflictColumns.length && data[options.conflictColumns[0]] !== void 0) {
+          return await this.selectOne(table, {
+            where: {
+              and: [
+                {
+                  column: options.conflictColumns[0],
+                  op: "=",
+                  value: data[options.conflictColumns[0]]
+                }
+              ]
+            }
+          });
+        }
+        return data;
+      } catch (error) {
+        throw this.handleQueryError(error, "upsert", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
+  // ============================================================
+  // Migration Support (Default implementations, can override)
+  // ============================================================
+  /**
+   * Run pending migrations.
+   *
+   * @remarks
+   * Default implementation is a placeholder. Subclasses should implement
+   * migration tracking and execution logic.
+   *
+   * @param migrations - Array of migrations to run
+   * @returns Migration result with applied and pending migrations
+   *
+   * @throws {DatabaseError} If migration fails
+   */
+  // Base implementation throws synchronously; dialect adapters override with async logic.
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async migrate(_migrations) {
+    throw this.createDatabaseError(
+      "query",
+      "migrate() must be implemented by dialect-specific adapter. Use PostgresAdapter, MySqlAdapter, or SqliteAdapter.",
+      void 0
+    );
+  }
+  /**
+   * Rollback the last migration.
+   *
+   * @remarks
+   * Default implementation is a placeholder. Subclasses should implement
+   * migration rollback logic.
+   *
+   * @returns Migration result after rollback
+   *
+   * @throws {DatabaseError} If rollback fails
+   */
+  // Base implementation throws synchronously; dialect adapters override with async logic.
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async rollback() {
+    throw this.createDatabaseError(
+      "query",
+      "rollback() must be implemented by dialect-specific adapter. Use PostgresAdapter, MySqlAdapter, or SqliteAdapter.",
+      void 0
+    );
+  }
+  /**
+   * Get migration status.
+   *
+   * @remarks
+   * Default implementation is a placeholder. Subclasses should implement
+   * migration status checking.
+   *
+   * @returns Current migration status
+   *
+   * @throws {DatabaseError} If status check fails
+   */
+  async getMigrationStatus() {
+    try {
+      const rows = await this.executeQuery(`SELECT * FROM "__drizzle_migrations" ORDER BY created_at ASC`);
+      const applied = rows.map((r) => ({
+        id: String(r.id),
+        name: r.hash,
+        appliedAt: new Date(r.created_at),
+        checksum: r.hash
+      }));
+      return {
+        applied,
+        pending: [],
+        current: applied.length > 0 ? applied[applied.length - 1].id : null
+      };
+    } catch {
+      return { applied: [], pending: [], current: null };
+    }
+  }
+  // ============================================================
+  // Schema Operations (Default implementations, can override)
+  // ============================================================
+  /**
+   * Create a new table.
+   *
+   * @remarks
+   * Default implementation is a placeholder. Subclasses should implement
+   * table creation logic.
+   *
+   * @param definition - Table definition
+   * @param options - Creation options
+   *
+   * @throws {DatabaseError} If table creation fails
+   */
+  async createTable(definition, options) {
+    const columnDefs = definition.columns.map((col) => {
+      let colSql = `${this.escapeIdentifier(col.name)} ${col.type.toUpperCase()}`;
+      if (col.primaryKey) colSql += " PRIMARY KEY";
+      if (col.nullable === false) colSql += " NOT NULL";
+      if (col.unique) colSql += " UNIQUE";
+      if (col.default !== void 0) {
+        colSql += ` DEFAULT ${renderDefaultValue(col.default, col.name)}`;
+      }
+      return colSql;
+    });
+    const ifNotExists = options?.ifNotExists !== false ? "IF NOT EXISTS " : "";
+    const query = `CREATE TABLE ${ifNotExists}${this.escapeIdentifier(definition.name)} (
+  ${columnDefs.join(",\n  ")}
+)`;
+    try {
+      await this.executeQuery(query);
+    } catch (error) {
+      throw this.handleQueryError(error, "createTable", definition.name);
+    }
+  }
+  /**
+   * Drop a table.
+   *
+   * @remarks
+   * Default implementation is a placeholder. Subclasses should implement
+   * table dropping logic.
+   *
+   * @param tableName - Name of table to drop
+   * @param options - Drop options
+   *
+   * @throws {DatabaseError} If table drop fails
+   */
+  async dropTable(tableName, options) {
+    const ifExists = options?.ifExists !== false ? "IF EXISTS " : "";
+    const cascade = options?.cascade ? " CASCADE" : "";
+    const query = `DROP TABLE ${ifExists}${this.escapeIdentifier(tableName)}${cascade}`;
+    try {
+      await this.executeQuery(query);
+    } catch (error) {
+      throw this.handleQueryError(error, "dropTable", tableName);
+    }
+  }
+  /**
+   * Alter an existing table.
+   *
+   * @remarks
+   * Default implementation is a placeholder. Subclasses should implement
+   * table alteration logic.
+   *
+   * @param tableName - Name of table to alter
+   * @param operations - Alteration operations
+   * @param options - Alter options
+   *
+   * @throws {DatabaseError} If table alteration fails
+   */
+  async alterTable(tableName, operations, _options) {
+    const quotedTable = this.escapeIdentifier(tableName);
+    for (const op of operations) {
+      let query;
+      switch (op.kind) {
+        case "add_column": {
+          let colDef = `${this.escapeIdentifier(op.column.name)} ${op.column.type.toUpperCase()}`;
+          if (op.column.nullable === false) colDef += " NOT NULL";
+          if (op.column.unique) colDef += " UNIQUE";
+          if (op.column.default !== void 0) {
+            const defaultVal = typeof op.column.default === "object" && op.column.default !== null && "sql" in op.column.default ? op.column.default.sql : typeof op.column.default === "string" ? `'${op.column.default}'` : String(op.column.default);
+            colDef += ` DEFAULT ${defaultVal}`;
+          }
+          query = `ALTER TABLE ${quotedTable} ADD COLUMN ${colDef}`;
+          break;
+        }
+        case "drop_column": {
+          const cascade = op.cascade ? " CASCADE" : "";
+          query = `ALTER TABLE ${quotedTable} DROP COLUMN ${this.escapeIdentifier(op.columnName)}${cascade}`;
+          break;
+        }
+        case "rename_column":
+          query = `ALTER TABLE ${quotedTable} RENAME COLUMN ${this.escapeIdentifier(op.from)} TO ${this.escapeIdentifier(op.to)}`;
+          break;
+        case "modify_column": {
+          query = `ALTER TABLE ${quotedTable} ALTER COLUMN ${this.escapeIdentifier(op.column.name)} TYPE ${op.column.type.toUpperCase()}`;
+          break;
+        }
+        case "add_constraint":
+          {
+            const constraintCols = op.constraint.columns ?? [];
+            const colList = constraintCols.map((c) => this.escapeIdentifier(c)).join(", ");
+            if (op.constraint.type === "check" && op.constraint.expression) {
+              query = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.escapeIdentifier(op.constraint.name)} CHECK (${op.constraint.expression})`;
+            } else {
+              query = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.escapeIdentifier(op.constraint.name)} ${op.constraint.type.toUpperCase()} (${colList})`;
+            }
+            break;
+          }
+        case "drop_constraint": {
+          const cascadeConstraint = op.cascade ? " CASCADE" : "";
+          query = `ALTER TABLE ${quotedTable} DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}${cascadeConstraint}`;
+          break;
+        }
+        default:
+          throw this.createDatabaseError(
+            "query",
+            `Unsupported alter table operation: ${op.kind}`,
+            void 0
+          );
+      }
+      try {
+        await this.executeQuery(query);
+      } catch (error) {
+        throw this.handleQueryError(error, "alterTable", tableName);
+      }
+    }
+  }
+  /**
+   * Check if a table exists in the database.
+   *
+   * @remarks
+   * Uses dialect-specific information schema queries to check table existence.
+   * This is useful for development mode auto-sync to determine whether to
+   * CREATE or DROP/CREATE tables.
+   *
+   * @param tableName - Name of table to check
+   * @param schema - Optional schema name (defaults to 'public' for PostgreSQL)
+   * @returns True if table exists, false otherwise
+   *
+   * @throws {DatabaseError} If query fails
+   *
+   * @example
+   * ```typescript
+   * const exists = await adapter.tableExists('users');
+   * if (exists) {
+   *   await adapter.dropTable('users');
+   * }
+   * await adapter.createTable(userTableDef);
+   * ```
+   */
+  async tableExists(tableName, schema) {
+    try {
+      let sql;
+      const params = [];
+      switch (this.dialect) {
+        case "postgresql":
+          sql = `
+            SELECT EXISTS (
+              SELECT FROM information_schema.tables
+              WHERE table_schema = $1
+              AND table_name = $2
+            ) as exists
+          `;
+          params.push(schema ?? "public", tableName);
+          break;
+        case "mysql":
+          sql = `
+            SELECT COUNT(*) as count
+            FROM information_schema.tables
+            WHERE table_schema = DATABASE()
+            AND table_name = ?
+          `;
+          params.push(tableName);
+          break;
+        case "sqlite":
+          sql = `
+            SELECT COUNT(*) as count
+            FROM sqlite_master
+            WHERE type = 'table'
+            AND name = ?
+          `;
+          params.push(tableName);
+          break;
+        default:
+          throw this.createDatabaseError(
+            "query",
+            `tableExists not implemented for dialect: ${String(this.dialect)}`,
+            void 0
+          );
+      }
+      const results = await this.executeQuery(
+        sql,
+        params
+      );
+      if (results.length === 0) {
+        return false;
+      }
+      const row = results[0];
+      if ("exists" in row) {
+        return row.exists === true || row.exists === "t" || row.exists === 1;
+      }
+      if ("count" in row) {
+        return Number(row.count) > 0;
+      }
+      return false;
+    } catch (error) {
+      throw this.handleQueryError(error, "tableExists", tableName);
+    }
+  }
+  /**
+   * Get list of all tables in the database.
+   *
+   * @remarks
+   * Uses dialect-specific information schema queries to list tables.
+   * Useful for detecting orphaned tables or validating schema state.
+   *
+   * @param schema - Optional schema name (defaults to 'public' for PostgreSQL)
+   * @returns Array of table names
+   *
+   * @throws {DatabaseError} If query fails
+   */
+  async listTables(schema) {
+    try {
+      let sql;
+      const params = [];
+      switch (this.dialect) {
+        case "postgresql":
+          sql = `
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = $1
+            AND table_type = 'BASE TABLE'
+            ORDER BY table_name
+          `;
+          params.push(schema ?? "public");
+          break;
+        case "mysql":
+          sql = `
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = DATABASE()
+            AND table_type = 'BASE TABLE'
+            ORDER BY table_name
+          `;
+          break;
+        case "sqlite":
+          sql = `
+            SELECT name as table_name
+            FROM sqlite_master
+            WHERE type = 'table'
+            AND name NOT LIKE 'sqlite_%'
+            ORDER BY name
+          `;
+          break;
+        default:
+          throw this.createDatabaseError(
+            "query",
+            `listTables not implemented for dialect: ${String(this.dialect)}`,
+            void 0
+          );
+      }
+      const results = await this.executeQuery(
+        sql,
+        params
+      );
+      return results.map((row) => row.table_name);
+    } catch (error) {
+      throw this.handleQueryError(error, "listTables", "");
+    }
+  }
+  // ============================================================
+  // Protected Utilities
+  // ============================================================
+  // Old raw SQL query builders (buildSelectQuery, buildInsertQuery, buildUpdateQuery,
+  // buildDeleteQuery, buildUpsertQuery, buildWhereClause, buildPlaceholder,
+  // buildPlaceholders) have been removed. CRUD methods now use Drizzle query API
+  // via the TableResolver set during boot. See drizzle-where.ts for where clause
+  // translation.
+  // NOTE: The following content up to escapeIdentifier has been removed.
+  // If you're looking for the old query builder methods, see git history
+  // (commit before "refactor: remove dead SQL builder code").
+  /**
+   * Escape a table or column identifier.
+   *
+   * @remarks
+   * Default uses double quotes (SQL standard).
+   * MySQL adapter should override to use backticks.
+   *
+   * @param identifier - Identifier to escape
+   * @returns Escaped identifier
+   *
+   * @protected
+   */
+  escapeIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+  /**
+   * Create a DatabaseError with proper error kind classification.
+   *
+   * @remarks
+   * Protected helper for subclasses to create consistent errors.
+   * Subclasses can override to add dialect-specific error classification.
+   *
+   * @param kind - Error kind
+   * @param message - Error message
+   * @param cause - Original error
+   * @returns DatabaseError instance
+   *
+   * @protected
+   */
+  createDatabaseError(kind, message, cause) {
+    return createDatabaseError({
+      kind,
+      message,
+      cause
+    });
+  }
+  /**
+   * Handle query errors and convert to DatabaseError.
+   *
+   * @remarks
+   * Protected helper for consistent error handling across CRUD operations.
+   * Subclasses can override to add dialect-specific error classification.
+   *
+   * @param error - Original error
+   * @param operation - Operation that failed
+   * @param table - Table name
+   * @returns DatabaseError instance
+   *
+   * @protected
+   */
+  handleQueryError(error, operation, table) {
+    if (isDatabaseError(error)) {
+      return error;
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return this.createDatabaseError(
+      "query",
+      `${operation} operation failed on table '${table}': ${errorMessage}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+var ALLOWED_DEFAULT_SQL_EXPRESSIONS = /* @__PURE__ */ new Set([
+  "current_timestamp",
+  "now()",
+  "gen_random_uuid()",
+  "uuid_generate_v4()",
+  "current_date",
+  "current_time"
+]);
+function renderDefaultValue(value, columnName) {
+  if (value === null) return "NULL";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(
+        `DEFAULT for column "${columnName}" must be a finite number (got ${value}).`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "TRUE" : "FALSE";
+  }
+  if (typeof value === "string") {
+    if (/[;\\\n\r\0]/.test(value)) {
+      throw new Error(
+        `DEFAULT string for column "${columnName}" contains characters that are not allowed in DDL (no semicolons, backslashes, control chars, or null bytes).`
+      );
+    }
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  if (typeof value === "object" && value !== null && "sql" in value) {
+    const raw = value.sql;
+    if (typeof raw !== "string") {
+      throw new Error(
+        `DEFAULT for column "${columnName}" has a { sql } expression that is not a string.`
+      );
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (!ALLOWED_DEFAULT_SQL_EXPRESSIONS.has(normalized)) {
+      throw new Error(
+        `DEFAULT for column "${columnName}" uses a SQL expression "${raw}" that is not on the allowlist. Allowed: ${[...ALLOWED_DEFAULT_SQL_EXPRESSIONS].join(", ")}.`
+      );
+    }
+    return raw.trim();
+  }
+  throw new Error(
+    `DEFAULT for column "${columnName}" has an unsupported type (${typeof value}).`
+  );
+}
+
+// src/index.ts
+var version = "0.1.0";
+
+exports.DrizzleAdapter = DrizzleAdapter;
+exports.version = version;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map