@constl/utils-tests 0.1.8 → 0.2.0

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.1.8";
+export declare const version = "0.2.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '0.1.8';
+export const version = '0.2.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.8",
+  "version": "0.2.0",
   "license": "AGPL-3.0-or-later",
   "name": "@constl/utils-tests",
   "author": "Julien Jean Malard-Adam",
@@ -20,8 +20,7 @@
     "postbuild": "./dist/**/*"
   },
   "devDependencies": {
-    "@constl/ipa": "^0.8.2",
-    "@constl/orbit-db-types": "^1.1.0",
+    "@constl/ipa": "^0.8.3",
     "@types/crypto-js": "^4.1.1",
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.5.4",
@@ -54,10 +53,10 @@
   },
   "dependencies": {
     "@achingbrain/nat-port-mapper": "1.0.8",
+    "@orbitdb/core": "^1.0.0",
     "chokidar": "^3.5.3",
     "genversion": "^3.1.1",
     "ipfs-core": "^0.18.1",
-    "orbit-db": "^0.29.0",
     "rimraf": "^5.0.1",
     "uint8arrays": "^4.0.6",
     "uuid": "^9.0.0",

package/renovate.json

@@ -1,6 +1,4 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": [
-    "config:base"
-  ]
+  "extends": ["config:base"]
 }

package/src/@types/shims-orbit-db-core.d.ts

