rac-delta 1.0.0

package/dist/infrastructure/adapters/local-storage-adapter.d.ts

@@ -0,0 +1,23 @@
+import { Readable } from 'stream';
+import { BlobInfo, HashStorageAdapter } from '../../core/adapters';
+import { LocalStorageConfig } from '../../core/config';
+import { RDIndex } from '../../core/models';
+import { Nullish } from '../../core/types';
+export declare class LocalStorageAdapter extends HashStorageAdapter {
+    private readonly config;
+    constructor(config: LocalStorageConfig);
+    dispose(): Promise<void>;
+    private resolveChunkPath;
+    private resolveIndexPath;
+    getChunk(hash: string): Promise<Readable | null>;
+    putChunk(hash: string, data: Readable, opts?: Nullish<{
+        overwrite?: Nullish<boolean>;
+    }>): Promise<void>;
+    chunkExists(hash: string): Promise<boolean>;
+    deleteChunk(hash: string): Promise<void>;
+    listChunks(): Promise<string[]>;
+    getChunkInfo(hash: string): Promise<BlobInfo | null>;
+    getRemoteIndex(): Promise<RDIndex | null>;
+    putRemoteIndex(index: RDIndex): Promise<void>;
+}
+//# sourceMappingURL=local-storage-adapter.d.ts.map

package/dist/infrastructure/adapters/local-storage-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-adapter.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/adapters/local-storage-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAIlC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,mBAAoB,SAAQ,kBAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,kBAAkB;IAIjD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,gBAAgB;IAKlB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAWhD,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE,OAAO,CAAC;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,GAC/C,OAAO,CAAC,IAAI,CAAC;IA4BV,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW3C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxC,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAoB/B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAepD,cAAc,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAgBzC,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAKpD"}

