@fireproof/core-gateways-base 0.22.0-keybag → 0.23.1-dev-issue-1057

package/fp-envelope-serialize.ts

@@ -1,208 +0,0 @@
-import { exception2Result, Result, URI } from "@adviser/cement";
-import type {
-  CarClockLink,
-  DbMeta,
-  DbMetaBinary,
-  DbMetaEvent,
-  FPDecoder,
-  FPEncoder,
-  LinkOrCid,
-  SerializedMeta,
-  SerializedWAL,
-  WALState,
-} from "@fireproof/core-types-blockstore";
-import {
-  FPEnvelope,
-  FPEnvelopeCar,
-  FPEnvelopeFile,
-  FPEnvelopeMeta,
-  FPEnvelopeType,
-  FPEnvelopeTypes,
-  FPEnvelopeWAL,
-} from "@fireproof/core-types-blockstore";
-import { PARAM, PromiseToUInt8, SuperThis } from "@fireproof/core-types-base";
-import { decodeEventBlock, EventBlock } from "@web3-storage/pail/clock";
-import { base64pad } from "multiformats/bases/base64";
-import { CID, Link } from "multiformats";
-import { fromJSON } from "multiformats/link";
-import { format, parse } from "@ipld/dag-json";
-import { EventView } from "@web3-storage/pail/clock/api";
-import { coercePromiseIntoUint8 } from "@fireproof/core-runtime";
-
-export async function dbMetaEvent2Serialized(
-  sthis: SuperThis,
-  dbEvents: Omit<DbMetaEvent, "eventCid">[],
-): Promise<SerializedMeta[]> {
-  return await Promise.all(
-    dbEvents.map(async (dbEvent) => {
-      const event = await EventBlock.create<DbMetaBinary>(
-        {
-          dbMeta: sthis.txt.encode(format(dbEvent.dbMeta)),
-        },
-        dbEvent.parents as unknown as Link<EventView<DbMetaBinary>, number, number, 1>[],
-      );
-      return {
-        cid: event.cid.toString(),
-        parents: dbEvent.parents.map((i) => i.toString()),
-        data: base64pad.encode(event.bytes),
-      } satisfies SerializedMeta;
-    }),
-  );
-}
-
-function WALState2Serialized(sthis: SuperThis, wal: WALState): SerializedWAL {
-  const serializedWAL: SerializedWAL = {
-    fileOperations: wal.fileOperations.map((fop) => ({
-      cid: fop.cid.toString(),
-      public: fop.public,
-    })),
-    noLoaderOps: wal.noLoaderOps.map((nop) => ({
-      cars: nop.cars.map((i) => i.toString()),
-    })),
-    operations: wal.operations.map((op) => ({
-      cars: op.cars.map((i) => i.toString()),
-    })),
-  };
-  return serializedWAL;
-}
-
-const defaultEncoder: FPEncoder = {
-  car: async (sthis: SuperThis, payload: Uint8Array) => Result.Ok(payload),
-  file: async (sthis: SuperThis, payload: Uint8Array) => Result.Ok(payload),
-  meta: async (sthis: SuperThis, payload: SerializedMeta[]) => Result.Ok(sthis.txt.encode(JSON.stringify(payload))),
-  wal: async (sthis: SuperThis, payload: SerializedWAL) => Result.Ok(sthis.txt.encode(JSON.stringify(payload))),
-};
-
-export async function fpSerialize<T>(
-  sthis: SuperThis,
-  env: FPEnvelope<T>,
-  pencoder?: Partial<FPEncoder>,
-): Promise<Result<Uint8Array>> {
-  const encoder = {
-    ...defaultEncoder,
-    ...pencoder,
-  };
-  switch (env.type) {
-    case FPEnvelopeTypes.FILE:
-      return encoder.file(sthis, (env as FPEnvelopeFile).payload);
-    case FPEnvelopeTypes.CAR:
-      return encoder.car(sthis, (env as FPEnvelopeCar).payload);
-    case FPEnvelopeTypes.WAL:
-      return encoder.wal(sthis, WALState2Serialized(sthis, (env as FPEnvelopeWAL).payload));
-    case FPEnvelopeTypes.META:
-      return encoder.meta(sthis, await dbMetaEvent2Serialized(sthis, (env as FPEnvelopeMeta).payload));
-    default:
-      throw sthis.logger.Error().Str("type", env.type).Msg("unsupported store").AsError();
-  }
-}
-
-export async function decode2DbMetaEvents(
-  sthis: SuperThis,
-  rserializedMeta: Result<SerializedMeta[]>,
-): Promise<Result<DbMetaEvent[]>> {
-  if (rserializedMeta.isErr()) {
-    return Result.Err(rserializedMeta.Err());
-  }
-  const serializedMeta = rserializedMeta.unwrap();
-  if (!Array.isArray(serializedMeta)) {
-    return sthis.logger.Debug().Any("metaEntries", serializedMeta).Msg("No data in MetaEntries").ResultError();
-  }
-  // if (!serializedMeta.length) {
-  //   return sthis.logger.Debug().Msg("No MetaEntries found").ResultError();
-  // }
-  return Result.Ok(
-    await Promise.all(
-      serializedMeta.map(async (metaEntry) => {
-        const eventBlock = await decodeEventBlock<DbMetaBinary>(base64pad.decode(metaEntry.data));
-        const dbMeta = parse<DbMeta>(sthis.txt.decode(eventBlock.value.data.dbMeta));
-        return {
-          eventCid: eventBlock.cid as CarClockLink,
-          parents: metaEntry.parents.map((i: string) => CID.parse(i)),
-          dbMeta,
-        } satisfies DbMetaEvent;
-      }),
-    ),
-  );
-}
-
-function toCid(sthis: SuperThis, link: LinkOrCid): CID {
-  if (typeof link === "string") {
-    return CID.parse(link);
-  }
-  return fromJSON(link);
-}
-
-async function decode2WalState(sthis: SuperThis, rserializedWAL: Result<SerializedWAL>): Promise<Result<WALState>> {
-  if (rserializedWAL.isErr()) {
-    return Result.Err(rserializedWAL.Err());
-  }
-  const serializedWAL = rserializedWAL.unwrap();
-  return Result.Ok({
-    fileOperations: (serializedWAL.fileOperations || []).map((fop) => ({
-      cid: toCid(sthis, fop.cid),
-      public: fop.public,
-    })),
-    noLoaderOps: (serializedWAL.noLoaderOps || []).map((nop) => ({
-      cars: (nop.cars || []).map((i) => toCid(sthis, i)),
-    })),
-    operations: (serializedWAL.operations || []).map((op) => ({
-      cars: (op.cars || []).map((i) => toCid(sthis, i)),
-    })),
-  });
-}
-// export type CARDecodeEnvelopeBase = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
-// export type FILEDecodeEnvelopeBase = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
-// export type WALDecodeEnvelopeBase = (sthis: SuperThis, payload: SerializedWAL) => Promise<Result<SerializedWAL>>;
-// export type METADecodeEnvelopeBase = (sthis: SuperThis, payload: SerializedMeta[]) => Promise<Result<SerializedMeta[]>>;
-
-const defaultDecoder = {
-  car: async (sthis: SuperThis, payload: Uint8Array) => Result.Ok(payload),
-  file: async (sthis: SuperThis, payload: Uint8Array) => Result.Ok(payload),
-  meta: async (sthis: SuperThis, payload: Uint8Array) =>
-    exception2Result(() => JSON.parse(sthis.txt.decode(payload)) as SerializedMeta[]),
-  wal: async (sthis: SuperThis, payload: Uint8Array) =>
-    exception2Result(() => JSON.parse(sthis.txt.decode(payload)) as SerializedWAL),
-};
-
-function makeFPEnvelope<S>(type: FPEnvelopeType, payload: Result<S>): Result<FPEnvelope<S>> {
-  if (payload.isErr()) {
-    return Result.Err(payload.Err());
-  }
-  return Result.Ok({
-    type,
-    payload: payload.unwrap(),
-  });
-}
-
-export async function fpDeserialize<S>(
-  sthis: SuperThis,
-  url: URI,
-  intoRaw: PromiseToUInt8,
-  pdecoder?: Partial<FPDecoder>,
-): Promise<Result<FPEnvelope<S>>> {
-  const rraw = await coercePromiseIntoUint8(intoRaw);
-  if (rraw.isErr()) {
-    return Result.Err(rraw.Err());
-  }
-  const raw = rraw.unwrap();
-  const decoder = {
-    ...defaultDecoder,
-    ...pdecoder,
-  };
-  switch (url.getParam(PARAM.STORE)) {
-    case "car":
-      return makeFPEnvelope(FPEnvelopeTypes.CAR, await decoder.car(sthis, raw)) as Result<FPEnvelope<S>>;
-    case "file":
-      return makeFPEnvelope(FPEnvelopeTypes.FILE, await decoder.file(sthis, raw)) as Result<FPEnvelope<S>>;
-    case "wal":
-      return makeFPEnvelope(FPEnvelopeTypes.WAL, await decode2WalState(sthis, await decoder.wal(sthis, raw))) as Result<
-        FPEnvelope<S>
-      >;
-    case "meta":
-      return makeFPEnvelope(FPEnvelopeTypes.META, await decode2DbMetaEvents(sthis, await decoder.meta(sthis, raw))) as Result<
-        FPEnvelope<S>
-      >;
-    default:
-      return sthis.logger.Error().Str("store", url.getParam(PARAM.STORE)).Msg("unsupported store").ResultError();
-  }
-}

