@mostajs/blob-store 0.1.0 → 0.2.0

package/README.md

@@ -50,14 +50,40 @@ Erreurs **typées** (jamais nues) : `StorageError` avec un `code` (`not_found`,
 - **`FilesystemDriver`** — disque local. Sanitise les chemins (le `..` est refusé : un driver
   de stockage est une surface d'attaque).
 - **`CachingDriver`** — décorateur de cache devant un driver d'origine.
-- **S3** — à venir (voir la feuille de route ; `@mostajs/storage` promettait « FS / S3 » sans
-  jamais livrer S3 : la dette est soldée **ici**, pour que tous les consommateurs en profitent).
+- **`S3Driver`** — S3 **et tout service S3-compatible** : AWS, MinIO, Scaleway, Wasabi,
+  Backblaze… **Zéro dépendance** : SigV4 est implémenté ici (S3 n'est que du HTTP signé), au
+  lieu de tirer `@aws-sdk/client-s3` et ses dizaines de mégaoctets. Pour héberger les
+  sauvegardes de vos clients sur vos propres serveurs, cette souveraineté n'est pas un détail.
+
+  ```js
+  import { S3Driver } from '@mostajs/blob-store/drivers/s3';
+
+  const s3 = new S3Driver({
+    endpoint: 'http://localhost:9000',   // MinIO auto-hébergé, ou https://s3.eu-west-3.amazonaws.com
+    region: 'eu-west-3',
+    accessKeyId: process.env.S3_KEY,
+    secretAccessKey: process.env.S3_SECRET,
+    forcePathStyle: true,                // requis par la plupart des services auto-hébergés
+  });
+  ```
+
+  **Dette soldée** : `@mostajs/storage` annonçait « bytes in object storage (FS / **S3**) »
+  depuis sa 0.2.0 — sans qu'aucun pilote S3 n'existe. La promesse est tenue **ici**, au niveau
+  de la primitive, pour qu'`archive-box` et `backup` en profitent aussi. La poser dans
+  `storage` aurait payé la dette au mauvais étage.
 
 ## Tests
 
 ```bash
-npm test   # 10 tests mjs-unit, sur un VRAI répertoire temporaire
+npm test   # 28 tests mjs-unit : disque réel, SigV4, serveur S3 simulé
 ```
 
-Un test de stockage qui n'écrit rien ne prouve rien : les tests exercent le disque réel, avec
-un vecteur SHA-256 **vérifié indépendamment** (et non recopié depuis le pilote lui-même).
+Un test de stockage qui n'écrit rien ne prouve rien :
+
+- **Filesystem** — disque réel, vecteur SHA-256 **vérifié indépendamment** (et non recopié
+  depuis le pilote lui-même).
+- **SigV4** — validée contre les **vecteurs officiels d'AWS** (dérivation de clé, requête
+  canonique et signature de la suite « get-vanilla »). Une signature fausse ne se manifesterait
+  qu'à l'exécution, par un `403 SignatureDoesNotMatch` indéchiffrable sur un serveur distant.
+- **S3** — serveur S3 **simulé** qui **refuse toute requête non signée** : un pilote qui
+  « marcherait » sans `Authorization` passerait des tests naïfs, puis échouerait chez le client.

package/dist/drivers/s3.d.ts

@@ -0,0 +1,51 @@
+import type { StorageDriver, PutBody, PutOptions, GetObjectResult, StatResult } from '../driver.js';
+import type { ObjectRef, PutObjectResult } from '../types.js';
+import { type SigV4Credentials } from './sigv4.js';
+export interface S3DriverConfig extends SigV4Credentials {
+    /** Ex. `https://s3.eu-west-3.amazonaws.com` ou `http://localhost:9000` (MinIO). */
+    endpoint: string;
+    region: string;
+    /**
+     * `true` (défaut) → `https://host/bucket/cle` ; `false` → `https://bucket.host/cle`.
+     * Les services auto-hébergés (MinIO) exigent généralement le style « path ».
+     */
+    forcePathStyle?: boolean;
+    /** Timeout par requête (ms). Défaut 30 s — une requête sans borne fige l'appelant. */
+    timeoutMs?: number;
+}
+export declare class S3Driver implements StorageDriver {
+    private config;
+    readonly id = "s3";
+    constructor(config: S3DriverConfig);
+    /** URL d'un objet (ou du bucket si `key` est vide), selon le style d'adressage. */
+    private url;
+    /** Envoie une requête signée. Traduit les statuts HTTP en `StorageError` typées. */
+    private send;
+    /**
+     * Écrit un objet.
+     *
+     * Le corps est mis EN MÉMOIRE avant envoi. C'est un choix assumé : SigV4 exige soit le
+     * hash sha256 de la charge utile, soit la signature par blocs (« chunked »), nettement plus
+     * complexe. Bufferiser donne un `checksum` fiable et un `Content-Length` exact — au prix de
+     * la mémoire. Pour de très gros objets, ce pilote appellera un jour l'upload multipart ;
+     * mieux vaut une limite CONNUE qu'un streaming subtilement faux.
+     */
+    put(ref: ObjectRef, body: PutBody, opts: PutOptions): Promise<PutObjectResult>;
+    get(ref: ObjectRef): Promise<GetObjectResult>;
+    delete(ref: ObjectRef): Promise<void>;
+    exists(ref: ObjectRef): Promise<boolean>;
+    stat(ref: ObjectRef): Promise<StatResult>;
+    list(args: {
+        bucket: string;
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        items: {
+            path: string;
+            size: number;
+            modifiedAt: Date;
+        }[];
+        nextCursor?: string;
+    }>;
+}

package/dist/drivers/s3.js

@@ -0,0 +1,219 @@
+// @mostajs/blob-store — Pilote S3 (et tout service S3-compatible)
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+// License: AGPL-3.0-or-later
+//
+// ZÉRO DÉPENDANCE : S3 n'est que du HTTP signé (SigV4). On n'embarque pas
+// `@aws-sdk/client-s3` — des dizaines de Mo de dépendances pour poser et relire des octets.
+//
+// Conséquence heureuse : le pilote parle à TOUT service S3-compatible — AWS, mais aussi
+// MinIO, Scaleway, Wasabi, Backblaze, ou un MinIO auto-hébergé. Pour des sauvegardes
+// clients, cette souveraineté n'est pas un détail.
+//
+// DETTE SOLDÉE : `@mostajs/storage` annonçait « bytes in object storage (FS / S3) » depuis
+// sa 0.2.0 — sans qu'aucun pilote S3 n'existe. La promesse est tenue ICI, au niveau de la
+// primitive, pour que `@mostajs/archive-box` et `@mostajs/backup` en profitent aussi. La
+// poser dans `storage` aurait payé la dette au mauvais étage.
+import { StorageError } from '../types.js';
+import { signRequest, hashPayload, uriEncode } from './sigv4.js';
+/** Lit entièrement un corps en mémoire (voir la note sur le buffering dans `put`). */
+async function toBytes(body) {
+    if (body instanceof Uint8Array)
+        return body;
+    const chunks = [];
+    for await (const chunk of body) {
+        chunks.push(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+    }
+    const total = chunks.reduce((n, c) => n + c.length, 0);
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+        out.set(c, off);
+        off += c.length;
+    }
+    return out;
+}
+/** Extrait le contenu des balises `<tag>…</tag>` — suffisant pour le XML plat de S3. */
+function xmlAll(xml, tag) {
+    const re = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, 'g');
+    const out = [];
+    let m;
+    while ((m = re.exec(xml)) !== null)
+        out.push(m[1]);
+    return out;
+}
+const xmlOne = (xml, tag) => xmlAll(xml, tag)[0];
+export class S3Driver {
+    config;
+    id = 's3';
+    constructor(config) {
+        this.config = config;
+        if (!config.endpoint)
+            throw new StorageError('driver_error', 'S3Driver: endpoint requis');
+        if (!config.region)
+            throw new StorageError('driver_error', 'S3Driver: region requise');
+    }
+    /** URL d'un objet (ou du bucket si `key` est vide), selon le style d'adressage. */
+    url(bucket, key = '') {
+        const base = new URL(this.config.endpoint);
+        const pathStyle = this.config.forcePathStyle !== false;
+        const encodedKey = key ? uriEncode(key, false) : '';
+        const host = pathStyle ? base.host : `${bucket}.${base.host}`;
+        const path = pathStyle
+            ? `/${uriEncode(bucket, false)}${encodedKey ? `/${encodedKey}` : ''}`
+            : `/${encodedKey}`;
+        return { href: `${base.protocol}//${host}${path}`, host, path };
+    }
+    /** Envoie une requête signée. Traduit les statuts HTTP en `StorageError` typées. */
+    async send(args) {
+        const { href, host, path } = this.url(args.bucket, args.key);
+        const payloadHash = args.payloadHash ?? hashPayload(args.body);
+        const { headers } = signRequest({
+            req: {
+                method: args.method,
+                path,
+                query: args.query,
+                headers: { host, ...(args.headers ?? {}) },
+                payloadHash,
+            },
+            credentials: this.config,
+            region: this.config.region,
+        });
+        const qs = args.query
+            ? '?' + Object.keys(args.query).sort().map((k) => `${uriEncode(k)}=${uriEncode(args.query[k])}`).join('&')
+            : '';
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 30_000);
+        let res;
+        try {
+            res = await fetch(href + qs, {
+                method: args.method,
+                headers,
+                body: args.body,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            throw new StorageError('driver_error', `S3 ${args.method} ${args.bucket}/${args.key ?? ''} : ${err.message}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (res.status === 404) {
+            throw new StorageError('not_found', `S3 : objet introuvable (${args.bucket}/${args.key ?? ''})`);
+        }
+        if (res.status === 403 || res.status === 401) {
+            // Cause n°1 en pratique : horloge décalée, mauvaise région, ou secret erroné.
+            throw new StorageError('access_denied', `S3 : accès refusé (${res.status}) — vérifier clés, région et horloge`);
+        }
+        if (res.status === 412) {
+            throw new StorageError('driver_error', `S3 : l'objet existe déjà (ifNotExists)`, { status: 412 });
+        }
+        if (!res.ok) {
+            const detail = await res.text().catch(() => '');
+            throw new StorageError('driver_error', `S3 ${args.method} → HTTP ${res.status}`, { body: detail.slice(0, 300) });
+        }
+        return res;
+    }
+    /**
+     * Écrit un objet.
+     *
+     * Le corps est mis EN MÉMOIRE avant envoi. C'est un choix assumé : SigV4 exige soit le
+     * hash sha256 de la charge utile, soit la signature par blocs (« chunked »), nettement plus
+     * complexe. Bufferiser donne un `checksum` fiable et un `Content-Length` exact — au prix de
+     * la mémoire. Pour de très gros objets, ce pilote appellera un jour l'upload multipart ;
+     * mieux vaut une limite CONNUE qu'un streaming subtilement faux.
+     */
+    async put(ref, body, opts) {
+        const bytes = await toBytes(body);
+        const checksum = hashPayload(bytes);
+        const headers = {
+            'content-type': opts.mimeType,
+            'content-length': String(bytes.length),
+        };
+        // Création atomique : S3 (et MinIO) refusent l'écriture si l'objet existe → HTTP 412.
+        if (opts.ifNotExists)
+            headers['if-none-match'] = '*';
+        for (const [k, v] of Object.entries(opts.metadata ?? {})) {
+            headers[`x-amz-meta-${k.toLowerCase()}`] = v;
+        }
+        const res = await this.send({
+            method: 'PUT',
+            bucket: ref.bucket,
+            key: ref.path,
+            body: bytes,
+            headers,
+            payloadHash: checksum,
+        });
+        const etag = (res.headers.get('etag') ?? '').replace(/"/g, '');
+        return { ref, size: bytes.length, etag: etag || checksum.slice(0, 32), checksum };
+    }
+    async get(ref) {
+        const res = await this.send({ method: 'GET', bucket: ref.bucket, key: ref.path });
+        if (!res.body)
+            throw new StorageError('driver_error', 'S3 : réponse sans corps');
+        const metadata = {};
+        res.headers.forEach((v, k) => {
+            if (k.startsWith('x-amz-meta-'))
+                metadata[k.slice('x-amz-meta-'.length)] = v;
+        });
+        return {
+            stream: res.body,
+            size: Number(res.headers.get('content-length') ?? -1),
+            mimeType: res.headers.get('content-type') ?? 'application/octet-stream',
+            etag: (res.headers.get('etag') ?? '').replace(/"/g, ''),
+            metadata,
+        };
+    }
+    async delete(ref) {
+        await this.send({ method: 'DELETE', bucket: ref.bucket, key: ref.path });
+    }
+    async exists(ref) {
+        try {
+            await this.send({ method: 'HEAD', bucket: ref.bucket, key: ref.path });
+            return true;
+        }
+        catch (err) {
+            if (err instanceof StorageError && err.code === 'not_found')
+                return false;
+            throw err;
+        }
+    }
+    async stat(ref) {
+        const res = await this.send({ method: 'HEAD', bucket: ref.bucket, key: ref.path });
+        const metadata = {};
+        res.headers.forEach((v, k) => {
+            if (k.startsWith('x-amz-meta-'))
+                metadata[k.slice('x-amz-meta-'.length)] = v;
+        });
+        const lastModified = res.headers.get('last-modified');
+        return {
+            size: Number(res.headers.get('content-length') ?? -1),
+            mimeType: res.headers.get('content-type') ?? 'application/octet-stream',
+            etag: (res.headers.get('etag') ?? '').replace(/"/g, ''),
+            // S3 renvoie `Last-Modified` en date HTTP. Absent (certains services S3-compatibles
+            // l'omettent sur HEAD) → epoch, plutôt qu'une `Invalid Date` qui contaminerait l'appelant.
+            modifiedAt: lastModified ? new Date(lastModified) : new Date(0),
+            metadata,
+        };
+    }
+    async list(args) {
+        const query = { 'list-type': '2' };
+        if (args.prefix)
+            query.prefix = args.prefix;
+        if (args.limit)
+            query['max-keys'] = String(Math.max(1, Math.min(args.limit, 1000)));
+        if (args.cursor)
+            query['continuation-token'] = args.cursor;
+        const res = await this.send({ method: 'GET', bucket: args.bucket, query });
+        const xml = await res.text();
+        // XML plat de S3 : une extraction par balises suffit, et évite une dépendance de parsing.
+        const items = xmlAll(xml, 'Contents').map((entry) => ({
+            path: decodeURIComponent(xmlOne(entry, 'Key') ?? ''),
+            size: Number(xmlOne(entry, 'Size') ?? 0),
+            modifiedAt: new Date(xmlOne(entry, 'LastModified') ?? 0),
+        }));
+        const truncated = xmlOne(xml, 'IsTruncated') === 'true';
+        const nextCursor = truncated ? xmlOne(xml, 'NextContinuationToken') : undefined;
+        return { items, ...(nextCursor ? { nextCursor } : {}) };
+    }
+}

package/dist/drivers/sigv4.d.ts

@@ -0,0 +1,55 @@
+export interface SigV4Credentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    /** Jeton de session (STS / rôles temporaires). */
+    sessionToken?: string;
+}
+export interface SigV4Request {
+    method: string;
+    /** Chemin déjà encodé (ex. `/bucket/objet%20a.txt`). */
+    path: string;
+    /** Paramètres de requête (seront triés et encodés). */
+    query?: Record<string, string>;
+    headers: Record<string, string>;
+    /** sha256 hex de la charge utile (`UNSIGNED-PAYLOAD` accepté). */
+    payloadHash: string;
+}
+/** sha256 hex d'une charge utile (à passer en `payloadHash`). */
+export declare function hashPayload(body: Uint8Array | string | undefined): string;
+/**
+ * Encodage d'URI d'AWS : RFC 3986 STRICT. `encodeURIComponent` laisse passer `!'()*`,
+ * qu'AWS attend encodés — un seul caractère divergent, et la signature ne correspond plus.
+ */
+export declare function uriEncode(str: string, encodeSlash?: boolean): string;
+/** Horodatage AWS : `20260713T024500Z` et sa date courte `20260713`. */
+export declare function amzDate(now: Date): {
+    amzDate: string;
+    dateStamp: string;
+};
+/** Clé de signature dérivée (date → région → service → aws4_request). */
+export declare function signingKey(secret: string, dateStamp: string, region: string, service: string): Buffer;
+/** Requête canonique — l'ordre et l'encodage sont NORMATIFS : la moindre variation casse tout. */
+export declare function canonicalRequest(req: SigV4Request): {
+    canonical: string;
+    signedHeaders: string;
+};
+/**
+ * Calcule l'en-tête `Authorization` d'une requête SigV4.
+ * Retourne aussi les en-têtes à AJOUTER (`x-amz-date`, `x-amz-content-sha256`…).
+ */
+export declare function signRequest(args: {
+    req: SigV4Request;
+    credentials: SigV4Credentials;
+    region: string;
+    service?: string;
+    now?: Date;
+}): {
+    authorization: string;
+    headers: Record<string, string>;
+};
+/** Exposé pour les tests (vecteurs officiels AWS). */
+export declare const _internal: {
+    sha256hex: (data: string | Uint8Array) => string;
+    hmac: (key: Buffer | string, data: string) => Buffer;
+    ALGO: string;
+};

package/dist/drivers/sigv4.js

@@ -0,0 +1,105 @@
+// @mostajs/blob-store — Signature AWS SigV4 (AWS4-HMAC-SHA256)
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+// License: AGPL-3.0-or-later
+//
+// ZÉRO DÉPENDANCE. S3 n'est que du HTTP signé : inutile de tirer `@aws-sdk/client-s3`
+// (des dizaines de Mo de dépendances) pour poser et relire des octets. On signe nous-mêmes,
+// avec `node:crypto` — et le pilote fonctionne alors avec TOUT service S3-compatible
+// (AWS, MinIO, Scaleway, Wasabi, Backblaze…), pas seulement AWS.
+//
+// Référence : AWS Signature Version 4 — « Create a signed request ».
+// La correction de ce fichier est vérifiée contre les VECTEURS OFFICIELS d'AWS
+// (test-scripts/sigv4.test.mjs) : une signature fausse échouerait en silence côté serveur,
+// avec un « 403 SignatureDoesNotMatch » indéchiffrable.
+import { createHash, createHmac } from 'node:crypto';
+const ALGO = 'AWS4-HMAC-SHA256';
+const sha256hex = (data) => createHash('sha256').update(data).digest('hex');
+const hmac = (key, data) => createHmac('sha256', key).update(data, 'utf8').digest();
+/** sha256 hex d'une charge utile (à passer en `payloadHash`). */
+export function hashPayload(body) {
+    return sha256hex(body ?? '');
+}
+/**
+ * Encodage d'URI d'AWS : RFC 3986 STRICT. `encodeURIComponent` laisse passer `!'()*`,
+ * qu'AWS attend encodés — un seul caractère divergent, et la signature ne correspond plus.
+ */
+export function uriEncode(str, encodeSlash = true) {
+    let out = '';
+    for (const ch of str) {
+        if (/[A-Za-z0-9_.~-]/.test(ch)) {
+            out += ch;
+        }
+        else if (ch === '/') {
+            out += encodeSlash ? '%2F' : '/';
+        }
+        else {
+            out += [...new TextEncoder().encode(ch)]
+                .map((b) => `%${b.toString(16).toUpperCase().padStart(2, '0')}`)
+                .join('');
+        }
+    }
+    return out;
+}
+/** Horodatage AWS : `20260713T024500Z` et sa date courte `20260713`. */
+export function amzDate(now) {
+    const iso = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
+    return { amzDate: iso, dateStamp: iso.slice(0, 8) };
+}
+/** Clé de signature dérivée (date → région → service → aws4_request). */
+export function signingKey(secret, dateStamp, region, service) {
+    const kDate = hmac(`AWS4${secret}`, dateStamp);
+    const kRegion = hmac(kDate, region);
+    const kService = hmac(kRegion, service);
+    return hmac(kService, 'aws4_request');
+}
+/** Requête canonique — l'ordre et l'encodage sont NORMATIFS : la moindre variation casse tout. */
+export function canonicalRequest(req) {
+    const query = req.query ?? {};
+    const canonicalQuery = Object.keys(query)
+        .sort()
+        .map((k) => `${uriEncode(k)}=${uriEncode(query[k])}`)
+        .join('&');
+    // En-têtes : noms en minuscules, triés, valeurs « trimmées » et espaces internes compactés.
+    const lower = {};
+    for (const [k, v] of Object.entries(req.headers)) {
+        lower[k.toLowerCase()] = String(v).trim().replace(/\s+/g, ' ');
+    }
+    const names = Object.keys(lower).sort();
+    const canonicalHeaders = names.map((n) => `${n}:${lower[n]}\n`).join('');
+    const signedHeaders = names.join(';');
+    const canonical = [
+        req.method.toUpperCase(),
+        req.path,
+        canonicalQuery,
+        canonicalHeaders,
+        signedHeaders,
+        req.payloadHash,
+    ].join('\n');
+    return { canonical, signedHeaders };
+}
+/**
+ * Calcule l'en-tête `Authorization` d'une requête SigV4.
+ * Retourne aussi les en-têtes à AJOUTER (`x-amz-date`, `x-amz-content-sha256`…).
+ */
+export function signRequest(args) {
+    const service = args.service ?? 's3';
+    const { amzDate: stamp, dateStamp } = amzDate(args.now ?? new Date());
+    const headers = {
+        ...args.req.headers,
+        'x-amz-date': stamp,
+        'x-amz-content-sha256': args.req.payloadHash,
+    };
+    if (args.credentials.sessionToken) {
+        headers['x-amz-security-token'] = args.credentials.sessionToken;
+    }
+    const { canonical, signedHeaders } = canonicalRequest({ ...args.req, headers });
+    const scope = `${dateStamp}/${args.region}/${service}/aws4_request`;
+    const stringToSign = [ALGO, stamp, scope, sha256hex(canonical)].join('\n');
+    const key = signingKey(args.credentials.secretAccessKey, dateStamp, args.region, service);
+    const signature = createHmac('sha256', key).update(stringToSign, 'utf8').digest('hex');
+    const authorization = `${ALGO} Credential=${args.credentials.accessKeyId}/${scope}, ` +
+        `SignedHeaders=${signedHeaders}, Signature=${signature}`;
+    return { authorization, headers: { ...headers, authorization } };
+}
+/** Exposé pour les tests (vecteurs officiels AWS). */
+export const _internal = { sha256hex, hmac, ALGO };

package/dist/index.d.ts

@@ -24,8 +24,16 @@ export { StorageError, STORAGE_ERROR_HTTP } from './types.js';
 export type { StorageDriver, PutBody, PutOptions, GetObjectResult, StatResult, } from './driver.js';
 export { FilesystemDriver } from './drivers/filesystem.js';
 export { CachingDriver } from './drivers/caching.js';
+/**
+ * Pilote S3 — et tout service S3-compatible (MinIO, Scaleway, Wasabi, Backblaze…).
+ * Zéro dépendance : SigV4 est implémenté ici (S3 n'est que du HTTP signé), plutôt que de
+ * tirer `@aws-sdk/client-s3`. Solde la promesse « FS / S3 » que `@mostajs/storage` affichait
+ * sans la tenir — et la solde AU BON ÉTAGE, pour qu'archive-box et backup en profitent.
+ */
+export { S3Driver, type S3DriverConfig } from './drivers/s3.js';
+export { signRequest, hashPayload, uriEncode, type SigV4Credentials } from './drivers/sigv4.js';
 export declare const moduleInfo: {
     readonly name: "@mostajs/blob-store";
-    readonly version: "0.1.0";
+    readonly version: "0.2.0";
     readonly level: "N0";
 };

package/dist/index.js

@@ -22,4 +22,12 @@
 export { StorageError, STORAGE_ERROR_HTTP } from './types.js';
 export { FilesystemDriver } from './drivers/filesystem.js';
 export { CachingDriver } from './drivers/caching.js';
-export const moduleInfo = { name: '@mostajs/blob-store', version: '0.1.0', level: 'N0' };
+/**
+ * Pilote S3 — et tout service S3-compatible (MinIO, Scaleway, Wasabi, Backblaze…).
+ * Zéro dépendance : SigV4 est implémenté ici (S3 n'est que du HTTP signé), plutôt que de
+ * tirer `@aws-sdk/client-s3`. Solde la promesse « FS / S3 » que `@mostajs/storage` affichait
+ * sans la tenir — et la solde AU BON ÉTAGE, pour qu'archive-box et backup en profitent.
+ */
+export { S3Driver } from './drivers/s3.js';
+export { signRequest, hashPayload, uriEncode } from './drivers/sigv4.js';
+export const moduleInfo = { name: '@mostajs/blob-store', version: '0.2.0', level: 'N0' };

package/llms.txt

@@ -1,4 +1,4 @@
-# @mostajs/blob-store — 0.1.0
+# @mostajs/blob-store — 0.2.0
 Auteur : Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later · Niveau N0 · ZÉRO dépendance
 
 RÔLE
@@ -23,6 +23,11 @@ API
                        | tenant_violation | signature_invalid | signature_expired | driver_error
   FilesystemDriver new FilesystemDriver({ rootDir })   — refuse '..' (path traversal)
   CachingDriver    décorateur de cache devant un driver d'origine
+  S3Driver         new S3Driver({ endpoint, region, accessKeyId, secretAccessKey,
+                                  forcePathStyle?, sessionToken?, timeoutMs? })
+                   S3 + TOUT service S3-compatible (MinIO/Scaleway/Wasabi/Backblaze).
+                   SigV4 intégré (zéro dépendance — pas d'@aws-sdk). Sous-chemin /drivers/s3.
+  signRequest, hashPayload, uriEncode  — SigV4 exposée (sous-chemin /sigv4)
 
 CE QUI N'EST PAS ICI
   FileMeta (row File en base, accountId multi-tenant) reste dans @mostajs/storage : c'est une
@@ -32,4 +37,7 @@ CONSOMMATEURS
   @mostajs/storage (octets + ORM + RBAC) · @mostajs/archive-box · @mostajs/backup
 
 TESTS
-  npm test   10 tests mjs-unit sur un vrai répertoire temporaire (sha256 vérifié indépendamment)
+  npm test   28 tests mjs-unit :
+             - filesystem : disque réel, sha256 vérifié indépendamment
+             - sigv4      : VECTEURS OFFICIELS AWS (get-vanilla) — signature exacte
+             - s3         : serveur S3 simulé qui REFUSE toute requête non signée

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mostajs/blob-store",
-  "version": "0.1.0",
-  "description": "Ranger des octets — contrat StorageDriver (put/get/delete/exists/stat/list) + pilotes filesystem et caching. Primitive N0, zéro dépendance. Extrait de @mostajs/storage.",
+  "version": "0.2.0",
+  "description": "Ranger des octets — contrat StorageDriver (put/get/delete/exists/stat/list) + pilotes filesystem, caching et S3 (SigV4 intégré, tout service S3-compatible). Primitive N0, zéro dépendance.",
   "license": "AGPL-3.0-or-later",
   "author": "Dr Hamid MADANI <drmdh@msn.com>",
   "type": "module",
@@ -30,6 +30,16 @@
       "types": "./dist/drivers/caching.d.ts",
       "import": "./dist/drivers/caching.js",
       "default": "./dist/drivers/caching.js"
+    },
+    "./drivers/s3": {
+      "types": "./dist/drivers/s3.d.ts",
+      "import": "./dist/drivers/s3.js",
+      "default": "./dist/drivers/s3.js"
+    },
+    "./sigv4": {
+      "types": "./dist/drivers/sigv4.d.ts",
+      "import": "./dist/drivers/sigv4.js",
+      "default": "./dist/drivers/sigv4.js"
     }
   },
   "files": [
@@ -58,4 +68,4 @@
     "@types/node": "^20.19.43",
     "typescript": "^5.6.0"
   }
-}
+}