@fileverse/api 0.0.2 → 0.0.4

package/dist/cli/index.js

@@ -528,250 +528,247 @@ var init_infra = __esm({
   }
 });
 
-// src/infra/database/adapters/sqlite-adapter.ts
-import Database from "better-sqlite3";
-var SqliteAdapter;
-var init_sqlite_adapter = __esm({
-  "src/infra/database/adapters/sqlite-adapter.ts"() {
+// src/infra/database/adapters/sql-compat.ts
+function sqliteToPostgres(sql) {
+  let result = "";
+  let paramIndex = 0;
+  let inString = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'") {
+      if (inString && i + 1 < sql.length && sql[i + 1] === "'") {
+        result += "''";
+        i++;
+        continue;
+      }
+      inString = !inString;
+      result += ch;
+    } else if (ch === "?" && !inString) {
+      paramIndex++;
+      result += `$${paramIndex}`;
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+var init_sql_compat = __esm({
+  "src/infra/database/adapters/sql-compat.ts"() {
     "use strict";
     init_esm_shims();
+  }
+});
+
+// src/infra/database/adapters/postgres-adapter.ts
+var postgres_adapter_exports = {};
+__export(postgres_adapter_exports, {
+  PostgresAdapter: () => PostgresAdapter
+});
+async function getPg() {
+  if (!pgModule) {
+    pgModule = await import("pg");
+  }
+  return pgModule;
+}
+var pgModule, PostgresAdapter;
+var init_postgres_adapter = __esm({
+  "src/infra/database/adapters/postgres-adapter.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sql_compat();
     init_infra();
-    init_config();
-    SqliteAdapter = class {
-      db;
-      constructor(dbPath) {
-        this.db = new Database(dbPath, {
-          verbose: config.NODE_ENV === "development" ? (msg) => logger.debug(String(msg)) : void 0
-        });
-        this.db.pragma("journal_mode = WAL");
-        this.db.pragma("foreign_keys = ON");
-        this.db.prepare("SELECT 1").get();
-        logger.info(`SQLite database connected: ${dbPath}`);
+    pgModule = null;
+    PostgresAdapter = class {
+      pool = null;
+      connectionUrl;
+      connected = false;
+      dialect = "postgres";
+      constructor(connectionUrl) {
+        this.connectionUrl = connectionUrl;
+      }
+      async getPool() {
+        if (!this.pool) {
+          const pg = await getPg();
+          this.pool = new pg.default.Pool({
+            connectionString: this.connectionUrl,
+            max: 10,
+            ssl: this.connectionUrl.includes("sslmode=require") || this.connectionUrl.includes("amazonaws.com") || this.connectionUrl.includes("heroku") ? { rejectUnauthorized: false } : void 0
+          });
+          const client = await this.pool.connect();
+          client.release();
+          this.connected = true;
+          logger.info("PostgreSQL database connected");
+        }
+        return this.pool;
       }
       async select(sql, params = []) {
-        const stmt = this.db.prepare(sql);
-        return stmt.all(params);
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return result.rows;
       }
       async selectOne(sql, params = []) {
-        const stmt = this.db.prepare(sql);
-        return stmt.get(params);
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return result.rows[0] ?? void 0;
       }
       async execute(sql, params = []) {
-        const stmt = this.db.prepare(sql);
-        const result = stmt.run(params);
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
         return {
-          changes: result.changes,
-          lastInsertRowid: result.lastInsertRowid
+          changes: result.rowCount ?? 0,
+          lastInsertRowid: 0
         };
       }
       async transaction(callback) {
-        this.db.exec("SAVEPOINT txn");
+        const pool = await this.getPool();
+        const client = await pool.connect();
         try {
-          const result = await callback(this);
-          this.db.exec("RELEASE txn");
+          await client.query("BEGIN");
+          const result = await callback();
+          await client.query("COMMIT");
           return result;
-        } catch (err) {
-          this.db.exec("ROLLBACK TO txn");
-          throw err;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
         }
       }
       async exec(sql) {
-        this.db.exec(sql);
+        const pool = await this.getPool();
+        await pool.query(sql);
       }
       async close() {
-        this.db.close();
-        logger.info("Database connection closed");
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+          this.connected = false;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.connected;
       }
     };
   }
 });
 
-// src/infra/database/adapters/pg-adapter.ts
-import pg from "pg";
-function translateParams(sql) {
-  let idx = 0;
-  return sql.replace(/\?/g, () => `$${++idx}`);
-}
-function mapRow(row) {
-  const mapped = {};
-  for (const [key, value] of Object.entries(row)) {
-    const mappedKey = COLUMN_NAME_MAP[key] ?? key;
-    mapped[mappedKey] = value instanceof Date ? value.toISOString() : value;
-  }
-  return mapped;
-}
-var Pool, COLUMN_NAME_MAP, PgClientAdapter, PgAdapter;
-var init_pg_adapter = __esm({
-  "src/infra/database/adapters/pg-adapter.ts"() {
+// src/infra/database/adapters/sqlite-adapter.ts
+var sqlite_adapter_exports = {};
+__export(sqlite_adapter_exports, {
+  SqliteAdapter: () => SqliteAdapter
+});
+import Database from "better-sqlite3";
+var SqliteAdapter;
+var init_sqlite_adapter = __esm({
+  "src/infra/database/adapters/sqlite-adapter.ts"() {
     "use strict";
     init_esm_shims();
     init_infra();
-    ({ Pool } = pg);
-    COLUMN_NAME_MAP = {
-      ddocid: "ddocId",
-      localversion: "localVersion",
-      onchainversion: "onchainVersion",
-      syncstatus: "syncStatus",
-      isdeleted: "isDeleted",
-      onchainfileid: "onChainFileId",
-      portaladdress: "portalAddress",
-      createdat: "createdAt",
-      updatedat: "updatedAt",
-      linkkey: "linkKey",
-      linkkeynonce: "linkKeyNonce",
-      commentkey: "commentKey",
-      portalseed: "portalSeed",
-      owneraddress: "ownerAddress",
-      apikeyseed: "apiKeySeed",
-      collaboratoraddress: "collaboratorAddress",
-      fileid: "fileId",
-      retrycount: "retryCount",
-      lasterror: "lastError",
-      lockedat: "lockedAt",
-      nextretryat: "nextRetryAt",
-      userophash: "userOpHash",
-      pendingpayload: "pendingPayload",
-      folderid: "folderId",
-      folderref: "folderRef",
-      foldername: "folderName",
-      metadataipfshash: "metadataIPFSHash",
-      contentipfshash: "contentIPFSHash",
-      lasttransactionhash: "lastTransactionHash",
-      lasttransactionblocknumber: "lastTransactionBlockNumber",
-      lasttransactionblocktimestamp: "lastTransactionBlockTimestamp",
-      created_at: "created_at",
-      updated_at: "updated_at"
-    };
-    PgClientAdapter = class {
-      constructor(client) {
-        this.client = client;
-      }
-      async select(sql, params = []) {
-        const result = await this.client.query(translateParams(sql), params);
-        return result.rows.map((row) => mapRow(row));
-      }
-      async selectOne(sql, params = []) {
-        const result = await this.client.query(translateParams(sql), params);
-        return result.rows[0] ? mapRow(result.rows[0]) : void 0;
-      }
-      async execute(sql, params = []) {
-        const result = await this.client.query(translateParams(sql), params);
-        return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
+    SqliteAdapter = class {
+      constructor(dbPath) {
+        this.dbPath = dbPath;
       }
-      async transaction(callback) {
-        await this.client.query("SAVEPOINT nested_txn");
-        try {
-          const result = await callback(this);
-          await this.client.query("RELEASE SAVEPOINT nested_txn");
-          return result;
-        } catch (err) {
-          await this.client.query("ROLLBACK TO SAVEPOINT nested_txn");
-          throw err;
+      db = null;
+      dialect = "sqlite";
+      getDb() {
+        if (!this.db) {
+          this.db = new Database(this.dbPath);
+          this.db.pragma("journal_mode = WAL");
+          this.db.pragma("foreign_keys = ON");
+          this.db.prepare("SELECT 1").get();
+          logger.info(`SQLite database connected: ${this.dbPath}`);
         }
-      }
-      async exec(sql) {
-        await this.client.query(sql);
-      }
-      async close() {
-      }
-    };
-    PgAdapter = class {
-      pool;
-      constructor(connectionString) {
-        const url = new URL(connectionString);
-        const isLocal = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
-        const sslDisabled = connectionString.includes("sslmode=disable");
-        const needsSsl = !isLocal && !sslDisabled;
-        this.pool = new Pool({
-          connectionString,
-          // pg requires password to be a string; local trust/peer auth uses empty string
-          password: url.password || "",
-          max: 20,
-          idleTimeoutMillis: 3e4,
-          ssl: needsSsl ? { rejectUnauthorized: false } : void 0
-        });
-        logger.info(`PostgreSQL pool created (ssl: ${needsSsl ? "on" : "off"})`);
+        return this.db;
       }
       async select(sql, params = []) {
-        const result = await this.pool.query(translateParams(sql), params);
-        return result.rows.map((row) => mapRow(row));
+        const stmt = this.getDb().prepare(sql);
+        return stmt.all(params);
       }
       async selectOne(sql, params = []) {
-        const result = await this.pool.query(translateParams(sql), params);
-        return result.rows[0] ? mapRow(result.rows[0]) : void 0;
+        const stmt = this.getDb().prepare(sql);
+        return stmt.get(params);
       }
       async execute(sql, params = []) {
-        const result = await this.pool.query(translateParams(sql), params);
-        return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
+        const stmt = this.getDb().prepare(sql);
+        const result = stmt.run(params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
       }
       async transaction(callback) {
-        const client = await this.pool.connect();
+        const db = this.getDb();
+        const savepointName = `sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        db.exec(`SAVEPOINT ${savepointName}`);
         try {
-          await client.query("BEGIN");
-          const clientAdapter = new PgClientAdapter(client);
-          const result = await callback(clientAdapter);
-          await client.query("COMMIT");
+          const result = await callback();
+          db.exec(`RELEASE ${savepointName}`);
           return result;
-        } catch (err) {
-          await client.query("ROLLBACK");
-          throw err;
-        } finally {
-          client.release();
+        } catch (error) {
+          db.exec(`ROLLBACK TO ${savepointName}`);
+          db.exec(`RELEASE ${savepointName}`);
+          throw error;
         }
       }
       async exec(sql) {
-        await this.pool.query(sql);
+        this.getDb().exec(sql);
       }
       async close() {
-        await this.pool.end();
-        logger.info("PostgreSQL pool closed");
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.db !== null && this.db.open;
       }
     };
   }
 });
 
 // src/infra/database/connection.ts
-var connection_exports = {};
-__export(connection_exports, {
-  closeAdapter: () => closeAdapter,
-  getAdapter: () => getAdapter,
-  getAdapterSync: () => getAdapterSync
-});
-async function getAdapter() {
+import path5 from "path";
+import fs3 from "fs";
+async function initializeAdapter() {
   if (adapter) return adapter;
-  const databaseUrl = config.DATABASE_URL;
-  const dbPath = config.DB_PATH;
+  const databaseUrl = process.env.DATABASE_URL;
+  const dbPath = process.env.DB_PATH;
   if (databaseUrl) {
-    adapter = new PgAdapter(databaseUrl);
+    const { PostgresAdapter: PostgresAdapter2 } = await Promise.resolve().then(() => (init_postgres_adapter(), postgres_adapter_exports));
+    adapter = new PostgresAdapter2(databaseUrl);
+    logger.info("Using PostgreSQL adapter");
   } else if (dbPath) {
-    adapter = new SqliteAdapter(dbPath);
+    const dbDir = path5.dirname(dbPath.trim());
+    if (!fs3.existsSync(dbDir)) {
+      fs3.mkdirSync(dbDir, { recursive: true });
+    }
+    const { SqliteAdapter: SqliteAdapter2 } = await Promise.resolve().then(() => (init_sqlite_adapter(), sqlite_adapter_exports));
+    adapter = new SqliteAdapter2(dbPath);
+    logger.info("Using SQLite adapter");
   } else {
-    throw new Error("Either DATABASE_URL or DB_PATH must be set");
-  }
-  return adapter;
-}
-function getAdapterSync() {
-  if (!adapter) {
     throw new Error(
-      "Database adapter not initialized. Call getAdapter() at startup first."
+      "No database configured. Set DATABASE_URL (PostgreSQL) or DB_PATH (SQLite)."
     );
   }
   return adapter;
 }
-async function closeAdapter() {
-  if (adapter) {
-    await adapter.close();
-    adapter = null;
+async function getAdapter() {
+  if (!adapter) {
+    return initializeAdapter();
   }
+  return adapter;
 }
 var adapter;
 var init_connection = __esm({
   "src/infra/database/connection.ts"() {
     "use strict";
     init_esm_shims();
-    init_sqlite_adapter();
-    init_pg_adapter();
-    init_config();
+    init_infra();
     adapter = null;
   }
 });
@@ -796,16 +793,20 @@ var init_query_builder = __esm({
     init_constants3();
     QueryBuilder = class {
       static async select(sql, params = []) {
-        return getAdapterSync().select(sql, params);
+        const adapter2 = await getAdapter();
+        return adapter2.select(sql, params);
       }
       static async selectOne(sql, params = []) {
-        return getAdapterSync().selectOne(sql, params);
+        const adapter2 = await getAdapter();
+        return adapter2.selectOne(sql, params);
       }
       static async execute(sql, params = []) {
-        return getAdapterSync().execute(sql, params);
+        const adapter2 = await getAdapter();
+        return adapter2.execute(sql, params);
       }
       static async transaction(callback) {
-        return getAdapterSync().transaction(callback);
+        const adapter2 = await getAdapter();
+        return adapter2.transaction(callback);
       }
       static paginate(sql, options = {}) {
         let query = sql;
@@ -1017,7 +1018,7 @@ __export(migrations_exports, {
   runMigrations: () => runMigrations
 });
 async function runMigrations() {
-  const adapter2 = getAdapterSync();
+  const adapter2 = await getAdapter();
   await adapter2.exec(STABLE_SCHEMA);
   logger.debug("Database schema ready");
 }
@@ -1377,7 +1378,7 @@ var decryptSavedData = async (apiKey, encryptedData) => {
 };
 
 // src/cli/index.ts
-var program = new Command().name("fileverse-api").description("Run the Fileverse API server").version("0.0.2").option("--apiKey <key>", "API key for authentication").option("--rpcUrl <url>", "RPC URL for blockchain connection").option("--port <port>", "Port to run the server on", "8001").option("--db <path>", "Database path").action(async (options) => {
+var program = new Command().name("fileverse-api").description("Run the Fileverse API server").version("0.0.3").option("--apiKey <key>", "API key for authentication").option("--rpcUrl <url>", "RPC URL for blockchain connection").option("--port <port>", "Port to run the server on", "8001").option("--db <path>", "Database path").action(async (options) => {
   try {
     console.log("Fileverse API - Starting initialization...\n");
     if (needsPrompting(options)) {
@@ -1402,8 +1403,6 @@ var program = new Command().name("fileverse-api").description("Run the Fileverse
     loadConfig();
     console.log(`\u2713 Configuration saved to ${envPath}
 `);
-    const { getAdapter: getAdapter2 } = await Promise.resolve().then(() => (init_connection(), connection_exports));
-    await getAdapter2();
     const { runMigrations: runMigrations2 } = await Promise.resolve().then(() => (init_migrations(), migrations_exports));
     await runMigrations2();
     console.log("\u2713 Database migrations complete");