package/dist/infrastructure/adapters/local-storage-adapter.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageAdapter = void 0;
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const exceptions_1 = require("../../core/exceptions");
+const adapters_1 = require("../../core/adapters");
+class LocalStorageAdapter extends adapters_1.HashStorageAdapter {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async dispose() {
+        return;
+    }
+    resolveChunkPath(hash) {
+        const prefix = this.config.pathPrefix ?? '';
+        return (0, path_1.join)(this.config.basePath, prefix, 'chunks', hash);
+    }
+    resolveIndexPath() {
+        const prefix = this.config.pathPrefix ?? '';
+        return (0, path_1.join)(this.config.basePath, prefix, 'rd-index.json');
+    }
+    async getChunk(hash) {
+        const path = this.resolveChunkPath(hash);
+        try {
+            await (0, promises_1.access)(path);
+            return (0, fs_1.createReadStream)(path);
+        }
+        catch {
+            return null;
+        }
+    }
+    async putChunk(hash, data, opts) {
+        const path = this.resolveChunkPath(hash);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+        if (!opts?.overwrite) {
+            try {
+                await (0, promises_1.access)(path);
+                throw new exceptions_1.ChunkAlreadyExistsException(`${hash}`);
+            }
+            catch (error) {
+                const nodeError = error;
+                if (nodeError.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        await new Promise((resolve, reject) => {
+            const writeStream = (0, fs_1.createWriteStream)(path);
+            data.pipe(writeStream);
+            writeStream.on('finish', () => resolve());
+            writeStream.on('error', (err) => reject(err));
+            data.on('error', (err) => reject(err));
+        });
+    }
+    async chunkExists(hash) {
+        const path = this.resolveChunkPath(hash);
+        try {
+            await (0, promises_1.access)(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async deleteChunk(hash) {
+        const path = this.resolveChunkPath(hash);
+        await (0, promises_1.rm)(path, { force: true });
+    }
+    async listChunks() {
+        const prefix = this.config.pathPrefix ?? '';
+        const chunksDir = (0, path_1.join)(this.config.basePath, prefix, 'chunks');
+        const hashes = [];
+        try {
+            const entries = await (0, promises_1.readdir)(chunksDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    hashes.push(entry.name);
+                }
+            }
+        }
+        catch {
+            // if no /chunks directory return empty
+        }
+        return hashes;
+    }
+    async getChunkInfo(hash) {
+        const path = this.resolveChunkPath(hash);
+        try {
+            const stats = await (0, promises_1.stat)(path);
+            return {
+                hash,
+                size: stats.size,
+                modified: stats.mtime,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getRemoteIndex() {
+        const indexPath = this.resolveIndexPath();
+        try {
+            const data = await (0, promises_1.readFile)(indexPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async putRemoteIndex(index) {
+        const indexPath = this.resolveIndexPath();
+        await (0, promises_1.mkdir)((0, path_1.dirname)(indexPath), { recursive: true });
+        await (0, promises_1.writeFile)(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+    }
+}
+exports.LocalStorageAdapter = LocalStorageAdapter;

package/dist/infrastructure/adapters/s3-storage-adapter.d.ts

@@ -0,0 +1,24 @@
+import { Readable } from 'stream';
+import { BlobInfo, HashStorageAdapter } from '../../core/adapters';
+import { S3StorageConfig } from '../../core/config';
+import { RDIndex } from '../../core/models';
+import { Nullish } from '../../core/types';
+export declare class S3StorageAdapter extends HashStorageAdapter {
+    private readonly config;
+    private readonly s3;
+    constructor(config: S3StorageConfig);
+    dispose(): Promise<void>;
+    private resolveKey;
+    getChunk(hash: string): Promise<Readable | null>;
+    putChunk(hash: string, data: Readable, opts?: {
+        overwrite?: Nullish<boolean>;
+        size?: Nullish<number>;
+    }): Promise<void>;
+    chunkExists(hash: string): Promise<boolean>;
+    deleteChunk(hash: string): Promise<void>;
+    listChunks(): Promise<string[]>;
+    getChunkInfo(hash: string): Promise<BlobInfo | null>;
+    putRemoteIndex(index: RDIndex): Promise<void>;
+    getRemoteIndex(): Promise<RDIndex | null>;
+}
+//# sourceMappingURL=s3-storage-adapter.d.ts.map

package/dist/infrastructure/adapters/s3-storage-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3-storage-adapter.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/adapters/s3-storage-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAWlC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,gBAAiB,SAAQ,kBAAkB;IAG1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;gBAED,MAAM,EAAE,eAAe;IAU9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B,OAAO,CAAC,UAAU;IAIZ,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAiBhD,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;KAAE,GAC9D,OAAO,CAAC,IAAI,CAAC;IAoBV,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAY3C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxC,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IA8B/B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAqBpD,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAe7C,cAAc,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;CA6BhD"}

package/dist/infrastructure/adapters/s3-storage-adapter.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageAdapter = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const adapters_1 = require("../../core/adapters");
+class S3StorageAdapter extends adapters_1.HashStorageAdapter {
+    config;
+    s3;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.s3 = new client_s3_1.S3Client({
+            region: config.region,
+            endpoint: config.endpoint,
+            credentials: config.credentials,
+        });
+    }
+    async dispose() {
+        this.s3.destroy();
+    }
+    resolveKey(hash) {
+        return this.config.pathPrefix ? `${this.config.pathPrefix}/chunks/${hash}` : hash;
+    }
+    async getChunk(hash) {
+        try {
+            const key = this.resolveKey(hash);
+            const res = await this.s3.send(new client_s3_1.GetObjectCommand({ Bucket: this.config.bucket, Key: key }));
+            return res.Body;
+        }
+        catch (error) {
+            if (error instanceof client_s3_1.NoSuchKey) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async putChunk(hash, data, opts) {
+        const key = this.resolveKey(hash);
+        if (!opts?.overwrite) {
+            const exists = await this.chunkExists(hash);
+            if (exists) {
+                return;
+            }
+        }
+        await this.s3.send(new client_s3_1.PutObjectCommand({
+            Bucket: this.config.bucket,
+            Key: key,
+            Body: data,
+            ContentLength: opts?.size,
+        }));
+    }
+    async chunkExists(hash) {
+        try {
+            const key = this.resolveKey(hash);
+            await this.s3.send(new client_s3_1.HeadObjectCommand({ Bucket: this.config.bucket, Key: key }));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async deleteChunk(hash) {
+        const key = this.resolveKey(hash);
+        await this.s3.send(new client_s3_1.DeleteObjectCommand({ Bucket: this.config.bucket, Key: key }));
+    }
+    async listChunks() {
+        const chunks = [];
+        let continuationToken;
+        const prefix = this.config.pathPrefix ? `${this.config.pathPrefix}/chunks` : undefined;
+        do {
+            const res = await this.s3.send(new client_s3_1.ListObjectsV2Command({
+                Bucket: this.config.bucket,
+                Prefix: prefix,
+                ContinuationToken: continuationToken,
+            }));
+            const keys = res.Contents?.map((obj) => this.config.pathPrefix
+                ? obj.Key.replace(`${this.config.pathPrefix}/chunks/`, '')
+                : obj.Key);
+            if (keys) {
+                chunks.push(...keys);
+            }
+            continuationToken = res.NextContinuationToken;
+        } while (continuationToken);
+        return chunks;
+    }
+    async getChunkInfo(hash) {
+        try {
+            const key = this.resolveKey(hash);
+            const res = await this.s3.send(new client_s3_1.HeadObjectCommand({ Bucket: this.config.bucket, Key: key }));
+            return {
+                hash,
+                size: res.ContentLength ?? 0,
+                modified: res.LastModified,
+                metadata: res.Metadata,
+            };
+        }
+        catch (error) {
+            if (error instanceof client_s3_1.NoSuchKey) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async putRemoteIndex(index) {
+        const key = this.config.pathPrefix
+            ? `${this.config.pathPrefix}/rd-index.json`
+            : 'rd-index.json';
+        await this.s3.send(new client_s3_1.PutObjectCommand({
+            Bucket: this.config.bucket,
+            Key: key,
+            Body: JSON.stringify(index),
+            ContentType: 'application/json',
+        }));
+    }
+    async getRemoteIndex() {
+        const key = this.config.pathPrefix
+            ? `${this.config.pathPrefix}/rd-index.json`
+            : 'rd-index.json';
+        try {
+            const result = await this.s3.send(new client_s3_1.GetObjectCommand({
+                Bucket: this.config.bucket,
+                Key: key,
+            }));
+            if (!result.Body) {
+                return null;
+            }
+            const buffer = Buffer.from(await result.Body.transformToByteArray());
+            const data = buffer.toString('utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error instanceof client_s3_1.NoSuchKey) {
+                return null;
+            }
+            throw error;
+        }
+    }
+}
+exports.S3StorageAdapter = S3StorageAdapter;

package/dist/infrastructure/adapters/ssh-storage-adapter.d.ts

@@ -0,0 +1,28 @@
+import { Readable } from 'stream';
+import { BlobInfo, HashStorageAdapter } from '../../core/adapters';
+import { SSHStorageConfig } from '../../core/config';
+import { RDIndex } from '../../core/models';
+export declare class SSHStorageAdapter extends HashStorageAdapter {
+    private readonly config;
+    private sftp;
+    private client;
+    constructor(config: SSHStorageConfig);
+    private connecting;
+    private connect;
+    private resolveChunkPath;
+    private resolveIndexPath;
+    getChunk(hash: string): Promise<Readable | null>;
+    putChunk(hash: string, data: Readable): Promise<void>;
+    chunkExists(hash: string): Promise<boolean>;
+    deleteChunk(hash: string): Promise<void>;
+    listChunks(): Promise<string[]>;
+    getChunkInfo(hash: string): Promise<BlobInfo | null>;
+    getRemoteIndex(): Promise<RDIndex | null>;
+    private readStream;
+    putRemoteIndex(index: RDIndex): Promise<void>;
+    dispose(): Promise<void>;
+    private createDirIfNotFound;
+    private promisifyStat;
+    private promisifyMkdir;
+}
+//# sourceMappingURL=ssh-storage-adapter.d.ts.map

package/dist/infrastructure/adapters/ssh-storage-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssh-storage-adapter.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/adapters/ssh-storage-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAI5C,qBAAa,iBAAkB,SAAQ,kBAAkB;IAI3C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHnC,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,MAAM,CAAuB;gBAER,MAAM,EAAE,gBAAgB;IAIrD,OAAO,CAAC,UAAU,CAAqC;YAEzC,OAAO;IA0CrB,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,gBAAgB;IAKlB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAwBhD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS3C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAexC,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAe/B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAuBpD,cAAc,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAkC/C,OAAO,CAAC,UAAU;IAaZ,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAehB,mBAAmB;IAgBjC,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,cAAc;CAKvB"}

package/dist/infrastructure/adapters/ssh-storage-adapter.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSHStorageAdapter = void 0;
+const ssh2_1 = require("ssh2");
+const stream_1 = require("stream");
+const path_1 = require("path");
+const adapters_1 = require("../../core/adapters");
+class SSHStorageAdapter extends adapters_1.HashStorageAdapter {
+    config;
+    sftp = null;
+    client = null;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    connecting = null;
+    async connect() {
+        if (this.sftp) {
+            return this.sftp;
+        }
+        if (this.connecting) {
+            return this.connecting;
+        }
+        this.connecting = new Promise((resolve, reject) => {
+            const client = new ssh2_1.Client();
+            client
+                .on('ready', () => {
+                client.sftp((err, sftp) => {
+                    if (err) {
+                        client.end();
+                        this.connecting = null;
+                        return reject(err);
+                    }
+                    this.client = client;
+                    this.sftp = sftp;
+                    this.connecting = null;
+                    resolve(sftp);
+                });
+            })
+                .on('error', (err) => {
+                this.connecting = null;
+                reject(err);
+            })
+                .connect({
+                host: this.config.host,
+                port: this.config.port ?? 22,
+                username: this.config.credentials.username,
+                password: this.config.credentials.password,
+                privateKey: this.config.credentials.privateKey,
+            });
+        });
+        return this.connecting;
+    }
+    resolveChunkPath(hash) {
+        const prefix = this.config.pathPrefix ?? '';
+        return (0, path_1.join)(prefix, 'chunks', hash);
+    }
+    resolveIndexPath() {
+        const prefix = this.config.pathPrefix ?? '';
+        return (0, path_1.join)(prefix, 'rd-index.json');
+    }
+    async getChunk(hash) {
+        const sftp = await this.connect();
+        const remotePath = this.resolveChunkPath(hash);
+        return new Promise((resolve, reject) => {
+            sftp.stat(remotePath, (error) => {
+                if (error) {
+                    if (error?.code === 2) {
+                        return resolve(null); // ENOENT
+                    }
+                    return reject(error);
+                }
+                try {
+                    const stream = sftp.createReadStream(remotePath);
+                    resolve(stream);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async putChunk(hash, data) {
+        const sftp = await this.connect();
+        const remotePath = this.resolveChunkPath(hash);
+        const dir = remotePath.substring(0, remotePath.lastIndexOf('/'));
+        await this.createDirIfNotFound(sftp, dir);
+        return new Promise((resolve, reject) => {
+            const writeStream = sftp.createWriteStream(remotePath);
+            data.pipe(writeStream);
+            writeStream.on('close', resolve);
+            writeStream.on('error', reject);
+        });
+    }
+    async chunkExists(hash) {
+        const sftp = await this.connect();
+        const remotePath = this.resolveChunkPath(hash);
+        return new Promise((resolve) => {
+            sftp.stat(remotePath, (error) => resolve(error ? false : true));
+        });
+    }
+    async deleteChunk(hash) {
+        const sftp = await this.connect();
+        const remotePath = this.resolveChunkPath(hash);
+        return new Promise((resolve, reject) => {
+            sftp.unlink(remotePath, (error) => {
+                if (error && error?.code !== 2) {
+                    return reject(error);
+                }
+                resolve();
+            });
+        });
+    }
+    async listChunks() {
+        const sftp = await this.connect();
+        const prefix = (0, path_1.join)(this.config.pathPrefix ?? '', 'chunks');
+        return new Promise((resolve, reject) => {
+            sftp.readdir(prefix, (error, list) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(list.map((file) => file.filename));
+            });
+        });
+    }
+    async getChunkInfo(hash) {
+        const sftp = await this.connect();
+        const remotePath = this.resolveChunkPath(hash);
+        return new Promise((resolve, reject) => {
+            sftp.stat(remotePath, (error, stats) => {
+                if (error) {
+                    if (error.code === 2) {
+                        return resolve(null);
+                    }
+                    return reject(error);
+                }
+                resolve({
+                    hash,
+                    size: stats.size,
+                    modified: stats.mtime ? new Date(stats.mtime * 1000) : undefined,
+                });
+            });
+        });
+    }
+    async getRemoteIndex() {
+        const sftp = await this.connect();
+        const remotePath = this.resolveIndexPath();
+        return new Promise((resolve, reject) => {
+            sftp.stat(remotePath, (error) => {
+                if (error) {
+                    if (error.code === 2) {
+                        return resolve(null);
+                    }
+                    return reject(error);
+                }
+                try {
+                    const stream = sftp.createReadStream(remotePath);
+                    this.readStream(stream)
+                        .then((data) => {
+                        try {
+                            const index = JSON.parse(data);
+                            resolve(index);
+                        }
+                        catch (err) {
+                            reject(err);
+                        }
+                    })
+                        .catch(reject);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    readStream(stream) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            stream.on('data', (chunk) => {
+                data += chunk.toString();
+            });
+            stream.on('end', () => resolve(data));
+            stream.on('error', reject);
+        });
+    }
+    async putRemoteIndex(index) {
+        const sftp = await this.connect();
+        const remotePath = this.resolveIndexPath();
+        const json = JSON.stringify(index, null, 2);
+        return new Promise((resolve, reject) => {
+            const writeStream = sftp.createWriteStream(remotePath, { flags: 'w' });
+            const readable = stream_1.Readable.from([json]);
+            writeStream.on('close', resolve);
+            writeStream.on('error', reject);
+            readable.pipe(writeStream);
+        });
+    }
+    async dispose() {
+        if (this.sftp && typeof this.sftp.end === 'function') {
+            this.sftp.end();
+        }
+        this.sftp = null;
+        if (this.client !== null) {
+            await new Promise((resolve) => {
+                this.client?.once('close', resolve);
+                this.client?.end();
+            });
+            this.client = null;
+        }
+    }
+    async createDirIfNotFound(sftp, dir) {
+        const parts = dir.split('/').filter(Boolean);
+        let current = '';
+        for (const part of parts) {
+            current += '/' + part;
+            try {
+                await this.promisifyStat(sftp, current);
+            }
+            catch (error) {
+                if (error?.code === 2) {
+                    await this.promisifyMkdir(sftp, current);
+                }
+            }
+        }
+    }
+    promisifyStat(sftp, path) {
+        return new Promise((resolve, reject) => {
+            sftp.stat(path, (err, stats) => (err ? reject(err) : resolve(stats)));
+        });
+    }
+    promisifyMkdir(sftp, path) {
+        return new Promise((resolve, reject) => {
+            sftp.mkdir(path, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+}
+exports.SSHStorageAdapter = SSHStorageAdapter;

package/dist/infrastructure/adapters/url-storage-adapter.d.ts

@@ -0,0 +1,14 @@
+import { Readable } from 'stream';
+import { BlobInfo, UrlStorageAdapter } from '../../core/adapters';
+import { RDIndex } from '../../core/models';
+export declare class DefaultUrlStorageAdapter extends UrlStorageAdapter {
+    dispose(): Promise<void>;
+    getChunkByUrl(url: string): Promise<Readable | null>;
+    putChunkByUrl(url: string, data: Readable): Promise<void>;
+    chunkExistsByUrl(url: string): Promise<boolean>;
+    deleteChunkByUrl(url: string): Promise<void>;
+    getChunkInfoByUrl(hash: string, url: string): Promise<BlobInfo | null>;
+    getRemoteIndexByUrl(url: string): Promise<RDIndex | null>;
+    putRemoteIndexByUrl(url: string, index: RDIndex): Promise<void>;
+}
+//# sourceMappingURL=url-storage-adapter.d.ts.map

package/dist/infrastructure/adapters/url-storage-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-storage-adapter.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/adapters/url-storage-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAUlE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,qBAAa,wBAAyB,SAAQ,iBAAiB;IACvD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAcpD,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAYzD,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc/C,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5C,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAyBtE,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAczD,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAatE"}