@fileverse/api 0.0.2 → 0.0.3

package/dist/index.js

@@ -57,9 +57,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;
     },
@@ -71,19 +68,16 @@ function getRuntimeConfig() {
     }
   };
 }
-function validateDbConfig() {
+function validateDbPath() {
   const dbPath = process.env.DB_PATH;
-  const databaseUrl = process.env.DATABASE_URL;
-  if (!dbPath && !databaseUrl) {
-    console.error("Error: Either DB_PATH or DATABASE_URL environment variable is required");
-    console.error("Please set DB_PATH or DATABASE_URL in your .env file (config/.env or ~/.fileverse/.env) or run the CLI first");
+  if (!dbPath) {
+    console.error("Error: DB_PATH environment variable is required");
+    console.error("Please set DB_PATH in your .env file (config/.env or ~/.fileverse/.env) or run the CLI first");
     process.exit(1);
   }
-  if (dbPath && !databaseUrl) {
-    const dbDir = path2.dirname(dbPath.trim());
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true });
-    }
+  const dbDir = path2.dirname(dbPath.trim());
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
   }
 }
 var config = {
@@ -112,9 +106,6 @@ var config = {
   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;
   },
@@ -207,237 +198,71 @@ var asyncHandlerArray = (resolvers) => {
   return resolvers.map(asyncHandler);
 };
 
-// src/infra/database/adapters/sqlite-adapter.ts
+// src/infra/database/connection.ts
 import Database from "better-sqlite3";
-var 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
-    };
+var DatabaseConnectionManager = class _DatabaseConnectionManager {
+  static instance;
+  db = null;
+  constructor() {
   }
-  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;
+  static getInstance() {
+    if (!_DatabaseConnectionManager.instance) {
+      _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
     }
+    return _DatabaseConnectionManager.instance;
   }
-  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";
-var { Pool } = pg;
-var 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"
-};
-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 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;
+  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) {
-    await this.client.query(sql);
+    return this.db;
   }
   async close() {
-  }
-};
-var PgAdapter = class {
-  pool;
-  constructor(connectionString) {
-    const url2 = new URL(connectionString);
-    const isLocal = url2.hostname === "localhost" || url2.hostname === "127.0.0.1" || url2.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: url2.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 adapter = null;
-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 databaseConnectionManager = DatabaseConnectionManager.getInstance();
 
 // src/domain/file/constants.ts
 var DEFAULT_LIST_LIMIT = 10;
 
 // src/infra/database/query-builder.ts
+function getDb() {
+  return databaseConnectionManager.getConnection();
+}
 var 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;
@@ -456,6 +281,15 @@ var QueryBuilder = class {
   }
 };
 
+// src/infra/database/index.ts
+function getDb2() {
+  return databaseConnectionManager.getConnection();
+}
+var closeDatabase = async () => {
+  await databaseConnectionManager.close();
+};
+var database_default = getDb2;
+
 // src/infra/database/models/files.model.ts
 import { uuidv7 } from "uuidv7";
 var FilesModel = class {
@@ -489,15 +323,15 @@ var FilesModel = class {
       link: fileRaw.link
     };
   }
-  static async findAll(portalAddress, limit, skip) {
+  static findAll(portalAddress, limit, skip) {
     const whereClause = "isDeleted = 0 AND portalAddress = ?";
     const params = [portalAddress];
     const countSql = `
-      SELECT COUNT(*) as count
-      FROM ${this.TABLE}
+      SELECT COUNT(*) as count 
+      FROM ${this.TABLE} 
       WHERE ${whereClause}
     `;
-    const totalResult = await QueryBuilder.selectOne(countSql, params);
+    const totalResult = QueryBuilder.selectOne(countSql, params);
     const total = totalResult?.count || 0;
     const sql = `
       SELECT *
@@ -510,51 +344,51 @@ var FilesModel = class {
       orderBy: "createdAt",
       orderDirection: "DESC"
     });
-    const filesRaw = await QueryBuilder.select(completeSql, params);
+    const filesRaw = QueryBuilder.select(completeSql, params);
     const files = filesRaw.map(this.parseFile);
     const hasNext = skip !== void 0 && limit !== void 0 ? skip + limit < total : false;
     return { files, total, hasNext };
   }
-  static async findById(_id, portalAddress) {
+  static findById(_id, portalAddress) {
     const sql = `
       SELECT *
-      FROM ${this.TABLE}
+      FROM ${this.TABLE} 
       WHERE _id = ? AND isDeleted = 0 AND portalAddress = ?
     `;
-    const result = await QueryBuilder.selectOne(sql, [_id, portalAddress]);
+    const result = QueryBuilder.selectOne(sql, [_id, portalAddress]);
     return result ? this.parseFile(result) : void 0;
   }
-  static async findByIdIncludingDeleted(_id) {
+  static findByIdIncludingDeleted(_id) {
     const sql = `
       SELECT *
-      FROM ${this.TABLE}
+      FROM ${this.TABLE} 
       WHERE _id = ?
     `;
-    const result = await QueryBuilder.selectOne(sql, [_id]);
+    const result = QueryBuilder.selectOne(sql, [_id]);
     return result ? this.parseFile(result) : void 0;
   }
-  static async findByIdExcludingDeleted(_id) {
+  static findByIdExcludingDeleted(_id) {
     const sql = `
       SELECT *
-      FROM ${this.TABLE}
+      FROM ${this.TABLE} 
       WHERE _id = ? AND isDeleted = 0
     `;
-    const result = await QueryBuilder.selectOne(sql, [_id]);
+    const result = QueryBuilder.selectOne(sql, [_id]);
     return result ? this.parseFile(result) : void 0;
   }
-  static async findByDDocId(ddocId, portalAddress) {
+  static findByDDocId(ddocId, portalAddress) {
     const sql = `
       SELECT *
-      FROM ${this.TABLE}
+      FROM ${this.TABLE} 
       WHERE ddocId = ? AND isDeleted = 0 AND portalAddress = ?
     `;
-    const result = await QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
+    const result = QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
     return result ? this.parseFile(result) : void 0;
   }
-  static async searchByTitle(searchTerm, portalAddress, limit, skip) {
+  static searchByTitle(searchTerm, portalAddress, limit, skip) {
     const sql = `
       SELECT *
-      FROM ${this.TABLE}
+      FROM ${this.TABLE} 
       WHERE LOWER(title) LIKE LOWER(?) AND isDeleted = 0 AND portalAddress = ?
     `;
     const completeSql = QueryBuilder.paginate(sql, {
@@ -563,24 +397,24 @@ var FilesModel = class {
       orderBy: "createdAt",
       orderDirection: "DESC"
     });
-    const filesRaw = await QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
+    const filesRaw = QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
     return filesRaw.map(this.parseFile);
   }
-  static async create(input) {
+  static create(input) {
     const _id = uuidv7();
     const sql = `
-      INSERT INTO ${this.TABLE}
-      (_id, title, content, ddocId, portalAddress)
+      INSERT INTO ${this.TABLE} 
+      (_id, title, content, ddocId, portalAddress) 
       VALUES (?, ?, ?, ?, ?)
     `;
-    await QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
-    const created = await this.findById(_id, input.portalAddress);
+    QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
+    const created = this.findById(_id, input.portalAddress);
     if (!created) {
       throw new Error("Failed to create file");
     }
     return created;
   }
-  static async update(_id, payload, portalAddress) {
+  static update(_id, payload, portalAddress) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const keys = [];
     const values = [];
@@ -599,22 +433,22 @@ var FilesModel = class {
     values.push(now, _id, portalAddress);
     const updateChain = keys.join(", ");
     const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE _id = ? AND portalAddress = ?`;
-    await QueryBuilder.execute(sql, values);
-    const updated = await this.findById(_id, portalAddress);
+    QueryBuilder.execute(sql, values);
+    const updated = this.findById(_id, portalAddress);
     if (!updated) {
       throw new Error("Failed to update file");
     }
     return updated;
   }
-  static async softDelete(_id) {
+  static softDelete(_id) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const sql = `
-      UPDATE ${this.TABLE}
+      UPDATE ${this.TABLE} 
       SET isDeleted = 1, syncStatus = 'pending', updatedAt = ?
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [now, _id]);
-    const deleted = await this.findByIdIncludingDeleted(_id);
+    QueryBuilder.execute(sql, [now, _id]);
+    const deleted = this.findByIdIncludingDeleted(_id);
     if (!deleted) {
       throw new Error("Failed to delete file");
     }
@@ -626,22 +460,22 @@ var FilesModel = class {
 import { uuidv7 as uuidv72 } from "uuidv7";
 var 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 = [];
@@ -656,15 +490,15 @@ var PortalsModel = class {
     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,
@@ -679,12 +513,12 @@ var PortalsModel = class {
 import { uuidv7 as uuidv73 } from "uuidv7";
 var 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,
@@ -695,29 +529,29 @@ var ApiKeysModel = class {
     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]);
   }
@@ -729,9 +563,9 @@ var FoldersModel = class {
   /**
    * List all folders with pagination
    */
-  static async findAll(limit, skip) {
+  static findAll(limit, skip) {
     const countSql = `SELECT COUNT(*) as count FROM ${this.TABLE} WHERE isDeleted = 0`;
-    const totalResult = await QueryBuilder.selectOne(countSql);
+    const totalResult = QueryBuilder.selectOne(countSql);
     const total = totalResult?.count || 0;
     const sql = QueryBuilder.paginate(`SELECT * FROM ${this.TABLE} WHERE isDeleted = 0`, {
       limit,
@@ -739,8 +573,7 @@ var FoldersModel = class {
       orderBy: "created_at",
       orderDirection: "DESC"
     });
-    const foldersRaw = await QueryBuilder.select(sql);
-    const folders = foldersRaw.map((folderRaw) => ({
+    const folders = QueryBuilder.select(sql).map((folderRaw) => ({
       ...folderRaw,
       isDeleted: Boolean(folderRaw.isDeleted)
     }));
@@ -751,9 +584,9 @@ var FoldersModel = class {
    * Get a single folder by folderRef and folderId
    * Includes ddocs array (as per API spec)
    */
-  static async findByFolderRefAndId(folderRef, folderId) {
+  static findByFolderRefAndId(folderRef, folderId) {
     const sql = `SELECT * FROM ${this.TABLE} WHERE folderRef = ? AND folderId = ? AND isDeleted = 0`;
-    const folderRaw = await QueryBuilder.selectOne(sql, [folderRef, folderId]);
+    const folderRaw = QueryBuilder.selectOne(sql, [folderRef, folderId]);
     if (!folderRaw) {
       return void 0;
     }
@@ -770,9 +603,9 @@ var FoldersModel = class {
   /**
    * Get folder by folderRef only
    */
-  static async findByFolderRef(folderRef) {
+  static findByFolderRef(folderRef) {
     const sql = `SELECT * FROM ${this.TABLE} WHERE folderRef = ? AND isDeleted = 0 LIMIT 1`;
-    const folderRaw = await QueryBuilder.selectOne(sql, [folderRef]);
+    const folderRaw = QueryBuilder.selectOne(sql, [folderRef]);
     if (!folderRaw) {
       return void 0;
     }
@@ -784,9 +617,9 @@ var FoldersModel = class {
   /**
    * Search folders by folderName (case-insensitive substring match)
    */
-  static async searchByName(searchTerm, limit, skip) {
+  static searchByName(searchTerm, limit, skip) {
     const sql = QueryBuilder.paginate(
-      `SELECT * FROM ${this.TABLE}
+      `SELECT * FROM ${this.TABLE} 
        WHERE isDeleted = 0 AND LOWER(folderName) LIKE LOWER(?)`,
       {
         limit,
@@ -795,7 +628,7 @@ var FoldersModel = class {
         orderDirection: "DESC"
       }
     );
-    const foldersRaw = await QueryBuilder.select(sql, [`%${searchTerm}%`]);
+    const foldersRaw = QueryBuilder.select(sql, [`%${searchTerm}%`]);
     return foldersRaw.map((folderRaw) => ({
       ...folderRaw,
       isDeleted: Boolean(folderRaw.isDeleted)
@@ -804,15 +637,15 @@ var FoldersModel = class {
   /**
    * Create a new folder
    */
-  static async create(input) {
+  static create(input) {
     const _id = input._id || `folder_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const sql = `INSERT INTO ${this.TABLE} (
       _id, onchainFileId, folderId, folderRef, folderName, portalAddress, metadataIPFSHash,
-      contentIPFSHash, isDeleted, lastTransactionHash, lastTransactionBlockNumber,
+      contentIPFSHash, isDeleted, lastTransactionHash, lastTransactionBlockNumber, 
       lastTransactionBlockTimestamp, created_at, updated_at
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-    await QueryBuilder.execute(sql, [
+    QueryBuilder.execute(sql, [
       _id,
       input.onchainFileId,
       input.folderId,
@@ -830,7 +663,7 @@ var FoldersModel = class {
       now
     ]);
     const selectSql = `SELECT * FROM ${this.TABLE} WHERE folderRef = ? AND folderId = ? AND isDeleted = 0`;
-    const folderRaw = await QueryBuilder.selectOne(selectSql, [input.folderRef, input.folderId]);
+    const folderRaw = QueryBuilder.selectOne(selectSql, [input.folderRef, input.folderId]);
     if (!folderRaw) {
       throw new Error("Failed to create folder");
     }
@@ -862,16 +695,16 @@ function onNewEvent(callback) {
 var RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
 var EventsModel = class {
   static TABLE = "events";
-  static async create(input) {
+  static create(input) {
     const _id = uuidv74();
     const timestamp = Date.now();
     const status = "pending";
     const sql = `
-      INSERT INTO ${this.TABLE}
-      (_id, type, timestamp, fileId, portalAddress, status, retryCount, lastError, lockedAt, nextRetryAt)
+      INSERT INTO ${this.TABLE} 
+      (_id, type, timestamp, fileId, portalAddress, status, retryCount, lastError, lockedAt, nextRetryAt) 
       VALUES (?, ?, ?, ?, ?, ?, 0, NULL, NULL, NULL)
     `;
-    await QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
+    QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
     notifyNewEvent();
     return {
       _id,
@@ -886,22 +719,22 @@ var EventsModel = class {
       nextRetryAt: null
     };
   }
-  static async findById(_id) {
+  static findById(_id) {
     const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
-    const row = await QueryBuilder.selectOne(sql, [_id]);
+    const row = QueryBuilder.selectOne(sql, [_id]);
     return row ? this.parseEvent(row) : void 0;
   }
-  static async findNextPending() {
+  static findNextPending() {
     const sql = `
       SELECT * FROM ${this.TABLE}
       WHERE status = 'pending'
       ORDER BY timestamp ASC
       LIMIT 1
     `;
-    const row = await QueryBuilder.selectOne(sql, []);
+    const row = QueryBuilder.selectOne(sql, []);
     return row ? this.parseEvent(row) : void 0;
   }
-  static async findNextEligible(lockedFileIds) {
+  static findNextEligible(lockedFileIds) {
     const now = Date.now();
     const exclusionClause = lockedFileIds.length > 0 ? `AND e1.fileId NOT IN (${lockedFileIds.map(() => "?").join(", ")})` : "";
     const sql = `
@@ -919,29 +752,29 @@ var EventsModel = class {
       LIMIT 1
     `;
     const params = [now, ...lockedFileIds];
-    const row = await QueryBuilder.selectOne(sql, params);
+    const row = QueryBuilder.selectOne(sql, params);
     return row ? this.parseEvent(row) : void 0;
   }
-  static async markProcessing(_id) {
+  static markProcessing(_id) {
     const sql = `
       UPDATE ${this.TABLE}
       SET status = 'processing',
           lockedAt = ?
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [Date.now(), _id]);
+    QueryBuilder.execute(sql, [Date.now(), _id]);
   }
-  static async markProcessed(_id) {
+  static markProcessed(_id) {
     const sql = `
       UPDATE ${this.TABLE}
       SET status = 'processed',
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [_id]);
+    QueryBuilder.execute(sql, [_id]);
   }
-  static async scheduleRetry(_id, errorMsg) {
-    const event = await this.findById(_id);
+  static scheduleRetry(_id, errorMsg) {
+    const event = this.findById(_id);
     if (!event) return;
     const delay = RETRY_DELAYS_MS[Math.min(event.retryCount, RETRY_DELAYS_MS.length - 1)];
     const nextRetryAt = Date.now() + delay;
@@ -954,9 +787,9 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
   }
-  static async scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
+  static scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
     const nextRetryAt = Date.now() + retryAfterMs;
     const sql = `
       UPDATE ${this.TABLE}
@@ -966,9 +799,9 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
   }
-  static async markFailed(_id, errorMsg) {
+  static markFailed(_id, errorMsg) {
     const sql = `
       UPDATE ${this.TABLE}
       SET status = 'failed',
@@ -976,9 +809,9 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [errorMsg, _id]);
+    QueryBuilder.execute(sql, [errorMsg, _id]);
   }
-  static async listFailed(portalAddress) {
+  static listFailed(portalAddress) {
     const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
     const sql = `
       SELECT * FROM ${this.TABLE}
@@ -987,10 +820,10 @@ var EventsModel = class {
       ORDER BY timestamp ASC
     `;
     const params = portalAddress != null ? [portalAddress] : [];
-    const rows = await QueryBuilder.select(sql, params);
+    const rows = QueryBuilder.select(sql, params);
     return rows.map((row) => this.parseEvent(row));
   }
-  static async resetFailedToPending(_id, portalAddress) {
+  static resetFailedToPending(_id, portalAddress) {
     const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
     const sql = `
       UPDATE ${this.TABLE}
@@ -1004,13 +837,13 @@ var EventsModel = class {
       ${portalClause}
     `;
     const params = portalAddress != null ? [_id, portalAddress] : [_id];
-    const result = await QueryBuilder.execute(sql, params);
+    const result = QueryBuilder.execute(sql, params);
     if (result.changes > 0) {
       notifyNewEvent();
     }
     return result.changes > 0;
   }
-  static async resetAllFailedToPending(portalAddress) {
+  static resetAllFailedToPending(portalAddress) {
     const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
     const sql = `
       UPDATE ${this.TABLE}
@@ -1023,13 +856,13 @@ var EventsModel = class {
       ${portalClause}
     `;
     const params = portalAddress != null ? [portalAddress] : [];
-    const result = await QueryBuilder.execute(sql, params);
+    const result = QueryBuilder.execute(sql, params);
     if (result.changes > 0) {
       notifyNewEvent();
     }
     return result.changes;
   }
-  static async resetStaleEvents(staleThreshold) {
+  static resetStaleEvents(staleThreshold) {
     const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
@@ -1040,16 +873,16 @@ var EventsModel = class {
       AND lockedAt IS NOT NULL
       AND lockedAt < ?
     `;
-    const result = await QueryBuilder.execute(sql, [staleThreshold]);
+    const result = QueryBuilder.execute(sql, [staleThreshold]);
     return result.changes;
   }
-  static async setEventPendingOp(_id, userOpHash, payload) {
+  static setEventPendingOp(_id, userOpHash, payload) {
     const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
-    await QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
+    QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
   }
-  static async clearEventPendingOp(_id) {
+  static clearEventPendingOp(_id) {
     const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
-    await QueryBuilder.execute(sql, [_id]);
+    QueryBuilder.execute(sql, [_id]);
   }
   static parseEvent(row) {
     return {
@@ -2637,12 +2470,12 @@ var FileManager = class {
 };
 
 // src/domain/portal/publish.ts
-async function getPortalData(fileId) {
-  const file2 = await FilesModel.findByIdIncludingDeleted(fileId);
+function getPortalData(fileId) {
+  const file2 = FilesModel.findByIdIncludingDeleted(fileId);
   if (!file2) {
     throw new Error(`File with _id ${fileId} not found`);
   }
-  const portalDetails = await PortalsModel.findByPortalAddress(file2.portalAddress);
+  const portalDetails = PortalsModel.findByPortalAddress(file2.portalAddress);
   if (!portalDetails) {
     throw new Error(`Portal with address ${file2.portalAddress} not found`);
   }
@@ -2682,7 +2515,7 @@ var executeOperation = async (fileManager, file2, operation) => {
 };
 var handleExistingFileOp = async (fileId, operation) => {
   try {
-    const { file: file2, portalDetails, apiKey } = await getPortalData(fileId);
+    const { file: file2, portalDetails, apiKey } = getPortalData(fileId);
     const apiKeySeed = toUint8Array3(apiKey);
     const { privateAccountKey, ucanSecret } = deriveCollaboratorKeys(apiKeySeed);
     const fileManager = await createFileManager(
@@ -2698,7 +2531,7 @@ var handleExistingFileOp = async (fileId, operation) => {
   }
 };
 var handleNewFileOp = async (fileId) => {
-  const { file: file2, portalDetails, apiKey } = await getPortalData(fileId);
+  const { file: file2, portalDetails, apiKey } = getPortalData(fileId);
   const apiKeySeed = toUint8Array3(apiKey);
   const { privateAccountKey, ucanSecret } = deriveCollaboratorKeys(apiKeySeed);
   const fileManager = await createFileManager(
@@ -2710,7 +2543,7 @@ var handleNewFileOp = async (fileId) => {
   return fileManager.submitAddFileTrx(file2);
 };
 var getProxyAuthParams = async (fileId) => {
-  const { portalDetails, apiKey } = await getPortalData(fileId);
+  const { portalDetails, apiKey } = getPortalData(fileId);
   const apiKeySeed = toUint8Array3(apiKey);
   const { privateAccountKey, ucanSecret } = deriveCollaboratorKeys(apiKeySeed);
   const fileManager = await createFileManager(
@@ -2723,7 +2556,7 @@ var getProxyAuthParams = async (fileId) => {
 };
 
 // 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");
   }
@@ -2731,11 +2564,11 @@ async function savePortal(input) {
 }
 
 // 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`);
   }
@@ -2799,7 +2632,7 @@ var processEvent = async (event) => {
     return { success: false, error: errorMsg };
   }
 };
-var onTransactionSuccess = async (fileId, file2, onChainFileId, pending) => {
+var onTransactionSuccess = (fileId, file2, onChainFileId, pending) => {
   const frontendUrl = getRuntimeConfig().FRONTEND_URL;
   const payload = {
     onchainVersion: file2.localVersion,
@@ -2810,14 +2643,14 @@ var onTransactionSuccess = async (fileId, file2, onChainFileId, pending) => {
     metadata: pending.metadata,
     link: `${frontendUrl}/${file2.portalAddress}/${onChainFileId}#key=${pending.linkKey}`
   };
-  const updatedFile = await FilesModel.update(fileId, payload, file2.portalAddress);
+  const updatedFile = FilesModel.update(fileId, payload, file2.portalAddress);
   if (updatedFile.localVersion === updatedFile.onchainVersion) {
-    await FilesModel.update(fileId, { syncStatus: "synced" }, file2.portalAddress);
+    FilesModel.update(fileId, { syncStatus: "synced" }, file2.portalAddress);
   }
 };
 var processCreateEvent = async (event) => {
   const { fileId } = event;
-  const file2 = await FilesModel.findByIdIncludingDeleted(fileId);
+  const file2 = FilesModel.findByIdIncludingDeleted(fileId);
   if (!file2) {
     throw new Error(`File ${fileId} not found`);
   }
@@ -2836,18 +2669,18 @@ var processCreateEvent = async (event) => {
       timeout
     );
     if (!receipt2.success) {
-      await EventsModel.clearEventPendingOp(event._id);
+      EventsModel.clearEventPendingOp(event._id);
       throw new Error(`User operation failed: ${receipt2.reason}`);
     }
     const onChainFileId2 = parseFileEventLog(receipt2.logs, "AddedFile", ADDED_FILE_EVENT);
     const pending = JSON.parse(event.pendingPayload);
-    await onTransactionSuccess(fileId, file2, onChainFileId2, pending);
-    await EventsModel.clearEventPendingOp(event._id);
+    onTransactionSuccess(fileId, file2, onChainFileId2, pending);
+    EventsModel.clearEventPendingOp(event._id);
     logger.info(`File ${file2.ddocId} created and published successfully (resumed from pending op)`);
     return;
   }
   const result = await handleNewFileOp(fileId);
-  await EventsModel.setEventPendingOp(event._id, result.userOpHash, {
+  EventsModel.setEventPendingOp(event._id, result.userOpHash, {
     linkKey: result.linkKey,
     linkKeyNonce: result.linkKeyNonce,
     commentKey: result.commentKey,
@@ -2861,22 +2694,22 @@ var processCreateEvent = async (event) => {
     timeout
   );
   if (!receipt.success) {
-    await EventsModel.clearEventPendingOp(event._id);
+    EventsModel.clearEventPendingOp(event._id);
     throw new Error(`User operation failed: ${receipt.reason}`);
   }
   const onChainFileId = parseFileEventLog(receipt.logs, "AddedFile", ADDED_FILE_EVENT);
-  await onTransactionSuccess(fileId, file2, onChainFileId, {
+  onTransactionSuccess(fileId, file2, onChainFileId, {
     linkKey: result.linkKey,
     linkKeyNonce: result.linkKeyNonce,
     commentKey: result.commentKey,
     metadata: result.metadata
   });
-  await EventsModel.clearEventPendingOp(event._id);
+  EventsModel.clearEventPendingOp(event._id);
   logger.info(`File ${file2.ddocId} created and published successfully`);
 };
 var processUpdateEvent = async (event) => {
   const { fileId } = event;
-  const file2 = await FilesModel.findByIdExcludingDeleted(fileId);
+  const file2 = FilesModel.findByIdExcludingDeleted(fileId);
   if (!file2) {
     return;
   }
@@ -2891,15 +2724,15 @@ var processUpdateEvent = async (event) => {
     onchainVersion: file2.localVersion,
     metadata: result.metadata
   };
-  const updatedFile = await FilesModel.update(fileId, payload, file2.portalAddress);
+  const updatedFile = FilesModel.update(fileId, payload, file2.portalAddress);
   if (updatedFile.localVersion === updatedFile.onchainVersion) {
-    await FilesModel.update(fileId, { syncStatus: "synced" }, file2.portalAddress);
+    FilesModel.update(fileId, { syncStatus: "synced" }, file2.portalAddress);
   }
   logger.info(`File ${file2.ddocId} updated and published successfully`);
 };
 var processDeleteEvent = async (event) => {
   const { fileId } = event;
-  const file2 = await FilesModel.findByIdIncludingDeleted(fileId);
+  const file2 = FilesModel.findByIdIncludingDeleted(fileId);
   if (!file2) {
     return;
   }
@@ -2920,7 +2753,7 @@ var processDeleteEvent = async (event) => {
     payload.metadata = result.metadata;
     payload.isDeleted = 1;
   }
-  await FilesModel.update(fileId, payload, file2.portalAddress);
+  FilesModel.update(fileId, payload, file2.portalAddress);
   logger.info(`File ${fileId} delete event processed (syncStatus set to synced)`);
 };
 
@@ -2946,11 +2779,10 @@ var FileEventsWorker = class {
       return;
     }
     this.isRunning = true;
-    this.recoverStaleEvents().then((staleCount) => {
-      if (staleCount > 0) {
-        logger.info(`Recovered ${staleCount} stale event(s)`);
-      }
-    });
+    const staleCount = this.recoverStaleEvents();
+    if (staleCount > 0) {
+      logger.info(`Recovered ${staleCount} stale event(s)`);
+    }
     this.signalCleanup = onNewEvent(() => {
       this.pendingSignal = true;
       this.wakeUp();
@@ -2979,10 +2811,10 @@ var FileEventsWorker = class {
     let foundAny = false;
     while (this.activeProcessors.size < this.concurrency && this.isRunning) {
       const lockedFileIds = Array.from(this.activeProcessors.keys());
-      const event = await EventsModel.findNextEligible(lockedFileIds);
+      const event = EventsModel.findNextEligible(lockedFileIds);
       if (!event) break;
       foundAny = true;
-      await EventsModel.markProcessing(event._id);
+      EventsModel.markProcessing(event._id);
       const processor = this.processEventWrapper(event);
       this.activeProcessors.set(event.fileId, processor);
     }
@@ -2993,33 +2825,33 @@ var FileEventsWorker = class {
     try {
       const result = await processEvent(event);
       if (result.success) {
-        await EventsModel.markProcessed(event._id);
+        EventsModel.markProcessed(event._id);
       } else {
-        await this.handleFailure(event, result.error);
+        this.handleFailure(event, result.error);
       }
     } catch (err) {
-      await this.handleFailure(event, err);
+      this.handleFailure(event, err);
     } finally {
       this.activeProcessors.delete(event.fileId);
     }
   }
-  async handleFailure(event, error48) {
+  handleFailure(event, error48) {
     const errorMsg = error48 instanceof Error ? error48.message : String(error48);
     if (error48 instanceof RateLimitError) {
       const retryAfterMs = error48.retryAfterSeconds * 1e3;
-      await EventsModel.scheduleRetryAfter(event._id, errorMsg, retryAfterMs);
+      EventsModel.scheduleRetryAfter(event._id, errorMsg, retryAfterMs);
       logger.warn(`Event ${event._id} rate limited; retry after ${error48.retryAfterSeconds}s`);
       return;
     }
     if (event.retryCount < MAX_RETRIES) {
-      await EventsModel.scheduleRetry(event._id, errorMsg);
+      EventsModel.scheduleRetry(event._id, errorMsg);
       logger.warn(`Event ${event._id} failed (retry ${event.retryCount + 1}/${MAX_RETRIES}): ${errorMsg}`);
     } else {
-      await EventsModel.markFailed(event._id, errorMsg);
+      EventsModel.markFailed(event._id, errorMsg);
       logger.error(`Event ${event._id} permanently failed after ${MAX_RETRIES} retries: ${errorMsg}`);
     }
   }
-  async recoverStaleEvents() {
+  recoverStaleEvents() {
     const staleThreshold = Date.now() - STALE_THRESHOLD_MS;
     return EventsModel.resetStaleEvents(staleThreshold);
   }
@@ -3108,8 +2940,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 '{}',
@@ -3129,8 +2961,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 (
@@ -3139,7 +2971,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
 );
 
@@ -3175,16 +3007,16 @@ 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);
 CREATE INDEX IF NOT EXISTS idx_folders_created_at ON folders(created_at);
 `;
-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");
 }
 
@@ -3222,16 +3054,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,
@@ -3264,7 +3096,7 @@ var initializeFromApiKey = async (apiKey) => {
   logger.debug("API key data retrieved");
   const keyMaterial = await decryptSavedData(apiKey, data.encryptedKeyMaterial);
   const appMaterial = await decryptSavedData(apiKey, data.encryptedAppMaterial);
-  const result = await initializeWithData({ keyMaterial, appMaterial, id: data.id });
+  const result = initializeWithData({ keyMaterial, appMaterial, id: data.id });
   logger.debug("Portal saved");
   if (result.apiKeySaved) {
     logger.debug("API key saved");
@@ -3289,10 +3121,10 @@ import { Router } from "express";
 
 // src/domain/file/index.ts
 import { generate } from "short-uuid";
-async function listFiles(params) {
+function listFiles(params) {
   const { limit, skip, portalAddress } = params;
   const effectiveLimit = limit || DEFAULT_LIST_LIMIT;
-  const result = await FilesModel.findAll(portalAddress, effectiveLimit, skip);
+  const result = FilesModel.findAll(portalAddress, effectiveLimit, skip);
   const processedFiles = result.files.map((file2) => ({
     ddocId: file2.ddocId,
     link: file2.link,
@@ -3313,11 +3145,11 @@ async function listFiles(params) {
     hasNext: result.hasNext
   };
 }
-async function getFile(ddocId, portalAddress) {
+function getFile(ddocId, portalAddress) {
   if (!ddocId) {
     throw new Error("ddocId is required");
   }
-  const file2 = await FilesModel.findByDDocId(ddocId, portalAddress);
+  const file2 = FilesModel.findByDDocId(ddocId, portalAddress);
   if (!file2) {
     return null;
   }
@@ -3341,13 +3173,13 @@ var createFile = async (input) => {
     throw new Error("title, content, and portalAddress are required");
   }
   const ddocId = generate();
-  const file2 = await FilesModel.create({
+  const file2 = FilesModel.create({
     title: input.title,
     content: input.content,
     ddocId,
     portalAddress: input.portalAddress
   });
-  await EventsModel.create({ type: "create", fileId: file2._id, portalAddress: file2.portalAddress });
+  EventsModel.create({ type: "create", fileId: file2._id, portalAddress: file2.portalAddress });
   return file2;
 };
 var updateFile = async (ddocId, payload, portalAddress) => {
@@ -3357,7 +3189,7 @@ var updateFile = async (ddocId, payload, portalAddress) => {
   if (!payload.title && !payload.content) {
     throw new Error("At least one field is required: Either provide title, content, or both");
   }
-  const existingFile = await FilesModel.findByDDocId(ddocId, portalAddress);
+  const existingFile = FilesModel.findByDDocId(ddocId, portalAddress);
   if (!existingFile) {
     throw new Error(`File with ddocId ${ddocId} not found`);
   }
@@ -3367,8 +3199,8 @@ var updateFile = async (ddocId, payload, portalAddress) => {
     syncStatus: "pending"
     // since the update is done in local db, it's not on the chain yet. hence pending
   };
-  const updatedFile = await FilesModel.update(existingFile._id, updatePayload, portalAddress);
-  await EventsModel.create({ type: "update", fileId: updatedFile._id, portalAddress: updatedFile.portalAddress });
+  const updatedFile = FilesModel.update(existingFile._id, updatePayload, portalAddress);
+  EventsModel.create({ type: "update", fileId: updatedFile._id, portalAddress: updatedFile.portalAddress });
   return {
     ddocId: updatedFile.ddocId,
     link: updatedFile.link,
@@ -3388,12 +3220,12 @@ var deleteFile = async (ddocId, portalAddress) => {
   if (!ddocId) {
     throw new Error("ddocId is required");
   }
-  const existingFile = await FilesModel.findByDDocId(ddocId, portalAddress);
+  const existingFile = FilesModel.findByDDocId(ddocId, portalAddress);
   if (!existingFile) {
     throw new Error(`File with ddocId ${ddocId} not found`);
   }
-  const deletedFile = await FilesModel.softDelete(existingFile._id);
-  await EventsModel.create({ type: "delete", fileId: deletedFile._id, portalAddress: deletedFile.portalAddress });
+  const deletedFile = FilesModel.softDelete(existingFile._id);
+  EventsModel.create({ type: "delete", fileId: deletedFile._id, portalAddress: deletedFile.portalAddress });
   return deletedFile;
 };
 
@@ -3448,7 +3280,7 @@ var listHandler = async (req, res) => {
   if (!apiKey) {
     throw new Error("API key is required");
   }
-  const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+  const apiKeyInfo = ApiKeysModel.findByApiKey(apiKey);
   if (!apiKeyInfo) {
     throw new Error("Invalid API key");
   }
@@ -3456,7 +3288,7 @@ var listHandler = async (req, res) => {
   if (!portalAddress) {
     throw new Error("Portal address is required");
   }
-  const result = await listFiles({ limit, skip, portalAddress });
+  const result = listFiles({ limit, skip, portalAddress });
   res.json({
     ddocs: result.ddocs,
     total: result.total,
@@ -3469,7 +3301,7 @@ var getHandler = async (req, res) => {
   if (!apiKey) {
     throw new Error("API key is required");
   }
-  const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+  const apiKeyInfo = ApiKeysModel.findByApiKey(apiKey);
   if (!apiKeyInfo) {
     throw new Error("Invalid API key");
   }
@@ -3481,7 +3313,7 @@ var getHandler = async (req, res) => {
     return res.status(400).json({ error: "Missing required header: x-portal-address is required" });
   }
   try {
-    const file2 = await getFile(ddocId, portalAddress);
+    const file2 = getFile(ddocId, portalAddress);
     if (!file2) {
       return res.status(404).json({ error: "DDoc not found" });
     }
@@ -3507,7 +3339,7 @@ var createHandler = async (req, res) => {
         error: "Missing content: Either provide a file upload or fileContent text field"
       });
     }
-    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const apiKeyInfo = ApiKeysModel.findByApiKey(apiKey);
     if (!apiKeyInfo) {
       return res.status(400).json({ error: "Invalid API key" });
     }
@@ -3552,7 +3384,7 @@ var updateHandler = async (req, res) => {
       title: clientPayload.title,
       content: clientPayload.content
     };
-    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKeySeed);
+    const apiKeyInfo = ApiKeysModel.findByApiKey(apiKeySeed);
     if (!apiKeyInfo) {
       return res.status(400).json({ error: "Invalid API key" });
     }
@@ -3573,7 +3405,7 @@ var deleteHandler = async (req, res) => {
     if (!apiKey) {
       return res.status(400).json({ error: "API key is required" });
     }
-    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const apiKeyInfo = ApiKeysModel.findByApiKey(apiKey);
     if (!apiKeyInfo) {
       return res.status(400).json({ error: "Invalid API key" });
     }
@@ -3614,9 +3446,9 @@ var ddocs_default = router;
 import { Router as Router2 } from "express";
 
 // src/domain/folder/listFolders.ts
-async function listFolders(params) {
+function listFolders(params) {
   const { limit, skip } = params;
-  const result = await FoldersModel.findAll(limit, skip);
+  const result = FoldersModel.findAll(limit, skip);
   return {
     folders: result.folders,
     total: result.total,
@@ -3625,11 +3457,11 @@ async function listFolders(params) {
 }
 
 // src/domain/folder/getFolder.ts
-async function getFolder(folderRef, folderId) {
+function getFolder(folderRef, folderId) {
   if (!folderRef || !folderId) {
     throw new Error("folderRef and folderId are required");
   }
-  const folder = await FoldersModel.findByFolderRefAndId(folderRef, folderId);
+  const folder = FoldersModel.findByFolderRefAndId(folderRef, folderId);
   if (!folder) {
     return null;
   }
@@ -3637,7 +3469,7 @@ async function getFolder(folderRef, folderId) {
 }
 
 // src/domain/folder/createFolder.ts
-async function createFolder(input) {
+function createFolder(input) {
   if (!input.folderId) {
     throw new Error("folderId is required");
   }
@@ -3650,7 +3482,7 @@ async function createFolder(input) {
   if (!input.portalAddress) {
     throw new Error("portalAddress is required");
   }
-  const existing = await FoldersModel.findByFolderRefAndId(input.folderRef, input.folderId);
+  const existing = FoldersModel.findByFolderRefAndId(input.folderRef, input.folderId);
   if (existing) {
     throw new Error("Folder with this folderRef and folderId already exists");
   }
@@ -3661,7 +3493,7 @@ async function createFolder(input) {
 var listHandler2 = async (req, res) => {
   const limit = req.query.limit ? parseInt(req.query.limit, 10) : void 0;
   const skip = req.query.skip ? parseInt(req.query.skip, 10) : void 0;
-  const result = await listFolders({ limit, skip });
+  const result = listFolders({ limit, skip });
   res.json({
     folders: result.folders,
     total: result.total,
@@ -3677,7 +3509,7 @@ var getHandler2 = async (req, res) => {
     return res.status(400).json({ error: "folderRef and folderId are required" });
   }
   try {
-    const folder = await getFolder(folderRef, folderId);
+    const folder = getFolder(folderRef, folderId);
     if (!folder) {
       return res.status(404).json({ error: "Folder not found" });
     }
@@ -3707,7 +3539,7 @@ var createHandler2 = async (req, res) => {
         error: "Missing required fields: lastTransactionBlockNumber and lastTransactionBlockTimestamp are required"
       });
     }
-    const folder = await createFolder(input);
+    const folder = createFolder(input);
     res.status(201).json(folder);
   } catch (error48) {
     if (error48.message.includes("already exists")) {
@@ -3729,18 +3561,18 @@ var folders_default = router2;
 import { Router as Router3 } from "express";
 
 // src/domain/search/searchNodes.ts
-async function searchNodes(params) {
+function searchNodes(params) {
   const { query, limit, skip, portalAddress } = params;
   if (!query || query.trim().length === 0) {
     return { nodes: [], total: 0, hasNext: false };
   }
-  const files = await FilesModel.searchByTitle(query, portalAddress, limit, skip);
+  const files = FilesModel.searchByTitle(query, portalAddress, limit, skip);
   const normalizedNodes = files.map((file2) => ({
     type: "file",
     ...file2
   }));
   const countSql = `SELECT COUNT(*) as count FROM files WHERE LOWER(title) LIKE LOWER(?) AND isDeleted = 0 AND portalAddress = ?`;
-  const totalResult = await QueryBuilder.selectOne(countSql, [`%${query}%`, portalAddress]);
+  const totalResult = QueryBuilder.selectOne(countSql, [`%${query}%`, portalAddress]);
   const total = totalResult?.count || 0;
   const hasNext = skip !== void 0 && limit !== void 0 ? skip + limit < total : false;
   return {
@@ -3758,8 +3590,7 @@ var searchHandler = async (req, res) => {
   const runtimConfig = getRuntimeConfig();
   const apiKey = runtimConfig.API_KEY;
   if (!apiKey) throw new Error("API key is required");
-  const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
-  const portalAddress = apiKeyInfo?.portalAddress;
+  const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
   if (!portalAddress) throw new Error("Portal address is required");
   if (!query) {
     return res.status(400).json({ error: 'Query parameter "q" is required' });
@@ -3767,7 +3598,7 @@ var searchHandler = async (req, res) => {
   if (!portalAddress) {
     return res.status(400).json({ error: "Missing required header: x-portal-address is required" });
   }
-  const result = await searchNodes({ query, limit, skip, portalAddress });
+  const result = searchNodes({ query, limit, skip, portalAddress });
   res.json({
     nodes: result.nodes,
     total: result.total,
@@ -3787,12 +3618,11 @@ import { Router as Router4 } from "express";
 // src/interface/api/router/events/listFailed.ts
 var listFailedHandler = async (req, res) => {
   const apiKey = req.query.apiKey;
-  const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
-  const portalAddress = apiKeyInfo?.portalAddress;
+  const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
   if (!portalAddress) {
     return res.status(401).json({ error: "Invalid or missing API key" });
   }
-  const events = await EventsModel.listFailed(portalAddress);
+  const events = EventsModel.listFailed(portalAddress);
   res.json(events);
 };
 var listFailed_default = [listFailedHandler];
@@ -3800,13 +3630,12 @@ var listFailed_default = [listFailedHandler];
 // src/interface/api/router/events/retryOne.ts
 var retryOneHandler = async (req, res) => {
   const apiKey = req.query.apiKey;
-  const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
-  const portalAddress = apiKeyInfo?.portalAddress;
+  const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
   if (!portalAddress) {
     return res.status(401).json({ error: "Invalid or missing API key" });
   }
   const _id = req.params.id;
-  const updated = await EventsModel.resetFailedToPending(_id, portalAddress);
+  const updated = EventsModel.resetFailedToPending(_id, portalAddress);
   if (!updated) {
     return res.status(404).json({ error: "Event not found or not in failed state" });
   }
@@ -3817,12 +3646,11 @@ var retryOne_default = [retryOneHandler];
 // src/interface/api/router/events/retryAllFailed.ts
 var retryAllFailedHandler = async (req, res) => {
   const apiKey = req.query.apiKey;
-  const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
-  const portalAddress = apiKeyInfo?.portalAddress;
+  const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
   if (!portalAddress) {
     return res.status(401).json({ error: "Invalid or missing API key" });
   }
-  const count = await EventsModel.resetAllFailedToPending(portalAddress);
+  const count = EventsModel.resetAllFailedToPending(portalAddress);
   res.json({ retried: count });
 };
 var retryAllFailed_default = [retryAllFailedHandler];
@@ -17911,9 +17739,8 @@ var port = parseInt(config.PORT || "8001", 10);
 var ip = config.IP || "0.0.0.0";
 var server;
 var startServer = async () => {
-  validateDbConfig();
-  await getAdapter();
-  await runMigrations();
+  validateDbPath();
+  runMigrations();
   const apiKey = config.API_KEY;
   if (!apiKey) {
     logger.error("API_KEY environment variable is not set");
@@ -17958,7 +17785,7 @@ var shutdown = async () => {
     logger.error("Error closing worker:", error48);
   }
   try {
-    await closeAdapter();
+    await closeDatabase();
     logger.info("Database connection closed");
   } catch (error48) {
     logger.error("Error closing database:", error48);