@constl/utils-tests 0.2.3 → 1.0.1

package/package.json

@@ -1,11 +1,11 @@
 {
-  "version": "0.2.3",
+  "version": "1.0.1",
   "license": "AGPL-3.0-or-later",
   "name": "@constl/utils-tests",
   "author": "Julien Jean Malard-Adam",
   "type": "module",
-  "types": "./dist/index.d.ts",
-  "exports": "./dist/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": "./dist/src/index.js",
   "engines": {
     "node": ">=20"
   },
@@ -20,69 +20,77 @@
     "postbuild": "./dist/**/*"
   },
   "devDependencies": {
-    "@constl/ipa": "^0.9.5",
-    "@types/crypto-js": "^4.1.3",
-    "@types/mocha": "^10.0.3",
-    "@types/node": "^20.8.9",
-    "@types/uuid": "^9.0.6",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.9.0",
-    "aegir": "^41.0.0",
+    "@chainsafe/libp2p-noise": "^15.0.0",
+    "@chainsafe/libp2p-yamux": "^6.0.1",
+    "@constl/ipa": "^0.9.25",
+    "@libp2p/circuit-relay-v2": "^1.0.13",
+    "@libp2p/crypto": "^4.0.1",
+    "@libp2p/identify": "^1.0.12",
+    "@libp2p/peer-id-factory": "^4.0.5",
+    "@libp2p/websockets": "^8.0.13",
+    "@multiformats/multiaddr": "^12.1.14",
+    "@multiformats/multiaddr-matcher": "^1.1.2",
+    "@orbitdb/feed-db": "^1.0.0",
+    "@types/crypto-js": "^4.2.2",
+    "@types/file-saver": "^2.0.7",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.11.10",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^6.20.0",
+    "@typescript-eslint/parser": "^6.20.0",
+    "aegir": "^42.2.2",
     "browserify-fs": "^1.0.0",
     "buffer": "^6.0.3",
-    "core-js": "^3.33.1",
+    "core-js": "^3.35.1",
     "crypto-browserify": "^3.12.0",
-    "eslint": "^8.52.0",
+    "eslint": "^8.56.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^9.0.0",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.1.1",
+    "file-saver": "^2.0.5",
+    "keys": "link:@libp2p/crypto/keys",
     "mocha": "^10.2.0",
     "os-browserify": "^0.3.0",
-    "playwright": "^1.39.0",
-    "prettier": "^3.0.3",
+    "playwright": "^1.41.1",
+    "prettier": "^3.2.4",
     "process": "^0.11.10",
     "source-map-support": "^0.5.21",
-    "ts-patch": "^3.0.2",
+    "stream-browserify": "^3.0.0",
+    "ts-patch": "^3.1.2",
     "tsconfig-paths": "^4.2.0",
     "tscpaths": "^0.0.9",
-    "typescript": "5.2.2",
+    "typescript": "5.3.3",
     "typescript-transform-paths": "^3.4.6"
   },
   "dependencies": {
-    "@orbitdb/core": "^1.0.0",
+    "@helia/block-brokers": "^2.0.0",
+    "@orbitdb/quickstart": "^1.0.0",
+    "blockstore-core": "^4.3.10",
+    "blockstore-level": "^1.1.7",
     "chokidar": "^3.5.3",
-    "genversion": "^3.1.1",
-    "ipfs-core": "^0.18.1",
+    "events": "^3.3.0",
+    "genversion": "^3.2.0",
+    "helia": "^3.0.1",
+    "libp2p": "^1.2.1",
     "rimraf": "^5.0.5",
-    "uint8arrays": "^4.0.6",
+    "uint8arrays": "^5.0.1",
     "uuid": "^9.0.1",
     "wherearewe": "^2.0.1"
   },