package/index.ts

@@ -1,7 +0,0 @@
-export * from "./fp-envelope-serialize.js";
-export * from "./def-serde-gateway.js";
-export * from "./interceptor-gateway.js";
-export * from "./uri-interceptor.js";
-export * from "./utils.js";
-export * from "./indexeddb-version.js";
-export * from "./meta-key-hack.js";

package/indexeddb-version.ts

@@ -1 +0,0 @@
-export const INDEXEDDB_VERSION = "v0.19-indexeddb";

package/interceptor-gateway.ts

@@ -1,174 +0,0 @@
-import { Result, URI } from "@adviser/cement";
-import type {
-  FPEnvelope,
-  FPEnvelopeMeta,
-  SerdeGateway,
-  SerdeGatewayBuildUrlReturn,
-  SerdeGatewayCloseReturn,
-  SerdeGatewayCtx,
-  SerdeGatewayDeleteReturn,
-  SerdeGatewayDestroyReturn,
-  SerdeGatewayGetReturn,
-  SerdeGatewayInterceptor,
-  SerdeGatewayPutReturn,
-  SerdeGatewayStartReturn,
-  SerdeGatewaySubscribeReturn,
-  SerdeGetResult,
-  UnsubscribeResult,
-  VoidResult,
-} from "@fireproof/core-types-blockstore";
-import type { SuperThis } from "@fireproof/core-types-base";
-
-export class PassThroughGateway implements SerdeGatewayInterceptor {
-  async buildUrl(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>> {
-    const op = { url, key };
-    return Result.Ok({ op });
-  }
-  async start(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayStartReturn>> {
-    const op = { url };
-    return Result.Ok({ op });
-  }
-  async close(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayCloseReturn>> {
-    const op = { url };
-    return Result.Ok({ op });
-  }
-  async delete(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDeleteReturn>> {
-    const op = { url };
-    return Result.Ok({ op });
-  }
-  async destroy(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDestroyReturn>> {
-    const op = { url };
-    return Result.Ok({ op });
-  }
-  async put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<SerdeGatewayPutReturn<T>>> {
-    const op = { url, body };
-    return Result.Ok({ op });
-  }
-  async get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayGetReturn<S>>> {
-    const op = { url };
-    return Result.Ok({ op });
-  }
-  async subscribe(
-    ctx: SerdeGatewayCtx,
-    url: URI,
-    callback: (meta: FPEnvelopeMeta) => Promise<void>,
-  ): Promise<Result<SerdeGatewaySubscribeReturn>> {
-    const op = { url, callback };
-    return Result.Ok({ op });
-  }
-}
-
-const passThrougthGateway = new PassThroughGateway();
-
-export class InterceptorGateway implements SerdeGateway {
-  readonly innerGW: SerdeGateway;
-  readonly interceptor: SerdeGatewayInterceptor;
-
-  constructor(sthis: SuperThis, innerGW: SerdeGateway, interceptor: SerdeGatewayInterceptor | undefined) {
-    this.innerGW = innerGW;
-    this.interceptor = interceptor || passThrougthGateway;
-  }
-
-  async buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>> {
-    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
-    if (rret.isErr()) {
-      return 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: SerdeGatewayCtx, iurl: URI): Promise<Result<void>> {
-    const rret = await this.interceptor.destroy(ctx, iurl);
-    if (rret.isErr()) {
-      return 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: SerdeGatewayCtx, url: URI): Promise<Result<URI>> {
-    const rret = await this.interceptor.start(ctx, url);
-    if (rret.isErr()) {
-      return 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: SerdeGatewayCtx, url: URI): Promise<VoidResult> {
-    const rret = await this.interceptor.close(ctx, url);
-    if (rret.isErr()) {
-      return 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<T>(ctx: SerdeGatewayCtx, url: URI, fpEnv: FPEnvelope<T>): Promise<VoidResult> {
-    const rret = await this.interceptor.put(ctx, url, fpEnv);
-    if (rret.isErr()) {
-      return 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<S>(ctx: SerdeGatewayCtx, url: URI): Promise<SerdeGetResult<S>> {
-    const rret = await this.interceptor.get<S>(ctx, url);
-    if (rret.isErr()) {
-      return 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: SerdeGatewayCtx, url: URI, callback: (msg: FPEnvelopeMeta) => Promise<void>): Promise<UnsubscribeResult> {
-    if (!this.innerGW.subscribe) {
-      return 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 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: SerdeGatewayCtx, url: URI): Promise<VoidResult> {
-    const rret = await this.interceptor.delete(ctx, url);
-    if (rret.isErr()) {
-      return 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: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>> {
-    return this.innerGW.getPlain(ctx, url, key);
-  }
-}

package/meta-key-hack.ts

@@ -1,260 +0,0 @@
-import { exception2Result, Result, URI } from "@adviser/cement";
-import {
-  FPEnvelopeMeta,
-  SerializedMeta,
-  V2SerializedMetaKey,
-  Gateway,
-  Loadable,
-  FPEnvelope,
-  SerdeGateway,
-  SerdeGatewayCtx,
-} from "@fireproof/core-types-blockstore";
-
-import { PARAM, SuperThis, NotFoundError } from "@fireproof/core-types-base";
-import { DefSerdeGateway } from "./def-serde-gateway.js";
-
-type V1SerializedMetaKey = SerializedMeta & {
-  // old version
-  readonly key?: string | string[];
-  // new version
-  readonly keys?: string[];
-};
-
-// type SerializedMetaWithKey = V1SerializedMetaKey[] | V2SerializedMetaKey;
-
-function fromV1toV2SerializedMetaKey(v1s: unknown[], keys: string[] = []): V2SerializedMetaKey {
-  const res = (v1s as Partial<V1SerializedMetaKey>[]).reduce(
-    (acc, v1) => {
-      const keys: string[] = [];
-      if (v1.key) {
-        if (typeof v1.key === "string") {
-          acc.keys.add(v1.key);
-        } else {
-          keys.push(...v1.key);
-        }
-      }
-      if (v1.keys) {
-        keys.push(...v1.keys);
-      }
-      for (const key of keys) {
-        acc.keys.add(key);
-      }
-      if (typeof v1.cid === "string" && (!v1.data || typeof v1.data === "string") && (!v1.parents || Array.isArray(v1.parents))) {
-        acc.metas.set(v1.cid, {
-          data: v1.data ?? "",
-          parents: v1.parents ?? [],
-          cid: v1.cid,
-        });
-      }
-      return acc;
-    },
-    {
-      metas: new Map<string, SerializedMeta>(),
-      keys: new Set<string>(keys),
-    },
-  );
-  return {
-    metas: Array.from(res.metas.values()),
-    keys: Array.from(res.keys),
-  };
-}
-
-function isV2SerializedMetaKey(or: NonNullable<unknown>): or is Partial<V2SerializedMetaKey> {
-  const my = or as Partial<V2SerializedMetaKey>;
-  return my !== null && (!my.keys || Array.isArray(my.keys)) && (!my.metas || Array.isArray(my.metas));
-}
-
-function toV2SerializedMetaKey(or: NonNullable<unknown>): V2SerializedMetaKey {
-  if (Array.isArray(or)) {
-    return fromV1toV2SerializedMetaKey(or);
-  }
-  if (isV2SerializedMetaKey(or)) {
-    return fromV1toV2SerializedMetaKey(or.metas ?? [], or.keys ?? []);
-  }
-  throw new Error("not a valid serialized meta key");
-}
-
-export async function V2SerializedMetaKeyExtractKey(
-  ctx: SerdeGatewayCtx,
-  v2: V2SerializedMetaKey,
-): Promise<Result<SerializedMeta[]>> {
-  const kb = await ctx.loader.keyBag();
-  if (!kb) {
-    return Promise.resolve(Result.Err(new Error("missing keybag")));
-  }
-  const dataUrl = await ctx.loader.attachedStores.local().active.car.url();
-  const keyName = dataUrl.getParam(PARAM.STORE_KEY);
-  if (!keyName) {
-    ctx.loader.sthis.logger.Warn().Url(dataUrl).Msg("missing store key");
-  } else {
-    const rKey = await kb.getNamedKey(keyName);
-    if (rKey.isErr()) {
-      ctx.loader.sthis.logger.Warn().Str("keyName", keyName).Msg("did not found a extractable key");
-    } else {
-      for (const keyStr of v2.keys) {
-        // side effect: in the keybag
-        // this is the key gossip protocol
-        // it basically collects all the keys that are used distributed metas
-        const res = await rKey.Ok().upsert(keyStr, false);
-        if (res.isErr()) {
-          ctx.loader.sthis.logger.Warn().Str("keyStr", keyStr).Msg("failed to upsert key");
-        }
-      }
-    }
-  }
-  return Promise.resolve(Result.Ok(v2.metas));
-}
-
-export async function decodeAsToSerializedMeta(ctx: SerdeGatewayCtx, raw: Uint8Array): Promise<Result<V2SerializedMetaKey>> {
-  const rJsObj = exception2Result(() => JSON.parse(ctx.loader.sthis.txt.decode(raw))) as Result<NonNullable<unknown>>;
-  if (rJsObj.isErr()) {
-    return Result.Err(rJsObj);
-  }
-  const v2 = toV2SerializedMetaKey(rJsObj.unwrap());
-  const metas = await V2SerializedMetaKeyExtractKey(ctx, v2);
-  if (metas.isErr()) {
-    return Result.Err(metas);
-  }
-  return Result.Ok({
-    metas: metas.Ok(),
-    keys: v2.keys,
-  });
-}
-
-export function addKeyToDbMetaDecoder(
-  ctx: SerdeGatewayCtx & { readonly lastDecodedMetas?: V2SerializedMetaKey[] },
-): SerdeGatewayCtx & { lastDecodedMetas: V2SerializedMetaKey[] } {
-  const lastDecodedMetas: V2SerializedMetaKey[] = ctx.lastDecodedMetas ?? [];
-  return {
-    ...ctx,
-    lastDecodedMetas,
-    decoder: {
-      meta: async (sthis: SuperThis, raw: Uint8Array): Promise<Result<SerializedMeta[]>> => {
-        const r = await decodeAsToSerializedMeta(ctx, raw);
-        if (r.isErr()) {
-          return Promise.resolve(Result.Err(r));
-        }
-        // we only want to keep the last 2 metas
-        if (lastDecodedMetas.length > 2) {
-          lastDecodedMetas.shift();
-        }
-        lastDecodedMetas.push(r.Ok());
-        return Promise.resolve(Result.Ok(r.Ok().metas));
-      },
-    },
-  };
-}
-
-async function wrapEncode<T extends V1SerializedMetaKey[] | V2SerializedMetaKey>(
-  ctx: SerdeGatewayCtx,
-  payload: SerializedMeta[],
-  fn: (payload: SerializedMeta[], keyM: string[]) => T,
-): Promise<Result<T>> {
-  const carStore = ctx.loader.attachedStores.local().active.car;
-  const kb = await ctx.loader.keyBag();
-  if (!kb) {
-    return Promise.resolve(Result.Err(new Error("missing keybag")));
-  }
-  const keyName = carStore.url().getParam(PARAM.STORE_KEY) ?? "";
-  const rKex = await kb.getNamedKey(keyName);
-  if (rKex.isErr()) {
-    return Promise.resolve(Result.Err(rKex.Err()));
-  }
-  /* security: we don't want to log the key */
-  const keyMaterials = await rKex
-    .Ok()
-    .asV2KeysItem()
-    .then((i) => Object.values(i.keys).map((i) => i.key));
-
-  return Promise.resolve(Result.Ok(fn(payload, keyMaterials)));
-}
-
-export function encodeAsV1SerializedMetaKey(
-  ctx: SerdeGatewayCtx,
-  payload: SerializedMeta[],
-): Promise<Result<V1SerializedMetaKey[]>> {
-  return wrapEncode(ctx, payload, (payload, keyM) => payload.map((p) => ({ ...p, key: keyM }) satisfies V1SerializedMetaKey));
-}
-
-export function encodeAsV2SerializedMetaKey(ctx: SerdeGatewayCtx, payload: SerializedMeta[]): Promise<Result<V2SerializedMetaKey>> {
-  return wrapEncode(
-    ctx,
-    payload,
-    (payload, keyM) =>
-      ({
-        metas: payload,
-        keys: keyM,
-      }) satisfies V2SerializedMetaKey,
-  );
-}
-
-export function addKeyToDbMetaEncoder(ctx: SerdeGatewayCtx, version: "v1" | "v2"): SerdeGatewayCtx {
-  return {
-    ...ctx,
-    encoder: {
-      meta: async (sthis: SuperThis, payload: SerializedMeta[]): Promise<Result<Uint8Array>> => {
-        let obj: Result<V1SerializedMetaKey[] | V2SerializedMetaKey>;
-        switch (version) {
-          case "v1":
-            obj = await encodeAsV1SerializedMetaKey(ctx, payload);
-            break;
-          case "v2":
-            obj = await encodeAsV2SerializedMetaKey(ctx, payload);
-            break;
-          default:
-            return Promise.resolve(Result.Err(`unknown version:[${version}]`));
-        }
-        if (obj.isErr()) {
-          return Promise.resolve(Result.Err(obj));
-        }
-        try {
-          return Promise.resolve(Result.Ok(sthis.txt.encode(JSON.stringify(obj.Ok()))));
-        } catch (e) {
-          return Promise.resolve(Result.Err(e as Error));
-        }
-      },
-    },
-  };
-}
-
-export class AddKeyToDbMetaGateway implements SerdeGateway {
-  private readonly sdGw: DefSerdeGateway;
-  readonly version: "v1" | "v2";
-  constructor(gw: Gateway, version: "v1" | "v2") {
-    this.sdGw = new DefSerdeGateway(gw);
-    this.version = version;
-  }
-
-  buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>> {
-    return this.sdGw.buildUrl(ctx, baseUrl, key);
-  }
-  start(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<URI>> {
-    return this.sdGw.start(ctx, baseUrl);
-  }
-  close(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<void, Error>> {
-    return this.sdGw.close(ctx, baseUrl);
-  }
-  async put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<void, Error>> {
-    return this.sdGw.put(addKeyToDbMetaEncoder(ctx, this.version), url, body);
-  }
-  async get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<FPEnvelope<S>, Error | NotFoundError>> {
-    return this.sdGw.get(addKeyToDbMetaDecoder({ ...ctx, lastDecodedMetas: this.lastDecodedMetas }), url);
-  }
-
-  // only for tests
-  readonly lastDecodedMetas: V2SerializedMetaKey[] = [];
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  delete(ctx: SerdeGatewayCtx, url: URI, loader?: Loadable): Promise<Result<void, Error>> {
-    return this.sdGw.delete(ctx, url);
-  }
-  subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<() => void, Error>> {
-    return this.sdGw.subscribe(addKeyToDbMetaDecoder({ ...ctx, lastDecodedMetas: this.lastDecodedMetas }), url, callback);
-  }
-  getPlain(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>> {
-    return this.sdGw.getPlain(ctx, url, key);
-  }
-  destroy(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<void, Error>> {
-    return this.sdGw.destroy(ctx, baseUrl);
-  }
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": [
-    "/home/runner/work/fireproof/fireproof/tsconfig.dist.json"
-  ],
-  "compilerOptions": {
-    "noEmit": false,
-    "outDir": "./"
-  },
-  "include": [
-    "**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    ".git",
-    ".vscode"
-  ]
-}