Merge pull request #92 from ardriveapp/dev

PE-741: Release ArDrive Core v1.0.5

Author: fedellen

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ardrive-core-js",
-	"version": "1.0.4",
+	"version": "1.0.5",
 	"description": "ArDrive Core contains the essential back end application features to support the ArDrive CLI and Desktop apps, such as file management, Permaweb upload/download, wallet management and other common functions.",
 	"main": "./lib/exports.js",
 	"types": "./lib/exports.d.ts",

src/ardrive.ts

@@ -5,7 +5,12 @@ import {
 	ArFSPrivateFile,
 	ArFSPrivateFileOrFolderWithPaths
 } from './arfs/arfs_entities';
-import { ArFSFolderToUpload, ArFSFileToUpload } from './arfs/arfs_file_wrapper';
+import {
+	ArFSFolderToUpload,
+	ArFSFileToUpload,
+	ArFSEntityToUpload,
+	ArFSManifestToUpload
+} from './arfs/arfs_file_wrapper';
 import {
 	ArFSPublicFileMetadataTransactionData,
 	ArFSPrivateFileMetadataTransactionData,
@@ -38,7 +43,9 @@ import {
 	DriveID,
 	stubTransactionID,
 	UploadPublicFileParams,
-	UploadPrivateFileParams
+	UploadPrivateFileParams,
+	ArFSManifestResult,
+	UploadPublicManifestParams
 } from './types';
 import {
 	CommunityTipParams,
@@ -1002,6 +1009,83 @@ export class ArDrive extends ArDriveAnonymous {
 		};
 	}
 
+	public async uploadPublicManifest({
+		folderId,
+		destManifestName = 'DriveManifest.json',
+		maxDepth = Number.MAX_SAFE_INTEGER,
+		conflictResolution = upsertOnConflicts
+	}: UploadPublicManifestParams): Promise<ArFSManifestResult> {
+		const driveId = await this.arFsDao.getDriveIdForFolderId(folderId);
+
+		// Assert that the owner of this drive is consistent with the provided wallet
+		const owner = await this.getOwnerForDriveId(driveId);
+		await this.assertOwnerAddress(owner);
+
+		const filesAndFolderNames = await this.arFsDao.getPublicNameConflictInfoInFolder(folderId);
+
+		const fileToFolderConflict = filesAndFolderNames.folders.find((f) => f.folderName === destManifestName);
+		if (fileToFolderConflict) {
+			// File names CANNOT conflict with folder names
+			throw new Error(errorMessage.entityNameExists);
+		}
+
+		// Manifest becomes a new revision if the destination name conflicts for
+		// --replace and --upsert behaviors, since it will be newly created each time
+		const existingFileId = filesAndFolderNames.files.find((f) => f.fileName === destManifestName)?.fileId;
+		if (existingFileId && conflictResolution === skipOnConflicts) {
+			// Return empty result if there is an existing manifest and resolution is set to skip
+			return { ...emptyArFSResult, links: [] };
+		}
+
+		const children = await this.listPublicFolder({
+			folderId,
+			maxDepth,
+			includeRoot: true,
+			owner
+		});
+		const arweaveManifest = new ArFSManifestToUpload(children, destManifestName);
+
+		const uploadBaseCosts = await this.estimateAndAssertCostOfFileUpload(
+			arweaveManifest.size,
+			this.stubPublicFileMetadata(arweaveManifest),
+			'public'
+		);
+		const fileDataRewardSettings = { reward: uploadBaseCosts.fileDataBaseReward, feeMultiple: this.feeMultiple };
+		const metadataRewardSettings = { reward: uploadBaseCosts.metaDataBaseReward, feeMultiple: this.feeMultiple };
+
+		const uploadFileResult = await this.arFsDao.uploadPublicFile({
+			parentFolderId: folderId,
+			wrappedFile: arweaveManifest,
+			driveId,
+			fileDataRewardSettings,
+			metadataRewardSettings,
+			destFileName: destManifestName,
+			existingFileId
+		});
+
+		const { tipData, reward: communityTipTrxReward } = await this.sendCommunityTip({
+			communityWinstonTip: uploadBaseCosts.communityWinstonTip
+		});
+
+		return Promise.resolve({
+			created: [
+				{
+					type: 'file',
+					metadataTxId: uploadFileResult.metaDataTrxId,
+					dataTxId: uploadFileResult.dataTrxId,
+					entityId: uploadFileResult.fileId
+				}
+			],
+			tips: [tipData],
+			fees: {
+				[`${uploadFileResult.dataTrxId}`]: uploadFileResult.dataTrxReward,
+				[`${uploadFileResult.metaDataTrxId}`]: uploadFileResult.metaDataTrxReward,
+				[`${tipData.txId}`]: communityTipTrxReward
+			},
+			links: arweaveManifest.getLinksOutput(uploadFileResult.dataTrxId)
+		});
+	}
+
 	public async createPublicFolder({
 		folderName,
 		driveId,
@@ -1487,7 +1571,7 @@ export class ArDrive extends ArDriveAnonymous {
 
 	// Provides for stubbing metadata during cost estimations since the data trx ID won't yet be known
 	private stubPublicFileMetadata(
-		wrappedFile: ArFSFileToUpload,
+		wrappedFile: ArFSEntityToUpload,
 		destinationFileName?: string
 	): ArFSPublicFileMetadataTransactionData {
 		const { fileSize, dataContentType, lastModifiedDateMS } = wrappedFile.gatherFileInfo();

src/arfs/arfs_file_wrapper.test.ts

@@ -0,0 +1,230 @@
+import { expect } from 'chai';
+import {
+	stubEntitiesWithNestedFileWithPaths,
+	stubEntitiesWithNoFilesWithPaths,
+	stubEntitiesWithOneFileWithPaths,
+	stubEntitiesWithPathsAndIndexInRoot,
+	stubPublicEntitiesWithPaths,
+	stubSpecialCharEntitiesWithPaths
+} from '../../tests/stubs';
+import { stubTransactionID, W } from '../types';
+import { ArFSFileToUpload, ArFSFolderToUpload, ArFSManifestToUpload, wrapFileOrFolder } from './arfs_file_wrapper';
+
+describe('ArFSManifestToUpload class', () => {
+	it('will link to an index.html file in the root of the folder if it exists', () => {
+		const manifest = new ArFSManifestToUpload(stubEntitiesWithPathsAndIndexInRoot, 'DriveManifest.json');
+
+		// Ensure arweave required fields exist
+		expect(manifest.manifest.manifest).to.equal('arweave/paths');
+		expect(manifest.manifest.version).to.equal('0.1.0');
+
+		// Expect index path to be linked to index.html
+		expect(manifest.manifest.index.path).to.equal('index.html');
+
+		// Assert the structure is consistent with provided stub hierarchy
+		expect(manifest.manifest.paths).to.deep.equal({
+			'file-in-root': {
+				id: '0000000000000000000000000000000000000000001'
+			},
+			'index.html': {
+				id: '0000000000000000000000000000000000000000004'
+			},
+			'parent-folder/child-folder/file-in-child': {
+				id: '0000000000000000000000000000000000000000003'
+			},
+			'parent-folder/file-in-parent': {
+				id: '0000000000000000000000000000000000000000002'
+			}
+		});
+	});
+
+	it('constructs a manifest compatible with arweave gateways', () => {
+		const manifest = new ArFSManifestToUpload(stubPublicEntitiesWithPaths, 'DriveManifest.json');
+
+		// Ensure arweave required fields exist
+		expect(manifest.manifest.manifest).to.equal('arweave/paths');
+		expect(manifest.manifest.version).to.equal('0.1.0');
+
+		// Expect index path to be the first file
+		expect(manifest.manifest.index.path).to.equal('file-in-root');
+
+		// Assert the structure is consistent with provided stub hierarchy
+		expect(manifest.manifest.paths).to.deep.equal({
+			'file-in-root': {
+				id: '0000000000000000000000000000000000000000001'
+			},
+			'parent-folder/child-folder/file-in-child': {
+				id: '0000000000000000000000000000000000000000003'
+			},
+			'parent-folder/file-in-parent': {
+				id: '0000000000000000000000000000000000000000002'
+			}
+		});
+	});
+
+	it('throws an error when constructed with a hierarchy that has no file entities', () => {
+		expect(() => new ArFSManifestToUpload(stubEntitiesWithNoFilesWithPaths, 'NameTestManifest.json')).to.throw(
+			Error,
+			'Cannot construct a manifest of a folder that has no file entities!'
+		);
+	});
+
+	it('getBaseFileName function returns the provided name', () => {
+		const manifest = new ArFSManifestToUpload(stubPublicEntitiesWithPaths, 'NameTestManifest.json');
+
+		expect(manifest.getBaseFileName()).to.equal('NameTestManifest.json');
+	});
+
+	it('gatherFileInfo function returns the expected results', () => {
+		const currentUnixTimeMs = Math.round(Date.now() / 1000);
+		const manifest = new ArFSManifestToUpload(stubPublicEntitiesWithPaths, 'TestManifest.json');
+
+		const { dataContentType, lastModifiedDateMS, fileSize } = manifest.gatherFileInfo();
+
+		expect(dataContentType).to.equal('application/x.arweave-manifest+json');
+		expect(+lastModifiedDateMS).to.equal(currentUnixTimeMs);
+		expect(+fileSize).to.equal(336);
+	});
+
+	it('getFileDataBuffer function returns a compatible Buffer we can use to upload', () => {
+		const manifest = new ArFSManifestToUpload(stubPublicEntitiesWithPaths, 'TestManifest.json');
+
+		expect(manifest.getFileDataBuffer() instanceof Buffer).to.be.true;
+	});
+
+	describe('getLinksOutput function', () => {
+		it('produces compatible links with a standard hierarchy', () => {
+			const manifest = new ArFSManifestToUpload(stubPublicEntitiesWithPaths, 'TestManifest.json');
+
+			const linksOutput = manifest.getLinksOutput(stubTransactionID);
+
+			expect(linksOutput.length).to.equal(4);
+			expect(linksOutput[0]).to.equal(`https://arweave.net/${stubTransactionID}`);
+			expect(linksOutput[1]).to.equal(`https://arweave.net/${stubTransactionID}/file-in-root`);
+			expect(linksOutput[2]).to.equal(
+				`https://arweave.net/${stubTransactionID}/parent-folder/child-folder/file-in-child`
+			);
+			expect(linksOutput[3]).to.equal(`https://arweave.net/${stubTransactionID}/parent-folder/file-in-parent`);
+		});
+
+		it('produces compatible links with a hierarchy of one single file', () => {
+			const manifest = new ArFSManifestToUpload(stubEntitiesWithOneFileWithPaths, 'TestManifest.json');
+
+			const linksOutput = manifest.getLinksOutput(stubTransactionID);
+
+			expect(linksOutput.length).to.equal(2);
+			expect(linksOutput[0]).to.equal(`https://arweave.net/${stubTransactionID}`);
+			expect(linksOutput[1]).to.equal(`https://arweave.net/${stubTransactionID}/file-in-root`);
+		});
+
+		it('produces compatible links with a hierarchy of one nested file', () => {
+			const manifest = new ArFSManifestToUpload(stubEntitiesWithNestedFileWithPaths, 'TestManifest.json');
+
+			const linksOutput = manifest.getLinksOutput(stubTransactionID);
+
+			expect(linksOutput.length).to.equal(2);
+			expect(linksOutput[0]).to.equal(`https://arweave.net/${stubTransactionID}`);
+			expect(linksOutput[1]).to.equal(
+				`https://arweave.net/${stubTransactionID}/parent-folder/child-folder/file-in-child`
+			);
+		});
+
+		it('produces compatible links with a hierarchy of entities with special characters', () => {
+			const manifest = new ArFSManifestToUpload(stubSpecialCharEntitiesWithPaths, 'TestManifest.json');
+
+			const linksOutput = manifest.getLinksOutput(stubTransactionID);
+
+			expect(linksOutput.length).to.equal(4);
+			expect(linksOutput[0]).to.equal(`https://arweave.net/${stubTransactionID}`);
+			expect(linksOutput[1]).to.equal(
+				`https://arweave.net/${stubTransactionID}/%25%26%40*(%25%26(%40*%3A%22%3E%3F%7B%7D%5B%5D`
+			);
+			expect(linksOutput[2]).to.equal(
+				`https://arweave.net/${stubTransactionID}/~!%40%23%24%25%5E%26*()_%2B%7B%7D%7C%5B%5D%3A%22%3B%3C%3E%3F%2C./%60/'/''_%5C___''_'__/'___'''_/QWERTYUIOPASDFGHJKLZXCVBNM!%40%23%24%25%5E%26*()_%2B%7B%7D%3A%22%3E%3F`
+			);
+			expect(linksOutput[3]).to.equal(
+				`https://arweave.net/${stubTransactionID}/~!%40%23%24%25%5E%26*()_%2B%7B%7D%7C%5B%5D%3A%22%3B%3C%3E%3F%2C./%60/dwijqndjqwnjNJKNDKJANKDNJWNJIvmnbzxnmvbcxvbm%2Cuiqwerioeqwndjkla`
+			);
+		});
+	});
+});
+
+describe('ArFSFileToUpload class', () => {
+	let fileToUpload: ArFSFileToUpload;
+
+	beforeEach(() => {
+		// Start each test with a newly wrapped file
+		fileToUpload = wrapFileOrFolder('./test_wallet.json') as ArFSFileToUpload;
+	});
+
+	it('throws an error on construction if file max size limit is exceeded', () => {
+		expect(
+			() => new ArFSFileToUpload('./test_wallet.json', { ...fileToUpload.fileStats, size: 2_147_483_647 })
+		).to.throw(Error, 'Files greater than "2147483646" bytes are not yet supported!');
+	});
+
+	it('gatherFileInfo function returns the expected results', () => {
+		const { dataContentType, fileSize, lastModifiedDateMS } = fileToUpload.gatherFileInfo();
+
+		expect(dataContentType).to.equal('application/json');
+		expect(+fileSize).to.equal(3204);
+
+		// Last modified date varies between local dev environments and CI environment
+		const expectedLastModifiedDate = fileToUpload.lastModifiedDate;
+		expect(+lastModifiedDateMS).to.equal(+expectedLastModifiedDate);
+	});
+
+	it('getFileDataBuffer function returns a compatible Buffer we can use to upload', () => {
+		expect(fileToUpload.getFileDataBuffer() instanceof Buffer).to.be.true;
+	});
+
+	it('getBaseFileName function returns the correct name', () => {
+		expect(fileToUpload.getBaseFileName()).to.equal('test_wallet.json');
+	});
+
+	it('encryptedDataSize function returns the expected size', () => {
+		expect(+fileToUpload.encryptedDataSize()).to.equal(3220);
+	});
+
+	it('getBaseCosts function throws an error if base costs are not set', () => {
+		expect(() => fileToUpload.getBaseCosts()).to.throw(Error, 'Base costs on file were never set!');
+	});
+
+	it('getBaseCosts function returns any assigned base costs', () => {
+		fileToUpload.baseCosts = { fileDataBaseReward: W(1), metaDataBaseReward: W(2) };
+
+		expect(+fileToUpload.getBaseCosts().fileDataBaseReward).to.equal(1);
+		expect(+fileToUpload.getBaseCosts().metaDataBaseReward).to.equal(2);
+	});
+});
+
+describe('ArFSFolderToUpload class', () => {
+	let folderToUpload: ArFSFolderToUpload;
+
+	beforeEach(() => {
+		// Start each test with a newly wrapped folder
+		folderToUpload = wrapFileOrFolder('./tests/stub_files/bulk_root_folder') as ArFSFolderToUpload;
+	});
+
+	it('getTotalByteCount function returns the expected size', () => {
+		expect(+folderToUpload.getTotalByteCount()).to.equal(52);
+	});
+
+	it('getTotalByteCount function returns the expected size if files are to be encrypted', () => {
+		expect(+folderToUpload.getTotalByteCount(true)).to.equal(116);
+	});
+
+	it('getBaseFileName function returns the correct name', () => {
+		expect(folderToUpload.getBaseFileName()).to.equal('bulk_root_folder');
+	});
+
+	it('getBaseCosts function throws an error if base costs are not set', () => {
+		expect(() => folderToUpload.getBaseCosts()).to.throw(Error, 'Base costs on folder were never set!');
+	});
+
+	it('getBaseCosts function returns any assigned base costs', () => {
+		folderToUpload.baseCosts = { metaDataBaseReward: W(1) };
+
+		expect(+folderToUpload.getBaseCosts().metaDataBaseReward).to.equal(1);
+	});
+});