@@ -0,0 +1,236 @@
+declare module "@orbitdb/core" {
+  import EventEmitter from "events";
+  import type { IPFS } from "ipfs-core";
+
+  export function Database(args: {
+    ipfs: IPFS;
+    identity?: Identity;
+    address: string;
+    name?: string;
+    access?: AccessController;
+    directory?: string;
+    meta?: object;
+    headsStorage?: Storage;
+    entryStorage?: Storage;
+    indexStorage?: Storage;
+    referencesCount?: number;
+    syncAutomatically?: boolean;
+    onUpdate?: () => void;
+  }): Promise<{
+    type: string;
+    addOperation: (args: {
+      op: string;
+      key: string | null;
+      value: unknown;
+    }) => Promise<string>;
+    address: string;
+    close(): Promise<void>;
+    drop(): Promise<void>;
+    events: EventEmitter;
+    access: AccessController;
+    log: Log;
+  }>;
+
+  export type Identity = {
+    id: string;
+    publicKey: string;
+    signatures: {
+      id: string;
+      publicKey: string;
+    };
+    type: string;
+    sign: (identity: Identity, data: string) => Promise<string>;
+    verify: (
+      signature: string,
+      publicKey: string,
+      data: string,
+    ) => Promise<boolean>;
+  };
+
+  export type OrbitDB = {
+    id: string;
+    open: (
+      address: string,
+      OrbitDBDatabaseOptions?,
+    ) => ReturnType<typeof Database>;
+    stop;
+    ipfs;
+    directory;
+    keystore;
+    identity: Identity;
+    peerId;
+  };
+  export function createOrbitDB(args: {
+    ipfs: IPFS;
+    directory: string;
+  }): Promise<OrbitDB>;
+
+  export function useAccessController(accessController: { type: string }): void;
+  export function isValidAddress(address: unknown): boolean;
+
+  export type Log = {
+    id;
+    clock: Clock;
+    heads: () => Promise<Entry[]>;
+    traverse: () => AsyncGenerator<Entry, void, unknown>;
+  };
+  export type Identity = {
+    id: string;
+    publicKey: object;
+    sigantures: object;
+    type: string;
+    sign: () => string;
+    verify: () => boolean;
+  };
+
+  export function AccessControllerGenerator({
+    orbitdb,
+    identities,
+    address,
+  }: {
+    orbitdb: OrbitDB;
+    identities: Identities;
+    address?: string;
+  }): Promise<AccessController>;
+
+  export class AccessController {
+    type: string;
+    address: string;
+    canAppend: (entry: Entry) => Promise<boolean>;
+  }
+
+  export function IPFSAccessController(args: {
+    write: string[];
+    storage: Storage;
+  }): (args: {
+    orbitdb: OrbitDB;
+    identities: Identities;
+    address: string;
+  }) => Promise<{
+    type: "ipfs";
+    address: string;
+    write: string[];
+    canAppend: (entry: Entry) => Promise<boolean>;
+  }>;
+  export class Identities {
+    getIdentity;
+    verifyIdentity: (identity) => boolean;
+  }
+  export class Storage {
+    put;
+    get;
+  }
+  export function IPFSBlockStorage({
+    ipfs: IPFS,
+    pin: boolean,
+  }): Promise<Storage>;
+  export function LRUStorage({ size: number }): Promise<Storage>;
+  export function ComposedStorage(...args: Storage[]): Promise<Storage>;
+
+  export type OrbitDBDatabaseOptions = {
+    type: string;
+    AccessController: AccessControllerGenerator;
+  };
+
+  export type Clock = {
+    id: string;
+    time: number;
+  };
+
+  export type Entry<T = unknown> = {
+    id: string;
+    payload: { op: string; key: string | null; value?: T };
+    next: string[];
+    refs: string[];
+    clock: Clock;
+    v: integer;
+    key: string;
+    identity: string;
+    sig: string;
+    hash: string;
+  };
+
+  // Temporaires
+  export type Store = FeedStore | SetStore | KeyValueStore | OrderedKeyValueStore;
+  
+  export type FeedStore = Awaited<ReturnType<typeof Database>> & {
+    remove: (hash: string) => Promise<string>
+  };
+  export type FeedStoreTypé<T extends élémentsBd> = Omit<
+    FeedStore,
+    "add" | "all"
+  > & {
+    add: (value: T) => Promise<string>;
+    all: () => Promise<
+      {
+        value: T;
+        hash: string;
+      }[]
+    >;
+  };
+
+  export type SetDatabase = ReturnType<typeof Database>;
+  export type SetStore = Awaited<SetDatabase>;
+  export type SetStoreTypé<T extends élémentsBd> = Omit<
+    SetStore,
+    "put" | "set" | "del" | "all"
+  > & {
+    put: (value: T) => Promise<string>;
+    set: SetStoreTypé<T>["put"];
+    del: (value: T) => Promise<string>;
+    all: () => Promise<
+      {
+        value: T;
+        hash: string;
+      }[]
+    >;
+  };
+
+  export type OrderedKeyValue = ReturnType<typeof Database>;
+  export type OrderedKeyValueStore = Awaited<OrderedKeyValue>;
+  export type OrderedKeyValueStoreTypé<T extends { [clef: string]: unknown }> =
+    Omit<OrderedKeyValueStore, "put" | "set" | "del" | "move" | "get" | "all"> & {
+      put: <K extends keyof T>(
+        key: K,
+        value: T[K],
+        position?: number
+      ) => Promise<string>;
+      set: OrderedKeyValueStoreTypé<T>["put"];
+      del: <K extends keyof T>(key: K) => Promise<string>;
+      move: <K extends keyof T>(key: K, position: number) => Promise<string>;
+      get: <K extends keyof T>(key: K) => Promise<T[K] | undefined>;
+      all: () => Promise<
+        {
+          key: keyof T;
+          value: T[keyof T];
+          hash: string;
+        }[]
+      >;
+    };
+
+  export type KeyValueStore = {
+    type: "keyvalue";
+    address: string;
+    put(key: string, value: unknown): Promise<string>;
+    set: KeyValueStore["put"];
+    del(key: string): Promise<string>;
+    get(key: string): Promise<unknown | undefined>;
+    all(): Promise<{ key: string; value: unknown; hash: string }[]>;
+    close(): Promise<void>;
+    drop(): Promise<void>;
+    events: EventEmitter;
+    access: AccessController;
+    log: Log;
+  };
+  export type KeyValueStoreTypé<T extends { [clef: string]: unknown }> = Omit<
+    KeyValueStore,
+    "put" | "set" | "del" | "get" | "all"
+  > & {
+    put<K extends keyof T>(key: K, value: T[K]): Promise<string>;
+    set: KeyValueStoreTypé<T>["put"];
+    del<K extends keyof T>(key: K): Promise<string>;
+    get<K extends keyof T>(key: K): Promise<T[K] | undefined>;
+    all(): Promise<T>;
+  };
+
+}

package/src/attente.ts

