@fileverse/api 0.0.1 → 0.0.2

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,51 +528,251 @@ var init_infra = __esm({
   }
 });
 
-// src/infra/database/connection.ts
+// src/infra/database/adapters/sqlite-adapter.ts
 import Database from "better-sqlite3";
-var DatabaseConnectionManager, databaseConnectionManager;
-var init_connection = __esm({
-  "src/infra/database/connection.ts"() {
+var SqliteAdapter;
+var init_sqlite_adapter = __esm({
+  "src/infra/database/adapters/sqlite-adapter.ts"() {
     "use strict";
     init_esm_shims();
-    init_config();
     init_infra();
-    DatabaseConnectionManager = class _DatabaseConnectionManager {
-      static instance;
-      db = null;
-      constructor() {
+    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}`);
+      }
+      async select(sql, params = []) {
+        const stmt = this.db.prepare(sql);
+        return stmt.all(params);
       }
-      static getInstance() {
-        if (!_DatabaseConnectionManager.instance) {
-          _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
+      async selectOne(sql, params = []) {
+        const stmt = this.db.prepare(sql);
+        return stmt.get(params);
+      }
+      async execute(sql, params = []) {
+        const stmt = this.db.prepare(sql);
+        const result = stmt.run(params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
+      }
+      async transaction(callback) {
+        this.db.exec("SAVEPOINT txn");
+        try {
+          const result = await callback(this);
+          this.db.exec("RELEASE txn");
+          return result;
+        } catch (err) {
+          this.db.exec("ROLLBACK TO txn");
+          throw err;
         }
-        return _DatabaseConnectionManager.instance;
       }
-      getConnection() {
-        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.pragma("journal_mode = WAL");
-          this.db.pragma("foreign_keys = ON");
-          this.db.prepare("SELECT 1").get();
-          logger.info(`SQLite database connected: ${dbPath}`);
+      async exec(sql) {
+        this.db.exec(sql);
+      }
+      async close() {
+        this.db.close();
+        logger.info("Database connection closed");
+      }
+    };
+  }
+});
+
+// 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"() {
+    "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 };
+      }
+      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;
         }
-        return this.db;
+      }
+      async exec(sql) {
+        await this.client.query(sql);
       }
       async close() {
-        if (this.db) {
-          this.db.close();
-          this.db = null;
-          logger.info("Database connection closed");
+      }
+    };
+    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"})`);
+      }
+      async select(sql, params = []) {
+        const result = await this.pool.query(translateParams(sql), params);
+        return result.rows.map((row) => mapRow(row));
+      }
+      async selectOne(sql, params = []) {
+        const result = await this.pool.query(translateParams(sql), params);
+        return result.rows[0] ? mapRow(result.rows[0]) : void 0;
+      }
+      async execute(sql, params = []) {
+        const result = await this.pool.query(translateParams(sql), params);
+        return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
+      }
+      async transaction(callback) {
+        const client = await this.pool.connect();
+        try {
+          await client.query("BEGIN");
+          const clientAdapter = new PgClientAdapter(client);
+          const result = await callback(clientAdapter);
+          await client.query("COMMIT");
+          return result;
+        } catch (err) {
+          await client.query("ROLLBACK");
+          throw err;
+        } finally {
+          client.release();
         }
       }
-      isConnected() {
-        return this.db !== null && this.db.open;
+      async exec(sql) {
+        await this.pool.query(sql);
+      }
+      async close() {
+        await this.pool.end();
+        logger.info("PostgreSQL pool closed");
       }
     };
-    databaseConnectionManager = DatabaseConnectionManager.getInstance();
+  }
+});
+
+// src/infra/database/connection.ts
+var connection_exports = {};
+__export(connection_exports, {
+  closeAdapter: () => closeAdapter,
+  getAdapter: () => getAdapter,
+  getAdapterSync: () => getAdapterSync
+});
+async function getAdapter() {
+  if (adapter) return adapter;
+  const databaseUrl = config.DATABASE_URL;
+  const dbPath = config.DB_PATH;
+  if (databaseUrl) {
+    adapter = new PgAdapter(databaseUrl);
+  } else if (dbPath) {
+    adapter = new SqliteAdapter(dbPath);
+  } 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."
+    );
+  }
+  return adapter;
+}
+async function closeAdapter() {
+  if (adapter) {
+    await adapter.close();
+    adapter = null;
+  }
+}
+var adapter;
+var init_connection = __esm({
+  "src/infra/database/connection.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_adapter();
+    init_pg_adapter();
+    init_config();
+    adapter = null;
   }
 });
 
@@ -581,9 +787,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 +795,17 @@ 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 = []) {
+        return getAdapterSync().select(sql, params);
       }
-      static selectOne(sql, params = []) {
-        const stmt = getDb().prepare(sql);
-        return stmt.get(params);
+      static async selectOne(sql, params = []) {
+        return getAdapterSync().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 = []) {
+        return getAdapterSync().execute(sql, params);
       }
-      static transaction(callback) {
-        return getDb().transaction(callback)();
+      static async transaction(callback) {
+        return getAdapterSync().transaction(callback);
       }
       static paginate(sql, options = {}) {
         let query = sql;
@@ -631,17 +827,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 +856,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 +886,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 +917,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 +933,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 +997,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 +1016,9 @@ var migrations_exports = {};
 __export(migrations_exports, {
   runMigrations: () => runMigrations
 });
-function runMigrations() {
-  const db = database_default();
-  db.exec(STABLE_SCHEMA);
+async function runMigrations() {
+  const adapter2 = getAdapterSync();
+  await adapter2.exec(STABLE_SCHEMA);
   logger.debug("Database schema ready");
 }
 var STABLE_SCHEMA;
@@ -835,7 +1026,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 +1037,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 +1058,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 +1068,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 +1104,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 +1339,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,
@@ -1186,7 +1377,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.1").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.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) => {
   try {
     console.log("Fileverse API - Starting initialization...\n");
     if (needsPrompting(options)) {
@@ -1211,10 +1402,12 @@ 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));
-    runMigrations2();
+    await runMigrations2();
     console.log("\u2713 Database migrations complete");
-    const result = initializeWithData({
+    const result = await initializeWithData({
       keyMaterial,
       appMaterial,
       id: data.id