@fireproof/core 0.20.0-dev-preview-54 → 0.20.0-dev-preview-55

package/deno.json

@@ -1,8 +1,8 @@
 {
   "imports": {
     "@fireproof/core": "./index.js",
-    "@adviser/cement": "npm:@adviser/cement@~0.4.1",
-    "@fireproof/vendor": "npm:@fireproof/vendor@~2.0.1",
+    "@adviser/cement": "npm:@adviser/cement@~0.4.3",
+    "@fireproof/vendor": "npm:@fireproof/vendor@~2.0.2",
     "@ipld/car": "npm:@ipld/car@^5.4.0",
     "@ipld/dag-cbor": "npm:@ipld/dag-cbor@^9.2.2",
     "@ipld/dag-json": "npm:@ipld/dag-json@^10.2.3",

package/index.cjs

@@ -2163,6 +2163,9 @@ var DatabaseImpl = class {
     const result = await this.ledger.writeQueue.push({ id, del: true });
     return { id, clock: result?.head, name: this.name };
   }
+  async remove(id) {
+    return this.del(id);
+  }
   async changes(since = [], opts = {}) {
     await this.ready();
     this.logger.Debug().Any("since", since).Any("opts", opts).Msg("changes");
@@ -2229,6 +2232,7 @@ __export(blockstore_exports, {
   MetaActiveStore: () => MetaActiveStore,
   PassThroughGateway: () => PassThroughGateway,
   TaskManager: () => TaskManager,
+  URIInterceptor: () => URIInterceptor,
   WALActiveStore: () => WALActiveStore,
   createAttachedStores: () => createAttachedStores,
   createDbMetaEvent: () => createDbMetaEvent,
@@ -2236,7 +2240,7 @@ __export(blockstore_exports, {
   ensureStoreEnDeFile: () => ensureStoreEnDeFile,
   getDefaultURI: () => getDefaultURI,
   getGatewayFactoryItem: () => getGatewayFactoryItem,
-  getStartedGateway: () => getStartedGateway,
+  getInterceptableGateway: () => getInterceptableGateway,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
   toCIDBlock: () => toCIDBlock,
@@ -2299,7 +2303,7 @@ var WALActiveStore = class extends BaseActiveStore {
 var import_cement18 = require("@adviser/cement");
 
 // src/blockstore/store.ts
-var import_cement17 = require("@adviser/cement");
+var import_cement16 = require("@adviser/cement");
 
 // src/blockstore/loader.ts
 var import_p_limit = __toESM(require("p-limit"), 1);
@@ -3629,151 +3633,11 @@ var import_clock2 = require("@fireproof/vendor/@web3-storage/pail/clock");
 var import_dag_json2 = require("@ipld/dag-json");
 var import_p_retry = __toESM(require("p-retry"), 1);
 var import_p_map = __toESM(require("p-map"), 1);
-
-// src/blockstore/interceptor-gateway.ts
-var import_cement16 = require("@adviser/cement");
-var PassThroughGateway = class {
-  async buildUrl(ctx, url, key) {
-    const op = { url, key };
-    return import_cement16.Result.Ok({ op });
-  }
-  async start(ctx, url) {
-    const op = { url };
-    return import_cement16.Result.Ok({ op });
-  }
-  async close(ctx, url) {
-    const op = { url };
-    return import_cement16.Result.Ok({ op });
-  }
-  async delete(ctx, url) {
-    const op = { url };
-    return import_cement16.Result.Ok({ op });
-  }
-  async destroy(ctx, url) {
-    const op = { url };
-    return import_cement16.Result.Ok({ op });
-  }
-  async put(ctx, url, body) {
-    const op = { url, body };
-    return import_cement16.Result.Ok({ op });
-  }
-  async get(ctx, url) {
-    const op = { url };
-    return import_cement16.Result.Ok({ op });
-  }
-  async subscribe(ctx, url, callback) {
-    const op = { url, callback };
-    return import_cement16.Result.Ok({ op });
-  }
-};
-var passThrougthGateway = new PassThroughGateway();
-var InterceptorGateway = class {
-  constructor(sthis, innerGW, interceptor) {
-    this.innerGW = innerGW;
-    this.interceptor = interceptor || passThrougthGateway;
-  }
-  async buildUrl(ctx, baseUrl, key) {
-    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
-  }
-  async destroy(ctx, iurl) {
-    const rret = await this.interceptor.destroy(ctx, iurl);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.destroy(ctx, ret.op.url);
-  }
-  async start(ctx, url) {
-    const rret = await this.interceptor.start(ctx, url);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return await this.innerGW.start(ctx, ret.op.url);
-  }
-  async close(ctx, url) {
-    const rret = await this.interceptor.close(ctx, url);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return await this.innerGW.close(ctx, ret.op.url);
-  }
-  async put(ctx, url, fpEnv) {
-    const rret = await this.interceptor.put(ctx, url, fpEnv);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
-  }
-  async get(ctx, url) {
-    const rret = await this.interceptor.get(ctx, url);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.get(ctx, ret.op.url);
-  }
-  async subscribe(ctx, url, callback) {
-    if (!this.innerGW.subscribe) {
-      return import_cement16.Result.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
-    }
-    const rret = await this.interceptor.subscribe(ctx, url, callback);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
-  }
-  async delete(ctx, url) {
-    const rret = await this.interceptor.delete(ctx, url);
-    if (rret.isErr()) {
-      return import_cement16.Result.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.delete(ctx, url);
-  }
-  async getPlain(ctx, url, key) {
-    return this.innerGW.getPlain(ctx, url, key);
-  }
-};
-
-// src/blockstore/store.ts
 function guardVersion(url) {
   if (!url.hasParam("version")) {
-    return import_cement17.Result.Err(`missing version: ${url.toString()}`);
+    return import_cement16.Result.Err(`missing version: ${url.toString()}`);
   }
-  return import_cement17.Result.Ok(url);
+  return import_cement16.Result.Ok(url);
 }
 var BaseStoreImpl = class {
   // readonly loader: Loadable;
@@ -3789,8 +3653,10 @@ var BaseStoreImpl = class {
       throw logger.Error().Url(this._url).Msg("missing name").AsError();
     }
     this.logger = logger.With().Str("this", this.sthis.nextId().str).Ref("url", () => this._url.toString()).Logger();
-    this.realGateway = opts.gateway;
-    this.gateway = new InterceptorGateway(this.sthis, opts.gateway, opts.gatewayInterceptor);
+    this.gateway = opts.gateway;
+  }
+  get realGateway() {
+    return this.gateway.innerGW;
   }
   url() {
     return this._url;
@@ -3833,7 +3699,7 @@ var BaseStoreImpl = class {
     }
     if (this.ready) {
       const fn = this.ready.bind(this);
-      const ready = await (0, import_cement17.exception2Result)(fn);
+      const ready = await (0, import_cement16.exception2Result)(fn);
       if (ready.isErr()) {
         await this.close();
         return ready;
@@ -3940,7 +3806,7 @@ var MetaStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement17.Result.Ok(void 0);
+    return import_cement16.Result.Ok(void 0);
   }
   async destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4007,7 +3873,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement17.Result.Ok(void 0);
+    return import_cement16.Result.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4032,7 +3898,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     this.storeType = "wal";
     // readonly tag: string = "rwal-base";
     // readonly loader: Loadable;
-    this._ready = new import_cement17.ResolveOnce();
+    this._ready = new import_cement16.ResolveOnce();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
@@ -4094,7 +3960,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     const retryableUpload = (fn, description) => (0, import_p_retry.default)(fn, {
       retries: 5,
       onFailedAttempt: (error) => {
-        this.logger.Warn().Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
+        this.logger.Warn().Any("error", error).Any("fn", fn.toString()).Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
       }
     });
     try {
@@ -4209,7 +4075,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement17.Result.Ok(void 0);
+    return import_cement16.Result.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4217,81 +4083,200 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
 };
 
-// src/blockstore/store-factory.ts
-var onceGateway = new import_cement18.KeyedResolvOnce();
-var gatewayInstances = new import_cement18.KeyedResolvOnce();
-async function getStartedGateway(ctx, url) {
-  return onceGateway.get(url.toString()).once(async () => {
-    const item = getGatewayFactoryItem(url.protocol);
-    if (item) {
-      const ret = {
-        url,
-        ...await gatewayInstances.get(url.protocol).once(async () => ({
-          gateway: await item.serdegateway(ctx.loader.sthis)
-        }))
-      };
-      const res = await ret.gateway.start(ctx, url);
-      if (res.isErr()) {
-        return import_cement18.Result.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
-      }
-      ret.url = res.Ok();
-      return import_cement18.Result.Ok(ret);
+// src/blockstore/interceptor-gateway.ts
+var import_cement17 = require("@adviser/cement");
+var PassThroughGateway = class {
+  async buildUrl(ctx, url, key) {
+    const op = { url, key };
+    return import_cement17.Result.Ok({ op });
+  }
+  async start(ctx, url) {
+    const op = { url };
+    return import_cement17.Result.Ok({ op });
+  }
+  async close(ctx, url) {
+    const op = { url };
+    return import_cement17.Result.Ok({ op });
+  }
+  async delete(ctx, url) {
+    const op = { url };
+    return import_cement17.Result.Ok({ op });
+  }
+  async destroy(ctx, url) {
+    const op = { url };
+    return import_cement17.Result.Ok({ op });
+  }
+  async put(ctx, url, body) {
+    const op = { url, body };
+    return import_cement17.Result.Ok({ op });
+  }
+  async get(ctx, url) {
+    const op = { url };
+    return import_cement17.Result.Ok({ op });
+  }
+  async subscribe(ctx, url, callback) {
+    const op = { url, callback };
+    return import_cement17.Result.Ok({ op });
+  }
+};
+var passThrougthGateway = new PassThroughGateway();
+var InterceptorGateway = class {
+  constructor(sthis, innerGW, interceptor) {
+    this.innerGW = innerGW;
+    this.interceptor = interceptor || passThrougthGateway;
+  }
+  async buildUrl(ctx, baseUrl, key) {
+    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
     }
-    return import_cement18.Result.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
-  });
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
+  }
+  async destroy(ctx, iurl) {
+    const rret = await this.interceptor.destroy(ctx, iurl);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.destroy(ctx, ret.op.url);
+  }
+  async start(ctx, url) {
+    const rret = await this.interceptor.start(ctx, url);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.start(ctx, ret.op.url);
+  }
+  async close(ctx, url) {
+    const rret = await this.interceptor.close(ctx, url);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.close(ctx, ret.op.url);
+  }
+  async put(ctx, url, fpEnv) {
+    const rret = await this.interceptor.put(ctx, url, fpEnv);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
+  }
+  async get(ctx, url) {
+    const rret = await this.interceptor.get(ctx, url);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.get(ctx, ret.op.url);
+  }
+  async subscribe(ctx, url, callback) {
+    if (!this.innerGW.subscribe) {
+      return import_cement17.Result.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+    }
+    const rret = await this.interceptor.subscribe(ctx, url, callback);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
+  }
+  async delete(ctx, url) {
+    const rret = await this.interceptor.delete(ctx, url);
+    if (rret.isErr()) {
+      return import_cement17.Result.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.delete(ctx, url);
+  }
+  async getPlain(ctx, url, key) {
+    return this.innerGW.getPlain(ctx, url, key);
+  }
+};
+
+// src/blockstore/store-factory.ts
+async function getInterceptableGateway(ctx, url, opt) {
+  const item = getGatewayFactoryItem(url.protocol);
+  if (item) {
+    return import_cement18.Result.Ok(new InterceptorGateway(ctx.loader.sthis, await item.serdegateway(ctx.loader.sthis), opt.gatewayInterceptor));
+  }
+  return import_cement18.Result.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
 }
 async function carStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "car").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new CarStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new CarStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function fileStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "file").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new FileStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new FileStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function metaStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "meta").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new MetaStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new MetaStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function WALStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "wal").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new WALStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new WALStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
@@ -4339,6 +4324,57 @@ function toStoreRuntime(sthis, endeOpts = {}) {
   };
 }
 
+// src/blockstore/uri-interceptor.ts
+var URIInterceptor = class _URIInterceptor extends PassThroughGateway {
+  static withMapper(mapper) {
+    return new _URIInterceptor().addMapper(mapper);
+  }
+  #uriMapper = /* @__PURE__ */ new Set();
+  addMapper(mapper) {
+    this.#uriMapper.add(mapper);
+    return this;
+  }
+  async #map(uri) {
+    let ret = uri;
+    for (const mapper of this.#uriMapper) {
+      ret = await mapper(ret);
+    }
+    return ret;
+  }
+  async buildUrl(ctx, url, key) {
+    const ret = await super.buildUrl(ctx, await this.#map(url), key);
+    return ret;
+  }
+  async start(ctx, url) {
+    const ret = await super.start(ctx, await this.#map(url));
+    return ret;
+  }
+  async close(ctx, url) {
+    const ret = await super.close(ctx, await this.#map(url));
+    return ret;
+  }
+  async delete(ctx, url) {
+    const ret = await super.delete(ctx, await this.#map(url));
+    return ret;
+  }
+  async destroy(ctx, url) {
+    const ret = await super.destroy(ctx, await this.#map(url));
+    return ret;
+  }
+  async put(ctx, url, body) {
+    const ret = await super.put(ctx, await this.#map(url), body);
+    return ret;
+  }
+  async get(ctx, url) {
+    const ret = await super.get(ctx, await this.#map(url));
+    return ret;
+  }
+  async subscribe(ctx, url, callback) {
+    const ret = await super.subscribe(ctx, await this.#map(url), callback);
+    return ret;
+  }
+};
+
 // src/crdt-helpers.ts
 var import_link2 = require("multiformats/link");
 var import_sha27 = require("multiformats/hashes/sha2");
@@ -5276,6 +5312,6 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-54": "xxxx"
+  "0.20.0-dev-preview-55": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map