rac-delta 1.0.0

package/dist/infrastructure/services/memory-delta-service.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDeltaService = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const invariant_1 = require("../../core/utils/invariant");
+class MemoryDeltaService {
+    hasher;
+    constructor(hasher) {
+        this.hasher = hasher;
+    }
+    async createIndexFromDirectory(rootPath, chunkSize, concurrency = 6, ignorePatterns) {
+        (0, invariant_1.invariant)('rootPath must be a valid string', typeof rootPath === 'string' && rootPath !== '');
+        const rootDir = (0, path_1.isAbsolute)(rootPath) ? rootPath : (0, path_1.resolve)(process.cwd(), rootPath);
+        const filePaths = [];
+        for await (const relativePath of this.walkFiles(rootDir, undefined, ignorePatterns)) {
+            filePaths.push(relativePath.replace(/\\/g, '/'));
+        }
+        const ignoredFiles = new Set(['rd-index.json']);
+        const filteredPaths = filePaths.filter((p) => !ignoredFiles.has(p));
+        const results = new Array(filteredPaths.length);
+        let currentIndex = 0;
+        const worker = async () => {
+            while (true) {
+                const i = currentIndex++;
+                if (i >= filteredPaths.length) {
+                    break;
+                }
+                const relativePath = filteredPaths[i];
+                const fullPath = (0, path_1.join)(rootDir, relativePath);
+                const stats = await (0, promises_1.stat)(fullPath);
+                const fileEntry = await this.hasher.hashFile(relativePath, rootDir, chunkSize);
+                results[i] = {
+                    ...fileEntry,
+                    path: relativePath,
+                    modifiedAt: stats.mtimeMs,
+                };
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, () => worker()));
+        return {
+            version: 1,
+            createdAt: Date.now(),
+            chunkSize,
+            files: results,
+        };
+    }
+    async createFileEntryFromStream(stream, path) {
+        const fileHasher = await this.hasher.createStreamingHasher();
+        const chunks = await this.hasher.hashStream(stream, (chunk) => {
+            fileHasher.update(chunk);
+        });
+        const fileHash = fileHasher.digest('hex');
+        const totalSize = chunks.reduce((total, chunk) => total + chunk.size, 0);
+        const fileEntry = {
+            path: path.replace(/\\/g, '/'),
+            size: totalSize,
+            hash: fileHash,
+            modifiedAt: Date.now(),
+            chunks,
+        };
+        return fileEntry;
+    }
+    async *walkFiles(dir, prefix = '', ignorePatterns) {
+        const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const absPath = (0, path_1.join)(dir, entry.name);
+            const relPath = (0, path_1.join)(prefix, entry.name).replace(/\\/g, '/');
+            if (ignorePatterns?.length && this.matchesAnyPattern(relPath, ignorePatterns)) {
+                continue;
+            }
+            if (entry.isFile()) {
+                yield relPath;
+            }
+            else if (entry.isDirectory()) {
+                yield* this.walkFiles(absPath, relPath, ignorePatterns);
+            }
+        }
+    }
+    matchesAnyPattern(path, patterns) {
+        for (const pattern of patterns) {
+            const regex = this.globToRegex(pattern);
+            if (regex.test(path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    globToRegex(glob) {
+        glob = glob.replace(/\\/g, '/');
+        let pattern = glob.replace(/([.+^${}()|[\]\\])/g, '\\$1');
+        pattern = pattern.replace(/\*\*\/?/g, '(.*/)?');
+        pattern = pattern.replace(/\*/g, '[^/]*');
+        pattern = '^' + pattern;
+        return new RegExp(pattern, 'i');
+    }
+    // source: where the changes come
+    // target: where the changes will apply
+    compare(source, target) {
+        const deltaPlan = {
+            deletedFiles: [],
+            missingChunks: [],
+            obsoleteChunks: [],
+            newAndModifiedFiles: [],
+        };
+        const targetFilesMap = new Map();
+        const sourcePaths = new Set(source.files.map((f) => f.path));
+        if (target) {
+            for (const file of target.files) {
+                targetFilesMap.set(file.path, file);
+                // Check for deleted files (they exist in target but not in source, so they will be removed from target)
+                if (!sourcePaths.has(file.path)) {
+                    deltaPlan.deletedFiles.push(file.path);
+                    for (const chunk of file.chunks) {
+                        deltaPlan.obsoleteChunks.push({ ...chunk, filePath: file.path });
+                    }
+                }
+            }
+        }
+        // Process source files
+        for (const srcFile of source.files) {
+            const targetFile = targetFilesMap.get(srcFile.path);
+            // New file (not in target)
+            if (!targetFile) {
+                deltaPlan.missingChunks.push(...srcFile.chunks.map((c) => ({ ...c, filePath: srcFile.path })));
+                deltaPlan.newAndModifiedFiles.push(srcFile);
+                continue;
+            }
+            const targetChunks = new Map(targetFile.chunks.map((c) => [`${c.hash}@${c.offset}`, c]));
+            const sourceChunkKeys = new Set(srcFile.chunks.map((c) => `${c.hash}@${c.offset}`));
+            // File exists -> compare chunks
+            for (const chunk of srcFile.chunks) {
+                const key = `${chunk.hash}@${chunk.offset}`;
+                if (!targetChunks.has(key)) {
+                    deltaPlan.missingChunks.push({ ...chunk, filePath: srcFile.path });
+                    deltaPlan.newAndModifiedFiles.push(srcFile);
+                }
+            }
+            // Check obsolete chunks in target that are not in source
+            for (const chunk of targetFile.chunks) {
+                const key = `${chunk.hash}@${chunk.offset}`;
+                if (!sourceChunkKeys.has(key)) {
+                    deltaPlan.obsoleteChunks.push({ ...chunk, filePath: srcFile.path });
+                }
+            }
+        }
+        return deltaPlan;
+    }
+    mergePlans(base, updates) {
+        const mergeFiles = (a, b) => {
+            const seen = new Set();
+            const result = [];
+            for (const file of [...a, ...b]) {
+                if (!seen.has(file.path)) {
+                    seen.add(file.path);
+                    result.push(file);
+                }
+            }
+            return result;
+        };
+        const mergeChunks = (a, b) => {
+            const seen = new Set();
+            const result = [];
+            for (const chunk of [...a, ...b]) {
+                const key = `${chunk.hash}@${chunk.offset}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    result.push(chunk);
+                }
+            }
+            return result;
+        };
+        const mergeStrings = (a, b) => {
+            return Array.from(new Set([...a, ...b]));
+        };
+        return {
+            deletedFiles: mergeStrings(base.deletedFiles, updates.deletedFiles),
+            missingChunks: mergeChunks(base.missingChunks, updates.missingChunks),
+            obsoleteChunks: mergeChunks(base.obsoleteChunks, updates.obsoleteChunks),
+            newAndModifiedFiles: mergeFiles(base.newAndModifiedFiles, updates.newAndModifiedFiles),
+        };
+    }
+    async compareForUpload(localIndex, remoteIndex) {
+        const deltaPlan = this.compare(localIndex, remoteIndex);
+        const allNeededHashes = new Set();
+        for (const file of localIndex.files) {
+            for (const chunk of file.chunks) {
+                allNeededHashes.add(chunk.hash);
+            }
+        }
+        deltaPlan.obsoleteChunks = deltaPlan.obsoleteChunks.filter((chunk) => !allNeededHashes.has(chunk.hash));
+        return deltaPlan;
+    }
+    async compareForDownload(localIndex, remoteIndex) {
+        return this.compare(remoteIndex, localIndex);
+    }
+}
+exports.MemoryDeltaService = MemoryDeltaService;

package/dist/infrastructure/services/memory-reconstruction-service.d.ts

@@ -0,0 +1,25 @@
+import { Readable } from 'stream';
+import { ChunkSource, HasherService, ReconstructionOptions, ReconstructionService } from '../../core/services';
+import { DeltaPlan, FileEntry } from '../../core/models';
+import { Nullish } from '../../core/types';
+export declare class MemoryReconstructionService implements ReconstructionService {
+    private readonly hasher;
+    constructor(hasher: HasherService);
+    reconstructAll(plan: DeltaPlan, outputDir: string, chunkSource: ChunkSource, options?: Nullish<ReconstructionOptions>): Promise<void>;
+    reconstructFile(entry: FileEntry, outputPath: string, chunkSource: ChunkSource, options?: ReconstructionOptions): Promise<void>;
+    reconstructToStream(entry: FileEntry, chunkSource: ChunkSource): Promise<Readable>;
+    private fileExists;
+    /** Performs partial reconstruction directly in the existing file */
+    private reconstructInPlace;
+    /** Reconstructs file fully or partially via .tmp file and replaces it atomically */
+    private reconstructToTemp;
+    /**
+     * Tries to read an existing chunk from a file descriptor if possible.
+     * Falls back to fetching from chunkSource if hash does not match.
+     */
+    private processChunkDataSmart;
+    private getChunkData;
+    private writeToStream;
+    private fetchChunksSmart;
+}
+//# sourceMappingURL=memory-reconstruction-service.d.ts.map

package/dist/infrastructure/services/memory-reconstruction-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-reconstruction-service.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/memory-reconstruction-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAyB,MAAM,QAAQ,CAAC;AAIzD,OAAO,EACL,WAAW,EAEX,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,SAAS,EAAS,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,2BAA4B,YAAW,qBAAqB;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAE5C,cAAc,CAClB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC;IAmFV,eAAe,CACnB,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,qBAIR,GACA,OAAO,CAAC,IAAI,CAAC;IAgDV,mBAAmB,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;YAsB1E,UAAU;IASxB,oEAAoE;YACtD,kBAAkB;IAiChC,oFAAoF;YACtE,iBAAiB;IAmF/B;;;OAGG;YACW,qBAAqB;YA2BrB,YAAY;YAcZ,aAAa;YAuDZ,gBAAgB;CAmChC"}

package/dist/infrastructure/services/memory-reconstruction-service.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryReconstructionService = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const stream_1 = require("stream");
+const promises_2 = require("stream/promises");
+const fs_1 = require("fs");
+const services_1 = require("../../core/services");
+const exceptions_1 = require("../../core/exceptions");
+const utils_1 = require("../../core/utils");
+class MemoryReconstructionService {
+    hasher;
+    constructor(hasher) {
+        this.hasher = hasher;
+    }
+    async reconstructAll(plan, outputDir, chunkSource, options) {
+        const dir = (0, path_1.isAbsolute)(outputDir) ? outputDir : (0, path_1.resolve)(process.cwd(), outputDir);
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+        const files = [...plan.newAndModifiedFiles];
+        const total = files.length;
+        let completed = 0;
+        let globalBytesWritten = 0;
+        let globalBytesReceived = 0;
+        const startTime = Date.now();
+        let error = null;
+        const queue = files.map((entry, index) => ({ entry, index }));
+        const fileProgressMap = new Map();
+        const isNetworkSource = typeof chunkSource.streamChunks === 'function';
+        const totalNetworkBytes = isNetworkSource
+            ? plan.missingChunks.reduce((accumulator, chunk) => accumulator + chunk.size, 0)
+            : 0;
+        const totalBytesToWrite = files.reduce((accumulator, file) => accumulator + (file.size ?? 0), 0);
+        const next = async () => {
+            while (queue.length && !error) {
+                const { entry } = queue.shift();
+                const outputPath = (0, path_1.join)(dir, entry.path);
+                try {
+                    await this.reconstructFile(entry, outputPath, chunkSource, {
+                        ...options,
+                        onProgress: (fileProgress, fileBytesWritten, fileBytesReceived) => {
+                            fileProgressMap.set(entry.path, fileProgress);
+                            globalBytesWritten += fileBytesWritten ?? 0;
+                            if (isNetworkSource) {
+                                globalBytesReceived += fileBytesReceived ?? 0;
+                            }
+                            const reconstructProgress = Math.min((globalBytesWritten / totalBytesToWrite) * 100, 100);
+                            const networkProgress = isNetworkSource
+                                ? Math.min((globalBytesReceived / totalNetworkBytes) * 100, 100)
+                                : undefined;
+                            const elapsed = Math.max((Date.now() - startTime) / 1000, 0.001);
+                            const diskSpeed = globalBytesWritten / elapsed;
+                            const netSpeed = isNetworkSource ? globalBytesReceived / elapsed : 0;
+                            if (isNetworkSource) {
+                                options?.onProgress?.(reconstructProgress, diskSpeed, networkProgress, netSpeed);
+                            }
+                            else {
+                                options?.onProgress?.(reconstructProgress, diskSpeed);
+                            }
+                        },
+                    });
+                    completed++;
+                    fileProgressMap.set(entry.path, 100);
+                }
+                catch (err) {
+                    error = err instanceof Error ? err : new Error(String(err));
+                    break;
+                }
+            }
+        };
+        const workers = Array.from({ length: Math.min(options?.fileConcurrency ?? 5, total) }, next);
+        await Promise.allSettled(workers);
+        if (error) {
+            throw error;
+        }
+    }
+    async reconstructFile(entry, outputPath, chunkSource, options = {
+        forceRebuild: false,
+        verifyAfterRebuild: true,
+        inPlaceReconstructionThreshold: services_1.DEFAULT_IN_PLACE_RECONSTRUCTION_THRESHOLD,
+    }) {
+        const defOutputPath = (0, path_1.isAbsolute)(outputPath) ? outputPath : (0, path_1.resolve)(process.cwd(), outputPath);
+        const { forceRebuild, verifyAfterRebuild, inPlaceReconstructionThreshold } = options;
+        const tempPath = `${defOutputPath}.tmp`;
+        await (0, promises_1.mkdir)((0, path_1.dirname)(defOutputPath), { recursive: true });
+        const exists = await this.fileExists(defOutputPath);
+        if (exists && !forceRebuild) {
+            const matches = await this.hasher.verifyFile(defOutputPath, entry.hash);
+            if (matches) {
+                return;
+            }
+        }
+        const stats = exists ? await (0, promises_1.stat)(defOutputPath) : null;
+        const isLargeFile = stats && stats.size > inPlaceReconstructionThreshold;
+        const existingLargeFileWithoutRebuild = exists && !forceRebuild && isLargeFile;
+        const progressCb = (chunkBytes, netBytes, processedChunks) => {
+            const fileProgress = (processedChunks / entry.chunks.length) * 100;
+            options.onProgress?.(fileProgress, chunkBytes, netBytes);
+        };
+        try {
+            if (existingLargeFileWithoutRebuild && inPlaceReconstructionThreshold !== 0) {
+                await this.reconstructInPlace(entry, defOutputPath, chunkSource, progressCb);
+            }
+            else {
+                await this.reconstructToTemp(entry, defOutputPath, tempPath, chunkSource, !!verifyAfterRebuild, exists, !!options.forceRebuild, progressCb);
+            }
+        }
+        catch (err) {
+            await (0, promises_1.rm)(tempPath, { force: true });
+            throw err;
+        }
+    }
+    // This will reconstruct to stream, not to disk
+    async reconstructToStream(entry, chunkSource) {
+        const output = new stream_1.PassThrough({ highWaterMark: 1024 * 1024 });
+        const chunks = entry.chunks ?? [];
+        // Starts async reconstruction without blocking stream return
+        const processChunks = async () => {
+            try {
+                for await (const { data } of this.fetchChunksSmart(chunks, chunkSource)) {
+                    await this.writeToStream(data, output);
+                }
+                output.end();
+            }
+            catch (err) {
+                output.destroy(err instanceof Error ? err : new Error(String(err)));
+            }
+        };
+        void processChunks();
+        return output;
+    }
+    async fileExists(path) {
+        try {
+            await (0, promises_1.access)(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Performs partial reconstruction directly in the existing file */
+    async reconstructInPlace(entry, outputPath, chunkSource, progressCb) {
+        const fd = await (0, promises_1.open)(outputPath, 'r+');
+        const isNetworkSource = typeof chunkSource.streamChunks === 'function';
+        try {
+            const chunkMap = new Map(entry.chunks.map((c) => [c.hash, c]));
+            let processed = 0;
+            for await (const { hash, data } of this.fetchChunksSmart(entry.chunks, chunkSource, false)) {
+                const chunk = chunkMap.get(hash);
+                if (!chunk) {
+                    continue;
+                }
+                const buffer = Buffer.isBuffer(data) ? data : await (0, utils_1.streamToBuffer)(data);
+                await fd.write(buffer, 0, buffer.length, chunk.offset);
+                processed++;
+                const netBytes = isNetworkSource ? buffer.length : 0;
+                progressCb?.(buffer.length, netBytes, processed);
+            }
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    /** Reconstructs file fully or partially via .tmp file and replaces it atomically */
+    async reconstructToTemp(entry, outputPath, tempPath, chunkSource, verifyAfterRebuild, fileExists, force, progressCb) {
+        const writeStream = (0, fs_1.createWriteStream)(tempPath, { flags: 'w' });
+        let writeError = null;
+        const onWriteError = (err) => {
+            writeError = err;
+        };
+        writeStream.once('error', onWriteError);
+        let processed = 0;
+        const isNetworkSource = typeof chunkSource.streamChunks === 'function';
+        try {
+            // Partial reconstruction via reading from existing file
+            if (fileExists && !force) {
+                const readFd = await (0, promises_1.open)(outputPath, 'r');
+                try {
+                    for (const chunk of entry.chunks) {
+                        await this.processChunkDataSmart(chunk, readFd, chunkSource, writeStream);
+                        processed++;
+                        progressCb?.(chunk.size, 0, processed);
+                    }
+                }
+                finally {
+                    await readFd.close();
+                }
+            }
+            // Full reconstruction
+            if (!fileExists || force) {
+                try {
+                    for await (const { data } of this.fetchChunksSmart(entry.chunks, chunkSource)) {
+                        let totalWritten = 0;
+                        await this.writeToStream(data, writeStream, (totalBytes) => {
+                            totalWritten = totalBytes;
+                        });
+                        processed++;
+                        progressCb?.(totalWritten, isNetworkSource ? totalWritten : 0, processed);
+                    }
+                    if (writeError) {
+                        throw writeError;
+                    }
+                }
+                catch (err) {
+                    writeStream.destroy();
+                    throw err;
+                }
+                finally {
+                    writeStream.removeListener('error', onWriteError);
+                    writeStream.end();
+                }
+            }
+            writeStream.end();
+            await new Promise((resolve, reject) => {
+                writeStream.on('finish', resolve);
+                writeStream.on('error', reject);
+            });
+            if (verifyAfterRebuild) {
+                const valid = await this.hasher.verifyFile(tempPath, entry.hash);
+                if (!valid) {
+                    throw new Error(`Hash mismatch after reconstructing ${entry.path}`);
+                }
+            }
+            await (0, promises_1.rename)(tempPath, outputPath);
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    /**
+     * Tries to read an existing chunk from a file descriptor if possible.
+     * Falls back to fetching from chunkSource if hash does not match.
+     */
+    async processChunkDataSmart(chunk, fd, chunkSource, writeStream) {
+        const buffer = Buffer.alloc(chunk.size);
+        await fd.read(buffer, 0, chunk.size, chunk.offset);
+        if (await this.hasher.verifyChunk(buffer, chunk.hash)) {
+            await this.writeToStream(buffer, writeStream);
+            return;
+        }
+        // fallback
+        const data = await this.getChunkData(chunk, chunkSource);
+        if (Buffer.isBuffer(data)) {
+            await this.writeToStream(data, writeStream);
+            return;
+        }
+        if (writeStream) {
+            await (0, promises_2.pipeline)(data, writeStream, { end: false });
+        }
+    }
+    async getChunkData(chunk, chunkSource) {
+        if (!chunkSource) {
+            throw new Error(`ChunkSource not provided for chunk ${chunk.hash}`);
+        }
+        const data = await chunkSource.getChunk(chunk.hash);
+        if (!data) {
+            throw new exceptions_1.ChunkNotFoundException(`${chunk.hash} not found in storage`);
+        }
+        return data;
+    }
+    async writeToStream(data, stream, onFinish) {
+        if (!stream) {
+            return;
+        }
+        if (Buffer.isBuffer(data)) {
+            const canContinue = stream.write(data);
+            if (!canContinue) {
+                await new Promise((resolve) => stream.once('drain', resolve));
+            }
+            onFinish?.(data.length);
+            return;
+        }
+        let totalBytes = 0;
+        await new Promise((resolve, reject) => {
+            const onError = (err) => {
+                cleanup();
+                reject(err instanceof Error ? err : new Error(String(err)));
+            };
+            const onEnd = () => {
+                cleanup();
+                onFinish?.(totalBytes);
+                resolve();
+            };
+            const cleanup = () => {
+                data.off('error', onError);
+                data.off('end', onEnd);
+                stream.off('error', onError);
+            };
+            data.on('error', onError);
+            stream.on('error', onError);
+            data.on('end', onEnd);
+            data.on('data', (chunk) => {
+                totalBytes += chunk.length;
+                const canContinue = stream.write(chunk);
+                if (!canContinue) {
+                    data.pause();
+                    stream.once('drain', () => data.resume());
+                }
+            });
+        });
+    }
+    async *fetchChunksSmart(chunks, chunkSource, preserveOrder = true) {
+        const hashes = chunks.map((c) => c.hash);
+        // 1. streamChunks available: streaming
+        if (chunkSource.streamChunks) {
+            for await (const { hash, data } of chunkSource.streamChunks(hashes, { preserveOrder })) {
+                yield { hash: hash, data };
+            }
+            return;
+        }
+        // 2. getChunks available: download all chunks
+        if (chunkSource.getChunks) {
+            const map = await chunkSource.getChunks(hashes);
+            for (const hash of hashes) {
+                const data = map.get(hash);
+                if (data) {
+                    yield { hash, data };
+                }
+            }
+            return;
+        }
+        // 3. fallback: individual getChunk
+        for (const chunk of chunks) {
+            const data = await chunkSource.getChunk(chunk.hash);
+            yield { hash: chunk.hash, data };
+        }
+    }
+}
+exports.MemoryReconstructionService = MemoryReconstructionService;

package/dist/infrastructure/services/memory-validation-service.d.ts

@@ -0,0 +1,9 @@
+import { ValidationService, HasherService } from '../../core/services';
+import { FileEntry, RDIndex } from '../../core/models';
+export declare class MemoryValidationService implements ValidationService {
+    private readonly hasher;
+    constructor(hasher: HasherService);
+    validateFile(entry: FileEntry, path: string): Promise<boolean>;
+    validateIndex(index: RDIndex, basePath: string): Promise<boolean>;
+}
+//# sourceMappingURL=memory-validation-service.d.ts.map

package/dist/infrastructure/services/memory-validation-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-validation-service.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/memory-validation-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEvD,qBAAa,uBAAwB,YAAW,iBAAiB;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAE5C,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAY9D,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAcxE"}

package/dist/infrastructure/services/memory-validation-service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryValidationService = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+class MemoryValidationService {
+    hasher;
+    constructor(hasher) {
+        this.hasher = hasher;
+    }
+    async validateFile(entry, path) {
+        try {
+            const finalPath = (0, path_1.isAbsolute)(path) ? path : (0, path_1.resolve)(process.cwd(), path);
+            const stats = await (0, promises_1.stat)(finalPath);
+            return stats.size === entry.size && (await this.hasher.verifyFile(finalPath, entry.hash));
+        }
+        catch {
+            return false;
+        }
+    }
+    async validateIndex(index, basePath) {
+        const directory = (0, path_1.isAbsolute)(basePath) ? basePath : (0, path_1.resolve)(process.cwd(), basePath);
+        for (const file of index.files) {
+            const filePath = (0, path_1.join)(directory, file.path);
+            const valid = await this.validateFile(file, filePath);
+            if (!valid) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.MemoryValidationService = MemoryValidationService;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "rac-delta",
+  "description": "Storage agnostic delta patching implementation of rac-delta protocol for NodeJs. With streaming support and file reconstruction.",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "delta",
+    "open",
+    "protocol",
+    "diff",
+    "delta-patching"
+  ],
+  "author": "Rubén Cruz contact@raccreativegames.com",
+  "license": "MIT",
+  "dependencies": {
+    "hash-wasm": "^4.12.0"
+  },
+  "peerDependencies": {
+    "@aws-sdk/client-s3": "^3.908.0",
+    "@azure/identity": "^4.13.0",
+    "@azure/storage-blob": "^12.28.0",
+    "@google-cloud/storage": "^7.17.2",
+    "ssh2": "^1.17.0"
+  },
+  "devDependencies": {
+    "@types/ssh2": "^1.15.5",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.37.0",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}