@fileverse/api 0.0.3 → 0.0.4

package/dist/commands/index.js

@@ -1,31 +1,58 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/commands/index.ts
-import { Command as Command9 } from "commander";
-
-// src/config/index.ts
-import dotenv from "dotenv";
+// node_modules/tsup/assets/esm_shims.js
 import path from "path";
-import fs from "fs";
-import os from "os";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
 
 // src/cli/constants.generated.ts
-var STATIC_CONFIG = {
-  API_URL: "https://prod-apps-storage-5cdacc06ff79.herokuapp.com/",
-  SERVER_DID: "did:key:z6Mkroj9bxTin6Z5S9qwx2G2b87NPrCX7S85FhCpmBGPcDCz",
-  PROXY_SERVER_DID: "did:key:z6MkrZSmq8D6vQG87YbjUQatXeptaCCXWdTx8fYaWxWbRUHB",
-  NETWORK_NAME: "gnosis",
-  DEFAULT_PORT: "8001",
-  DEFAULT_RPC_URL: "https://rpc.gnosischain.com",
-  PIMLICO_PROXY_URL: "https://pimlico-proxy-0a326da116f8.herokuapp.com/",
-  SERVICE_NAME: "fileverse-api",
-  LOG_LEVEL: "info",
-  FRONTEND_URL: "https://docs.fileverse.io"
-};
+var STATIC_CONFIG;
+var init_constants_generated = __esm({
+  "src/cli/constants.generated.ts"() {
+    "use strict";
+    init_esm_shims();
+    STATIC_CONFIG = {
+      API_URL: "https://prod-apps-storage-5cdacc06ff79.herokuapp.com/",
+      SERVER_DID: "did:key:z6Mkroj9bxTin6Z5S9qwx2G2b87NPrCX7S85FhCpmBGPcDCz",
+      PROXY_SERVER_DID: "did:key:z6MkrZSmq8D6vQG87YbjUQatXeptaCCXWdTx8fYaWxWbRUHB",
+      NETWORK_NAME: "gnosis",
+      DEFAULT_PORT: "8001",
+      DEFAULT_RPC_URL: "https://rpc.gnosischain.com",
+      PIMLICO_PROXY_URL: "https://pimlico-proxy-0a326da116f8.herokuapp.com/",
+      SERVICE_NAME: "fileverse-api",
+      LOG_LEVEL: "info",
+      FRONTEND_URL: "https://docs.fileverse.io"
+    };
+  }
+});
+
+// src/cli/constants.ts
+var init_constants = __esm({
+  "src/cli/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants_generated();
+  }
+});
 
 // src/config/index.ts
-var projectEnvPath = path.join(process.cwd(), "config", ".env");
-var userEnvPath = path.join(os.homedir(), ".fileverse", ".env");
+import dotenv from "dotenv";
+import path2 from "path";
+import fs from "fs";
+import os from "os";
 function getEnvPath() {
   if (fs.existsSync(projectEnvPath)) {
     return projectEnvPath;
@@ -36,7 +63,6 @@ function loadConfig(override = true) {
   const envPath = getEnvPath();
   dotenv.config({ path: envPath, override });
 }
-loadConfig(false);
 function getRuntimeConfig() {
   return {
     get API_KEY() {
@@ -48,6 +74,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;
     },
@@ -59,398 +88,538 @@ function getRuntimeConfig() {
     }
   };
 }
-var config = {
-  ...STATIC_CONFIG,
-  get SERVICE_NAME() {
-    return STATIC_CONFIG.SERVICE_NAME;
-  },
-  get LOG_LEVEL() {
-    return STATIC_CONFIG.LOG_LEVEL;
-  },
-  get NETWORK_NAME() {
-    return STATIC_CONFIG.NETWORK_NAME;
-  },
-  get UPLOAD_SERVER_URL() {
-    return STATIC_CONFIG.API_URL;
-  },
-  get UPLOAD_SERVER_DID() {
-    return STATIC_CONFIG.SERVER_DID;
-  },
-  get API_KEY() {
-    return process.env.API_KEY;
-  },
-  get RPC_URL() {
-    return process.env.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL;
-  },
-  get DB_PATH() {
-    return process.env.DB_PATH;
-  },
-  get PORT() {
-    return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
-  },
-  get NODE_ENV() {
-    return process.env.NODE_ENV || "production";
-  },
-  get IP() {
-    return process.env.IP || "0.0.0.0";
-  },
-  get FRONTEND_URL() {
-    return process.env.FRONTEND_URL || STATIC_CONFIG.FRONTEND_URL;
+var projectEnvPath, userEnvPath, config;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    projectEnvPath = path2.join(process.cwd(), "config", ".env");
+    userEnvPath = path2.join(os.homedir(), ".fileverse", ".env");
+    loadConfig(false);
+    config = {
+      ...STATIC_CONFIG,
+      get SERVICE_NAME() {
+        return STATIC_CONFIG.SERVICE_NAME;
+      },
+      get LOG_LEVEL() {
+        return STATIC_CONFIG.LOG_LEVEL;
+      },
+      get NETWORK_NAME() {
+        return STATIC_CONFIG.NETWORK_NAME;
+      },
+      get UPLOAD_SERVER_URL() {
+        return STATIC_CONFIG.API_URL;
+      },
+      get UPLOAD_SERVER_DID() {
+        return STATIC_CONFIG.SERVER_DID;
+      },
+      get API_KEY() {
+        return process.env.API_KEY;
+      },
+      get RPC_URL() {
+        return process.env.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL;
+      },
+      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;
+      },
+      get NODE_ENV() {
+        return process.env.NODE_ENV || "production";
+      },
+      get IP() {
+        return process.env.IP || "0.0.0.0";
+      },
+      get FRONTEND_URL() {
+        return process.env.FRONTEND_URL || STATIC_CONFIG.FRONTEND_URL;
+      }
+    };
   }
-};
+});
 
 // src/infra/logger.ts
 import pino from "pino";
