@oesp/sync-http 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# @oesp/sync-http
+
+Client de synchronisation HTTP pour OESP avec support des uploads fragmentés et vérification d'intégrité.
+
+## Installation
+
+```bash
+npm install @oesp/sync-http
+```
+
+## Fonctionnalités
+
+- **Upload par Session** : Création de session pour gérer les gros volumes de données.
+- **Envoi Fragmenté (Chunked)** : Découpage automatique des données pour éviter les timeouts et respecter les limites du serveur.
+- **Vérification d'Intégrité** : Calcul du hash SHA-256 pour chaque fragment envoyé.
+- **Opérations Asynchrones** : Gestion non-bloquante des requêtes réseau via `fetch`.
+- **Crypto Agnostique** : Injection du provider SHA-256.
+
+## Utilisation
+
+```ts
+import { OESPSyncClient } from '@oesp/sync-http';
+import { sha256 } from 'js-sha256'; // Exemple de lib externe
+
+// 1. Initialiser le client avec l'URL du serveur et le provider SHA-256
+const client = new OESPSyncClient({
+  baseUrl: 'https://mon-serveur-oesp.com',
+  sha256: async (data) => new Uint8Array(sha256.arrayBuffer(data))
+});
+
+// 2. Préparer les tokens à synchroniser (format string base64url ou raw)
+const tokensToSync = [
+  'OESP1.token1...',
+  'OESP1.token2...'
+];
+
+const deviceDid = 'oesp:did:my_device';
+
+try {
+  // 3. Lancer la synchronisation asynchrone
+  // La méthode gère automatiquement la création de session, le découpage et l'upload
+  const result = await client.syncTokens(
+    tokensToSync,
+    deviceDid
+  );
+
+  if (result.success) {
+    console.log(`Synchronisation réussie !`);
+    console.log(`Tokens envoyés : ${result.uploadedCount}`);
+    console.log(`ID de session : ${result.sessionId}`);
+  } else {
+    console.error(`Erreur de synchro : ${result.error}`);
+  }
+} catch (err) {
+  console.error("Erreur réseau ou client:", err);
+}
+```
+
+## Configuration Avancée
+
+Vous pouvez ajuster la taille des chunks lors de l'initialisation :
+
+```ts
+const client = new OESPSyncClient({
+  baseUrl: 'https://api.oesp.com',
+  sha256: mySha256Provider,
+  chunkSize: 1024 * 1024 // 1MB par chunk (défaut: 512KB)
+});
+```