-  "resolutions": {
-    "iso-constants": "git+https://github.com/inverted-capital/iso-constants.git#patch-1",
-    "ipfs-pubsub-1on1": "git+https://github.com/ipfs-shipyard/ipfs-pubsub-1on1.git"
-  },
-  "overrides": {
-    "iso-constants": {
-      ".": "git+https://github.com/inverted-capital/iso-constants.git#patch-1"
-    },
-    "ipfs-pubsub-1on1": {
-      ".": "git+https://github.com/ipfs-shipyard/ipfs-pubsub-1on1.git"
-    }
-  },
   "scripts": {
     "nettoyer": "rimraf dist",
-    "compiler": "pnpm versioner && pnpm nettoyer && pnpm tspc -p tsconfig.build.json",
+    "compiler": "pnpm versioner && pnpm formatter && pnpm nettoyer && pnpm tspc -p tsconfig.build.json",
     "test:node": "pnpm compiler && pnpm aegir test -t node --cov -- --exit",
-    "test:navig": "pnpm compiler && pnpm aegir test -t browser --cov",
+    "test:navig": "pnpm compiler && pnpm webrtc && pnpm aegir test -t browser --cov",
     "test:électron-principal": "pnpm compiler && pnpm aegir test -t electron-main --cov",
-    "test:électron-rendu": "pnpm compiler && pnpm aegir test -t electron-renderer --cov",
+    "test:électron-rendu": "pnpm compiler && pnpm webrtc && pnpm aegir test -t electron-renderer --cov",
     "test": "pnpm test:node && pnpm test:navig",
     "formatter": "pnpm prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\" && pnpm eslint --ext .js,.ts src",
     "publier": "pnpm versioner && pnpm compiler && (git commit -a -m 'version' || true) && pnpm publish",
-    "versioner": "pnpm genversion  --es6 --semi src/version.ts"
+    "versioner": "pnpm genversion  --es6 --semi src/version.ts",
+    "webrtc": "node ./test/utils/relai.js &"
   }
 }

package/renovate.json

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

package/src/@types/{shims-orbit-db-core.d.ts → shims-orbitdb-core.d.ts}

@@ -151,10 +151,14 @@ declare module "@orbitdb/core" {
   };
 
   // Temporaires
-  export type Store = FeedStore | SetStore | KeyValueStore | OrderedKeyValueStore;
-  
+  export type Store =
+    | FeedStore
+    | SetStore
+    | KeyValueStore
+    | OrderedKeyValueStore;
+
   export type FeedStore = Awaited<ReturnType<typeof Database>> & {
-    remove: (hash: string) => Promise<string>
+    remove: (hash: string) => Promise<string>;
   };
   export type FeedStoreTypé<T extends élémentsBd> = Omit<
     FeedStore,
