🎥 Make videos programmatically with React
import type {Dirent} from 'fs';
import {createReadStream, promises as fs} from 'fs';
import path from 'path';
import type {Privacy} from '../defaults';
import {makeStorageKey} from '../shared/make-storage-key';
import {getCloudStorageClient} from './helpers/get-cloud-storage-client';
type FileInfo = {
name: string;
size: number;
};
export type UploadDirProgress = {
totalFiles: number;
filesUploaded: number;
totalSize: number;
sizeUploaded: number;
};
export type MockFile = {
name: string;
content: string;
};
export const getDirFiles = (entry: string): MockFile[] => {
throw new TypeError(
'should only be executed in test ' + JSON.stringify(entry),
);
};
export const uploadDir = async ({
bucket,
localDir,
onProgress,
keyPrefix,
toUpload,
privacy,
}: {
bucket: string;
localDir: string;
keyPrefix: string;
onProgress: (progress: UploadDirProgress) => void;
toUpload: string[];
privacy: Privacy;
}) => {
async function getFiles(
directory: string,
originalDirectory: string,
filesToUpload: string[],
): Promise<FileInfo[]> {
const dirents = await fs.readdir(directory, {withFileTypes: true});
const _files = await Promise.all(
dirents
.map((dirent): [Dirent, string] => {
const res = path.resolve(directory, dirent.name);
return [dirent, res];
})
.filter(([dirent, res]) => {
const relative = path.relative(originalDirectory, res);
if (dirent.isDirectory()) {
return true;
}
if (!filesToUpload.includes(relative)) {
return false;
}
return true;
})
.map(async ([dirent, res]) => {
const {size} = await fs.stat(res);
return dirent.isDirectory()
? getFiles(res, originalDirectory, filesToUpload)
: [
{
name: res,
size,
},
];
}),
);
return _files.flat(1);
}
const files = await getFiles(localDir, localDir, toUpload);
const progresses: {[key: string]: number} = {};
for (const file of files) {
progresses[file.name] = 0;
}
const cloudStorageClient = getCloudStorageClient();
const uploads = files.map((file) => {
const filePath = file.name;
const destination = makeStorageKey(keyPrefix, localDir, filePath);
return new Promise((resolve, reject) => {
createReadStream(filePath)
.pipe(
cloudStorageClient
.bucket(bucket)
.file(destination)
.createWriteStream({
public: privacy === 'public',
}),
)
.on('error', (error) => reject(error))
.on('progress', (p) => {
progresses[filePath] = p.bytesWritten ?? 0;
})
.on('finish', () => resolve('done'));
});
});
const promise = Promise.all(uploads);
const interval = setInterval(() => {
onProgress({
totalSize: files.map((f) => f.size).reduce((a, b) => a + b, 0),
sizeUploaded: Object.values(progresses).reduce((a, b) => a + b, 0),
totalFiles: files.length,
filesUploaded: files.filter((f) => progresses[f.name] === f.size).length,
});
}, 1000);
await promise;
clearInterval(interval);
};