@fileverse/api 0.0.3 → 0.0.4

package/dist/cli/index.js

@@ -75,6 +75,9 @@ function getRuntimeConfig() {
     get DB_PATH() {
       return process.env.DB_PATH;
     },
+    get DATABASE_URL() {
+      return process.env.DATABASE_URL;
+    },
     get PORT() {
       return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
     },
@@ -121,6 +124,9 @@ var init_config = __esm({
       get DB_PATH() {
         return process.env.DB_PATH;
       },
+      get DATABASE_URL() {
+        return process.env.DATABASE_URL;
+      },
       get PORT() {
         return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
       },
@@ -382,11 +388,11 @@ var init_publish = __esm({
 });
 
 // src/domain/portal/saveApiKey.ts
-function addApiKey(input) {
+async function addApiKey(input) {
   if (!input.apiKeySeed || !input.name || !input.collaboratorAddress || !input.portalAddress) {
     throw new Error("apiKeySeed, name, collaboratorAddress, and portalAddress are required");
   }
-  const portal = PortalsModel.findByPortalAddress(input.portalAddress);
+  const portal = await PortalsModel.findByPortalAddress(input.portalAddress);
   if (!portal) {
     throw new Error(`Portal with address ${input.portalAddress} does not exist`);
   }
@@ -522,39 +528,195 @@ var init_infra = __esm({
   }
 });
 
-// src/infra/database/connection.ts
-import Database from "better-sqlite3";
-var DatabaseConnectionManager, databaseConnectionManager;
-var init_connection = __esm({
-  "src/infra/database/connection.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();
-    init_config();
+  }
+});
+
+// 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();
-    DatabaseConnectionManager = class _DatabaseConnectionManager {
-      static instance;
-      db = null;
-      constructor() {
+    pgModule = null;
+    PostgresAdapter = class {
+      pool = null;
+      connectionUrl;
+      connected = false;
+      dialect = "postgres";
+      constructor(connectionUrl) {
+        this.connectionUrl = connectionUrl;
       }
-      static getInstance() {
-        if (!_DatabaseConnectionManager.instance) {
-          _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
+      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 _DatabaseConnectionManager.instance;
+        return this.pool;
+      }
+      async select(sql, 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 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 pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return {
+          changes: result.rowCount ?? 0,
+          lastInsertRowid: 0
+        };
+      }
+      async transaction(callback) {
+        const pool = await this.getPool();
+        const client = await pool.connect();
+        try {
+          await client.query("BEGIN");
+          const result = await callback();
+          await client.query("COMMIT");
+          return result;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
+        }
+      }
+      async exec(sql) {
+        const pool = await this.getPool();
+        await pool.query(sql);
+      }
+      async close() {
+        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/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();
+    SqliteAdapter = class {
+      constructor(dbPath) {
+        this.dbPath = dbPath;
       }
-      getConnection() {
+      db = null;
+      dialect = "sqlite";
+      getDb() {
         if (!this.db) {
-          const dbPath = config.DB_PATH;
-          this.db = new Database(dbPath, {
-            verbose: config.NODE_ENV === "development" ? (msg) => logger.debug(String(msg)) : void 0
-          });
+          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: ${dbPath}`);
+          logger.info(`SQLite database connected: ${this.dbPath}`);
         }
         return this.db;
       }
+      async select(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        return stmt.all(params);
+      }
+      async selectOne(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        return stmt.get(params);
+      }
+      async execute(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        const result = stmt.run(params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
+      }
+      async transaction(callback) {
+        const db = this.getDb();
+        const savepointName = `sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        db.exec(`SAVEPOINT ${savepointName}`);
+        try {
+          const result = await callback();
+          db.exec(`RELEASE ${savepointName}`);
+          return result;
+        } catch (error) {
+          db.exec(`ROLLBACK TO ${savepointName}`);
+          db.exec(`RELEASE ${savepointName}`);
+          throw error;
+        }
+      }
+      async exec(sql) {
+        this.getDb().exec(sql);
+      }
       async close() {
         if (this.db) {
           this.db.close();
@@ -566,7 +728,48 @@ var init_connection = __esm({
         return this.db !== null && this.db.open;
       }
     };
-    databaseConnectionManager = DatabaseConnectionManager.getInstance();
+  }
+});
+
+// src/infra/database/connection.ts
+import path5 from "path";
+import fs3 from "fs";
+async function initializeAdapter() {
+  if (adapter) return adapter;
+  const databaseUrl = process.env.DATABASE_URL;
+  const dbPath = process.env.DB_PATH;
+  if (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) {
+    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(
+      "No database configured. Set DATABASE_URL (PostgreSQL) or DB_PATH (SQLite)."
+    );
+  }
+  return adapter;
+}
+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_infra();
+    adapter = null;
   }
 });
 
@@ -581,9 +784,6 @@ var init_constants3 = __esm({
 });
 
 // src/infra/database/query-builder.ts
-function getDb() {
-  return databaseConnectionManager.getConnection();
-}
 var QueryBuilder;
 var init_query_builder = __esm({
   "src/infra/database/query-builder.ts"() {
@@ -592,24 +792,21 @@ var init_query_builder = __esm({
     init_connection();
     init_constants3();
     QueryBuilder = class {
-      static select(sql, params = []) {
-        const stmt = getDb().prepare(sql);
-        return stmt.all(params);
+      static async select(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.select(sql, params);
       }
-      static selectOne(sql, params = []) {
-        const stmt = getDb().prepare(sql);
-        return stmt.get(params);
+      static async selectOne(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.selectOne(sql, params);
       }
-      static execute(sql, params = []) {
-        const stmt = getDb().prepare(sql);
-        const result = stmt.run(params);
-        return {
-          changes: result.changes,
-          lastInsertRowid: result.lastInsertRowid
-        };
+      static async execute(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.execute(sql, params);
       }
-      static transaction(callback) {
-        return getDb().transaction(callback)();
+      static async transaction(callback) {
+        const adapter2 = await getAdapter();
+        return adapter2.transaction(callback);
       }
       static paginate(sql, options = {}) {
         let query = sql;
@@ -631,17 +828,12 @@ var init_query_builder = __esm({
 });
 
 // src/infra/database/index.ts
-function getDb2() {
-  return databaseConnectionManager.getConnection();
-}
-var database_default;
 var init_database = __esm({
   "src/infra/database/index.ts"() {
     "use strict";
     init_esm_shims();
     init_connection();
     init_query_builder();
-    database_default = getDb2;
   }
 });
 
@@ -665,22 +857,22 @@ var init_portals_model = __esm({
     init_database();
     PortalsModel = class {
       static TABLE = "portals";
-      static findByPortalAddress(portalAddress) {
+      static async findByPortalAddress(portalAddress) {
         const sql = `SELECT _id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt FROM ${this.TABLE} WHERE portalAddress = ?`;
         return QueryBuilder.selectOne(sql, [portalAddress]);
       }
-      static create(input) {
+      static async create(input) {
         const _id = uuidv72();
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const sql = `INSERT INTO ${this.TABLE} (_id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)`;
-        QueryBuilder.execute(sql, [_id, input.portalAddress, input.portalSeed, input.ownerAddress, now, now]);
-        const created = this.findByPortalAddress(input.portalAddress);
+        await QueryBuilder.execute(sql, [_id, input.portalAddress, input.portalSeed, input.ownerAddress, now, now]);
+        const created = await this.findByPortalAddress(input.portalAddress);
         if (!created) {
           throw new Error("Failed to create portal");
         }
         return created;
       }
-      static update(portalAddress, input) {
+      static async update(portalAddress, input) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const keys = [];
         const values = [];
@@ -695,15 +887,15 @@ var init_portals_model = __esm({
         const updateChain = keys.join(", ");
         const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE portalAddress = ?`;
         values.push(portalAddress);
-        QueryBuilder.execute(sql, values);
-        const updated = this.findByPortalAddress(portalAddress);
+        await QueryBuilder.execute(sql, values);
+        const updated = await this.findByPortalAddress(portalAddress);
         if (!updated) {
           throw new Error("Failed to update portal");
         }
         return updated;
       }
-      static upsert(input) {
-        const existing = this.findByPortalAddress(input.portalAddress);
+      static async upsert(input) {
+        const existing = await this.findByPortalAddress(input.portalAddress);
         if (existing) {
           return this.update(input.portalAddress, {
             portalSeed: input.portalSeed,
@@ -726,12 +918,12 @@ var init_apikeys_model = __esm({
     init_database();
     ApiKeysModel = class {
       static TABLE = "api_keys";
-      static create(input) {
+      static async create(input) {
         const _id = uuidv73();
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        const sql = `INSERT INTO ${this.TABLE} (_id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt) 
+        const sql = `INSERT INTO ${this.TABLE} (_id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt)
     VALUES (?, ?, ?, ?, ?, ?)`;
-        const result = QueryBuilder.execute(sql, [
+        const result = await QueryBuilder.execute(sql, [
           _id,
           input.apiKeySeed,
           input.name,
@@ -742,29 +934,29 @@ var init_apikeys_model = __esm({
         if (result.changes === 0) {
           throw new Error("Failed to create API key");
         }
-        const created = this.findById(_id);
+        const created = await this.findById(_id);
         if (!created) {
           throw new Error("Failed to create API key");
         }
         return created;
       }
-      static findById(_id) {
+      static async findById(_id) {
         const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE _id = ? AND isDeleted = 0`;
         return QueryBuilder.selectOne(sql, [_id]);
       }
-      static findByCollaboratorAddress(collaboratorAddress) {
+      static async findByCollaboratorAddress(collaboratorAddress) {
         const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE collaboratorAddress = ? AND isDeleted = 0 LIMIT 1`;
         return QueryBuilder.selectOne(sql, [collaboratorAddress]);
       }
-      static delete(_id) {
+      static async delete(_id) {
         const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
-        QueryBuilder.execute(sql, [_id]);
+        await QueryBuilder.execute(sql, [_id]);
       }
-      static findByPortalAddress(portalAddress) {
+      static async findByPortalAddress(portalAddress) {
         const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE portalAddress = ? AND isDeleted = 0`;
         return QueryBuilder.selectOne(sql, [portalAddress]);
       }
-      static findByApiKey(apiKey) {
+      static async findByApiKey(apiKey) {
         const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE apiKeySeed = ? AND isDeleted = 0`;
         return QueryBuilder.selectOne(sql, [apiKey]);
       }
@@ -806,7 +998,7 @@ var init_models = __esm({
 });
 
 // src/domain/portal/savePortal.ts
-function savePortal(input) {
+async function savePortal(input) {
   if (!input.portalAddress || !input.portalSeed || !input.ownerAddress) {
     throw new Error("portalAddress, portalSeed, and ownerAddress are required");
   }
@@ -825,9 +1017,9 @@ var migrations_exports = {};
 __export(migrations_exports, {
   runMigrations: () => runMigrations
 });
-function runMigrations() {
-  const db = database_default();
-  db.exec(STABLE_SCHEMA);
+async function runMigrations() {
+  const adapter2 = await getAdapter();
+  await adapter2.exec(STABLE_SCHEMA);
   logger.debug("Database schema ready");
 }
 var STABLE_SCHEMA;
@@ -835,7 +1027,7 @@ var init_migrations = __esm({
   "src/infra/database/migrations/index.ts"() {
     "use strict";
     init_esm_shims();
-    init_database();
+    init_connection();
     init_infra();
     STABLE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS files (
@@ -846,8 +1038,8 @@ CREATE TABLE IF NOT EXISTS files (
   localVersion INTEGER NOT NULL DEFAULT 1,
   onchainVersion INTEGER NOT NULL DEFAULT 0,
   syncStatus TEXT NOT NULL DEFAULT 'pending',
-  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
   isDeleted INTEGER NOT NULL DEFAULT 0,
   portalAddress TEXT NOT NULL,
   metadata TEXT DEFAULT '{}',
@@ -867,8 +1059,8 @@ CREATE TABLE IF NOT EXISTS portals (
   portalAddress TEXT NOT NULL UNIQUE,
   portalSeed TEXT NOT NULL UNIQUE,
   ownerAddress TEXT NOT NULL,
-  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
+  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE TABLE IF NOT EXISTS api_keys (
@@ -877,7 +1069,7 @@ CREATE TABLE IF NOT EXISTS api_keys (
   name TEXT NOT NULL,
   collaboratorAddress TEXT NOT NULL UNIQUE,
   portalAddress TEXT NOT NULL,
-  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
   isDeleted INTEGER NOT NULL DEFAULT 0
 );
 
@@ -913,8 +1105,8 @@ CREATE TABLE IF NOT EXISTS folders (
   lastTransactionHash TEXT,
   lastTransactionBlockNumber INTEGER NOT NULL,
   lastTransactionBlockTimestamp INTEGER NOT NULL,
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 CREATE INDEX IF NOT EXISTS idx_folders_folderRef_folderId ON folders(folderRef, folderId);
 CREATE INDEX IF NOT EXISTS idx_folders_folderRef ON folders(folderRef);
@@ -1148,16 +1340,16 @@ import { toUint8Array as toUint8Array5 } from "js-base64";
 import { stringToBytes as stringToBytes2 } from "viem";
 import { toAESKey as toAESKey2, aesDecrypt } from "@fileverse/crypto/webcrypto";
 var SAVED_DATA_ENCRYPTION_KEY_INFO = "SAVED_DATA_ENCRYPTION_KEY";
-function initializeWithData(data) {
+async function initializeWithData(data) {
   const { keyMaterial, appMaterial } = data;
-  savePortal({
+  await savePortal({
     portalAddress: appMaterial.portalAddress,
     portalSeed: appMaterial.portalSeed,
     ownerAddress: appMaterial.ownerAddress
   });
-  const existingApiKey = ApiKeysModel.findByApiKey(keyMaterial.apiKeySeed);
+  const existingApiKey = await ApiKeysModel.findByApiKey(keyMaterial.apiKeySeed);
   if (!existingApiKey) {
-    addApiKey({
+    await addApiKey({
       apiKeySeed: keyMaterial.apiKeySeed,
       name: keyMaterial.name,
       collaboratorAddress: keyMaterial.collaboratorAddress,
@@ -1212,9 +1404,9 @@ var program = new Command().name("fileverse-api").description("Run the Fileverse
     console.log(`\u2713 Configuration saved to ${envPath}
 `);
     const { runMigrations: runMigrations2 } = await Promise.resolve().then(() => (init_migrations(), migrations_exports));
-    runMigrations2();
+    await runMigrations2();
     console.log("\u2713 Database migrations complete");
-    const result = initializeWithData({
+    const result = await initializeWithData({
       keyMaterial,
       appMaterial,
       id: data.id