@@ -189,11 +193,14 @@ declare module "@orbitdb/core" {
   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"> & {
+    Omit<
+      OrderedKeyValueStore,
+      "put" | "set" | "del" | "move" | "get" | "all"
+    > & {
       put: <K extends keyof T>(
         key: K,
         value: T[K],
-        position?: number
+        position?: number,
       ) => Promise<string>;
       set: OrderedKeyValueStoreTypé<T>["put"];
       del: <K extends keyof T>(key: K) => Promise<string>;
@@ -232,5 +239,4 @@ declare module "@orbitdb/core" {
     get<K extends keyof T>(key: K): Promise<T[K] | undefined>;
     all(): Promise<T>;
   };
-
 }

package/src/@types/shims-orbitdb-quickstart.d.ts

@@ -0,0 +1,15 @@
+declare module "@orbitdb/quickstart" {
+  import { Identities, Identity, OrbitDB } from "@orbitdb/core";
+  import { Libp2pOptions as Libp2pOptionsType } from "libp2p";
+
+  export function startOrbitDB(args: {
+    id?: string;
+    identity?: Identity;
+    identities?: Identities;
+    directory?: string;
+  }): Promise<OrbitDB>;
+  export function stopOrbitDB(orbitdb: OrbitDB): Promise<void>;
+
+  export const DefaultLibp2pOptions: Libp2pOptionsType;
+  export const DefaultLibp2pBrowserOptions: Libp2pOptionsType;
+}

package/src/attente.ts

@@ -21,12 +21,12 @@ export class AttendreRésultat<T> {
   }
 
   async attendreQue(f: (x: T) => boolean | Promise<boolean>): Promise<T> {
-    if (this.val !== undefined && await f(this.val)) return this.val;
+    if (this.val !== undefined && (await f(this.val))) return this.val;
     const id = uuidv4();
 
     return new Promise((résoudre) => {
       const fLorsqueChangé = async () => {
-        if (this.val !== undefined && await f(this.val)) {
+        if (this.val !== undefined && (await f(this.val))) {
           this.oublier(id);
           résoudre(this.val);
         }

package/src/constellation.ts

@@ -0,0 +1,80 @@
+import {
+  type réseau,
+  type client,
+  type ClientConstellation,
+} from "@constl/ipa";
+import { isBrowser } from "wherearewe";
+
+import { créerOrbiteTest } from "@/orbite.js";
+import { AttendreRésultat } from "@/attente.js";
+
+export const créerConstellationsTest = async <T = ClientConstellation>({
+  n = 1,
+  fGénérerClient,
+}: {
+  n: number;
+  fGénérerClient: ({ opts }: { opts: client.optsConstellation }) => T;
+}): Promise<{
+  clients: ReturnType<typeof fGénérerClient>[];
+  fOublier: () => Promise<void>;
+}> => {
+  const clients: ReturnType<typeof fGénérerClient>[] = [];
+  const fsOublier: (() => Promise<void>)[] = [];
+
+  // Nécessaire pour Playwright
+  if (isBrowser) window.localStorage.clear();
+
+  const { orbites, fOublier: fOublierOrbites } = await créerOrbiteTest({ n });
+  fsOublier.push(fOublierOrbites);
+
+  for (const i in [...Array(n).keys()]) {
+    const client = fGénérerClient({
+      opts: { orbite: orbites[i] },
+    });
+    clients.push(client);
+  }
+
+  const fOublier = async () => {
+    if (isBrowser) return; // Mystère et boule de gomme !!
+
+    await Promise.all(
+      clients.map((client) => (client as ClientConstellation).fermer()),
+    );
+    await Promise.all(fsOublier.map((f) => f()));
+  };
+  return { fOublier, clients };
+};
+
+export const constellationConnectéeÀ = async (
+  constellation: client.ClientConstellation,
+  connectéeÀ: client.ClientConstellation,
+): Promise<void> => {
+  const dispositifsConnectés = new AttendreRésultat<
+    réseau.statutDispositif[]
+  >();
+  const idCompte2 = await connectéeÀ.obtIdCompte();
+
+  const fOublier = await constellation.réseau!.suivreConnexionsDispositifs({
+    f: (dispositifs) => dispositifsConnectés.mettreÀJour(dispositifs),
+  });
+  await dispositifsConnectés.attendreQue((dispositifs) => {
+    return !!dispositifs.find((d) => d.infoDispositif.idCompte === idCompte2);
+  });
+  await fOublier();
+  return;
+};
+
+export const constellationsConnectées = async (
+  ...clients: client.ClientConstellation[]
+): Promise<void> => {
+  if (clients.length < 2) return;
+  const promesses: Promise<void>[] = [];
+  for (let i = 1; i < clients.length; i++) {
+    for (let j = 0; j < i; j++) {
+      promesses.push(constellationConnectéeÀ(clients[i], clients[j]));
+      promesses.push(constellationConnectéeÀ(clients[j], clients[i]));
+    }
+  }
+  await Promise.all(promesses);
+  return;
+};

package/src/dossiers.ts

@@ -1,7 +1,7 @@
 import { isNode, isElectronMain } from "wherearewe";
 import { v4 as uuidv4 } from "uuid";
 
-export const dossierTempoTests = async (): Promise<{
+export const dossierTempo = async (): Promise<{
   dossier: string;
   fEffacer: () => void;
 }> => {
@@ -24,23 +24,3 @@ export const dossierTempoTests = async (): Promise<{
     };
   }
 };
-
-export const obtDirTempoPourTest = async ({
-  base,
-  nom,
-}: {
-  base: string;
-  nom?: string;
-}): Promise<string> => {
-  if (isNode || isElectronMain) {
-    const fs = await import("fs");
-    const path = await import("path");
-
-    const dossier = path.resolve(base, (nom || "") + uuidv4());
-    fs.mkdirSync(dossier, { recursive: true });
-    return dossier;
-  } else {
-    const dossier = base + "/" + (nom || "") + uuidv4();
-    return dossier;
-  }
-};

package/src/index.ts

@@ -1,110 +1,7 @@
-import { once } from "events";
-
-import { FeedStoreTypé, KeyValueStoreTypé, OrbitDB, type Store } from "@orbitdb/core";
-
-import type { client, réseau, accès } from "@constl/ipa";
-
-import { AttendreRésultat } from "@/attente.js";
-
-export * as sfip from "@/sfip.js";
 export * as attente from "@/attente.js";
-export * as client from "@/client.js";
+export * as constellation from "@/constellation.js";
 export * as dossiers from "@/dossiers.js";
-export { version } from "@/version.js";
-
-type ContrôleurConstellation = Awaited<
-  ReturnType<ReturnType<typeof accès.cntrlConstellation.default>>
->;
-
-const attendreInvité = (accès: ContrôleurConstellation, idInvité: string): Promise<void> =>
-  new Promise<void>((resolve) => {
-    const testAutorisé = async () => {
-      const autorisé = await accès.estAutorisé(idInvité);
-      if (autorisé) {
-        clearInterval(interval);
-        resolve();
-      }
-    };
-    const interval = setInterval(testAutorisé, 100);
-    testAutorisé();
-  });
-
-export const clientConnectéÀ = async (
-  client1: client.ClientConstellation,
-  client2: client.ClientConstellation,
-): Promise<void> => {
-  const dispositifsConnectés = new AttendreRésultat<
-    réseau.statutDispositif[]
-  >();
-  const idCompte2 = await client2.obtIdCompte();
-
-  const fOublier = await client1.réseau!.suivreConnexionsDispositifs({
-    f: (dispositifs) => dispositifsConnectés.mettreÀJour(dispositifs),
-  });
-  await dispositifsConnectés.attendreQue((dispositifs) => {
-    return !!dispositifs.find((d) => d.infoDispositif.idCompte === idCompte2);
-  });
-  await fOublier();
-  return;
-};
-
-export const clientsConnectés = async (
-  ...clients: client.ClientConstellation[]
-): Promise<void> => {
-  if (clients.length < 2) return;
-  const promesses: Promise<void>[] = [];
-  for (let i = 1; i < clients.length; i++) {
-    for (let j = 0; j < i; j++) {
-      promesses.push(clientConnectéÀ(clients[i], clients[j]));
-      promesses.push(clientConnectéÀ(clients[j], clients[i]));
-    }
-  }
-  await Promise.all(promesses);
-  return;
-};
-
-export const attendreSync = async (bd: Store): Promise<void> => {
-  const accès = bd.access as unknown as ContrôleurConstellation;
-  await once(accès.bd!.events, "peer.exchanged");
-};
-
-export const peutÉcrire = async (
-  bd: KeyValueStoreTypé<{ [clef: string]: number }> | FeedStoreTypé<string>,
-  attendre?: OrbitDB,
-): Promise<boolean> => {
-  if (attendre) {
-    await attendreInvité(bd.access as unknown as ContrôleurConstellation, attendre.identity.id);
-  }
-
-  try {
-    if (bd.type === "keyvalue") {
-      const bdKV = bd as KeyValueStoreTypé<{ [clef: string]: number }>
-       
-      // Important d'avoir une clef unique pour éviter l'interférence entre les tests
-      const CLEF = "test" + Math.random().toString();
-      const VAL = 123;
-
-      await bdKV.set(CLEF, VAL);
-      const val = await bdKV.get(CLEF);
-
-      await bdKV.del(CLEF);
-      return val === VAL;
-    } else if (bd.type === "feed") {
-      const VAL = "test";
-
-      await (bd as FeedStoreTypé<string>).add(VAL);
-      const éléments = await (bd as FeedStoreTypé<string>).all();
+export * as orbite from "@/orbite.js";
+export * as sfip from "@/sfip.js";
 
-      const autorisé =
-        éléments.length === 1 && éléments[0].value === VAL;
-      if (éléments.length === 1) {
-        await (bd as FeedStoreTypé<string>).remove(éléments[0].hash);
-      }
-      return autorisé;
-    } else {
-      throw new Error(`Type de BD ${bd.type} non supporté par ce test.`);
-    }
-  } catch {
-    return false;
-  }
-};
+export { version } from "@/version.js";

package/src/orbite.ts

@@ -0,0 +1,165 @@
+/*
+Certaines parties de ce fichier proviennent d'OrbitDB
+
+MIT License
+
+Copyright (c) 2019 Haja Networks Oy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import type { Helia } from "helia";
+import type {
+  FeedStoreTypé,
+  KeyValueStoreTypé,
+  OrbitDB,
+  Store,
+} from "@orbitdb/core";
+
+import { once } from "events";
+
+import { dossierTempo } from "@/dossiers.js";
+import { connecterPairs } from "@/sfip.js";
+
+const OrbitDBQuickstart = await import("@orbitdb/quickstart");
+const { startOrbitDB, stopOrbitDB } = OrbitDBQuickstart;
+
+export const créerOrbiteTest = async ({
+  n = 1,
+}: {
+  n: number;
+}): Promise<{ orbites: OrbitDB[]; fOublier: () => Promise<void> }> => {
+  const sfips: Helia[] = [];
+  const orbites: OrbitDB[] = [];
+
+  const {
+    dossier: racineDossierOrbite,
+    fEffacer: fEffacerRacineDossierOrbite,
+  } = await dossierTempo();
+
+  fEffacerRacineDossierOrbite();
+
+  const _générer = async (i: number): Promise<void> => {
+    const racineDossier = `${racineDossierOrbite}/${i}`;
+    const orbite = await startOrbitDB({
+      directory: `${racineDossier}/orbite`,
+    });
+    for (const ip of sfips) {
+      await connecterPairs(orbite.ipfs, ip);
+    }
+    sfips.push(orbite.ipfs);
+
+    orbites.push(orbite);
+  };
+
+  await Promise.all([...Array(n).keys()].map((i) => _générer(i)));
+
+  const fOublier = async () => {
+    await Promise.all(orbites.map(stopOrbitDB));
+
+    fEffacerRacineDossierOrbite();
+  };
+  return { orbites, fOublier };
+};
+
+export const attendreSync = async (bd: Store): Promise<void> => {
+  const accèsBd = bd.access as unknown as ContrôleurConstellation;
+  await once(accèsBd.bd.events, "peer.exchanged");
+};
+
+export type ContrôleurConstellation = {
+  type: string;
+  address: string;
+  adresseBdAccès: string;
+  write: string;
+  estAutorisé: (id: string) => Promise<boolean>;
+  grant: (rôle: "MODÉRATEUR" | "MEMBRE", id: string) => Promise<void>;
+  revoke: (_rôle: "MODÉRATEUR" | "MEMBRE", _id: string) => Promise<void>;
+  bd: Store;
+};
+
+const attendreInvité = (
+  accès: ContrôleurConstellation,
+  idInvité: string,
+): Promise<void> =>
+  new Promise<void>((resolve) => {
+    const testAutorisé = async () => {
+      const autorisé = await accès.estAutorisé(idInvité);
+      if (autorisé) {
+        clearInterval(interval);
+        resolve();
+      }
+    };
+    const interval = setInterval(testAutorisé, 100);
+    testAutorisé();
+  });
+
+export const peutÉcrire = async (
+  bd: KeyValueStoreTypé<{ [clef: string]: number }> | FeedStoreTypé<string>,
+  attendre?: OrbitDB,
+): Promise<boolean> => {
+  if (attendre) {
+    await attendreInvité(
+      bd.access as unknown as ContrôleurConstellation,
+      attendre.identity.id,
+    );
+  }
+
+  try {
+    if (bd.type === "keyvalue") {
+      const bdKV = bd as KeyValueStoreTypé<{ [clef: string]: number }>;
+
+      // Important d'avoir une clef unique pour éviter l'interférence entre les tests
+      const CLEF = "test" + Math.random().toString();
+      const VAL = 123;
+
+      await bdKV.set(CLEF, VAL);
+      const val = await bdKV.get(CLEF);
+
+      await bdKV.del(CLEF);
+      return val === VAL;
+    } else if (bd.type === "feed") {
+      const VAL = "test";
+
+      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].value === VAL;
+      if (éléments.length === 1) {
+        await (bd as FeedStoreTypé<string>).remove(éléments[0].hash);
+      }
+      return autorisé;
+    } else if (bd.type === "set") {
+      const VAL = "test";
+
+      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].value === VAL;
+      if (éléments.length === 1) {
+        await (bd as FeedStoreTypé<string>).remove(éléments[0].hash);
+      }
+      return autorisé;
+    } else {
+      throw new Error(`Type de BD ${bd.type} non supporté par ce test.`);
+    }
+  } catch {
+    return false;
+  }
+};