@fileverse/api 0.0.2 → 0.0.3

package/dist/cli/index.js

@@ -75,9 +75,6 @@ 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;
     },
@@ -124,9 +121,6 @@ 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;
       },
@@ -388,11 +382,11 @@ var init_publish = __esm({
 });
 
 // src/domain/portal/saveApiKey.ts
-async function addApiKey(input) {
+function addApiKey(input) {
   if (!input.apiKeySeed || !input.name || !input.collaboratorAddress || !input.portalAddress) {
     throw new Error("apiKeySeed, name, collaboratorAddress, and portalAddress are required");
   }
-  const portal = await PortalsModel.findByPortalAddress(input.portalAddress);
+  const portal = PortalsModel.findByPortalAddress(input.portalAddress);
   if (!portal) {
     throw new Error(`Portal with address ${input.portalAddress} does not exist`);
   }
@@ -528,251 +522,51 @@ var init_infra = __esm({
   }
 });
 
-// src/infra/database/adapters/sqlite-adapter.ts
+// src/infra/database/connection.ts
 import Database from "better-sqlite3";
-var SqliteAdapter;
-var init_sqlite_adapter = __esm({
-  "src/infra/database/adapters/sqlite-adapter.ts"() {
+var DatabaseConnectionManager, databaseConnectionManager;
+var init_connection = __esm({
+  "src/infra/database/connection.ts"() {
     "use strict";
     init_esm_shims();
-    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}`);
-      }
-      async select(sql, params = []) {
-        const stmt = this.db.prepare(sql);
-        return stmt.all(params);
-      }
-      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;
-        }
-      }
-      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;
+    DatabaseConnectionManager = class _DatabaseConnectionManager {
+      static instance;
+      db = null;
+      constructor() {
       }
-      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;
+      static getInstance() {
+        if (!_DatabaseConnectionManager.instance) {
+          _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
         }
+        return _DatabaseConnectionManager.instance;
       }
-      async exec(sql) {
-        await this.client.query(sql);
+      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}`);
+        }
+        return this.db;
       }
       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"})`);
-      }
-      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();
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+          logger.info("Database connection closed");
         }
       }
-      async exec(sql) {
-        await this.pool.query(sql);
-      }
-      async close() {
-        await this.pool.end();
-        logger.info("PostgreSQL pool 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() {
-  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;
+    databaseConnectionManager = DatabaseConnectionManager.getInstance();
   }
 });
 
