@fireproof/core 0.18.0 → 0.19.0-dev-use-fix

package/store-sql-BG6SMGQJ.js

@@ -0,0 +1,344 @@
+import {
+  NotFoundError
+} from "./chunk-VZGT7ZYP.js";
+import {
+  ensureLogger,
+  ensureSQLOpts,
+  exception2Result,
+  exceptionWrapper,
+  getKey,
+  getName
+} from "./chunk-NZNG6TQT.js";
+import {
+  SysContainer
+} from "./chunk-H3A2HMMM.js";
+
+// src/runtime/store-sql/store-sql.ts
+import { Result } from "@adviser/cement";
+
+// src/runtime/store-sql/sqlite-adapter-better-sqlite3.ts
+import { KeyedResolvOnce } from "@adviser/cement";
+var onceSQLiteConnections = new KeyedResolvOnce();
+var SQLiteConnection = class _SQLiteConnection {
+  static fromURL(url, opts = {}) {
+    return new _SQLiteConnection(url, opts);
+  }
+  get client() {
+    if (!this._client) {
+      throw this.logger.Error().Msg("client not connected").AsError();
+    }
+    return this._client;
+  }
+  constructor(url, opts) {
+    this.opts = ensureSQLOpts(url, opts, "SQLiteConnection", { url });
+    this.logger = this.opts.logger;
+    this.url = url;
+    this.logger.Debug().Msg("constructor");
+  }
+  async connect() {
+    let fName = this.url.toString().replace("sqlite://", "").replace(/\?.*$/, "");
+    if (!fName) {
+      throw this.logger.Error().Str("url", this.url.toString()).Msg("filename is empty").AsError();
+    }
+    const hasName = this.url.searchParams.get("name");
+    if (hasName) {
+      fName = SysContainer.join(fName, hasName);
+      if (!fName.endsWith(".sqlite")) {
+        fName += ".sqlite";
+      }
+    }
+    this._client = await onceSQLiteConnections.get(fName).once(async () => {
+      this.logger.Debug().Str("filename", fName).Msg("connect");
+      const Sqlite3Database = (await import("better-sqlite3")).default;
+      if (hasName) {
+        await SysContainer.mkdir(SysContainer.dirname(fName), { recursive: true });
+      }
+      const db = new Sqlite3Database(fName, {
+        // verbose: console.log,
+        nativeBinding: "./node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+      });
+      if (!db) {
+        throw this.logger.Error().Msg("connect failed").AsError();
+      }
+      return db;
+    });
+  }
+  async close() {
+    this.logger.Debug().Msg("close");
+    await this.client.close();
+  }
+};
+
+// src/runtime/store-sql/sql-connection-factory.ts
+function SQLConnectionFactory(databaseURL, opts = {}) {
+  const logger = ensureLogger(opts, "SQLFactory");
+  switch (databaseURL.protocol) {
+    case "sqlite:":
+      logger.Debug().Str("databaseURL", databaseURL.toString()).Msg("connecting to sqlite");
+      return SQLiteConnection.fromURL(databaseURL, {
+        ...opts,
+        logger
+      });
+    default:
+      throw logger.Error().Msg("unsupported protocol " + databaseURL.protocol).AsError();
+  }
+}
+
+// src/runtime/store-sql/store-version-factory.ts
+async function WalStoreFactory(db) {
+  switch (db.opts.sqlFlavor) {
+    case "sqlite": {
+      const { V0_18_0SQLiteWalStore } = await import("./sqlite-wal-store-JFBQPOYT.js");
+      const store = new V0_18_0SQLiteWalStore(db);
+      return store;
+    }
+    default:
+      throw ensureLogger(db.opts, "WalStoreFactory").Error().Msg("unsupported db connection").AsError();
+  }
+}
+async function DataStoreFactory(db) {
+  switch (db.opts.sqlFlavor) {
+    case "sqlite": {
+      const { V0_18_0SQLiteDataStore } = await import("./sqlite-data-store-3ST7XOLX.js");
+      const store = new V0_18_0SQLiteDataStore(db);
+      return store;
+    }
+    default:
+      throw ensureLogger(db.opts, "DataStoreFactory").Error().Msg("unsupported db connection").AsError();
+  }
+}
+async function MetaStoreFactory(db) {
+  switch (db.opts.sqlFlavor) {
+    case "sqlite": {
+      const { V0_18_0SQLiteMetaStore } = await import("./sqlite-meta-store-QOIMCSJ7.js");
+      const store = new V0_18_0SQLiteMetaStore(db);
+      return store;
+    }
+    default:
+      throw ensureLogger(db.opts, "MetaStoreFactory").Error().Msg("unsupported db connection").AsError();
+  }
+}
+
+// src/runtime/store-sql/store-sql.ts
+var SQLWalGateway = class {
+  constructor(logger) {
+    this.walSQLStore = {};
+    this.logger = ensureLogger(logger, "SQLWalGateway");
+  }
+  buildUrl(baseUrl, key) {
+    const url = new URL(baseUrl.toString());
+    url.searchParams.set("key", key);
+    return Promise.resolve(Result.Ok(url));
+  }
+  async start(baseUrl) {
+    return exception2Result(async () => {
+      this.logger.Debug().Url(baseUrl).Msg("start");
+      const conn = SQLConnectionFactory(baseUrl);
+      const ws = await WalStoreFactory(conn);
+      await ws.start(baseUrl);
+      this.walSQLStore = ws;
+    });
+  }
+  close(baseUrl) {
+    return this.walSQLStore.close(baseUrl);
+  }
+  destroy(baseUrl) {
+    return this.walSQLStore.destroy(baseUrl);
+  }
+  async put(url, body) {
+    return exception2Result(async () => {
+      const branch = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      await this.walSQLStore.insert(url, {
+        state: body,
+        updated_at: /* @__PURE__ */ new Date(),
+        name,
+        branch
+      });
+    });
+  }
+  async get(url) {
+    return exceptionWrapper(async () => {
+      const branch = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      const record = await this.walSQLStore.select(url, { name, branch });
+      if (record.length === 0) {
+        return Result.Err(new NotFoundError(`not found ${name} ${branch}`));
+      }
+      return Result.Ok(record[0].state);
+    });
+  }
+  async delete(url) {
+    return exception2Result(async () => {
+      const branch = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      await this.walSQLStore.delete(url, { name, branch });
+    });
+  }
+};
+var SQLMetaGateway = class {
+  constructor(logger) {
+    this.metaSQLStore = {};
+    this.logger = ensureLogger(logger, "SQLMetaGateway");
+  }
+  buildUrl(baseUrl, key) {
+    const url = new URL(baseUrl.toString());
+    url.searchParams.set("key", key);
+    return Promise.resolve(Result.Ok(url));
+  }
+  async start(baseUrl) {
+    return exception2Result(async () => {
+      this.logger.Debug().Url(baseUrl).Msg("start");
+      const conn = SQLConnectionFactory(baseUrl);
+      const ws = await MetaStoreFactory(conn);
+      await ws.start(baseUrl);
+      this.metaSQLStore = ws;
+      this.logger.Debug().Url(baseUrl).Msg("started");
+    });
+  }
+  close(baseUrl) {
+    return this.metaSQLStore.close(baseUrl);
+  }
+  destroy(baseUrl) {
+    return this.metaSQLStore.destroy(baseUrl);
+  }
+  async put(url, body) {
+    return exception2Result(async () => {
+      const branch = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      await this.metaSQLStore.insert(url, {
+        meta: body,
+        updated_at: /* @__PURE__ */ new Date(),
+        name,
+        branch
+      });
+    });
+  }
+  async get(url) {
+    return exceptionWrapper(async () => {
+      const branch = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      const record = await this.metaSQLStore.select(url, {
+        name,
+        branch
+      });
+      if (record.length === 0) {
+        return Result.Err(new NotFoundError(`not found ${name} ${branch}`));
+      }
+      return Result.Ok(record[0].meta);
+    });
+  }
+  async delete(url) {
+    return exception2Result(async () => {
+      const branch = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      await this.metaSQLStore.delete(url, {
+        name,
+        branch
+      });
+    });
+  }
+};
+var SQLDataGateway = class {
+  constructor(logger) {
+    this.dataSQLStore = {};
+    this.logger = ensureLogger(logger, "SQLDataGateway");
+  }
+  buildUrl(baseUrl, key) {
+    const url = new URL(baseUrl.toString());
+    url.searchParams.set("key", key);
+    return Promise.resolve(Result.Ok(url));
+  }
+  async start(baseUrl) {
+    return exception2Result(async () => {
+      this.logger.Debug().Url(baseUrl).Msg("pre-sql-connection");
+      const conn = SQLConnectionFactory(baseUrl);
+      this.logger.Debug().Url(baseUrl).Msg("post-sql-connection");
+      const ws = await DataStoreFactory(conn);
+      this.logger.Debug().Url(baseUrl).Msg("post-data-store-factory");
+      await ws.start(baseUrl);
+      this.dataSQLStore = ws;
+      this.logger.Debug().Url(baseUrl).Msg("started");
+    });
+  }
+  close(baseUrl) {
+    return this.dataSQLStore.close(baseUrl);
+  }
+  destroy(baseUrl) {
+    return this.dataSQLStore.destroy(baseUrl);
+  }
+  async put(url, body) {
+    return exception2Result(async () => {
+      const cid = getKey(url, this.logger);
+      const name = getName(url, this.logger);
+      await this.dataSQLStore.insert(url, {
+        data: body,
+        updated_at: /* @__PURE__ */ new Date(),
+        name,
+        car: cid
+      });
+    });
+  }
+  async get(url) {
+    return exceptionWrapper(async () => {
+      const branch = getKey(url, this.logger);
+      const record = await this.dataSQLStore.select(url, branch);
+      if (record.length === 0) {
+        return Result.Err(new NotFoundError(`not found ${branch}`));
+      }
+      return Result.Ok(record[0].data);
+    });
+  }
+  async delete(url) {
+    return exception2Result(async () => {
+      const branch = getKey(url, this.logger);
+      await this.dataSQLStore.delete(url, branch);
+      return Result.Ok(void 0);
+    });
+  }
+};
+var SQLTestStore = class {
+  constructor(ilogger) {
+    const logger = ensureLogger(ilogger, "SQLTestStore");
+    this.logger = logger;
+  }
+  async get(url, key) {
+    const conn = SQLConnectionFactory(url);
+    const name = getName(url, this.logger);
+    switch (url.searchParams.get("store")) {
+      case "wal": {
+        const sqlStore = await WalStoreFactory(conn);
+        await sqlStore.start(url);
+        const records = await sqlStore.select(url, {
+          name,
+          branch: key
+        });
+        return records[0].state;
+      }
+      case "meta": {
+        const sqlStore = await MetaStoreFactory(conn);
+        await sqlStore.start(url);
+        const records = await sqlStore.select(url, {
+          name,
+          branch: key
+        });
+        return records[0].meta;
+      }
+      case "data": {
+        const sqlStore = await DataStoreFactory(conn);
+        await sqlStore.start(url);
+        const records = await sqlStore.select(url, key);
+        return records[0].data;
+      }
+      default:
+        throw this.logger.Error().Str("key", key).Msg(`Method not implemented`);
+    }
+  }
+};
+export {
+  SQLDataGateway,
+  SQLMetaGateway,
+  SQLTestStore,
+  SQLWalGateway
+};
+//# sourceMappingURL=store-sql-BG6SMGQJ.js.map

package/store-sql-BG6SMGQJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/store-sql/store-sql.ts","../../src/runtime/store-sql/sqlite-adapter-better-sqlite3.ts","../../src/runtime/store-sql/sql-connection-factory.ts","../../src/runtime/store-sql/store-version-factory.ts"],"sourcesContent":["import { Logger, Result } from \"@adviser/cement\";\n\nimport { TestStore } from \"../../blockstore/types.js\";\nimport { SQLConnectionFactory } from \"./sql-connection-factory.js\";\nimport { DataSQLStore, MetaSQLStore, WalSQLStore } from \"./types.js\";\nimport { DataStoreFactory, MetaStoreFactory, WalStoreFactory } from \"./store-version-factory.js\";\nimport { ensureLogger, exception2Result, exceptionWrapper, getKey, getName } from \"../../utils.js\";\nimport { Gateway, GetResult, NotFoundError } from \"../../blockstore/gateway.js\";\n\nexport class SQLWalGateway implements Gateway {\n  readonly logger: Logger;\n  walSQLStore: WalSQLStore = {} as WalSQLStore;\n  constructor(logger: Logger) {\n    this.logger = ensureLogger(logger, \"SQLWalGateway\");\n  }\n\n  buildUrl(baseUrl: URL, key: string): Promise<Result<URL>> {\n    const url = new URL(baseUrl.toString());\n    url.searchParams.set(\"key\", key);\n    return Promise.resolve(Result.Ok(url));\n  }\n\n  async start(baseUrl: URL): Promise<Result<void>> {\n    return exception2Result(async () => {\n      this.logger.Debug().Url(baseUrl).Msg(\"start\");\n      const conn = SQLConnectionFactory(baseUrl);\n      const ws = await WalStoreFactory(conn);\n      await ws.start(baseUrl);\n      this.walSQLStore = ws;\n    });\n  }\n  close(baseUrl: URL) {\n    return this.walSQLStore.close(baseUrl);\n  }\n  destroy(baseUrl: URL) {\n    return this.walSQLStore.destroy(baseUrl);\n  }\n\n  async put(url: URL, body: Uint8Array): Promise<Result<void>> {\n    return exception2Result(async () => {\n      const branch = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      await this.walSQLStore.insert(url, {\n        state: body,\n        updated_at: new Date(),\n        name,\n        branch,\n      });\n    });\n  }\n  async get(url: URL): Promise<GetResult> {\n    return exceptionWrapper(async () => {\n      const branch = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      const record = await this.walSQLStore.select(url, { name, branch });\n      if (record.length === 0) {\n        return Result.Err(new NotFoundError(`not found ${name} ${branch}`));\n      }\n      return Result.Ok(record[0].state);\n    });\n  }\n  async delete(url: URL): Promise<Result<void>> {\n    return exception2Result(async () => {\n      const branch = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      await this.walSQLStore.delete(url, { name, branch });\n    });\n  }\n}\n\nexport class SQLMetaGateway implements Gateway {\n  readonly logger: Logger;\n  metaSQLStore: MetaSQLStore = {} as MetaSQLStore;\n  constructor(logger: Logger) {\n    this.logger = ensureLogger(logger, \"SQLMetaGateway\");\n  }\n\n  buildUrl(baseUrl: URL, key: string): Promise<Result<URL>> {\n    const url = new URL(baseUrl.toString());\n    url.searchParams.set(\"key\", key);\n    return Promise.resolve(Result.Ok(url));\n  }\n\n  async start(baseUrl: URL): Promise<Result<void>> {\n    return exception2Result(async () => {\n      this.logger.Debug().Url(baseUrl).Msg(\"start\");\n      const conn = SQLConnectionFactory(baseUrl);\n      const ws = await MetaStoreFactory(conn);\n      await ws.start(baseUrl);\n      this.metaSQLStore = ws;\n      this.logger.Debug().Url(baseUrl).Msg(\"started\");\n    });\n  }\n  close(baseUrl: URL): Promise<Result<void>> {\n    return this.metaSQLStore.close(baseUrl);\n  }\n  destroy(baseUrl: URL): Promise<Result<void>> {\n    return this.metaSQLStore.destroy(baseUrl);\n  }\n\n  async put(url: URL, body: Uint8Array): Promise<Result<void>> {\n    return exception2Result(async () => {\n      const branch = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      await this.metaSQLStore.insert(url, {\n        meta: body,\n        updated_at: new Date(),\n        name,\n        branch,\n      });\n    });\n  }\n  async get(url: URL): Promise<GetResult> {\n    return exceptionWrapper(async () => {\n      const branch = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      const record = await this.metaSQLStore.select(url, {\n        name,\n        branch,\n      });\n      if (record.length === 0) {\n        return Result.Err(new NotFoundError(`not found ${name} ${branch}`));\n      }\n      return Result.Ok(record[0].meta);\n    });\n  }\n  async delete(url: URL): Promise<Result<void>> {\n    return exception2Result(async () => {\n      const branch = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      await this.metaSQLStore.delete(url, {\n        name,\n        branch,\n      });\n    });\n  }\n}\n\nexport class SQLDataGateway implements Gateway {\n  readonly logger: Logger;\n  dataSQLStore: DataSQLStore = {} as DataSQLStore;\n  constructor(logger: Logger) {\n    this.logger = ensureLogger(logger, \"SQLDataGateway\");\n  }\n\n  buildUrl(baseUrl: URL, key: string): Promise<Result<URL>> {\n    const url = new URL(baseUrl.toString());\n    url.searchParams.set(\"key\", key);\n    return Promise.resolve(Result.Ok(url));\n  }\n\n  async start(baseUrl: URL): Promise<Result<void>> {\n    return exception2Result(async () => {\n      this.logger.Debug().Url(baseUrl).Msg(\"pre-sql-connection\");\n      const conn = SQLConnectionFactory(baseUrl);\n      this.logger.Debug().Url(baseUrl).Msg(\"post-sql-connection\");\n      const ws = await DataStoreFactory(conn);\n      this.logger.Debug().Url(baseUrl).Msg(\"post-data-store-factory\");\n      await ws.start(baseUrl);\n      this.dataSQLStore = ws;\n      this.logger.Debug().Url(baseUrl).Msg(\"started\");\n    });\n  }\n  close(baseUrl: URL): Promise<Result<void>> {\n    return this.dataSQLStore.close(baseUrl);\n  }\n  destroy(baseUrl: URL): Promise<Result<void>> {\n    return this.dataSQLStore.destroy(baseUrl);\n  }\n\n  async put(url: URL, body: Uint8Array): Promise<Result<void>> {\n    return exception2Result(async () => {\n      const cid = getKey(url, this.logger);\n      const name = getName(url, this.logger);\n      await this.dataSQLStore.insert(url, {\n        data: body,\n        updated_at: new Date(),\n        name: name,\n        car: cid,\n      });\n    });\n  }\n  async get(url: URL): Promise<GetResult> {\n    return exceptionWrapper(async () => {\n      const branch = getKey(url, this.logger);\n      const record = await this.dataSQLStore.select(url, branch);\n      if (record.length === 0) {\n        return Result.Err(new NotFoundError(`not found ${branch}`));\n      }\n      return Result.Ok(record[0].data);\n    });\n  }\n  async delete(url: URL): Promise<Result<void>> {\n    return exception2Result(async () => {\n      const branch = getKey(url, this.logger);\n      await this.dataSQLStore.delete(url, branch);\n      return Result.Ok(undefined);\n    });\n  }\n}\n\nexport class SQLTestStore implements TestStore {\n  readonly logger: Logger;\n  constructor(ilogger: Logger) {\n    const logger = ensureLogger(ilogger, \"SQLTestStore\");\n    this.logger = logger;\n  }\n  async get(url: URL, key: string): Promise<Uint8Array> {\n    const conn = SQLConnectionFactory(url);\n    const name = getName(url, this.logger);\n    switch (url.searchParams.get(\"store\")) {\n      case \"wal\": {\n        const sqlStore = await WalStoreFactory(conn);\n        await sqlStore.start(url);\n        const records = await sqlStore.select(url, {\n          name,\n          branch: key,\n        });\n        return records[0].state;\n      }\n      case \"meta\": {\n        const sqlStore = await MetaStoreFactory(conn);\n        await sqlStore.start(url);\n        const records = await sqlStore.select(url, {\n          name,\n          branch: key,\n        });\n        return records[0].meta;\n      }\n      case \"data\": {\n        const sqlStore = await DataStoreFactory(conn);\n        await sqlStore.start(url);\n        const records = await sqlStore.select(url, key);\n        return records[0].data;\n      }\n      default:\n        throw this.logger.Error().Str(\"key\", key).Msg(`Method not implemented`);\n    }\n  }\n}\n","import type { Database } from \"better-sqlite3\";\nimport { KeyedResolvOnce, Logger } from \"@adviser/cement\";\n\nimport { DBConnection, SQLOpts } from \"./types.js\";\nimport { SysContainer } from \"../sys-container.js\";\nimport { ensureSQLOpts } from \"./ensurer.js\";\n\n// export function SimpleSQLite(filename: string, opts?: Partial<SQLOpts>): StoreOpts {\n//     ensureLogger(opts, \"SimpleSQLite\").Debug().Str(\"filename\", filename).Msg(\"SimpleSQLite\")\n//     const db = SQLiteConnection.fromFilename(filename, opts)\n//     return SQLiteStoreOptions({\n//         data: DataStoreFactory(db, opts),\n//         meta: MetaStoreFactory(db, opts),\n//         wal: WalStoreFactory(db, opts)\n//     }, opts)\n// }\n\nconst onceSQLiteConnections = new KeyedResolvOnce<Database>();\nexport class SQLiteConnection implements DBConnection {\n  static fromURL(url: URL, opts: Partial<SQLOpts> = {}): DBConnection {\n    return new SQLiteConnection(url, opts);\n  }\n  readonly url: URL;\n  readonly logger: Logger;\n  _client?: Database;\n\n  readonly opts: SQLOpts;\n\n  get client(): Database {\n    if (!this._client) {\n      throw this.logger.Error().Msg(\"client not connected\").AsError();\n    }\n    return this._client;\n  }\n\n  private constructor(url: URL, opts: Partial<SQLOpts>) {\n    // console.log(\"better-sqlite3->url->\", url);\n    this.opts = ensureSQLOpts(url, opts, \"SQLiteConnection\", { url });\n    this.logger = this.opts.logger;\n    this.url = url;\n    this.logger.Debug().Msg(\"constructor\");\n  }\n  async connect(): Promise<void> {\n    let fName = this.url.toString().replace(\"sqlite://\", \"\").replace(/\\?.*$/, \"\");\n    if (!fName) {\n      throw this.logger.Error().Str(\"url\", this.url.toString()).Msg(\"filename is empty\").AsError();\n    }\n    // const version = this.url.searchParams.get(\"version\");\n    // if (!version) {\n    //   throw this.logger.Error().Str(\"url\", this.url.toString()).Msg(\"version not found\").AsError();\n    // }\n    const hasName = this.url.searchParams.get(\"name\");\n    if (hasName) {\n      fName = SysContainer.join(fName, hasName);\n      if (!fName.endsWith(\".sqlite\")) {\n        fName += \".sqlite\";\n      }\n    }\n    this._client = await onceSQLiteConnections.get(fName).once(async () => {\n      this.logger.Debug().Str(\"filename\", fName).Msg(\"connect\");\n      const Sqlite3Database = (await import(\"better-sqlite3\")).default;\n      if (hasName) {\n        await SysContainer.mkdir(SysContainer.dirname(fName), { recursive: true });\n      }\n      const db = new Sqlite3Database(fName, {\n        // verbose: console.log,\n        nativeBinding: \"./node_modules/better-sqlite3/build/Release/better_sqlite3.node\",\n      });\n      // this.logger.Debug().Any(\"client\", this.client).Msg(\"connected\")\n      if (!db) {\n        throw this.logger.Error().Msg(\"connect failed\").AsError();\n      }\n      return db;\n    });\n  }\n  async close(): Promise<void> {\n    this.logger.Debug().Msg(\"close\");\n    await this.client.close();\n  }\n}\n","import { ensureLogger } from \"../../utils.js\";\nimport { SQLiteConnection } from \"./sqlite-adapter-better-sqlite3.js\";\nimport { DBConnection, SQLOpts } from \"./types.js\";\n\nexport function SQLConnectionFactory(databaseURL: URL, opts: Partial<SQLOpts> = {}): DBConnection {\n  const logger = ensureLogger(opts, \"SQLFactory\");\n  switch (databaseURL.protocol) {\n    case \"sqlite:\":\n      logger.Debug().Str(\"databaseURL\", databaseURL.toString()).Msg(\"connecting to sqlite\");\n      return SQLiteConnection.fromURL(databaseURL, {\n        ...opts,\n        logger,\n      });\n    default:\n      throw logger\n        .Error()\n        .Msg(\"unsupported protocol \" + databaseURL.protocol)\n        .AsError();\n  }\n}\n","import { Logger } from \"@adviser/cement\";\nimport { ensureLogger, LoggerOpts } from \"../../utils\";\nimport { DBConnection, DataSQLStore, MetaSQLStore, WalSQLStore } from \"./types\";\nimport { SQLITE_VERSION } from \"./v0.19-sqlite/version\";\n\nexport function prepareSQLVersion(iurl: URL, opts: LoggerOpts | Logger): URL {\n  if (iurl.searchParams.get(\"version\")) return iurl;\n  const url = new URL(iurl.toString());\n  switch (url.protocol) {\n    case \"sqlite:\":\n      {\n        url.searchParams.set(\"version\", SQLITE_VERSION);\n      }\n      break;\n    default:\n      throw ensureLogger(opts, \"ensureSQLVersion\").Error().Str(\"url\", url.toString()).Msg(\"unsupported protocol\").AsError();\n  }\n  return url;\n}\n\nexport async function WalStoreFactory(db: DBConnection): Promise<WalSQLStore> {\n  switch (db.opts.sqlFlavor) {\n    case \"sqlite\": {\n      const { V0_18_0SQLiteWalStore } = await import(\"./v0.19-sqlite/sqlite-wal-store.js\");\n      const store = new V0_18_0SQLiteWalStore(db);\n      return store;\n    }\n    default:\n      throw ensureLogger(db.opts, \"WalStoreFactory\").Error().Msg(\"unsupported db connection\").AsError();\n  }\n}\n\nexport async function DataStoreFactory(db: DBConnection): Promise<DataSQLStore> {\n  switch (db.opts.sqlFlavor) {\n    case \"sqlite\": {\n      const { V0_18_0SQLiteDataStore } = await import(\"./v0.19-sqlite/sqlite-data-store.js\");\n      const store = new V0_18_0SQLiteDataStore(db);\n      return store;\n    }\n    default:\n      throw ensureLogger(db.opts, \"DataStoreFactory\").Error().Msg(\"unsupported db connection\").AsError();\n  }\n}\n\nexport async function MetaStoreFactory(db: DBConnection): Promise<MetaSQLStore> {\n  switch (db.opts.sqlFlavor) {\n    case \"sqlite\": {\n      const { V0_18_0SQLiteMetaStore } = await import(\"./v0.19-sqlite/sqlite-meta-store.js\");\n      const store = new V0_18_0SQLiteMetaStore(db);\n      return store;\n    }\n    default:\n      throw ensureLogger(db.opts, \"MetaStoreFactory\").Error().Msg(\"unsupported db connection\").AsError();\n  }\n}\n"],"mappings":"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","names":[]}