-var isProduction = config.NODE_ENV === "production";
-var pinoInstance = pino({
-  name: STATIC_CONFIG.SERVICE_NAME,
-  level: STATIC_CONFIG.LOG_LEVEL,
-  formatters: {
-    bindings: (bindings) => ({ name: bindings.name }),
-    level: (label) => ({ level: label })
-  },
-  serializers: {
-    err(err) {
-      if (!err) return err;
-      if (isProduction) {
-        return { type: err.name, message: err.message };
-      }
-      return {
-        type: err.name,
-        message: err.message,
-        stack: err.stack
+var isProduction, pinoInstance, createLogMethod, logger;
+var init_logger = __esm({
+  "src/infra/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_config();
+    isProduction = config.NODE_ENV === "production";
+    pinoInstance = pino({
+      name: STATIC_CONFIG.SERVICE_NAME,
+      level: STATIC_CONFIG.LOG_LEVEL,
+      formatters: {
+        bindings: (bindings) => ({ name: bindings.name }),
+        level: (label) => ({ level: label })
+      },
+      serializers: {
+        err(err) {
+          if (!err) return err;
+          if (isProduction) {
+            return { type: err.name, message: err.message };
+          }
+          return {
+            type: err.name,
+            message: err.message,
+            stack: err.stack
+          };
+        }
+      },
+      transport: config.NODE_ENV !== "production" ? {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname",
+          errorProps: "*",
+          errorLikeObjectKeys: ["err", "error"]
+        }
+      } : void 0
+    });
+    createLogMethod = (level) => {
+      return (...args) => {
+        const [first, ...rest] = args;
+        const log = pinoInstance[level].bind(pinoInstance);
+        if (typeof first === "object" && first !== null && !(first instanceof Error)) {
+          log(first, ...rest);
+          return;
+        }
+        if (rest.length > 0) {
+          const last = rest[rest.length - 1];
+          if (last instanceof Error) {
+            log({ err: last }, first, ...rest.slice(0, -1));
+            return;
+          }
+        }
+        if (first instanceof Error) {
+          log({ err: first }, first.message);
+          return;
+        }
+        log(first, ...rest);
       };
-    }
-  },
-  transport: config.NODE_ENV !== "production" ? {
-    target: "pino-pretty",
-    options: {
-      colorize: true,
-      translateTime: "SYS:standard",
-      ignore: "pid,hostname",
-      errorProps: "*",
-      errorLikeObjectKeys: ["err", "error"]
-    }
-  } : void 0
+    };
+    logger = {
+      trace: createLogMethod("trace"),
+      debug: createLogMethod("debug"),
+      info: createLogMethod("info"),
+      warn: createLogMethod("warn"),
+      error: createLogMethod("error"),
+      fatal: createLogMethod("fatal"),
+      get level() {
+        return pinoInstance.level;
+      },
+      set level(lvl) {
+        pinoInstance.level = lvl;
+      },
+      child: pinoInstance.child.bind(pinoInstance)
+    };
+  }
 });
-var createLogMethod = (level) => {
-  return (...args) => {
-    const [first, ...rest] = args;
-    const log = pinoInstance[level].bind(pinoInstance);
-    if (typeof first === "object" && first !== null && !(first instanceof Error)) {
-      log(first, ...rest);
-      return;
-    }
-    if (rest.length > 0) {
-      const last = rest[rest.length - 1];
-      if (last instanceof Error) {
-        log({ err: last }, first, ...rest.slice(0, -1));
-        return;
+
+// src/infra/asyncHandler.ts
+var init_asyncHandler = __esm({
+  "src/infra/asyncHandler.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/domain/file/constants.ts
+var DEFAULT_LIST_LIMIT;
+var init_constants2 = __esm({
+  "src/domain/file/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_LIST_LIMIT = 10;
+  }
+});
+
+// src/infra/database/query-builder.ts
+var QueryBuilder;
+var init_query_builder = __esm({
+  "src/infra/database/query-builder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_connection();
+    init_constants2();
+    QueryBuilder = class {
+      static async select(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.select(sql, params);
       }
-    }
-    if (first instanceof Error) {
-      log({ err: first }, first.message);
-      return;
-    }
-    log(first, ...rest);
-  };
-};
-var logger = {
-  trace: createLogMethod("trace"),
-  debug: createLogMethod("debug"),
-  info: createLogMethod("info"),
-  warn: createLogMethod("warn"),
-  error: createLogMethod("error"),
-  fatal: createLogMethod("fatal"),
-  get level() {
-    return pinoInstance.level;
-  },
-  set level(lvl) {
-    pinoInstance.level = lvl;
-  },
-  child: pinoInstance.child.bind(pinoInstance)
-};
+      static async selectOne(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.selectOne(sql, params);
+      }
+      static async execute(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.execute(sql, params);
+      }
+      static async transaction(callback) {
+        const adapter2 = await getAdapter();
+        return adapter2.transaction(callback);
+      }
+      static paginate(sql, options = {}) {
+        let query = sql;
+        if (options.orderBy) {
+          query += ` ORDER BY ${options.orderBy} ${options.orderDirection || "ASC"}`;
+        }
+        const hasOffset = (options.offset ?? 0) > 0;
+        const limit = options.limit ?? (hasOffset ? DEFAULT_LIST_LIMIT : void 0);
+        if (limit) {
+          query += ` LIMIT ${limit}`;
+        }
+        if (hasOffset) {
+          query += ` OFFSET ${options.offset}`;
+        }
+        return query;
+      }
+    };
+  }
+});
 
-// src/infra/database/connection.ts
-import Database from "better-sqlite3";
+// src/infra/database/index.ts
+var closeDatabase;
+var init_database = __esm({
+  "src/infra/database/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_connection();
+    init_query_builder();
+    closeDatabase = async () => {
+      await closeAdapter();
+    };
+  }
+});
 
 // src/infra/database/models/files.model.ts
 import { uuidv7 } from "uuidv7";
-var FilesModel = class {
-  static TABLE = "files";
-  static parseFile(fileRaw) {
-    let metadata = {};
-    try {
-      if (fileRaw.metadata) {
-        metadata = typeof fileRaw.metadata === "string" ? JSON.parse(fileRaw.metadata) : fileRaw.metadata;
+var FilesModel;
+var init_files_model = __esm({
+  "src/infra/database/models/files.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    FilesModel = class {
+      static TABLE = "files";
+      static parseFile(fileRaw) {
+        let metadata = {};
+        try {
+          if (fileRaw.metadata) {
+            metadata = typeof fileRaw.metadata === "string" ? JSON.parse(fileRaw.metadata) : fileRaw.metadata;
+          }
+        } catch (e) {
+          metadata = {};
+        }
+        return {
+          _id: fileRaw._id,
+          ddocId: fileRaw.ddocId,
+          title: fileRaw.title,
+          content: fileRaw.content,
+          localVersion: fileRaw.localVersion,
+          onchainVersion: fileRaw.onchainVersion,
+          syncStatus: fileRaw.syncStatus,
+          isDeleted: fileRaw.isDeleted,
+          onChainFileId: fileRaw.onChainFileId ?? null,
+          portalAddress: fileRaw.portalAddress,
+          metadata: metadata || {},
+          createdAt: fileRaw.createdAt,
+          updatedAt: fileRaw.updatedAt,
+          linkKey: fileRaw.linkKey,
+          linkKeyNonce: fileRaw.linkKeyNonce,
+          commentKey: fileRaw.commentKey,
+          link: fileRaw.link
+        };
       }
-    } catch (e) {
-      metadata = {};
-    }
-    return {
-      _id: fileRaw._id,
-      ddocId: fileRaw.ddocId,
-      title: fileRaw.title,
-      content: fileRaw.content,
-      localVersion: fileRaw.localVersion,
-      onchainVersion: fileRaw.onchainVersion,
-      syncStatus: fileRaw.syncStatus,
-      isDeleted: fileRaw.isDeleted,
-      onChainFileId: fileRaw.onChainFileId ?? null,
-      portalAddress: fileRaw.portalAddress,
-      metadata: metadata || {},
-      createdAt: fileRaw.createdAt,
-      updatedAt: fileRaw.updatedAt,
-      linkKey: fileRaw.linkKey,
-      linkKeyNonce: fileRaw.linkKeyNonce,
-      commentKey: fileRaw.commentKey,
-      link: fileRaw.link
-    };
-  }
-  static findAll(portalAddress, limit, skip) {
-    const whereClause = "isDeleted = 0 AND portalAddress = ?";
-    const params = [portalAddress];
-    const countSql = `
-      SELECT COUNT(*) as count 
-      FROM ${this.TABLE} 
+      static async findAll(portalAddress, limit, skip) {
+        const whereClause = "isDeleted = 0 AND portalAddress = ?";
+        const params = [portalAddress];
+        const countSql = `
+      SELECT COUNT(*) as count
+      FROM ${this.TABLE}
       WHERE ${whereClause}
     `;
-    const totalResult = QueryBuilder.selectOne(countSql, params);
-    const total = totalResult?.count || 0;
-    const sql = `
+        const totalResult = await QueryBuilder.selectOne(countSql, params);
+        const total = totalResult?.count || 0;
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE ${whereClause}
     `;
-    const completeSql = QueryBuilder.paginate(sql, {
-      limit,
-      offset: skip,
-      orderBy: "createdAt",
-      orderDirection: "DESC"
-    });
-    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 findById(_id, portalAddress) {
-    const sql = `
+        const completeSql = QueryBuilder.paginate(sql, {
+          limit,
+          offset: skip,
+          orderBy: "createdAt",
+          orderDirection: "DESC"
+        });
+        const filesRaw = await 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) {
+        const sql = `
       SELECT *
-      FROM ${this.TABLE} 
+      FROM ${this.TABLE}
       WHERE _id = ? AND isDeleted = 0 AND portalAddress = ?
     `;
-    const result = QueryBuilder.selectOne(sql, [_id, portalAddress]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static findByIdIncludingDeleted(_id) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [_id, portalAddress]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async findByIdIncludingDeleted(_id) {
+        const sql = `
       SELECT *
-      FROM ${this.TABLE} 
+      FROM ${this.TABLE}
       WHERE _id = ?
     `;
-    const result = QueryBuilder.selectOne(sql, [_id]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static findByIdExcludingDeleted(_id) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [_id]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async findByIdExcludingDeleted(_id) {
+        const sql = `
       SELECT *
-      FROM ${this.TABLE} 
+      FROM ${this.TABLE}
       WHERE _id = ? AND isDeleted = 0
     `;
-    const result = QueryBuilder.selectOne(sql, [_id]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static findByDDocId(ddocId, portalAddress) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [_id]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async findByDDocId(ddocId, portalAddress) {
+        const sql = `
       SELECT *
-      FROM ${this.TABLE} 
+      FROM ${this.TABLE}
       WHERE ddocId = ? AND isDeleted = 0 AND portalAddress = ?
     `;
-    const result = QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static searchByTitle(searchTerm, portalAddress, limit, skip) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async 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, {
-      limit,
-      offset: skip,
-      orderBy: "createdAt",
-      orderDirection: "DESC"
-    });
-    const filesRaw = QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
-    return filesRaw.map(this.parseFile);
-  }
-  static create(input) {
-    const _id = uuidv7();
-    const sql = `
-      INSERT INTO ${this.TABLE} 
-      (_id, title, content, ddocId, portalAddress) 
+        const completeSql = QueryBuilder.paginate(sql, {
+          limit,
+          offset: skip,
+          orderBy: "createdAt",
+          orderDirection: "DESC"
+        });
+        const filesRaw = await QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
+        return filesRaw.map(this.parseFile);
+      }
+      static async create(input) {
+        const _id = uuidv7();
+        const sql = `
+      INSERT INTO ${this.TABLE}
+      (_id, title, content, ddocId, portalAddress)
       VALUES (?, ?, ?, ?, ?)
     `;
-    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 update(_id, payload, portalAddress) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const keys = [];
-    const values = [];
-    for (const [k, v] of Object.entries(payload)) {
-      if (v !== void 0) {
-        if (k === "metadata" && typeof v === "object") {
-          keys.push(`${k} = ?`);
-          values.push(JSON.stringify(v));
-        } else {
-          keys.push(`${k} = ?`);
-          values.push(v);
+        await QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
+        const created = await this.findById(_id, input.portalAddress);
+        if (!created) {
+          throw new Error("Failed to create file");
         }
+        return created;
       }
-    }
-    keys.push("updatedAt = ?");
-    values.push(now, _id, portalAddress);
-    const updateChain = keys.join(", ");
-    const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE _id = ? AND portalAddress = ?`;
-    QueryBuilder.execute(sql, values);
-    const updated = this.findById(_id, portalAddress);
-    if (!updated) {
-      throw new Error("Failed to update file");
-    }
-    return updated;
-  }
-  static softDelete(_id) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sql = `
-      UPDATE ${this.TABLE} 
+      static async update(_id, payload, portalAddress) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const keys = [];
+        const values = [];
+        for (const [k, v] of Object.entries(payload)) {
+          if (v !== void 0) {
+            if (k === "metadata" && typeof v === "object") {
+              keys.push(`${k} = ?`);
+              values.push(JSON.stringify(v));
+            } else {
+              keys.push(`${k} = ?`);
+              values.push(v);
+            }
+          }
+        }
+        keys.push("updatedAt = ?");
+        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);
+        if (!updated) {
+          throw new Error("Failed to update file");
+        }
+        return updated;
+      }
+      static async softDelete(_id) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const sql = `
+      UPDATE ${this.TABLE}
       SET isDeleted = 1, syncStatus = 'pending', updatedAt = ?
       WHERE _id = ?
     `;
-    QueryBuilder.execute(sql, [now, _id]);
-    const deleted = this.findByIdIncludingDeleted(_id);
-    if (!deleted) {
-      throw new Error("Failed to delete file");
-    }
-    return deleted;
+        await QueryBuilder.execute(sql, [now, _id]);
+        const deleted = await this.findByIdIncludingDeleted(_id);
+        if (!deleted) {
+          throw new Error("Failed to delete file");
+        }
+        return deleted;
+      }
+    };
   }
-};
+});
 
 // src/infra/database/models/portals.model.ts
 import { uuidv7 as uuidv72 } from "uuidv7";
+var init_portals_model = __esm({
+  "src/infra/database/models/portals.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+  }
+});
 
 // src/infra/database/models/apikeys.model.ts
 import { uuidv7 as uuidv73 } from "uuidv7";
-var ApiKeysModel = class {
-  static TABLE = "api_keys";
-  static create(input) {
-    const _id = uuidv73();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sql = `INSERT INTO ${this.TABLE} (_id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt) 
+var ApiKeysModel;
+var init_apikeys_model = __esm({
+  "src/infra/database/models/apikeys.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    ApiKeysModel = class {
+      static TABLE = "api_keys";
+      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)
     VALUES (?, ?, ?, ?, ?, ?)`;
-    const result = QueryBuilder.execute(sql, [
-      _id,
-      input.apiKeySeed,
-      input.name,
-      input.collaboratorAddress,
-      input.portalAddress,
-      now
-    ]);
-    if (result.changes === 0) {
-      throw new Error("Failed to create API key");
-    }
-    const created = this.findById(_id);
-    if (!created) {
-      throw new Error("Failed to create API key");
-    }
-    return created;
-  }
-  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 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) {
-    const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
-    QueryBuilder.execute(sql, [_id]);
-  }
-  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 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]);
+        const result = await QueryBuilder.execute(sql, [
+          _id,
+          input.apiKeySeed,
+          input.name,
+          input.collaboratorAddress,
+          input.portalAddress,
+          now
+        ]);
+        if (result.changes === 0) {
+          throw new Error("Failed to create API key");
+        }
+        const created = await this.findById(_id);
+        if (!created) {
+          throw new Error("Failed to create API key");
+        }
+        return created;
+      }
+      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 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 async delete(_id) {
+        const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
+        await QueryBuilder.execute(sql, [_id]);
+      }
+      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 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]);
+      }
+    };
   }
-};
+});
 
-// src/infra/database/models/events.model.ts
-import { uuidv7 as uuidv74 } from "uuidv7";
+// src/infra/database/models/folders.model.ts
+var init_folders_model = __esm({
+  "src/infra/database/models/folders.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+  }
+});
 
 // src/infra/worker/workerSignal.ts
 import { EventEmitter } from "events";
-var WorkerSignal = class extends EventEmitter {
-};
-var workerSignal = new WorkerSignal();
-workerSignal.setMaxListeners(20);
 function notifyNewEvent() {
   workerSignal.emit("newEvent");
 }
+var WorkerSignal, workerSignal;
+var init_workerSignal = __esm({
+  "src/infra/worker/workerSignal.ts"() {
+    "use strict";
+    init_esm_shims();
+    WorkerSignal = class extends EventEmitter {
+    };
+    workerSignal = new WorkerSignal();
+    workerSignal.setMaxListeners(20);
+  }
+});
 
 // src/infra/database/models/events.model.ts
-var RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
-var EventsModel = class {
-  static TABLE = "events";
-  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) 
+import { uuidv7 as uuidv74 } from "uuidv7";
+var RETRY_DELAYS_MS, EventsModel;
+var init_events_model = __esm({
+  "src/infra/database/models/events.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    init_workerSignal();
+    RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
+    EventsModel = class {
+      static TABLE = "events";
+      static async 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)
       VALUES (?, ?, ?, ?, ?, ?, 0, NULL, NULL, NULL)
     `;
-    QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
-    notifyNewEvent();
-    return {
-      _id,
-      type: input.type,
-      timestamp,
-      fileId: input.fileId,
-      portalAddress: input.portalAddress,
-      status,
-      retryCount: 0,
-      lastError: null,
-      lockedAt: null,
-      nextRetryAt: null
-    };
-  }
-  static findById(_id) {
-    const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
-    const row = QueryBuilder.selectOne(sql, [_id]);
-    return row ? this.parseEvent(row) : void 0;
-  }
-  static findNextPending() {
-    const sql = `
+        await QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
+        notifyNewEvent();
+        return {
+          _id,
+          type: input.type,
+          timestamp,
+          fileId: input.fileId,
+          portalAddress: input.portalAddress,
+          status,
+          retryCount: 0,
+          lastError: null,
+          lockedAt: null,
+          nextRetryAt: null
+        };
+      }
+      static async findById(_id) {
+        const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
+        const row = await QueryBuilder.selectOne(sql, [_id]);
+        return row ? this.parseEvent(row) : void 0;
+      }
+      static async findNextPending() {
+        const sql = `
       SELECT * FROM ${this.TABLE}
       WHERE status = 'pending'
       ORDER BY timestamp ASC
       LIMIT 1
     `;
-    const row = QueryBuilder.selectOne(sql, []);
-    return row ? this.parseEvent(row) : void 0;
-  }
-  static findNextEligible(lockedFileIds) {
-    const now = Date.now();
-    const exclusionClause = lockedFileIds.length > 0 ? `AND e1.fileId NOT IN (${lockedFileIds.map(() => "?").join(", ")})` : "";
-    const sql = `
+        const row = await QueryBuilder.selectOne(sql, []);
+        return row ? this.parseEvent(row) : void 0;
+      }
+      static async findNextEligible(lockedFileIds) {
+        const now = Date.now();
+        const exclusionClause = lockedFileIds.length > 0 ? `AND e1.fileId NOT IN (${lockedFileIds.map(() => "?").join(", ")})` : "";
+        const sql = `
       SELECT e1.* FROM ${this.TABLE} e1
       WHERE e1.status = 'pending'
       AND (e1.nextRetryAt IS NULL OR e1.nextRetryAt <= ?)
@@ -464,34 +633,34 @@ var EventsModel = class {
       ORDER BY e1.timestamp ASC
       LIMIT 1
     `;
-    const params = [now, ...lockedFileIds];
-    const row = QueryBuilder.selectOne(sql, params);
-    return row ? this.parseEvent(row) : void 0;
-  }
-  static markProcessing(_id) {
-    const sql = `
+        const params = [now, ...lockedFileIds];
+        const row = await QueryBuilder.selectOne(sql, params);
+        return row ? this.parseEvent(row) : void 0;
+      }
+      static async markProcessing(_id) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'processing',
           lockedAt = ?
       WHERE _id = ?
     `;
-    QueryBuilder.execute(sql, [Date.now(), _id]);
-  }
-  static markProcessed(_id) {
-    const sql = `
+        await QueryBuilder.execute(sql, [Date.now(), _id]);
+      }
+      static async markProcessed(_id) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'processed',
           lockedAt = NULL
       WHERE _id = ?
     `;
-    QueryBuilder.execute(sql, [_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;
-    const sql = `
+        await QueryBuilder.execute(sql, [_id]);
+      }
+      static async scheduleRetry(_id, errorMsg) {
+        const event = await 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;
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           retryCount = retryCount + 1,
@@ -500,11 +669,11 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
-  }
-  static scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
-    const nextRetryAt = Date.now() + retryAfterMs;
-    const sql = `
+        await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+      }
+      static async scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
+        const nextRetryAt = Date.now() + retryAfterMs;
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           lastError = ?,
@@ -512,33 +681,33 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
-  }
-  static markFailed(_id, errorMsg) {
-    const sql = `
+        await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+      }
+      static async markFailed(_id, errorMsg) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'failed',
           lastError = ?,
           lockedAt = NULL
       WHERE _id = ?
     `;
-    QueryBuilder.execute(sql, [errorMsg, _id]);
-  }
-  static listFailed(portalAddress) {
-    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
-    const sql = `
+        await QueryBuilder.execute(sql, [errorMsg, _id]);
+      }
+      static async listFailed(portalAddress) {
+        const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+        const sql = `
       SELECT * FROM ${this.TABLE}
       WHERE status = 'failed'
       ${portalClause}
       ORDER BY timestamp ASC
     `;
-    const params = portalAddress != null ? [portalAddress] : [];
-    const rows = QueryBuilder.select(sql, params);
-    return rows.map((row) => this.parseEvent(row));
-  }
-  static resetFailedToPending(_id, portalAddress) {
-    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
-    const sql = `
+        const params = portalAddress != null ? [portalAddress] : [];
+        const rows = await QueryBuilder.select(sql, params);
+        return rows.map((row) => this.parseEvent(row));
+      }
+      static async resetFailedToPending(_id, portalAddress) {
+        const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           retryCount = 0,
@@ -549,16 +718,16 @@ var EventsModel = class {
       AND status = 'failed'
       ${portalClause}
     `;
-    const params = portalAddress != null ? [_id, portalAddress] : [_id];
-    const result = QueryBuilder.execute(sql, params);
-    if (result.changes > 0) {
-      notifyNewEvent();
-    }
-    return result.changes > 0;
-  }
-  static resetAllFailedToPending(portalAddress) {
-    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
-    const sql = `
+        const params = portalAddress != null ? [_id, portalAddress] : [_id];
+        const result = await QueryBuilder.execute(sql, params);
+        if (result.changes > 0) {
+          notifyNewEvent();
+        }
+        return result.changes > 0;
+      }
+      static async resetAllFailedToPending(portalAddress) {
+        const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           retryCount = 0,
@@ -568,15 +737,15 @@ var EventsModel = class {
       WHERE status = 'failed'
       ${portalClause}
     `;
-    const params = portalAddress != null ? [portalAddress] : [];
-    const result = QueryBuilder.execute(sql, params);
-    if (result.changes > 0) {
-      notifyNewEvent();
-    }
-    return result.changes;
-  }
-  static resetStaleEvents(staleThreshold) {
-    const sql = `
+        const params = portalAddress != null ? [portalAddress] : [];
+        const result = await QueryBuilder.execute(sql, params);
+        if (result.changes > 0) {
+          notifyNewEvent();
+        }
+        return result.changes;
+      }
+      static async resetStaleEvents(staleThreshold) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           lockedAt = NULL,
@@ -586,51 +755,113 @@ var EventsModel = class {
       AND lockedAt IS NOT NULL
       AND lockedAt < ?
     `;
-    const result = QueryBuilder.execute(sql, [staleThreshold]);
-    return result.changes;
-  }
-  static setEventPendingOp(_id, userOpHash, payload) {
-    const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
-    QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
-  }
-  static clearEventPendingOp(_id) {
-    const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
-    QueryBuilder.execute(sql, [_id]);
-  }
-  static parseEvent(row) {
-    return {
-      _id: row._id,
-      type: row.type,
-      timestamp: row.timestamp,
-      fileId: row.fileId,
-      portalAddress: row.portalAddress ?? "",
-      status: row.status,
-      retryCount: row.retryCount,
-      lastError: row.lastError,
-      lockedAt: row.lockedAt,
-      nextRetryAt: row.nextRetryAt,
-      userOpHash: row.userOpHash ?? null,
-      pendingPayload: row.pendingPayload ?? null
+        const result = await QueryBuilder.execute(sql, [staleThreshold]);
+        return result.changes;
+      }
+      static async setEventPendingOp(_id, userOpHash, payload) {
+        const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
+        await QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
+      }
+      static async clearEventPendingOp(_id) {
+        const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
+        await QueryBuilder.execute(sql, [_id]);
+      }
+      static parseEvent(row) {
+        return {
+          _id: row._id,
+          type: row.type,
+          timestamp: row.timestamp,
+          fileId: row.fileId,
+          portalAddress: row.portalAddress ?? "",
+          status: row.status,
+          retryCount: row.retryCount,
+          lastError: row.lastError,
+          lockedAt: row.lockedAt,
+          nextRetryAt: row.nextRetryAt,
+          userOpHash: row.userOpHash ?? null,
+          pendingPayload: row.pendingPayload ?? null
+        };
+      }
     };
   }
-};
+});
+
+// src/infra/database/models/index.ts
+var init_models = __esm({
+  "src/infra/database/models/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_files_model();
+    init_portals_model();
+    init_apikeys_model();
+    init_folders_model();
+    init_events_model();
+  }
+});
 
 // src/sdk/key-store.ts
 import { eciesDecrypt, eciesEncrypt, generateECKeyPair } from "@fileverse/crypto/ecies";
+var init_key_store = __esm({
+  "src/sdk/key-store.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
 // src/sdk/auth-token-provider.ts
 import * as ucans from "@ucans/ucans";
+var init_auth_token_provider = __esm({
+  "src/sdk/auth-token-provider.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
-// src/domain/portal/publish.ts
-import { fromUint8Array as fromUint8Array3, toUint8Array as toUint8Array3 } from "js-base64";
-import { stringToBytes } from "viem";
-import { deriveHKDFKey } from "@fileverse/crypto/kdf";
-import { generateKeyPairFromSeed } from "@stablelib/ed25519";
-import * as ucans2 from "@ucans/ucans";
+// src/constants/chains.ts
+import { sepolia, gnosis } from "viem/chains";
+var init_chains = __esm({
+  "src/constants/chains.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
-// src/sdk/smart-agent.ts
-import { toHex as toHex2 } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
+// src/constants/events.ts
+var init_events = __esm({
+  "src/constants/events.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/constants/methods.ts
+var init_methods = __esm({
+  "src/constants/methods.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/constants/index.ts
+var NETWORK_NAME, UPLOAD_SERVER_URL, CHAIN_MAP, CHAIN;
+var init_constants3 = __esm({
+  "src/constants/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_config();
+    init_chains();
+    init_events();
+    init_methods();
+    NETWORK_NAME = STATIC_CONFIG.NETWORK_NAME;
+    UPLOAD_SERVER_URL = STATIC_CONFIG.API_URL;
+    CHAIN_MAP = {
+      gnosis,
+      sepolia
+    };
+    CHAIN = CHAIN_MAP[NETWORK_NAME];
+  }
+});
 
 // src/sdk/pimlico-utils.ts
 import { createPublicClient, http, hexToBigInt, toHex, toBytes } from "viem";
@@ -638,24 +869,35 @@ import { createPimlicoClient } from "permissionless/clients/pimlico";
 import { createSmartAccountClient } from "permissionless";
 import { toSafeSmartAccount } from "permissionless/accounts";
 import { entryPoint07Address } from "viem/account-abstraction";
-
-// src/constants/chains.ts
-import { sepolia, gnosis } from "viem/chains";
-
-// src/constants/index.ts
-var NETWORK_NAME = STATIC_CONFIG.NETWORK_NAME;
-var UPLOAD_SERVER_URL = STATIC_CONFIG.API_URL;
-var CHAIN_MAP = {
-  gnosis,
-  sepolia
-};
-var CHAIN = CHAIN_MAP[NETWORK_NAME];
-
-// src/sdk/pimlico-utils.ts
 import { generatePrivateKey } from "viem/accounts";
+var init_pimlico_utils = __esm({
+  "src/sdk/pimlico-utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants3();
+  }
+});
 
-// src/sdk/file-manager.ts
-import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array2 } from "js-base64";
+// src/sdk/smart-agent.ts
+import { toHex as toHex2 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var init_smart_agent = __esm({
+  "src/sdk/smart-agent.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pimlico_utils();
+    init_constants();
+  }
+});
+
+// src/sdk/file-encryption.ts
+import { generateRandomBytes } from "@fileverse/crypto/utils";
+var init_file_encryption = __esm({
+  "src/sdk/file-encryption.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
 // src/sdk/file-utils.ts
 import { getArgon2idHash } from "@fileverse/crypto/argon";
@@ -665,134 +907,448 @@ import { secretBoxEncrypt } from "@fileverse/crypto/nacl";
 import hkdf from "futoin-hkdf";
 import tweetnacl from "tweetnacl";
 import { fromUint8Array, toUint8Array } from "js-base64";
-
-// src/sdk/file-encryption.ts
-import { generateRandomBytes } from "@fileverse/crypto/utils";
-
-// src/sdk/file-utils.ts
 import { toAESKey, aesEncrypt } from "@fileverse/crypto/webcrypto";
 import axios from "axios";
 import { encodeFunctionData, parseEventLogs } from "viem";
+var init_file_utils = __esm({
+  "src/sdk/file-utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_encryption();
+    init_constants3();
+  }
+});
 
 // src/sdk/file-manager.ts
+import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array2 } from "js-base64";
 import { generateAESKey, exportAESKey } from "@fileverse/crypto/webcrypto";
 import { markdownToYjs } from "@fileverse/content-processor";
+var init_file_manager = __esm({
+  "src/sdk/file-manager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_utils();
+    init_constants();
+    init_constants3();
+    init_infra();
+  }
+});
+
+// src/domain/portal/publish.ts
+import { fromUint8Array as fromUint8Array3, toUint8Array as toUint8Array3 } from "js-base64";
+import { stringToBytes } from "viem";
+import { deriveHKDFKey } from "@fileverse/crypto/kdf";
+import { generateKeyPairFromSeed } from "@stablelib/ed25519";
+import * as ucans2 from "@ucans/ucans";
+var init_publish = __esm({
+  "src/domain/portal/publish.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+    init_infra();
+    init_key_store();
+    init_auth_token_provider();
+    init_smart_agent();
+    init_file_manager();
+    init_config();
+  }
+});
+
+// src/domain/portal/savePortal.ts
+var init_savePortal = __esm({
+  "src/domain/portal/savePortal.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/domain/portal/saveApiKey.ts
+var init_saveApiKey = __esm({
+  "src/domain/portal/saveApiKey.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/domain/portal/removeApiKey.ts
+var init_removeApiKey = __esm({
+  "src/domain/portal/removeApiKey.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/domain/portal/index.ts
+var init_portal = __esm({
+  "src/domain/portal/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_publish();
+    init_savePortal();
+    init_saveApiKey();
+    init_removeApiKey();
+  }
+});
 
 // src/errors/rate-limit.ts
 import { HttpRequestError } from "viem";
+var init_rate_limit = __esm({
+  "src/errors/rate-limit.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/infra/worker/eventProcessor.ts
+var init_eventProcessor = __esm({
+  "src/infra/worker/eventProcessor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_portal();
+    init_models();
+    init_infra();
+    init_pimlico_utils();
+    init_file_utils();
+    init_constants3();
+    init_rate_limit();
+  }
+});
 
 // src/infra/worker/worker.ts
-var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+var STALE_THRESHOLD_MS;
+var init_worker = __esm({
+  "src/infra/worker/worker.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_infra();
+    init_eventProcessor();
+    init_workerSignal();
+    init_models();
+    init_rate_limit();
+    STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/infra/worker/index.ts
+var init_worker2 = __esm({
+  "src/infra/worker/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_worker();
+    init_workerSignal();
+  }
+});
 
 // src/appWorker.ts
-var worker = null;
 async function closeWorker() {
   if (worker) {
     await worker.close();
     worker = null;
   }
 }
+var worker;
+var init_appWorker = __esm({
+  "src/appWorker.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_worker2();
+    worker = null;
+  }
+});
 
 // src/infra/reporter.ts
-var Reporter = class {
-  async reportError(message) {
-    console.error("Error reported:", message);
+var Reporter, reporter_default;
+var init_reporter = __esm({
+  "src/infra/reporter.ts"() {
+    "use strict";
+    init_esm_shims();
+    Reporter = class {
+      async reportError(message) {
+        console.error("Error reported:", message);
+      }
+    };
+    reporter_default = new Reporter();
   }
-};
-var reporter_default = new Reporter();
+});
 
-// src/infra/database/connection.ts
-var DatabaseConnectionManager = class _DatabaseConnectionManager {
-  static instance;
-  db = null;
-  constructor() {
-  }
-  static getInstance() {
-    if (!_DatabaseConnectionManager.instance) {
-      _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
-    }
-    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}`);
-    }
-    return this.db;
+// src/infra/index.ts
+var init_infra = __esm({
+  "src/infra/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_asyncHandler();
+    init_appWorker();
+    init_database();
+    init_reporter();
   }
-  async close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      logger.info("Database connection closed");
+});
+
+// src/infra/database/adapters/sql-compat.ts
+function sqliteToPostgres(sql) {
+  let result = "";
+  let paramIndex = 0;
+  let inString = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'") {
+      if (inString && i + 1 < sql.length && sql[i + 1] === "'") {
+        result += "''";
+        i++;
+        continue;
+      }
+      inString = !inString;
+      result += ch;
+    } else if (ch === "?" && !inString) {
+      paramIndex++;
+      result += `$${paramIndex}`;
+    } else {
+      result += ch;
     }
   }
-  isConnected() {
-    return this.db !== null && this.db.open;
+  return result;
+}
+var init_sql_compat = __esm({
+  "src/infra/database/adapters/sql-compat.ts"() {
+    "use strict";
+    init_esm_shims();
   }
-};
-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();
+// src/infra/database/adapters/postgres-adapter.ts
+var postgres_adapter_exports = {};
+__export(postgres_adapter_exports, {
+  PostgresAdapter: () => PostgresAdapter
+});
+async function getPg() {
+  if (!pgModule) {
+    pgModule = await import("pg");
+  }
+  return pgModule;
 }
-var QueryBuilder = class {
-  static select(sql, params = []) {
-    const stmt = getDb().prepare(sql);
-    return stmt.all(params);
-  }
-  static selectOne(sql, params = []) {
-    const stmt = getDb().prepare(sql);
-    return stmt.get(params);
-  }
-  static execute(sql, params = []) {
-    const stmt = getDb().prepare(sql);
-    const result = stmt.run(params);
-    return {
-      changes: result.changes,
-      lastInsertRowid: result.lastInsertRowid
+var pgModule, PostgresAdapter;
+var init_postgres_adapter = __esm({
+  "src/infra/database/adapters/postgres-adapter.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sql_compat();
+    init_infra();
+    pgModule = null;
+    PostgresAdapter = class {
+      pool = null;
+      connectionUrl;
+      connected = false;
+      dialect = "postgres";
+      constructor(connectionUrl) {
+        this.connectionUrl = connectionUrl;
+      }
+      async getPool() {
+        if (!this.pool) {
+          const pg = await getPg();
+          this.pool = new pg.default.Pool({
+            connectionString: this.connectionUrl,
+            max: 10,
+            ssl: this.connectionUrl.includes("sslmode=require") || this.connectionUrl.includes("amazonaws.com") || this.connectionUrl.includes("heroku") ? { rejectUnauthorized: false } : void 0
+          });
+          const client = await this.pool.connect();
+          client.release();
+          this.connected = true;
+          logger.info("PostgreSQL database connected");
+        }
+        return this.pool;
+      }
+      async select(sql, params = []) {
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return result.rows;
+      }
+      async selectOne(sql, params = []) {
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return result.rows[0] ?? void 0;
+      }
+      async execute(sql, params = []) {
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return {
+          changes: result.rowCount ?? 0,
+          lastInsertRowid: 0
+        };
+      }
+      async transaction(callback) {
+        const pool = await this.getPool();
+        const client = await pool.connect();
+        try {
+          await client.query("BEGIN");
+          const result = await callback();
+          await client.query("COMMIT");
+          return result;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
+        }
+      }
+      async exec(sql) {
+        const pool = await this.getPool();
+        await pool.query(sql);
+      }
+      async close() {
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+          this.connected = false;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.connected;
+      }
     };
   }
-  static transaction(callback) {
-    return getDb().transaction(callback)();
+});
+
+// src/infra/database/adapters/sqlite-adapter.ts
+var sqlite_adapter_exports = {};
+__export(sqlite_adapter_exports, {
+  SqliteAdapter: () => SqliteAdapter
+});
+import Database from "better-sqlite3";
+var SqliteAdapter;
+var init_sqlite_adapter = __esm({
+  "src/infra/database/adapters/sqlite-adapter.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_infra();
+    SqliteAdapter = class {
+      constructor(dbPath) {
+        this.dbPath = dbPath;
+      }
+      db = null;
+      dialect = "sqlite";
+      getDb() {
+        if (!this.db) {
+          this.db = new Database(this.dbPath);
+          this.db.pragma("journal_mode = WAL");
+          this.db.pragma("foreign_keys = ON");
+          this.db.prepare("SELECT 1").get();
+          logger.info(`SQLite database connected: ${this.dbPath}`);
+        }
+        return this.db;
+      }
+      async select(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        return stmt.all(params);
+      }
+      async selectOne(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        return stmt.get(params);
+      }
+      async execute(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        const result = stmt.run(params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
+      }
+      async transaction(callback) {
+        const db = this.getDb();
+        const savepointName = `sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        db.exec(`SAVEPOINT ${savepointName}`);
+        try {
+          const result = await callback();
+          db.exec(`RELEASE ${savepointName}`);
+          return result;
+        } catch (error) {
+          db.exec(`ROLLBACK TO ${savepointName}`);
+          db.exec(`RELEASE ${savepointName}`);
+          throw error;
+        }
+      }
+      async exec(sql) {
+        this.getDb().exec(sql);
+      }
+      async close() {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.db !== null && this.db.open;
+      }
+    };
   }
-  static paginate(sql, options = {}) {
-    let query = sql;
-    if (options.orderBy) {
-      query += ` ORDER BY ${options.orderBy} ${options.orderDirection || "ASC"}`;
-    }
-    const hasOffset = (options.offset ?? 0) > 0;
-    const limit = options.limit ?? (hasOffset ? DEFAULT_LIST_LIMIT : void 0);
-    if (limit) {
-      query += ` LIMIT ${limit}`;
-    }
-    if (hasOffset) {
-      query += ` OFFSET ${options.offset}`;
+});
+
+// src/infra/database/connection.ts
+import path3 from "path";
+import fs2 from "fs";
+async function initializeAdapter() {
+  if (adapter) return adapter;
+  const databaseUrl = process.env.DATABASE_URL;
+  const dbPath = process.env.DB_PATH;
+  if (databaseUrl) {
+    const { PostgresAdapter: PostgresAdapter2 } = await Promise.resolve().then(() => (init_postgres_adapter(), postgres_adapter_exports));
+    adapter = new PostgresAdapter2(databaseUrl);
+    logger.info("Using PostgreSQL adapter");
+  } else if (dbPath) {
+    const dbDir = path3.dirname(dbPath.trim());
+    if (!fs2.existsSync(dbDir)) {
+      fs2.mkdirSync(dbDir, { recursive: true });
     }
-    return query;
+    const { SqliteAdapter: SqliteAdapter2 } = await Promise.resolve().then(() => (init_sqlite_adapter(), sqlite_adapter_exports));
+    adapter = new SqliteAdapter2(dbPath);
+    logger.info("Using SQLite adapter");
+  } else {
+    throw new Error(
+      "No database configured. Set DATABASE_URL (PostgreSQL) or DB_PATH (SQLite)."
+    );
+  }
+  return adapter;
+}
+async function getAdapter() {
+  if (!adapter) {
+    return initializeAdapter();
   }
-};
-
-// src/infra/database/index.ts
-function getDb2() {
-  return databaseConnectionManager.getConnection();
+  return adapter;
 }
-var closeDatabase = async () => {
-  await databaseConnectionManager.close();
-};
-var database_default = getDb2;
+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_infra();
+    adapter = null;
+  }
+});
+
+// src/commands/index.ts
+init_esm_shims();
+init_config();
+init_logger();
+import { Command as Command9 } from "commander";
 
 // src/infra/database/migrations/index.ts
+init_esm_shims();
+init_connection();
+init_infra();
 var STABLE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS files (
   _id TEXT PRIMARY KEY,
@@ -802,8 +1358,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 '{}',
@@ -823,8 +1379,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 (
@@ -833,7 +1389,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
 );
 
@@ -869,29 +1425,33 @@ 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);
 CREATE INDEX IF NOT EXISTS idx_folders_created_at ON folders(created_at);
 `;
-function runMigrations() {
-  const db = database_default();
-  db.exec(STABLE_SCHEMA);
+async function runMigrations() {
+  const adapter2 = await getAdapter();
+  await adapter2.exec(STABLE_SCHEMA);
   logger.debug("Database schema ready");
 }
 
 // src/commands/listCommand.ts
+init_esm_shims();
 import { Command } from "commander";
 import Table from "cli-table3";
 
 // src/domain/file/index.ts
+init_esm_shims();
+init_models();
+init_constants2();
 import { generate } from "short-uuid";
-function listFiles(params) {
+async function listFiles(params) {
   const { limit, skip, portalAddress } = params;
   const effectiveLimit = limit || DEFAULT_LIST_LIMIT;
-  const result = FilesModel.findAll(portalAddress, effectiveLimit, skip);
+  const result = await FilesModel.findAll(portalAddress, effectiveLimit, skip);
   const processedFiles = result.files.map((file) => ({
     ddocId: file.ddocId,
     link: file.link,
@@ -912,11 +1472,11 @@ function listFiles(params) {
     hasNext: result.hasNext
   };
 }
-function getFile(ddocId, portalAddress) {
+async function getFile(ddocId, portalAddress) {
   if (!ddocId) {
     throw new Error("ddocId is required");
   }
-  const file = FilesModel.findByDDocId(ddocId, portalAddress);
+  const file = await FilesModel.findByDDocId(ddocId, portalAddress);
   if (!file) {
     return null;
   }
@@ -940,13 +1500,13 @@ var createFile = async (input) => {
     throw new Error("title, content, and portalAddress are required");
   }
   const ddocId = generate();
-  const file = FilesModel.create({
+  const file = await FilesModel.create({
     title: input.title,
     content: input.content,
     ddocId,
     portalAddress: input.portalAddress
   });
-  EventsModel.create({ type: "create", fileId: file._id, portalAddress: file.portalAddress });
+  await EventsModel.create({ type: "create", fileId: file._id, portalAddress: file.portalAddress });
   return file;
 };
 var updateFile = async (ddocId, payload, portalAddress) => {
@@ -956,7 +1516,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 = FilesModel.findByDDocId(ddocId, portalAddress);
+  const existingFile = await FilesModel.findByDDocId(ddocId, portalAddress);
   if (!existingFile) {
     throw new Error(`File with ddocId ${ddocId} not found`);
   }
@@ -966,8 +1526,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 = FilesModel.update(existingFile._id, updatePayload, portalAddress);
-  EventsModel.create({ type: "update", fileId: updatedFile._id, portalAddress: updatedFile.portalAddress });
+  const updatedFile = await FilesModel.update(existingFile._id, updatePayload, portalAddress);
+  await EventsModel.create({ type: "update", fileId: updatedFile._id, portalAddress: updatedFile.portalAddress });
   return {
     ddocId: updatedFile.ddocId,
     link: updatedFile.link,
@@ -987,16 +1547,17 @@ var deleteFile = async (ddocId, portalAddress) => {
   if (!ddocId) {
     throw new Error("ddocId is required");
   }
-  const existingFile = FilesModel.findByDDocId(ddocId, portalAddress);
+  const existingFile = await FilesModel.findByDDocId(ddocId, portalAddress);
   if (!existingFile) {
     throw new Error(`File with ddocId ${ddocId} not found`);
   }
-  const deletedFile = FilesModel.softDelete(existingFile._id);
-  EventsModel.create({ type: "delete", fileId: deletedFile._id, portalAddress: deletedFile.portalAddress });
+  const deletedFile = await FilesModel.softDelete(existingFile._id);
+  await EventsModel.create({ type: "delete", fileId: deletedFile._id, portalAddress: deletedFile.portalAddress });
   return deletedFile;
 };
 
 // src/commands/utils/util.ts
+init_esm_shims();
 var columnNames = {
   index: "#",
   ddocId: "DDoc ID",
@@ -1073,19 +1634,22 @@ After setup, you can use ddctl commands.
 }
 
 // src/commands/listCommand.ts
+init_config();
+init_models();
 var listCommand = new Command().name("list").description("List all ddocs").option("-l, --limit <number>", "Limit the number of results", parseInt).option("-s, --skip <number>", "Skip the first N results", parseInt).action(async (options) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     const params = {
       limit: options.limit,
       skip: options.skip,
       portalAddress
     };
-    const result = listFiles(params);
+    const result = await listFiles(params);
     if (result.ddocs.length === 0) {
       console.log("No ddocs found.");
       return;
@@ -1140,16 +1704,20 @@ Found ${result.total} ddoc(s):
 });
 
 // src/commands/getCommand.ts
+init_esm_shims();
 import { Command as Command2 } from "commander";
 import Table2 from "cli-table3";
+init_config();
+init_models();
 var getCommand = new Command2().name("get").description("Get a ddoc by its ID").argument("<ddocId>", "The ddoc ID to retrieve").action(async (ddocId) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
-    const file = getFile(ddocId, portalAddress);
+    const file = await getFile(ddocId, portalAddress);
     if (!file) {
       console.error(`Ddoc with ID "${ddocId}" not found.`);
       return;
@@ -1202,26 +1770,30 @@ Link: ${file.link}
 });
 
 // src/commands/createCommand.ts
+init_esm_shims();
 import { Command as Command3 } from "commander";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 import Table3 from "cli-table3";
+init_config();
+init_models();
 var createCommand = new Command3().name("create").description("Create a new ddoc from a file").argument("<filepath>", "Path to the file to create ddoc from").action(async (filepath) => {
   try {
-    if (!fs2.existsSync(filepath)) {
+    if (!fs3.existsSync(filepath)) {
       throw new Error(`File not found: ${filepath}`);
     }
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
-    const content = fs2.readFileSync(filepath, "utf-8");
+    const content = fs3.readFileSync(filepath, "utf-8");
     if (!content || content.trim().length === 0) {
       console.error("Error creating ddoc: File content cannot be empty. Add some content to the file and try again.");
       process.exit(1);
     }
-    const basename3 = path2.basename(filepath);
+    const basename3 = path4.basename(filepath);
     const lastDotIndex = basename3.lastIndexOf(".");
     const title = lastDotIndex > 0 ? basename3.substring(0, lastDotIndex) : basename3;
     const file = await createFile({ title, content, portalAddress });
@@ -1265,12 +1837,15 @@ var createCommand = new Command3().name("create").description("Create a new ddoc
 });
 
 // src/commands/updateCommand.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+init_esm_shims();
+import * as fs4 from "fs";
+import * as path5 from "path";
 import * as os2 from "os";
 import { Command as Command4 } from "commander";
 import { spawnSync } from "child_process";
 import Table4 from "cli-table3";
+init_models();
+init_config();
 function showTable(updatedFile) {
   const table = new Table4({
     head: [
@@ -1310,19 +1885,20 @@ var updateCommand = new Command4().name("update").description("Update an existin
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
-    const file = getFile(ddocId, portalAddress);
+    const file = await getFile(ddocId, portalAddress);
     if (!file) {
       throw new Error(`ddoc with ${ddocId} not found.`);
     }
     const filePath = options?.file ?? "";
     if (filePath) {
-      const content = fs3.readFileSync(filePath, "utf-8");
+      const content = fs4.readFileSync(filePath, "utf-8");
       if (!content || content.trim().length === 0) {
         throw new Error(`file content cannot be empty`);
       }
-      const basename3 = path3.basename(filePath);
+      const basename3 = path5.basename(filePath);
       const lastDotIndex = basename3.lastIndexOf(".");
       const title = lastDotIndex > 0 ? basename3.substring(0, lastDotIndex) : basename3;
       const payload = {
@@ -1334,15 +1910,15 @@ var updateCommand = new Command4().name("update").description("Update an existin
       showTable(updatedFile);
       return;
     }
-    const tmpFilePath = path3.join(os2.tmpdir(), `tmp-${ddocId}-${Date.now()}.txt`);
-    fs3.writeFileSync(tmpFilePath, file.content);
+    const tmpFilePath = path5.join(os2.tmpdir(), `tmp-${ddocId}-${Date.now()}.txt`);
+    fs4.writeFileSync(tmpFilePath, file.content);
     const editor = process.env.EDITOR || "vi";
     const result = spawnSync(editor, [tmpFilePath], { stdio: "inherit" });
     if (result.status === 0) {
-      const newContent = fs3.readFileSync(tmpFilePath, "utf-8");
+      const newContent = fs4.readFileSync(tmpFilePath, "utf-8");
       if (newContent === file.content) {
         console.log(`No changes made. Update cancelled.`);
-        fs3.unlinkSync(tmpFilePath);
+        fs4.unlinkSync(tmpFilePath);
         return;
       }
       const payload = {
@@ -1354,7 +1930,7 @@ var updateCommand = new Command4().name("update").description("Update an existin
       console.log("\n\u2713 Ddoc updated successfully!\n");
       showTable(updatedFile);
     }
-    fs3.unlinkSync(tmpFilePath);
+    fs4.unlinkSync(tmpFilePath);
   } catch (error) {
     console.error("Error updating ddoc:", error.message);
     throw error;
@@ -1362,13 +1938,17 @@ var updateCommand = new Command4().name("update").description("Update an existin
 });
 
 // src/commands/deleteCommand.ts
+init_esm_shims();
 import { Command as Command5 } from "commander";
+init_config();
+init_models();
 var deleteCommand = new Command5().name("delete").description("Delete one or more ddocs by their IDs").argument("<ddocIds...>", "One or more ddoc IDs to delete (space-separated)").action(async (ddocIds) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     for (const ddocId of ddocIds) {
       try {
@@ -1385,16 +1965,20 @@ var deleteCommand = new Command5().name("delete").description("Delete one or mor
 });
 
 // src/commands/downloadCommand.ts
+init_esm_shims();
 import { Command as Command6 } from "commander";
-import * as fs4 from "fs";
+import * as fs5 from "fs";
+init_config();
+init_models();
 var downloadCommand = new Command6().name("download").description("Download a ddoc to a local file").argument("<ddocId>", "The ddoc ID to download").option("-o, --output <filename>", "Output filename (only supports markdown)").action(async (ddocId, options) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
-    const file = getFile(ddocId, portalAddress);
+    const file = await getFile(ddocId, portalAddress);
     if (!file) {
       console.error(`Ddoc with ID "${ddocId}" not found.`);
       return;
@@ -1403,7 +1987,7 @@ var downloadCommand = new Command6().name("download").description("Download a dd
     if (options.output) {
       outputFilename = options.output.endsWith(".md") ? options.output : `${options.output}.md`;
     }
-    fs4.writeFileSync(outputFilename, file.content, "utf-8");
+    fs5.writeFileSync(outputFilename, file.content, "utf-8");
     console.log(`
 \u2713 Ddoc downloaded successfully to: ${outputFilename}
 `);
@@ -1414,15 +1998,19 @@ var downloadCommand = new Command6().name("download").description("Download a dd
 });
 
 // src/commands/viewCommand.ts
+init_esm_shims();
 import { Command as Command7 } from "commander";
+init_config();
+init_models();
 var viewCommand = new Command7().name("view").description("View content preview of a ddoc").argument("<ddocId>", "The ddoc ID to view").option("-n, --lines <number>", "Number of lines to preview (default: 10)", "10").action(async (ddocId, options) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
-    const file = getFile(ddocId, portalAddress);
+    const file = await getFile(ddocId, portalAddress);
     if (!file) {
       console.error(`Ddoc with ID "${ddocId}" not found.`);
       return;
@@ -1458,13 +2046,15 @@ Showing ${linesToShow} of ${totalLines} line${totalLines === 1 ? "" : "s"}
 });
 
 // src/commands/eventsCommand.ts
+init_esm_shims();
+init_models();
 import { Command as Command8 } from "commander";
 import Table5 from "cli-table3";
 var MAX_ERROR_LEN = 60;
 var eventsCommand = new Command8().name("events").description("Worker event operations (list failed, retry)");
 eventsCommand.command("list-failed").description("List all failed events").action(async () => {
   try {
-    const events = EventsModel.listFailed();
+    const events = await EventsModel.listFailed();
     if (events.length === 0) {
       console.log("No failed events.");
       return;
@@ -1497,7 +2087,7 @@ Failed events (${events.length}):
 });
 eventsCommand.command("retry <eventId>").description("Retry a single failed event by ID").action(async (eventId) => {
   try {
-    const updated = EventsModel.resetFailedToPending(eventId);
+    const updated = await EventsModel.resetFailedToPending(eventId);
     if (updated) {
       console.log(`Event ${eventId} reset to pending. Worker will pick it up.`);
     } else {
@@ -1512,7 +2102,7 @@ eventsCommand.command("retry <eventId>").description("Retry a single failed even
 });
 eventsCommand.command("retry-all").description("Retry all failed events").action(async () => {
   try {
-    const count = EventsModel.resetAllFailedToPending();
+    const count = await EventsModel.resetAllFailedToPending();
     console.log(`Reset ${count} failed event(s) to pending. Worker will pick them up.`);
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
@@ -1522,8 +2112,9 @@ eventsCommand.command("retry-all").description("Retry all failed events").action
 });
 
 // src/commands/index.ts
+init_infra();
 logger.level = "error";
-runMigrations();
+await runMigrations();
 var program = new Command9().name("ddctl").description("CLI tool to manage your ddocs").version("0.0.3").addHelpText("beforeAll", "\n").addHelpText("afterAll", "\n");
 program.addCommand(listCommand);
 program.addCommand(getCommand);