package/dist/index.cjs

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OESPSyncClient: () => OESPSyncClient,
+  getSyncConfig: () => getSyncConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/SyncClient.ts
+var import_core = require("@oesp/core");
+
+// src/env.ts
+var import_meta = {};
+function getSyncConfig(overrides = {}) {
+  const defaultBaseUrl = "http://oesp-sync-server:8000";
+  let envBaseUrl;
+  if (typeof process !== "undefined" && process.env?.OESP_SYNC_BASE_URL) {
+    envBaseUrl = process.env.OESP_SYNC_BASE_URL;
+  }
+  if (typeof import_meta !== "undefined" && import_meta.env?.VITE_OESP_SYNC_BASE_URL) {
+    envBaseUrl = import_meta.env.VITE_OESP_SYNC_BASE_URL;
+  }
+  return {
+    baseUrl: overrides.baseUrl || envBaseUrl || defaultBaseUrl,
+    apiKey: overrides.apiKey,
+    timeoutMs: overrides.timeoutMs || 3e4,
+    maxChunkBytes: overrides.maxChunkBytes || 5e5
+    // 500KB
+  };
+}
+
+// src/SyncClient.ts
+var OESPSyncClient = class {
+  constructor(opts) {
+    this.config = getSyncConfig(opts);
+    this.sha256 = opts.sha256;
+  }
+  setBaseUrl(url) {
+    this.config.baseUrl = url;
+  }
+  /**
+   * Synchronise une liste de tokens vers le serveur
+   */
+  async syncTokens(tokens, deviceDid, opts = {}) {
+    try {
+      const startRes = await fetch(`${this.config.baseUrl}/sync/start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          did: deviceDid,
+          pub: opts.devicePubB64,
+          meta: opts.clientMeta
+        })
+      });
+      if (!startRes.ok) throw new Error(`Failed to start sync: ${startRes.statusText}`);
+      const { session_id } = await startRes.json();
+      let uploadedCount = 0;
+      let totalBytes = 0;
+      const jsonlData = tokens.map((t) => JSON.stringify({ token: t })).join("\n");
+      const dataBytes = new TextEncoder().encode(jsonlData);
+      const chunks = this.chunkBytes(dataBytes, this.config.maxChunkBytes);
+      for (let i = 0; i < chunks.length; i++) {
+        const chunkRes = await fetch(`${this.config.baseUrl}/sync/upload`, {
+          method: "POST",
+          headers: {
+            "X-Session-ID": session_id,
+            "X-Chunk-Index": i.toString(),
+            "Content-Type": "application/octet-stream"
+          },
+          body: chunks[i]
+        });
+        if (!chunkRes.ok) throw new Error(`Failed to upload chunk ${i}: ${chunkRes.statusText}`);
+        totalBytes += chunks[i].length;
+      }
+      const finalHashBytes = await this.sha256(dataBytes);
+      const finalHash = (0, import_core.base64Encode)(finalHashBytes);
+      const commitRes = await fetch(`${this.config.baseUrl}/sync/commit`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          session_id,
+          final_hash: finalHash,
+          allow_expired: opts.allowExpired ?? true
+        })
+      });
+      if (!commitRes.ok) throw new Error(`Failed to commit: ${commitRes.statusText}`);
+      return {
+        success: true,
+        uploadedCount: tokens.length,
+        totalBytes,
+        sessionId: session_id
+      };
+    } catch (e) {
+      return {
+        success: false,
+        uploadedCount: 0,
+        totalBytes: 0,
+        error: e.message
+      };
+    }
+  }
+  chunkBytes(data, maxSize) {
+    const chunks = [];
+    for (let i = 0; i < data.length; i += maxSize) {
+      chunks.push(data.slice(i, i + maxSize));
+    }
+    return chunks;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OESPSyncClient,
+  getSyncConfig
+});

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+interface SyncConfig {
+    baseUrl: string;
+    apiKey?: string;
+    timeoutMs: number;
+    maxChunkBytes: number;
+}
+declare function getSyncConfig(overrides?: Partial<SyncConfig>): SyncConfig;
+
+interface SyncSummary {
+    success: boolean;
+    uploadedCount: number;
+    totalBytes: number;
+    sessionId?: string;
+    error?: string;
+}
+interface SyncOpts extends Partial<SyncConfig> {
+    sha256: (data: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+}
+declare class OESPSyncClient {
+    private config;
+    private sha256;
+    constructor(opts: SyncOpts);
+    setBaseUrl(url: string): void;
+    /**
+     * Synchronise une liste de tokens vers le serveur
+     */
+    syncTokens(tokens: string[], deviceDid: string, opts?: {
+        devicePubB64?: string;
+        clientMeta?: any;
+        allowExpired?: boolean;
+    }): Promise<SyncSummary>;
+    private chunkBytes;
+}
+
+export { OESPSyncClient, type SyncConfig, type SyncOpts, type SyncSummary, getSyncConfig };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+interface SyncConfig {
+    baseUrl: string;
+    apiKey?: string;
+    timeoutMs: number;
+    maxChunkBytes: number;
+}
+declare function getSyncConfig(overrides?: Partial<SyncConfig>): SyncConfig;
+
+interface SyncSummary {
+    success: boolean;
+    uploadedCount: number;
+    totalBytes: number;
+    sessionId?: string;
+    error?: string;
+}
+interface SyncOpts extends Partial<SyncConfig> {
+    sha256: (data: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+}
+declare class OESPSyncClient {
+    private config;
+    private sha256;
+    constructor(opts: SyncOpts);
+    setBaseUrl(url: string): void;
+    /**
+     * Synchronise une liste de tokens vers le serveur
+     */
+    syncTokens(tokens: string[], deviceDid: string, opts?: {
+        devicePubB64?: string;
+        clientMeta?: any;
+        allowExpired?: boolean;
+    }): Promise<SyncSummary>;
+    private chunkBytes;
+}
+
+export { OESPSyncClient, type SyncConfig, type SyncOpts, type SyncSummary, getSyncConfig };

package/dist/index.js

@@ -0,0 +1,104 @@
+// src/SyncClient.ts
+import { base64Encode } from "@oesp/core";
+
+// src/env.ts
+function getSyncConfig(overrides = {}) {
+  const defaultBaseUrl = "http://oesp-sync-server:8000";
+  let envBaseUrl;
+  if (typeof process !== "undefined" && process.env?.OESP_SYNC_BASE_URL) {
+    envBaseUrl = process.env.OESP_SYNC_BASE_URL;
+  }
+  if (typeof import.meta !== "undefined" && import.meta.env?.VITE_OESP_SYNC_BASE_URL) {
+    envBaseUrl = import.meta.env.VITE_OESP_SYNC_BASE_URL;
+  }
+  return {
+    baseUrl: overrides.baseUrl || envBaseUrl || defaultBaseUrl,
+    apiKey: overrides.apiKey,
+    timeoutMs: overrides.timeoutMs || 3e4,
+    maxChunkBytes: overrides.maxChunkBytes || 5e5
+    // 500KB
+  };
+}
+
+// src/SyncClient.ts
+var OESPSyncClient = class {
+  constructor(opts) {
+    this.config = getSyncConfig(opts);
+    this.sha256 = opts.sha256;
+  }
+  setBaseUrl(url) {
+    this.config.baseUrl = url;
+  }
+  /**
+   * Synchronise une liste de tokens vers le serveur
+   */
+  async syncTokens(tokens, deviceDid, opts = {}) {
+    try {
+      const startRes = await fetch(`${this.config.baseUrl}/sync/start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          did: deviceDid,
+          pub: opts.devicePubB64,
+          meta: opts.clientMeta
+        })
+      });
+      if (!startRes.ok) throw new Error(`Failed to start sync: ${startRes.statusText}`);
+      const { session_id } = await startRes.json();
+      let uploadedCount = 0;
+      let totalBytes = 0;
+      const jsonlData = tokens.map((t) => JSON.stringify({ token: t })).join("\n");
+      const dataBytes = new TextEncoder().encode(jsonlData);
+      const chunks = this.chunkBytes(dataBytes, this.config.maxChunkBytes);
+      for (let i = 0; i < chunks.length; i++) {
+        const chunkRes = await fetch(`${this.config.baseUrl}/sync/upload`, {
+          method: "POST",
+          headers: {
+            "X-Session-ID": session_id,
+            "X-Chunk-Index": i.toString(),
+            "Content-Type": "application/octet-stream"
+          },
+          body: chunks[i]
+        });
+        if (!chunkRes.ok) throw new Error(`Failed to upload chunk ${i}: ${chunkRes.statusText}`);
+        totalBytes += chunks[i].length;
+      }
+      const finalHashBytes = await this.sha256(dataBytes);
+      const finalHash = base64Encode(finalHashBytes);
+      const commitRes = await fetch(`${this.config.baseUrl}/sync/commit`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          session_id,
+          final_hash: finalHash,
+          allow_expired: opts.allowExpired ?? true
+        })
+      });
+      if (!commitRes.ok) throw new Error(`Failed to commit: ${commitRes.statusText}`);
+      return {
+        success: true,
+        uploadedCount: tokens.length,
+        totalBytes,
+        sessionId: session_id
+      };
+    } catch (e) {
+      return {
+        success: false,
+        uploadedCount: 0,
+        totalBytes: 0,
+        error: e.message
+      };
+    }
+  }
+  chunkBytes(data, maxSize) {
+    const chunks = [];
+    for (let i = 0; i < data.length; i += maxSize) {
+      chunks.push(data.slice(i, i + maxSize));
+    }
+    return chunks;
+  }
+};
+export {
+  OESPSyncClient,
+  getSyncConfig
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@oesp/sync-http",
+  "version": "1.0.0",
+  "private": false,
+  "description": "OESP HTTP Sync Client",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@oesp/core": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^1.6.0"
+  }
+}