@@ -71,7 +71,7 @@ export class AttendreFichierExiste extends EventEmitter {
       if (fichier === this.fichier) return;
       else
         throw new Error(
-          `Fichier téléchargé a le nom ${fichier}, et non pas ${this.fichier}.`
+          `Fichier téléchargé a le nom ${fichier}, et non pas ${this.fichier}.`,
         );
     } else {
       const chokidar = await import("chokidar");
@@ -115,7 +115,10 @@ export class AttendreFichierModifié extends EventEmitter {
     this.fsOublier.push(() => this.attendreExiste.annuler());
   }
 
-  async attendre(tempsAvant: number, condition?: () => Promise<boolean>): Promise<void> {
+  async attendre(
+    tempsAvant: number,
+    condition?: () => Promise<boolean>,
+  ): Promise<void> {
     await this.attendreExiste.attendre();
     const chokidar = await import("chokidar");
     const fs = await import("fs");
@@ -125,21 +128,20 @@ export class AttendreFichierModifié extends EventEmitter {
 
       const vérifierModifié = async () => {
         try {
-            const { mtime } = fs.statSync(this.fichier);
-            const prêt = mtime.getTime() > tempsAvant;
-
-            if (prêt && (!condition || await condition())) {
-                await écouteur.close();
-                clearInterval(intervale);
-                résoudre();
-            }
-        }
-        catch (e) {
-            // Le fichier a été effacé
-            écouteur.close();
-            rejeter(e);
+          const { mtime } = fs.statSync(this.fichier);
+          const prêt = mtime.getTime() > tempsAvant;
+
+          if (prêt && (!condition || (await condition()))) {
+            await écouteur.close();
+            clearInterval(intervale);
+            résoudre();
+          }
+        } catch (e) {
+          // Le fichier a été effacé
+          écouteur.close();
+          rejeter(e);
         }
-    }
+      };
 
       écouteur.on("change", async (adresse) => {
         if (adresse !== this.fichier) return;

package/src/client.ts

@@ -1,4 +1,4 @@
-import OrbitDB from "orbit-db";
+import {createOrbitDB, OrbitDB} from "@orbitdb/core";
 import { initierSFIP, arrêterSFIP } from "@/sfip.js";
 import { isBrowser } from "wherearewe";
 import type { IPFS } from "ipfs-core";
@@ -7,9 +7,8 @@ import type { client } from "@constl/ipa";
 import { connectPeers } from "@/orbitDbTestUtils.js";
 import { dossierTempoTests } from "@/dossiers.js";
 
-
 export const générerOrbites = async (
-  n = 1
+  n = 1,
 ): Promise<{ orbites: OrbitDB[]; fOublier: () => Promise<void> }> => {
   const sfips: IPFS[] = [];
   const orbites: OrbitDB[] = [];
@@ -24,7 +23,8 @@ export const générerOrbites = async (
   const _générer = async (i: number): Promise<void> => {
     const racineDossier = `${racineDossierOrbite}/${i}`;
     const sfip = await initierSFIP(`${racineDossier}/sfip`);
-    const orbite = await OrbitDB.createInstance(sfip, {
+    const orbite = await createOrbitDB({
+      ipfs: sfip,
       directory: `${racineDossier}/orbite`,
     });
 
@@ -42,13 +42,13 @@ export const générerOrbites = async (
     await Promise.all(
       orbites.map(async (orbite) => {
         await orbite.stop();
-      })
+      }),
     );
 
     await Promise.all(
       sfips.map(async (d) => {
         await arrêterSFIP(d);
-      })
+      }),
     );
 
     fEffacerRacineDossierOrbite();
@@ -56,21 +56,24 @@ export const générerOrbites = async (
   return { orbites, fOublier };
 };
 
-
-export const générerClients = async<T> ({
+export const générerClients = async <T>({
   n = 1,
   type = "proc",
-  générerClient
+  générerClient,
 }: {
-  n: number,
-  type?: "proc" | "travailleur",
-  générerClient: (args: { opts: client.optsConstellation; mandataire: "proc" | "travailleur"; }) => T,
+  n: number;
+  type?: "proc" | "travailleur";
+  générerClient: (args: {
+    opts: client.optsConstellation;
+    mandataire: "proc" | "travailleur";
+  }) => T;
 }): Promise<{
   clients: T[];
   fOublier: () => Promise<void>;
 }> => {
   const clients: T[] = [];
   const fsOublier: (() => Promise<void>)[] = [];
+
   // Nécessaire pour Playwright
   if (isBrowser) window.localStorage.clear();
 
@@ -81,7 +84,7 @@ export const générerClients = async<T> ({
     for (const i in [...Array(n).keys()]) {
       const client = générerClient({
         opts: { orbite: orbites[i] },
-        mandataire: type
+        mandataire: type,
       });
       clients.push(client);
     }
@@ -99,7 +102,7 @@ export const générerClients = async<T> ({
 
   const fOublier = async () => {
     if (isBrowser) return; // Mystère et boule de gomme !!
-    
+
     // @ts-expect-error À régler: type pour `fermer`
     await Promise.all(clients.map((client) => client.fermer()));
     await Promise.all(fsOublier.map((f) => f()));

package/src/index.ts

@@ -1,9 +1,6 @@
 import { once } from "events";
 
-import OrbitDB from "orbit-db";
-import type Store from "orbit-db-store";
-import type KeyValueStore from "orbit-db-kvstore";
-import type FeedStore from "orbit-db-feedstore";
+import { FeedStoreTypé, KeyValueStoreTypé, OrbitDB, type Store } from "@orbitdb/core";
 
 import type { client, réseau } from "@constl/ipa";
 
@@ -16,12 +13,10 @@ export * as client from "@/client.js";
 export * as dossiers from "@/dossiers.js";
 export { version } from "@/version.js";
 
-const attendreInvité = (bd: Store, idInvité: string): Promise<void> =>
+const attendreInvité = (accès: ContrôleurConstellation, idInvité: string): Promise<void> =>
   new Promise<void>((resolve) => {
     const testAutorisé = async () => {
-      const autorisé = await (
-        bd.access as unknown as ContrôleurConstellation
-      ).estAutorisé(idInvité);
+      const autorisé = await accès.estAutorisé(idInvité);
       if (autorisé) {
         clearInterval(interval);
         resolve();
@@ -33,7 +28,7 @@ const attendreInvité = (bd: Store, idInvité: string): Promise<void> =>
 
 export const clientConnectéÀ = async (
   client1: client.ClientConstellation,
-  client2: client.ClientConstellation
+  client2: client.ClientConstellation,
 ): Promise<void> => {
   const dispositifsConnectés = new AttendreRésultat<
     réseau.statutDispositif[]
@@ -71,35 +66,34 @@ export const attendreSync = async (bd: Store): Promise<void> => {
 };
 
 export const peutÉcrire = async (
-  bd: KeyValueStore<{ test: number }> | FeedStore<string>,
-  attendre?: OrbitDB
+  bd: KeyValueStoreTypé<{ test: number }> | FeedStoreTypé<string>,
+  attendre?: OrbitDB,
 ): Promise<boolean> => {
   if (attendre) {
-    await attendreInvité(bd, attendre.identity.id);
+    await attendreInvité(bd.access as unknown as ContrôleurConstellation, attendre.identity.id);
   }
 
   try {
     if (bd.type === "keyvalue") {
+      const bdKV = bd as KeyValueStoreTypé<{ test: number }>
       const CLEF = "test";
       const VAL = 123;
 
-      await (bd as KeyValueStore<{ test: number }>).set(CLEF, VAL);
-      const val = bd.get(CLEF);
+      await bdKV.set(CLEF, VAL);
+      const val = await bdKV.get(CLEF);
 
-      await (bd as KeyValueStore<{ test: number }>).del(CLEF);
+      await (bd as KeyValueStoreTypé<{ test: number }>).del(CLEF);
       return val === VAL;
     } else if (bd.type === "feed") {
       const VAL = "test";
 
-      await (bd as FeedStore<string>).add(VAL);
-      const éléments = (bd as FeedStore<string>)
-        .iterator({ limit: -1 })
-        .collect();
+      await (bd as FeedStoreTypé<string>).add(VAL);
+      const éléments = await (bd as FeedStoreTypé<string>).all();
 
       const autorisé =
-        éléments.length === 1 && éléments[0].payload.value === VAL;
+        éléments.length === 1 && éléments[0].value === VAL;
       if (éléments.length === 1) {
-        await (bd as FeedStore<string>).remove(éléments[0].hash);
+        await (bd as FeedStoreTypé<string>).remove(éléments[0].hash);
       }
       return autorisé;
     } else {

package/src/orbitDbTestUtils.ts

@@ -31,7 +31,7 @@ export const connectPeers = async (
   ipfs2: IPFS,
   options = {
     filter: defaultFilter,
-  }
+  },
 ) => {
   const id1 = await ipfs1.id();
   const id2 = await ipfs2.id();

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '0.1.8';
+export const version = '0.2.0';

package/src/@types/shims-orbit-db.d.ts

@@ -1 +0,0 @@
-export { OrbidtDB, OrbitDBAccessControllers } from "@constl/orbit-db-types";