tina4-nodejs 3.10.48 → 3.10.55

package/packages/orm/src/adapters/odbc.ts

@@ -0,0 +1,413 @@
+/**
+ * Tina4 ODBC Adapter — uses the `odbc` package (optional peer dependency).
+ *
+ * Install: npm install odbc
+ * URL format: odbc:///DSN=MyDSN
+ *             odbc:///DRIVER={driver};SERVER=host;DATABASE=db
+ *
+ * The connection string after stripping the "odbc:///" prefix is passed
+ * directly to odbc.connect(), so any valid ODBC connection string works.
+ */
+import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
+import { createRequire } from "node:module";
+
+let odbcModule: any = null;
+
+function requireOdbc(): any {
+  if (odbcModule) return odbcModule;
+  try {
+    const req = createRequire(import.meta.url);
+    odbcModule = req("odbc");
+    return odbcModule;
+  } catch {
+    throw new Error(
+      "The 'odbc' package is required for ODBC connections. Install it with: npm install odbc",
+    );
+  }
+}
+
+export interface OdbcConfig {
+  /** Full ODBC connection string, e.g. "DSN=MyDSN" or "DRIVER={SQL Server};SERVER=host;DATABASE=db" */
+  connectionString: string;
+}
+
+export class OdbcAdapter implements DatabaseAdapter {
+  private connection: any = null;
+  private _lastInsertId: number | bigint | null = null;
+  private _inTransaction: boolean = false;
+
+  /**
+   * Accepts either an OdbcConfig object or a raw connection string.
+   * When created via Database.create("odbc:///DSN=MyDSN"), the "odbc:///"
+   * prefix is stripped by parseDatabaseUrl and the remainder is passed here.
+   */
+  constructor(private config: OdbcConfig | string) {}
+
+  /** Extract the raw ODBC connection string from config. */
+  private getConnectionString(): string {
+    if (typeof this.config === "string") return this.config;
+    return this.config.connectionString;
+  }
+
+  /** Connect to the ODBC data source. Must be called before using the adapter. */
+  async connect(): Promise<void> {
+    const odbc = requireOdbc();
+    const connStr = this.getConnectionString();
+    // odbc package may expose connect as default export or named export
+    const connectFn = odbc.connect ?? odbc.default?.connect;
+    if (!connectFn) {
+      throw new Error("odbc module does not export a connect() function. Check your odbc package version.");
+    }
+    this.connection = await connectFn(connStr);
+  }
+
+  private ensureConnected(): void {
+    if (!this.connection) {
+      throw new Error("ODBC adapter not connected. Call connect() first.");
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Synchronous interface stubs — ODBC is async; use the *Async variants
+  // -------------------------------------------------------------------------
+
+  execute(sql: string, params?: unknown[]): unknown {
+    throw new Error("Use executeAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+    throw new Error("Use executeManyAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[] {
+    throw new Error("Use queryAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  fetch<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): T[] {
+    throw new Error("Use fetchAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  fetchOne<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null {
+    throw new Error("Use fetchOneAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  insert(table: string, data: Record<string, unknown>): DatabaseResult {
+    throw new Error("Use insertAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  update(table: string, data: Record<string, unknown>, filter: Record<string, unknown>): DatabaseResult {
+    throw new Error("Use updateAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[]): DatabaseResult {
+    throw new Error("Use deleteAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  startTransaction(): void {
+    throw new Error("Use startTransactionAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  commit(): void {
+    throw new Error("Use commitAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  rollback(): void {
+    throw new Error("Use rollbackAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  tables(): string[] {
+    throw new Error("Use tablesAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  columns(table: string): ColumnInfo[] {
+    throw new Error("Use columnsAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  tableExists(name: string): boolean {
+    throw new Error("Use tableExistsAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  createTable(name: string, columns: Record<string, FieldDefinition>): void {
+    throw new Error("Use createTableAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  getTableColumns(name: string): Array<{ name: string; type: string }> {
+    throw new Error("Use getTableColumnsAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  addColumn(table: string, colName: string, def: FieldDefinition): void {
+    throw new Error("Use addColumnAsync() for ODBC — async adapter requires async methods.");
+  }
+
+  // -------------------------------------------------------------------------
+  // Async methods — primary API for ODBC
+  // -------------------------------------------------------------------------
+
+  /** Execute a write statement (INSERT, UPDATE, DELETE, DDL). */
+  async executeAsync(sql: string, params?: unknown[]): Promise<unknown> {
+    this.ensureConnected();
+    const result = await this.connection.query(sql, params ?? []);
+    // Try to capture last insert id from result metadata if present
+    if (result && typeof result === "object" && "lastInsertId" in result) {
+      this._lastInsertId = (result as any).lastInsertId;
+    }
+    return result;
+  }
+
+  /** Execute a statement with multiple parameter sets inside a single transaction. */
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+    this.ensureConnected();
+    let totalAffected = 0;
+    let lastId: number | bigint | undefined;
+
+    await this.startTransactionAsync();
+    try {
+      for (const params of paramsList) {
+        await this.connection.query(sql, params);
+        totalAffected++;
+      }
+      await this.commitAsync();
+    } catch (e) {
+      await this.rollbackAsync();
+      throw e;
+    }
+
+    if (lastId !== undefined) this._lastInsertId = lastId;
+    return { totalAffected, lastInsertId: lastId };
+  }
+
+  /** Run a SELECT and return all matching rows. */
+  async queryAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]> {
+    this.ensureConnected();
+    const result = await this.connection.query(sql, params ?? []);
+    // odbc returns an array-like result object; spread into a plain array
+    return Array.from(result) as T[];
+  }
+
+  /** Run a SELECT with optional LIMIT/OFFSET pagination. */
+  async fetchAsync<T = Record<string, unknown>>(
+    sql: string,
+    params?: unknown[],
+    limit?: number,
+    skip?: number,
+  ): Promise<T[]> {
+    let effectiveSql = sql;
+    if (limit !== undefined) {
+      const sqlUpper = sql.toUpperCase().split("--")[0];
+      if (!sqlUpper.includes("LIMIT")) {
+        effectiveSql += ` LIMIT ${limit}`;
+        if (skip !== undefined && skip > 0) {
+          effectiveSql += ` OFFSET ${skip}`;
+        }
+      }
+    }
+    return this.queryAsync<T>(effectiveSql, params);
+  }
+
+  /** Run a SELECT and return the first row or null. */
+  async fetchOneAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T | null> {
+    const rows = await this.queryAsync<T>(sql, params);
+    return rows[0] ?? null;
+  }
+
+  /** Insert a single row into a table. */
+  async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
+    this.ensureConnected();
+    const keys = Object.keys(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
+    const values = Object.values(data);
+
+    try {
+      await this.connection.query(sql, values);
+      return { success: true, rowsAffected: 1, lastInsertId: this._lastInsertId ?? undefined };
+    } catch (e) {
+      return { success: false, rowsAffected: 0, error: (e as Error).message };
+    }
+  }
+
+  /** Update rows in a table matching filter. */
+  async updateAsync(table: string, data: Record<string, unknown>, filter: Record<string, unknown>): Promise<DatabaseResult> {
+    this.ensureConnected();
+    const setClauses = Object.keys(data).map((k) => `"${k}" = ?`).join(", ");
+    const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
+    const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+    const values = [...Object.values(data), ...Object.values(filter)];
+
+    try {
+      await this.connection.query(sql, values);
+      return { success: true, rowsAffected: 1 };
+    } catch (e) {
+      return { success: false, rowsAffected: 0, error: (e as Error).message };
+    }
+  }
+
+  /** Delete rows from a table. */
+  async deleteAsync(
+    table: string,
+    filter: Record<string, unknown> | string | Record<string, unknown>[],
+  ): Promise<DatabaseResult> {
+    this.ensureConnected();
+
+    if (Array.isArray(filter)) {
+      let totalAffected = 0;
+      for (const row of filter) {
+        const result = await this.deleteAsync(table, row);
+        totalAffected += result.rowsAffected;
+      }
+      return { success: true, rowsAffected: totalAffected };
+    }
+
+    if (typeof filter === "string") {
+      const sql = filter
+        ? `DELETE FROM "${table}" WHERE ${filter}`
+        : `DELETE FROM "${table}"`;
+      try {
+        await this.connection.query(sql, []);
+        return { success: true, rowsAffected: 1 };
+      } catch (e) {
+        return { success: false, rowsAffected: 0, error: (e as Error).message };
+      }
+    }
+
+    const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
+    const sql = `DELETE FROM "${table}" WHERE ${whereClauses}`;
+    const values = Object.values(filter);
+
+    try {
+      await this.connection.query(sql, values);
+      return { success: true, rowsAffected: 1 };
+    } catch (e) {
+      return { success: false, rowsAffected: 0, error: (e as Error).message };
+    }
+  }
+
+  /** Begin a transaction. */
+  async startTransactionAsync(): Promise<void> {
+    if (this._inTransaction) return;
+    this.ensureConnected();
+    // odbc connections have beginTransaction() method
+    await this.connection.beginTransaction();
+    this._inTransaction = true;
+  }
+
+  /** Commit the current transaction. */
+  async commitAsync(): Promise<void> {
+    if (!this._inTransaction) return;
+    this.ensureConnected();
+    await this.connection.commit();
+    this._inTransaction = false;
+  }
+
+  /** Rollback the current transaction. */
+  async rollbackAsync(): Promise<void> {
+    if (!this._inTransaction) return;
+    this.ensureConnected();
+    try {
+      await this.connection.rollback();
+    } catch {
+      // Rollback may fail if transaction already ended
+    }
+    this._inTransaction = false;
+  }
+
+  /** List all user tables using ODBC catalog functions. */
+  async tablesAsync(): Promise<string[]> {
+    this.ensureConnected();
+    // odbc.Connection.tables(catalog, schema, table, type) returns catalog rows
+    const rows: any[] = await this.connection.tables(null, null, null, "TABLE");
+    return rows.map((r: any) => r.TABLE_NAME ?? r.table_name ?? r.name).filter(Boolean);
+  }
+
+  /** Get column metadata for a table using ODBC catalog functions. */
+  async columnsAsync(table: string): Promise<ColumnInfo[]> {
+    this.ensureConnected();
+    // odbc.Connection.columns(catalog, schema, table, column)
+    const rows: any[] = await this.connection.columns(null, null, table, null);
+    return rows.map((r: any) => ({
+      name: r.COLUMN_NAME ?? r.column_name,
+      type: r.TYPE_NAME ?? r.type_name ?? r.DATA_TYPE ?? "",
+      nullable: (r.NULLABLE ?? r.nullable) === 1,
+      default: r.COLUMN_DEF ?? r.column_def ?? null,
+      primaryKey: false, // ODBC catalog doesn't easily expose PK; requires separate primaryKeys() call
+    }));
+  }
+
+  /** Check whether a table exists. */
+  async tableExistsAsync(name: string): Promise<boolean> {
+    this.ensureConnected();
+    const rows: any[] = await this.connection.tables(null, null, name, "TABLE");
+    return rows.length > 0;
+  }
+
+  /** Create a table from a FieldDefinition map. Uses generic SQL — works with most ODBC sources. */
+  async createTableAsync(name: string, columns: Record<string, FieldDefinition>): Promise<void> {
+    const colDefs: string[] = [];
+    for (const [colName, def] of Object.entries(columns)) {
+      const sqlType = fieldTypeToOdbc(def.type);
+      const parts = [`"${colName}" ${sqlType}`];
+      if (def.primaryKey) parts.push("PRIMARY KEY");
+      if (def.autoIncrement) parts.push("GENERATED ALWAYS AS IDENTITY"); // ANSI SQL
+      if (def.required && !def.primaryKey) parts.push("NOT NULL");
+      if (def.default !== undefined && def.default !== "now") {
+        parts.push(`DEFAULT ${sqlDefault(def.default)}`);
+      }
+      if (def.default === "now") parts.push("DEFAULT CURRENT_TIMESTAMP");
+      colDefs.push(parts.join(" "));
+    }
+    await this.connection.query(`CREATE TABLE IF NOT EXISTS "${name}" (${colDefs.join(", ")})`);
+  }
+
+  /** Get raw column name+type list for a table. */
+  async getTableColumnsAsync(name: string): Promise<Array<{ name: string; type: string }>> {
+    const cols = await this.columnsAsync(name);
+    return cols.map((c) => ({ name: c.name, type: c.type }));
+  }
+
+  /** Add a column to an existing table. */
+  async addColumnAsync(table: string, colName: string, def: FieldDefinition): Promise<void> {
+    const sqlType = fieldTypeToOdbc(def.type);
+    let sql = `ALTER TABLE "${table}" ADD COLUMN "${colName}" ${sqlType}`;
+    if (def.default !== undefined && def.default !== "now") {
+      sql += ` DEFAULT ${sqlDefault(def.default)}`;
+    } else if (def.default === "now") {
+      sql += " DEFAULT CURRENT_TIMESTAMP";
+    }
+    await this.connection.query(sql);
+  }
+
+  lastInsertId(): number | bigint | null {
+    return this._lastInsertId;
+  }
+
+  close(): void {
+    if (this.connection) {
+      // odbc close is async but we keep the sync interface — fire and forget
+      this.connection.close().catch(() => {});
+      this.connection = null;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function fieldTypeToOdbc(type: string): string {
+  switch (type) {
+    case "integer": return "INTEGER";
+    case "number":
+    case "numeric": return "DOUBLE PRECISION";
+    case "boolean": return "SMALLINT";
+    case "datetime": return "TIMESTAMP";
+    case "text": return "CLOB";
+    case "string":
+    default: return "VARCHAR(255)";
+  }
+}
+
+function sqlDefault(value: unknown): string {
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return String(value);
+}

package/packages/orm/src/adapters/sqlite.ts

@@ -146,9 +146,29 @@ export class SQLiteAdapter implements DatabaseAdapter {
     }
   }
 
-  startTransaction(): void { this.db.exec("BEGIN TRANSACTION"); }
-  commit(): void { this.db.exec("COMMIT"); }
-  rollback(): void { this.db.exec("ROLLBACK"); }
+  private _inTransaction = false;
+
+  startTransaction(): void {
+    if (this._inTransaction) return;
+    this.db.exec("BEGIN TRANSACTION");
+    this._inTransaction = true;
+  }
+
+  commit(): void {
+    if (!this._inTransaction) return;
+    this.db.exec("COMMIT");
+    this._inTransaction = false;
+  }
+
+  rollback(): void {
+    if (!this._inTransaction) return;
+    try {
+      this.db.exec("ROLLBACK");
+    } catch {
+      // Rollback may fail if transaction already ended
+    }
+    this._inTransaction = false;
+  }
 
   tables(): string[] {
     const rows = this.query<{ name: string }>(

package/packages/orm/src/autoCrud.ts

@@ -45,17 +45,26 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
         const items = adapter.query(sql, params);
         const [{ total }] = adapter.query<{ total: number }>(countSql, countParams);
 
-        const limit = options.limit ?? 20;
+        const limit = options.limit ?? 100;
         const page = options.page ?? 1;
+        const offset = (page - 1) * limit;
+        const totalPages = Math.ceil(total / limit);
 
         res.json({
+          // Primary keys
+          records: items,
           data: items,
-          meta: {
-            total,
-            page,
-            limit,
-            totalPages: Math.ceil(total / limit),
-          },
+          count: total,
+          total,
+          limit,
+          offset,
+          page,
+          per_page: limit,
+          perPage: limit,
+          totalPages,
+          total_pages: totalPages,
+          // Legacy nested meta (kept for any clients that use it)
+          meta: { total, page, limit, totalPages },
         });
       },
     });

package/packages/orm/src/baseModel.ts

@@ -1,13 +1,15 @@
-import { getAdapter, getNamedAdapter } from "./database.js";
+import { getAdapter, getNamedAdapter, setAdapter, parseDatabaseUrl } from "./database.js";
 import { validate as validateFields } from "./validation.js";
 import { QueryBuilder } from "./queryBuilder.js";
+import { SQLiteAdapter } from "./adapters/sqlite.js";
 import type { DatabaseAdapter, FieldDefinition, RelationshipDefinition } from "./types.js";
 
 /**
  * Convert a snake_case name to camelCase.
+ * Lowercases the input first so UPPERCASE DB column names (Firebird/Oracle) map correctly.
  */
 export function snakeToCamel(name: string): string {
-  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  return name.toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
 
 /**
@@ -90,8 +92,8 @@ export class BaseModel {
       }
       const reverseMapping = ModelClass.getReverseMapping();
       for (const [key, value] of Object.entries(data)) {
-        // If this DB column has a mapping, use the JS property name instead
-        const jsProp = reverseMapping[key] ?? key;
+        // Lowercase the DB column key so UPPERCASE columns (Firebird/Oracle) match the mapping
+        const jsProp = reverseMapping[key] ?? reverseMapping[key.toLowerCase()] ?? key;
         this[jsProp] = value;
       }
     }
@@ -147,12 +149,37 @@ export class BaseModel {
 
   /**
    * Get the database adapter for this model.
+   * If no adapter is registered, attempts auto-discovery from DATABASE_URL.
+   * SQLite URLs are initialised synchronously. Other engines require initDatabase()
+   * to be called before first use.
    */
   protected static getDb(): DatabaseAdapter {
     if (this._db) {
       return getNamedAdapter(this._db);
     }
-    return getAdapter();
+    try {
+      return getAdapter();
+    } catch {
+      // No adapter registered — try DATABASE_URL auto-discovery
+      const url = process.env.DATABASE_URL;
+      if (url) {
+        const parsed = parseDatabaseUrl(url);
+        if (parsed.type === "sqlite") {
+          // SQLite adapter is synchronous — create it inline and register as default
+          const dbPath = parsed.path ?? "./data/tina4.db";
+          const adapter = new SQLiteAdapter(dbPath);
+          setAdapter(adapter);
+          return adapter;
+        }
+        throw new Error(
+          `DATABASE_URL is set to a non-SQLite engine ("${parsed.type}"). ` +
+          `Call await initDatabase() at startup before using ORM models.`,
+        );
+      }
+      throw new Error(
+        "No database adapter configured. Call initDatabase() or set DATABASE_URL in .env.",
+      );
+    }
   }
 
   /**

package/packages/orm/src/database.ts

@@ -45,7 +45,7 @@ export function closeDatabase(): void {
 }
 
 export interface DatabaseConfig {
-  type?: "sqlite" | "postgres" | "mysql" | "mssql" | "sqlserver" | "firebird";
+  type?: "sqlite" | "postgres" | "mysql" | "mssql" | "sqlserver" | "firebird" | "mongodb" | "odbc";
   path?: string;
   url?: string;
   host?: string;
@@ -54,19 +54,23 @@ export interface DatabaseConfig {
   username?: string;
   password?: string;
   database?: string;
+  /** ODBC-specific: full connection string, e.g. "DSN=MyDSN" or "DRIVER={SQL Server};SERVER=host;DATABASE=db" */
+  connectionString?: string;
 }
 
 /**
  * Parsed result from a DATABASE_URL connection string.
  */
 export interface ParsedDatabaseUrl {
-  type: "sqlite" | "postgres" | "mysql" | "mssql" | "firebird";
+  type: "sqlite" | "postgres" | "mysql" | "mssql" | "firebird" | "mongodb" | "odbc";
   path?: string;
   host?: string;
   port?: number;
   user?: string;
   password?: string;
   database?: string;
+  /** ODBC-specific: raw connection string passed to odbc.connect() */
+  connectionString?: string;
 }
 
 /**
@@ -120,6 +124,28 @@ export function parseDatabaseUrl(url: string, username?: string, password?: stri
       port: match[4] ? parseInt(match[4], 10) : undefined,
       database: "/" + match[5],
     };
+  } else if (url.startsWith("odbc:///")) {
+    // odbc:///DSN=MyDSN  or  odbc:///DRIVER={driver};SERVER=host;DATABASE=db
+    // Strip the "odbc:///" prefix and pass the rest directly as the connection string
+    const connectionString = url.slice("odbc:///".length);
+    result = { type: "odbc", connectionString };
+  } else if (url.startsWith("mongodb://") || url.startsWith("mongodb+srv://")) {
+    // Pass through as-is; MongodbAdapter handles the full connection string
+    let parsed: URL;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new Error(`Invalid MongoDB URL: ${url}`);
+    }
+    const database = parsed.pathname.replace(/^\//, "") || "tina4";
+    result = {
+      type: "mongodb",
+      host: parsed.hostname || undefined,
+      port: parsed.port ? parseInt(parsed.port, 10) : undefined,
+      user: parsed.username ? decodeURIComponent(parsed.username) : undefined,
+      password: parsed.password ? decodeURIComponent(parsed.password) : undefined,
+      database,
+    };
   } else {
     // Normalize postgres:// to postgresql:// for URL parsing
     const normalizedUrl = url.startsWith("postgres://")
@@ -531,6 +557,17 @@ export class Database {
   getNextId(table: string, pkColumn = "id", generatorName?: string): number {
     const adapter = this.getNextAdapter();
 
+    // MongoDB — getNextId() is not supported synchronously.
+    // MongoDB uses ObjectId for primary keys by default.
+    // For integer sequences, use getNextIdAsync() instead.
+    if (this.dbType === "mongodb") {
+      throw new Error(
+        "getNextId() is not supported for MongoDB (async adapter). " +
+        "MongoDB uses ObjectId for _id by default. " +
+        "For integer sequences, use getNextIdAsync() or let MongoDB generate _id automatically.",
+      );
+    }
+
     // Firebird — use generators (atomic)
     if (this.dbType === "firebird") {
       const genName = generatorName ?? `GEN_${table.toUpperCase()}_ID`;
@@ -641,6 +678,18 @@ async function createAdapterFromUrl(url: string, username?: string, password?: s
       await adapter.connect();
       return adapter;
     }
+    case "mongodb": {
+      const { MongodbAdapter } = await import("./adapters/mongodb.js");
+      const adapter = new MongodbAdapter(url);
+      await adapter.connect();
+      return adapter;
+    }
+    case "odbc": {
+      const { OdbcAdapter } = await import("./adapters/odbc.js");
+      const adapter = new OdbcAdapter({ connectionString: parsed.connectionString ?? "" });
+      await adapter.connect();
+      return adapter;
+    }
   }
 }
 
@@ -730,6 +779,28 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
       setAdapter(adapter);
       return new Database(adapter);
     }
+    case "mongodb": {
+      const { MongodbAdapter } = await import("./adapters/mongodb.js");
+      const creds = resolvedUser && resolvedPassword
+        ? `${encodeURIComponent(resolvedUser)}:${encodeURIComponent(resolvedPassword)}@`
+        : "";
+      const host = config?.host ?? "localhost";
+      const port = config?.port ?? 27017;
+      const database = config?.database ?? "tina4";
+      const connectionString = `mongodb://${creds}${host}:${port}/${database}`;
+      const adapter = new MongodbAdapter(connectionString);
+      await adapter.connect();
+      setAdapter(adapter);
+      return new Database(adapter);
+    }
+    case "odbc": {
+      const { OdbcAdapter } = await import("./adapters/odbc.js");
+      const connStr = config?.connectionString ?? config?.url?.replace(/^odbc:\/\/\//, "") ?? "";
+      const adapter = new OdbcAdapter({ connectionString: connStr });
+      await adapter.connect();
+      setAdapter(adapter);
+      return new Database(adapter);
+    }
     default:
       throw new Error(`Unknown database type: ${type}`);
   }