@openqa/cli 1.3.4 → 2.0.0

package/dist/database/index.js

@@ -1,11 +1,328 @@
+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 });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// database/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  OpenQASQLiteDatabase: () => OpenQASQLiteDatabase
+});
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+var OpenQASQLiteDatabase;
+var init_sqlite = __esm({
+  "database/sqlite.ts"() {
+    "use strict";
+    init_esm_shims();
+    OpenQASQLiteDatabase = class {
+      db;
+      constructor(dbPath = "./data/openqa.db") {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.migrate();
+      }
+      migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS config (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS test_sessions (
+        id            TEXT PRIMARY KEY,
+        started_at    TEXT NOT NULL,
+        ended_at      TEXT,
+        status        TEXT NOT NULL DEFAULT 'running',
+        total_actions INTEGER NOT NULL DEFAULT 0,
+        bugs_found    INTEGER NOT NULL DEFAULT 0,
+        metadata      TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS actions (
+        id              TEXT PRIMARY KEY,
+        session_id      TEXT NOT NULL,
+        timestamp       TEXT NOT NULL,
+        type            TEXT NOT NULL,
+        description     TEXT NOT NULL,
+        input           TEXT,
+        output          TEXT,
+        screenshot_path TEXT,
+        FOREIGN KEY (session_id) REFERENCES test_sessions(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS bugs (
+        id                TEXT PRIMARY KEY,
+        session_id        TEXT NOT NULL,
+        title             TEXT NOT NULL,
+        description       TEXT NOT NULL,
+        severity          TEXT NOT NULL DEFAULT 'medium',
+        status            TEXT NOT NULL DEFAULT 'open',
+        github_issue_url  TEXT,
+        screenshot_path   TEXT,
+        created_at        TEXT NOT NULL,
+        updated_at        TEXT NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES test_sessions(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS kanban_tickets (
+        id             TEXT PRIMARY KEY,
+        bug_id         TEXT,
+        title          TEXT NOT NULL,
+        description    TEXT NOT NULL,
+        priority       TEXT NOT NULL DEFAULT 'medium',
+        column         TEXT NOT NULL DEFAULT 'backlog',
+        tags           TEXT,
+        screenshot_url TEXT,
+        created_at     TEXT NOT NULL,
+        updated_at     TEXT NOT NULL
+      );
+    `);
+      }
+      // ── Config ──
+      async getConfig(key) {
+        const row = this.db.prepare("SELECT value FROM config WHERE key = ?").get(key);
+        return row?.value ?? null;
+      }
+      async setConfig(key, value) {
+        this.db.prepare("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)").run(key, value);
+      }
+      async getAllConfig() {
+        const rows = this.db.prepare("SELECT key, value FROM config").all();
+        return Object.fromEntries(rows.map((r) => [r.key, r.value]));
+      }
+      async clearAllConfig() {
+        this.db.prepare("DELETE FROM config").run();
+      }
+      // ── Sessions ──
+      async createSession(id, metadata) {
+        const session = {
+          id,
+          started_at: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "running",
+          total_actions: 0,
+          bugs_found: 0,
+          metadata: metadata ? JSON.stringify(metadata) : void 0
+        };
+        this.db.prepare(`
+      INSERT INTO test_sessions (id, started_at, status, total_actions, bugs_found, metadata)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(session.id, session.started_at, session.status, session.total_actions, session.bugs_found, session.metadata ?? null);
+        return session;
+      }
+      async getSession(id) {
+        return this.db.prepare("SELECT * FROM test_sessions WHERE id = ?").get(id) ?? null;
+      }
+      async updateSession(id, updates) {
+        const fields = Object.keys(updates).map((k) => `${k} = ?`).join(", ");
+        const values = [...Object.values(updates), id];
+        this.db.prepare(`UPDATE test_sessions SET ${fields} WHERE id = ?`).run(...values);
+      }
+      async getRecentSessions(limit = 10) {
+        return this.db.prepare("SELECT * FROM test_sessions ORDER BY started_at DESC LIMIT ?").all(limit);
+      }
+      // ── Actions ──
+      async createAction(action) {
+        const newAction = {
+          id: `action_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          ...action
+        };
+        this.db.prepare(`
+      INSERT INTO actions (id, session_id, timestamp, type, description, input, output, screenshot_path)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          newAction.id,
+          newAction.session_id,
+          newAction.timestamp,
+          newAction.type,
+          newAction.description,
+          newAction.input ?? null,
+          newAction.output ?? null,
+          newAction.screenshot_path ?? null
+        );
+        return newAction;
+      }
+      async getSessionActions(sessionId) {
+        return this.db.prepare("SELECT * FROM actions WHERE session_id = ? ORDER BY timestamp DESC").all(sessionId);
+      }
+      // ── Bugs ──
+      async createBug(bug) {
+        const newBug = {
+          id: `bug_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          ...bug
+        };
+        this.db.prepare(`
+      INSERT INTO bugs (id, session_id, title, description, severity, status, github_issue_url, screenshot_path, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          newBug.id,
+          newBug.session_id,
+          newBug.title,
+          newBug.description,
+          newBug.severity,
+          newBug.status,
+          newBug.github_issue_url ?? null,
+          newBug.screenshot_path ?? null,
+          newBug.created_at,
+          newBug.updated_at
+        );
+        return newBug;
+      }
+      async updateBug(id, updates) {
+        const patch = { ...updates, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+        const fields = Object.keys(patch).map((k) => `${k} = ?`).join(", ");
+        const values = [...Object.values(patch), id];
+        this.db.prepare(`UPDATE bugs SET ${fields} WHERE id = ?`).run(...values);
+      }
+      async getAllBugs() {
+        return this.db.prepare("SELECT * FROM bugs ORDER BY created_at DESC").all();
+      }
+      async getBugsByStatus(status) {
+        return this.db.prepare("SELECT * FROM bugs WHERE status = ? ORDER BY created_at DESC").all(status);
+      }
+      // ── Kanban ──
+      async createKanbanTicket(ticket) {
+        const newTicket = {
+          id: `ticket_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          ...ticket
+        };
+        this.db.prepare(`
+      INSERT INTO kanban_tickets (id, bug_id, title, description, priority, column, tags, screenshot_url, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          newTicket.id,
+          newTicket.bug_id ?? null,
+          newTicket.title,
+          newTicket.description,
+          newTicket.priority,
+          newTicket.column,
+          newTicket.tags ?? null,
+          newTicket.screenshot_url ?? null,
+          newTicket.created_at,
+          newTicket.updated_at
+        );
+        return newTicket;
+      }
+      async updateKanbanTicket(id, updates) {
+        const patch = { ...updates, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+        const fields = Object.keys(patch).map((k) => `"${k}" = ?`).join(", ");
+        const values = [...Object.values(patch), id];
+        this.db.prepare(`UPDATE kanban_tickets SET ${fields} WHERE id = ?`).run(...values);
+      }
+      async getKanbanTickets() {
+        return this.db.prepare("SELECT * FROM kanban_tickets ORDER BY created_at DESC").all();
+      }
+      async getKanbanTicketsByColumn(column) {
+        return this.db.prepare('SELECT * FROM kanban_tickets WHERE "column" = ? ORDER BY created_at DESC').all(column);
+      }
+      async deleteKanbanTicket(id) {
+        this.db.prepare("DELETE FROM kanban_tickets WHERE id = ?").run(id);
+      }
+      // ── Storage / Cleanup ──
+      async pruneOldSessions(maxAgeDays) {
+        const cutoff = new Date(Date.now() - maxAgeDays * 864e5).toISOString();
+        const oldSessions = this.db.prepare("SELECT id FROM test_sessions WHERE started_at < ?").all(cutoff);
+        const ids = oldSessions.map((s) => s.id);
+        if (ids.length === 0) return { sessionsRemoved: 0, actionsRemoved: 0 };
+        const placeholders = ids.map(() => "?").join(", ");
+        const actionsResult = this.db.prepare(`DELETE FROM actions WHERE session_id IN (${placeholders})`).run(...ids);
+        this.db.prepare(`DELETE FROM test_sessions WHERE id IN (${placeholders})`).run(...ids);
+        return { sessionsRemoved: ids.length, actionsRemoved: actionsResult.changes };
+      }
+      async getStorageStats() {
+        const count = (table) => this.db.prepare(`SELECT COUNT(*) as n FROM ${table}`).get().n;
+        return {
+          sessions: count("test_sessions"),
+          actions: count("actions"),
+          bugs: count("bugs"),
+          tickets: count("kanban_tickets")
+        };
+      }
+      // ── Compat helpers (used by daemon.ts) ──
+      async getActiveAgents() {
+        const sessions = await this.getRecentSessions(1);
+        const current = sessions[0];
+        const isRunning = current?.status === "running";
+        return [{
+          name: "Main Agent",
+          status: isRunning ? "running" : "idle",
+          purpose: "Autonomous QA orchestration",
+          performance: current ? Math.min(100, Math.round(current.total_actions / 100 * 100)) : 0,
+          tasks: current?.total_actions ?? 0
+        }];
+      }
+      async getCurrentTasks() {
+        const sessions = await this.getRecentSessions(1);
+        if (!sessions[0]) return [];
+        const actions = await this.getSessionActions(sessions[0].id);
+        return actions.slice(0, 10).map((a, i) => ({
+          id: a.id,
+          name: a.type,
+          status: i === 0 && sessions[0].status === "running" ? "running" : "completed",
+          progress: i === 0 && sessions[0].status === "running" ? "65%" : "100%",
+          agent: "Main Agent",
+          started_at: a.timestamp,
+          result: a.output || a.description
+        }));
+      }
+      async getCurrentIssues() {
+        const bugs = await this.getAllBugs();
+        return bugs.slice(0, 10).map((b) => ({
+          id: b.id,
+          title: b.title,
+          description: b.description,
+          severity: b.severity,
+          status: b.status,
+          discovered_at: b.created_at,
+          agent: "Main Agent"
+        }));
+      }
+      async close() {
+        this.db.close();
+      }
+    };
+  }
+});
+
 // database/index.ts
+init_esm_shims();
+init_sqlite();
 import { Low } from "lowdb";
 import { JSONFile } from "lowdb/node";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-import { mkdirSync } from "fs";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
+import { dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { mkdirSync as mkdirSync2 } from "fs";
+async function createDatabase(path2) {
+  if (path2.endsWith(".db")) {
+    const { OpenQASQLiteDatabase: OpenQASQLiteDatabase2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+    return new OpenQASQLiteDatabase2(path2);
+  }
+  return new OpenQADatabase(path2);
+}
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
 var OpenQADatabase = class {
   constructor(dbPath = "./data/openqa.json") {
     this.dbPath = dbPath;
@@ -13,15 +330,16 @@ var OpenQADatabase = class {
   }
   db = null;
   initialize() {
-    const dir = dirname(this.dbPath);
-    mkdirSync(dir, { recursive: true });
+    const dir = dirname2(this.dbPath);
+    mkdirSync2(dir, { recursive: true });
     const adapter = new JSONFile(this.dbPath);
     this.db = new Low(adapter, {
       config: {},
       test_sessions: [],
       actions: [],
       bugs: [],
-      kanban_tickets: []
+      kanban_tickets: [],
+      users: []
     });
     this.db.read();
     if (!this.db.data) {
@@ -30,7 +348,8 @@ var OpenQADatabase = class {
         test_sessions: [],
         actions: [],
         bugs: [],
-        kanban_tickets: []
+        kanban_tickets: [],
+        users: []
       };
       this.db.write();
     }
@@ -40,6 +359,12 @@ var OpenQADatabase = class {
       this.initialize();
     }
     await this.db.read();
+    let migrated = false;
+    if (!this.db.data.users) {
+      this.db.data.users = [];
+      migrated = true;
+    }
+    if (migrated) await this.db.write();
   }
   async getConfig(key) {
     await this.ensureInitialized();
@@ -163,83 +488,183 @@ var OpenQADatabase = class {
     await this.ensureInitialized();
     return this.db.data.kanban_tickets.filter((t) => t.column === column).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
   }
+  async deleteKanbanTicket(id) {
+    await this.ensureInitialized();
+    const index = this.db.data.kanban_tickets.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      this.db.data.kanban_tickets.splice(index, 1);
+      await this.db.write();
+    }
+  }
   async clearAllConfig() {
     await this.ensureInitialized();
     this.db.data.config = {};
     await this.db.write();
   }
-  // Get real data methods
+  // Get real data methods - connected to actual database records
   async getActiveAgents() {
     await this.ensureInitialized();
     const sessions = await this.getRecentSessions(1);
     const currentSession = sessions[0];
-    if (!currentSession) {
-      return [{ name: "Main Agent", status: "idle", purpose: "Autonomous testing", performance: 0, tasks: 0 }];
-    }
-    return [
-      { name: "Main Agent", status: "running", purpose: "Autonomous testing", performance: 85, tasks: currentSession.total_actions || 0 },
-      { name: "Browser Specialist", status: "running", purpose: "UI testing", performance: 92, tasks: Math.floor((currentSession.total_actions || 0) * 0.3) },
-      { name: "API Tester", status: "running", purpose: "API testing", performance: 78, tasks: Math.floor((currentSession.total_actions || 0) * 0.2) },
-      { name: "Auth Specialist", status: "idle", purpose: "Authentication testing", performance: 95, tasks: Math.floor((currentSession.total_actions || 0) * 0.1) },
-      { name: "UI Tester", status: "running", purpose: "User interface testing", performance: 88, tasks: Math.floor((currentSession.total_actions || 0) * 0.25) },
-      { name: "Security Scanner", status: "idle", purpose: "Security testing", performance: 91, tasks: Math.floor((currentSession.total_actions || 0) * 0.15) }
+    const isRunning = currentSession?.status === "running";
+    const totalActions = currentSession?.total_actions || 0;
+    const agents = [
+      {
+        name: "Main Agent",
+        status: isRunning ? "running" : "idle",
+        purpose: "Autonomous QA orchestration",
+        performance: totalActions > 0 ? Math.min(100, Math.round(totalActions / 100 * 100)) : 0,
+        tasks: totalActions
+      }
     ];
+    if (currentSession && totalActions > 0) {
+      const actions = await this.getSessionActions(currentSession.id);
+      const actionTypes = actions.reduce((acc, action) => {
+        const type = action.type || "unknown";
+        acc[type] = (acc[type] || 0) + 1;
+        return acc;
+      }, {});
+      if (actionTypes["navigate"] || actionTypes["click"] || actionTypes["screenshot"]) {
+        agents.push({
+          name: "Browser Specialist",
+          status: isRunning ? "running" : "idle",
+          purpose: "UI navigation and interaction",
+          performance: Math.round(((actionTypes["navigate"] || 0) + (actionTypes["click"] || 0)) / totalActions * 100),
+          tasks: (actionTypes["navigate"] || 0) + (actionTypes["click"] || 0)
+        });
+      }
+      if (actionTypes["api_call"] || actionTypes["request"]) {
+        agents.push({
+          name: "API Tester",
+          status: isRunning ? "running" : "idle",
+          purpose: "API endpoint testing",
+          performance: Math.round((actionTypes["api_call"] || actionTypes["request"] || 0) / totalActions * 100),
+          tasks: actionTypes["api_call"] || actionTypes["request"] || 0
+        });
+      }
+      if (actionTypes["auth"] || actionTypes["login"]) {
+        agents.push({
+          name: "Auth Specialist",
+          status: isRunning ? "running" : "idle",
+          purpose: "Authentication testing",
+          performance: Math.round((actionTypes["auth"] || actionTypes["login"] || 0) / totalActions * 100),
+          tasks: actionTypes["auth"] || actionTypes["login"] || 0
+        });
+      }
+    }
+    return agents;
   }
   async getCurrentTasks() {
     await this.ensureInitialized();
     const sessions = await this.getRecentSessions(1);
     const currentSession = sessions[0];
-    if (!currentSession || currentSession.status === "completed") {
+    if (!currentSession) {
       return [];
     }
-    const tasks = [];
-    const taskTypes = ["Scan Application", "Test Authentication", "Generate Tests", "Analyze Results", "Create Reports"];
-    for (let i = 0; i < Math.min(5, Math.floor((currentSession.total_actions || 0) / 10)); i++) {
-      const taskType = taskTypes[i % taskTypes.length];
-      const status = i === 0 ? "running" : i === 1 ? "pending" : "completed";
-      const progress = status === "completed" ? "100%" : status === "running" ? "65%" : "0%";
-      tasks.push({
-        id: `task_${i + 1}`,
-        name: taskType,
-        status,
-        progress,
-        agent: ["Main Agent", "Browser Specialist", "API Tester", "UI Tester"][i % 4],
-        started_at: new Date(Date.now() - i * 10 * 60 * 1e3).toISOString(),
-        result: status === "completed" ? "Successfully completed task execution" : null
-      });
-    }
-    return tasks;
+    const actions = await this.getSessionActions(currentSession.id);
+    const recentActions = actions.slice(-10).reverse();
+    return recentActions.map((action, index) => ({
+      id: action.id,
+      name: action.type || "Unknown Action",
+      status: index === 0 && currentSession.status === "running" ? "running" : "completed",
+      progress: index === 0 && currentSession.status === "running" ? "65%" : "100%",
+      agent: "Main Agent",
+      started_at: action.timestamp,
+      result: action.output || action.description || "Completed"
+    }));
   }
   async getCurrentIssues() {
     await this.ensureInitialized();
-    const sessions = await this.getRecentSessions(1);
-    const currentSession = sessions[0];
-    if (!currentSession) {
-      return [];
+    const bugs = await this.getAllBugs();
+    return bugs.slice(0, 10).map((bug) => ({
+      id: bug.id,
+      title: bug.title,
+      description: bug.description,
+      severity: bug.severity || "medium",
+      status: bug.status || "open",
+      discovered_at: bug.created_at,
+      agent: "Main Agent"
+    }));
+  }
+  async pruneOldSessions(maxAgeDays) {
+    await this.ensureInitialized();
+    const cutoff = new Date(Date.now() - maxAgeDays * 864e5).toISOString();
+    const oldSessions = this.db.data.test_sessions.filter((s) => s.started_at < cutoff);
+    const oldSessionIds = new Set(oldSessions.map((s) => s.id));
+    const actionsBefore = this.db.data.actions.length;
+    this.db.data.actions = this.db.data.actions.filter((a) => !oldSessionIds.has(a.session_id));
+    const actionsRemoved = actionsBefore - this.db.data.actions.length;
+    this.db.data.test_sessions = this.db.data.test_sessions.filter((s) => s.started_at >= cutoff);
+    await this.db.write();
+    return { sessionsRemoved: oldSessions.length, actionsRemoved };
+  }
+  async getStorageStats() {
+    await this.ensureInitialized();
+    return {
+      sessions: this.db.data.test_sessions.length,
+      actions: this.db.data.actions.length,
+      bugs: this.db.data.bugs.length,
+      tickets: this.db.data.kanban_tickets.length
+    };
+  }
+  // ── User management ──────────────────────────────────────────────────────────
+  async countUsers() {
+    await this.ensureInitialized();
+    return this.db.data.users.length;
+  }
+  async findUserByUsername(username) {
+    await this.ensureInitialized();
+    return this.db.data.users.find((u) => u.username === username) ?? null;
+  }
+  async getUserById(id) {
+    await this.ensureInitialized();
+    return this.db.data.users.find((u) => u.id === id) ?? null;
+  }
+  async getAllUsers() {
+    await this.ensureInitialized();
+    return [...this.db.data.users];
+  }
+  async createUser(data) {
+    await this.ensureInitialized();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const user = {
+      id: `user_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      username: data.username,
+      passwordHash: data.passwordHash,
+      role: data.role,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.data.users.push(user);
+    await this.db.write();
+    return user;
+  }
+  async updateUser(id, updates) {
+    await this.ensureInitialized();
+    const idx = this.db.data.users.findIndex((u) => u.id === id);
+    if (idx !== -1) {
+      this.db.data.users[idx] = {
+        ...this.db.data.users[idx],
+        ...updates,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.db.write();
     }
-    const issues = [];
-    const bugCount = currentSession.bugs_found || 0;
-    if (bugCount > 0) {
-      const issueTypes = ["Critical Security Issue", "Performance Bottleneck", "UI Bug", "API Error", "Authentication Flaw"];
-      const severities = ["critical", "high", "medium", "low"];
-      for (let i = 0; i < Math.min(bugCount, 5); i++) {
-        issues.push({
-          id: `issue_${i + 1}`,
-          title: issueTypes[i % issueTypes.length],
-          description: `Issue detected during automated testing session`,
-          severity: severities[i % severities.length],
-          status: "open",
-          discovered_at: new Date(Date.now() - i * 30 * 60 * 1e3).toISOString(),
-          agent: ["Main Agent", "Browser Specialist", "API Tester"][i % 3]
-        });
-      }
+  }
+  async deleteUser(id) {
+    await this.ensureInitialized();
+    const idx = this.db.data.users.findIndex((u) => u.id === id);
+    if (idx !== -1) {
+      this.db.data.users.splice(idx, 1);
+      await this.db.write();
     }
-    return issues;
   }
   async close() {
   }
 };
 export {
-  OpenQADatabase
+  OpenQADatabase,
+  OpenQASQLiteDatabase,
+  createDatabase
 };
 //# sourceMappingURL=index.js.map