@@ -787,6 +581,9 @@ 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"() {
@@ -795,17 +592,24 @@ var init_query_builder = __esm({
     init_connection();
     init_constants3();
     QueryBuilder = class {
-      static async select(sql, params = []) {
-        return getAdapterSync().select(sql, params);
+      static select(sql, params = []) {
+        const stmt = getDb().prepare(sql);
+        return stmt.all(params);
       }
-      static async selectOne(sql, params = []) {
-        return getAdapterSync().selectOne(sql, params);
+      static selectOne(sql, params = []) {
+        const stmt = getDb().prepare(sql);
+        return stmt.get(params);
       }
-      static async execute(sql, params = []) {
-        return getAdapterSync().execute(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 transaction(callback) {
-        return getAdapterSync().transaction(callback);
+      static transaction(callback) {
+        return getDb().transaction(callback)();
       }
       static paginate(sql, options = {}) {
         let query = sql;
@@ -827,12 +631,17 @@ 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;
   }
 });
 
@@ -856,22 +665,22 @@ var init_portals_model = __esm({
     init_database();
     PortalsModel = class {
       static TABLE = "portals";
-      static async findByPortalAddress(portalAddress) {
+      static findByPortalAddress(portalAddress) {
         const sql = `SELECT _id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt FROM ${this.TABLE} WHERE portalAddress = ?`;
         return QueryBuilder.selectOne(sql, [portalAddress]);
       }
-      static async create(input) {
+      static create(input) {
         const _id = uuidv72();
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const sql = `INSERT INTO ${this.TABLE} (_id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)`;
-        await QueryBuilder.execute(sql, [_id, input.portalAddress, input.portalSeed, input.ownerAddress, now, now]);
-        const created = await this.findByPortalAddress(input.portalAddress);
+        QueryBuilder.execute(sql, [_id, input.portalAddress, input.portalSeed, input.ownerAddress, now, now]);
+        const created = this.findByPortalAddress(input.portalAddress);
         if (!created) {
           throw new Error("Failed to create portal");
         }
         return created;
       }
-      static async update(portalAddress, input) {
+      static update(portalAddress, input) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const keys = [];
         const values = [];
@@ -886,15 +695,15 @@ var init_portals_model = __esm({
         const updateChain = keys.join(", ");
         const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE portalAddress = ?`;
         values.push(portalAddress);
-        await QueryBuilder.execute(sql, values);
-        const updated = await this.findByPortalAddress(portalAddress);
+        QueryBuilder.execute(sql, values);
+        const updated = this.findByPortalAddress(portalAddress);
         if (!updated) {
           throw new Error("Failed to update portal");
         }
         return updated;
       }
-      static async upsert(input) {
-        const existing = await this.findByPortalAddress(input.portalAddress);
+      static upsert(input) {
+        const existing = this.findByPortalAddress(input.portalAddress);
         if (existing) {
           return this.update(input.portalAddress, {
             portalSeed: input.portalSeed,
@@ -917,12 +726,12 @@ var init_apikeys_model = __esm({
     init_database();
     ApiKeysModel = class {
       static TABLE = "api_keys";
-      static async create(input) {
+      static 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 = await QueryBuilder.execute(sql, [
+        const result = QueryBuilder.execute(sql, [
           _id,
           input.apiKeySeed,
           input.name,
@@ -933,29 +742,29 @@ var init_apikeys_model = __esm({
         if (result.changes === 0) {
           throw new Error("Failed to create API key");
         }
-        const created = await this.findById(_id);
+        const created = this.findById(_id);
         if (!created) {
           throw new Error("Failed to create API key");
         }
         return created;
       }
-      static async findById(_id) {
+      static 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 async findByCollaboratorAddress(collaboratorAddress) {
+      static 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 async delete(_id) {
+      static delete(_id) {
         const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
-        await QueryBuilder.execute(sql, [_id]);
+        QueryBuilder.execute(sql, [_id]);
       }
-      static async findByPortalAddress(portalAddress) {
+      static 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 async findByApiKey(apiKey) {
+      static 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]);
       }
@@ -997,7 +806,7 @@ var init_models = __esm({
 });
 
 // src/domain/portal/savePortal.ts
-async function savePortal(input) {
+function savePortal(input) {
   if (!input.portalAddress || !input.portalSeed || !input.ownerAddress) {
     throw new Error("portalAddress, portalSeed, and ownerAddress are required");
   }
@@ -1016,9 +825,9 @@ var migrations_exports = {};
 __export(migrations_exports, {
   runMigrations: () => runMigrations
 });
-async function runMigrations() {
-  const adapter2 = getAdapterSync();
-  await adapter2.exec(STABLE_SCHEMA);
+function runMigrations() {
+  const db = database_default();
+  db.exec(STABLE_SCHEMA);
   logger.debug("Database schema ready");
 }
 var STABLE_SCHEMA;
@@ -1026,7 +835,7 @@ var init_migrations = __esm({
   "src/infra/database/migrations/index.ts"() {
     "use strict";
     init_esm_shims();
-    init_connection();
+    init_database();
     init_infra();
     STABLE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS files (
@@ -1037,8 +846,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 TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
   isDeleted INTEGER NOT NULL DEFAULT 0,
   portalAddress TEXT NOT NULL,
   metadata TEXT DEFAULT '{}',
@@ -1058,8 +867,8 @@ CREATE TABLE IF NOT EXISTS portals (
   portalAddress TEXT NOT NULL UNIQUE,
   portalSeed TEXT NOT NULL UNIQUE,
   ownerAddress TEXT NOT NULL,
-  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE TABLE IF NOT EXISTS api_keys (
@@ -1068,7 +877,7 @@ CREATE TABLE IF NOT EXISTS api_keys (
   name TEXT NOT NULL,
   collaboratorAddress TEXT NOT NULL UNIQUE,
   portalAddress TEXT NOT NULL,
-  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
   isDeleted INTEGER NOT NULL DEFAULT 0
 );
 
@@ -1104,8 +913,8 @@ CREATE TABLE IF NOT EXISTS folders (
   lastTransactionHash TEXT,
   lastTransactionBlockNumber INTEGER NOT NULL,
   lastTransactionBlockTimestamp INTEGER NOT NULL,
-  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME 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);
@@ -1339,16 +1148,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";
-async function initializeWithData(data) {
+function initializeWithData(data) {
   const { keyMaterial, appMaterial } = data;
-  await savePortal({
+  savePortal({
     portalAddress: appMaterial.portalAddress,
     portalSeed: appMaterial.portalSeed,
     ownerAddress: appMaterial.ownerAddress
   });
-  const existingApiKey = await ApiKeysModel.findByApiKey(keyMaterial.apiKeySeed);
+  const existingApiKey = ApiKeysModel.findByApiKey(keyMaterial.apiKeySeed);
   if (!existingApiKey) {
-    await addApiKey({
+    addApiKey({
       apiKeySeed: keyMaterial.apiKeySeed,
       name: keyMaterial.name,
       collaboratorAddress: keyMaterial.collaboratorAddress,
@@ -1377,7 +1186,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,12 +1211,10 @@ 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();
+    runMigrations2();
     console.log("\u2713 Database migrations complete");
-    const result = await initializeWithData({
+    const result = initializeWithData({
       keyMaterial,
       appMaterial,
       id: data.id