package/tests/blockstore/loader.test.ts

@@ -0,0 +1,265 @@
+import * as codec from "@ipld/dag-cbor";
+import { sha256 as hasher } from "multiformats/hashes/sha2";
+import { BlockView } from "multiformats";
+import { encode } from "multiformats/block";
+import { CID } from "multiformats/cid";
+import { MemoryBlockstore } from "@web3-storage/pail/block";
+import { CRDTMeta, IndexTransactionMeta, bs, rt } from "@fireproof/core";
+
+class MyMemoryBlockStore extends bs.EncryptedBlockstore {
+  readonly memblock = new MemoryBlockstore();
+  constructor() {
+    const ebOpts = {
+      name: "MyMemoryBlockStore",
+    };
+    super(ebOpts);
+  }
+  ready(): Promise<void> {
+    return Promise.resolve();
+  }
+  close(): Promise<void> {
+    return this.loader.close();
+  }
+  loader = new bs.Loader("MyMemoryBlockStore", {});
+  readonly transactions = new Set<bs.CarTransaction>();
+  // readonly lastTxMeta?: TransactionMeta;
+  readonly compacting: boolean = false;
+
+  override async put(cid: bs.AnyAnyLink, block: Uint8Array): Promise<void> {
+    return this.memblock.put(cid, block);
+  }
+
+  // transaction<M ext(fn: (t: CarTransaction) => Promise<MetaType>, opts?: { noLoader: boolean }): Promise<MetaType> {
+  //   throw new Error("Method not implemented.");
+  // }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getFile(car: bs.AnyLink, cid: bs.AnyLink, isPublic?: boolean): Promise<Uint8Array> {
+    throw new Error("Method not implemented.");
+  }
+  compact(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  defaultCompact(blocks: bs.CompactionFetcher): Promise<bs.TransactionMeta> {
+    throw new Error("Method not implemented.");
+  }
+}
+
+describe("basic Loader simple", function () {
+  let loader: bs.Loader;
+  let block: BlockView;
+  let t: bs.CarTransaction;
+
+  afterEach(async function () {
+    await loader.close();
+    await loader.destroy();
+  });
+
+  beforeEach(async function () {
+    const testDbName = "test-loader-commit";
+    await rt.SysContainer.start();
+    const mockM = new MyMemoryBlockStore();
+    t = new bs.CarTransaction(mockM as bs.EncryptedBlockstore);
+    loader = new bs.Loader(testDbName, { public: true });
+    await loader.ready();
+    block = await encode({
+      value: { hello: "world" },
+      hasher,
+      codec,
+    });
+    await t.put(block.cid, block.bytes);
+    await mockM.put(block.cid, block.bytes);
+  });
+  it("should have an empty car log", function () {
+    expect(loader.carLog.length).toBe(0);
+  });
+  it("should commit", async function () {
+    const carGroup = await loader.commit(t, { head: [block.cid] });
+    expect(loader.carLog.length).toBe(1);
+    const reader = await loader.loadCar(carGroup[0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+});
+
+describe("basic Loader with two commits", function () {
+  let loader: bs.Loader;
+  let block: BlockView;
+  let block2: BlockView;
+  let block3: BlockView;
+  let block4: BlockView;
+  let t: bs.CarTransaction;
+  let carCid: bs.CarGroup;
+  let carCid0: bs.CarGroup;
+
+  afterEach(async function () {
+    await loader.close();
+    await loader.destroy();
+  });
+
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    const mockM = new MyMemoryBlockStore();
+    t = new bs.CarTransaction(mockM);
+    loader = new bs.Loader("test-loader-two-commit", { public: true });
+    block = await encode({
+      value: { hello: "world" },
+      hasher,
+      codec,
+    });
+    await t.put(block.cid, block.bytes);
+    carCid0 = await loader.commit(t, { head: [block.cid] });
+
+    block2 = await encode({
+      value: { hello: "universe" },
+      hasher,
+      codec,
+    });
+    await t.put(block2.cid, block2.bytes);
+    carCid = await loader.commit(t, { head: [block2.cid] });
+
+    block3 = await encode({
+      value: { hello: "multiverse" },
+      hasher,
+      codec,
+    });
+    await t.put(block3.cid, block3.bytes);
+
+    block4 = await encode({
+      value: { hello: "megaverse" },
+      hasher,
+      codec,
+    });
+
+    await t.put(block4.cid, block4.bytes);
+  });
+
+  it("should have a car log", function () {
+    expect(loader.carLog.length).toBe(2);
+    expect(loader.carLog[0].toString()).toBe(carCid.toString());
+    expect(loader.carLog[1].toString()).toBe(carCid0.toString());
+  });
+
+  it("should commit", async function () {
+    const reader = await loader.loadCar(carCid[0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.compact.length).toBe(0);
+    expect(parsed.cars.length).toBe(1);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+
+  it("should compact", async function () {
+    const compactCid = await loader.commit(t, { head: [block2.cid] }, { compact: true });
+    expect(loader.carLog.length).toBe(1);
+
+    const reader = await loader.loadCar(compactCid[0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.compact.length).toBe(2);
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+
+  it("compact should erase old files", async function () {
+    const cs = await loader.carStore();
+    await loader.commit(t, { head: [block2.cid] }, { compact: true });
+    expect(loader.carLog.length).toBe(1);
+    await loader.commit(t, { head: [block3.cid] }, { compact: false });
+    expect(loader.carLog.length).toBe(2);
+    expect(await cs.load(carCid[0])).toBeTruthy();
+    await loader.commit(t, { head: [block3.cid] }, { compact: true });
+    expect(loader.carLog.length).toBe(1);
+    const e0 = await cs.load(carCid[0]).catch((e) => e);
+    expect(e0 instanceof Error).toBeTruthy();
+    await loader.commit(t, { head: [block4.cid] }, { compact: false });
+    expect(loader.carLog.length).toBe(2);
+
+    const e = await loader.loadCar(carCid[0]).catch((e) => e);
+    expect(e).toBeTruthy();
+    expect(e instanceof Error).toBeTruthy();
+    expect(e.message).toMatch("missing car file");
+  }, 10000);
+});
+
+describe("basic Loader with index commits", function () {
+  let block: BlockView;
+  let ib: bs.EncryptedBlockstore;
+  let indexerResult: IndexTransactionMeta;
+  let cid: CID;
+  // let indexMap: Map<string, CID>;
+
+  afterEach(async function () {
+    await ib.close();
+    await ib.destroy();
+  });
+
+  beforeEach(async function () {
+    const name = "test-loader-index" + Math.random();
+    await rt.SysContainer.start();
+    // t = new CarTransaction()
+    ib = new bs.EncryptedBlockstore({ name });
+    block = await encode({
+      value: { hello: "world" },
+      hasher,
+      codec,
+    });
+    // console.log('block', block.cid)
+
+    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
+    indexerResult = {
+      indexes: {
+        hello: {
+          byId: cid,
+          byKey: cid,
+          head: [cid as CID<unknown, number, number, 1>],
+          name: "hello",
+          map: "(doc) => doc.hello",
+        },
+      },
+    };
+    // indexMap = new Map();
+  });
+
+  it("should start with an empty car log", function () {
+    expect(ib.loader).toBeTruthy();
+    expect(ib.loader.carLog.length).toBe(0);
+  });
+
+  it("should commit the index metadata", async function () {
+    const { cars: carCid } = await ib.transaction<IndexTransactionMeta>(
+      async (t) => {
+        await t.put(block.cid, block.bytes);
+        return indexerResult;
+      } /* , indexMap */,
+    );
+
+    expect(carCid).toBeTruthy();
+    expect(ib.loader).toBeTruthy();
+    const carLog = ib.loader.carLog;
+
+    expect(carLog.length).toBe(1);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const reader = await ib.loader.loadCar(carCid![0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<IndexTransactionMeta>(reader, ib.loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.indexes).toBeTruthy();
+    const indexes = parsed.meta.indexes;
+    expect(indexes).toBeTruthy();
+    expect(indexes.hello).toBeTruthy();
+    expect(indexes.hello.map).toBe("(doc) => doc.hello");
+    expect(indexes.hello.name).toBe("hello");
+  });
+});