functional-google-cloud
Version:
Google Cloud Utilities functions in Functional Programming Style
228 lines • 7.21 kB
JavaScript
import * as TEUtils from 'functional-types/lib/fp-ts/TaskEither';
import { getUnixTimestampIn } from './DateTime';
import * as TE from 'fp-ts/lib/TaskEither';
import * as E from 'fp-ts/lib/Either';
import * as R from 'fp-ts/lib/Reader';
import * as RT from 'fp-ts/lib/ReaderTask';
import { allPass, call, head, is, pipe, propIs, useWith, partialRight, } from 'ramda';
import * as FileType from 'functional-types/lib/FileType';
/**
* ```haskell
* isPath :: a -> bool
* ```
*/
export const isPath = (a) => allPass([is(Object), propIs(String, 'bucket'), propIs(String, 'filename')])(a);
/**
* ```haskell
* getWriteOnlySignedUrlConfigFromConfig :: WriteOnlyConfig -> GetSignedUrlConfig
* ```
*/
export const getWriteOnlySignedUrlConfigFromConfig = ({ expires_in: expiresIn, file_type: fileType }) => ({
version: 'v4',
action: 'write',
expires: getUnixTimestampIn(expiresIn),
contentType: FileType.toContentType(fileType),
});
/**
* ```haskell
* getReadOnlySignedUrlConfigFromConfig :: WriteOnlyConfig -> GetSignedUrlConfig
* ```
*/
export const getReadOnlySignedUrlConfigFromConfig = ({ expires_in: expiresIn }) => ({
version: 'v4',
action: 'read',
expires: getUnixTimestampIn(expiresIn),
});
/**
* ```haskell
* getSignedUrlTask :: File -> ReaderTask GetSignedUrlConfig [String]
* ```
*/
export const getSignedUrlTask = (file) => (config) => () => file.getSignedUrl(config);
/**
* ```haskell
* getWriteOnlySignedUrlArrayFromFileTask :: File -> ReaderTask WriteOnlyConfig [String]
* ```
*/
export const getWriteOnlySignedUrlArrayFromFileTask = useWith(call, [
getSignedUrlTask,
getWriteOnlySignedUrlConfigFromConfig,
]);
/**
* ```haskell
* getReadOnlySignedUrlArrayFromFileTask :: File -> ReaderTask WriteOnlyConfig [String]
* ```
*/
export const getReadOnlySignedUrlArrayFromFileTask = useWith(call, [
getSignedUrlTask,
getReadOnlySignedUrlConfigFromConfig,
]);
/**
* ```haskell
* getUploadUrlFromFileTask :: File -> ReaderTask WriteOnlyConfig String
* ```
*/
export const getUploadUrlFromFileTask = pipe(getWriteOnlySignedUrlArrayFromFileTask, RT.map(head));
/**
* ```haskell
* getDownloadUrlFromFileTask :: File -> ReaderTask WriteOnlyConfig String
* ```
*/
export const getDownloadUrlFromFileTask = pipe(getReadOnlySignedUrlArrayFromFileTask, RT.map(head));
/**
* ```haskell
* getTaskEitherFromTask :: Task -> TaskEither
* ```
*/
export const getTaskEitherFromTask = (task) => TE.tryCatch(task, E.toError);
/**
* ```haskell
* getUploadUrlFromFile :: File -> ReaderTaskEither WriteOnlyConfig String Error
* ```
*/
export const getUploadUrlFromFile = pipe(getUploadUrlFromFileTask, R.map(getTaskEitherFromTask));
/**
* ```haskell
* getDownloadUrlFromFile :: File -> ReaderTaskEither WriteOnlyConfig String Error
* ```
*/
export const getDownloadUrlFromFile = pipe(getDownloadUrlFromFileTask, R.map(getTaskEitherFromTask));
/**
* ```haskell
* getFileFromBucket :: Bucket -> Reader Path File
* ```
*/
export const getFileFromBucket = (bucket) => (path) => bucket.file(path.filename);
/**
* ```haskell
* getBucketFromStorageWithPath :: Storage -> Reader String Bucket
* ```
*/
const getBucketFromStorageWithPath = (storage) => (path) => storage.bucket(path.bucket);
/**
* ```haskell
* getFileFromStorage :: Storage -> Reader Path File
* ```
*/
export const getFileFromStorage = pipe(getBucketFromStorageWithPath, R.chain(getFileFromBucket));
/**
* ```haskell
* fetchFileTask :: File -> Task File
* ```
*/
const fetchFileTask = (file) => async () => {
const result = await file.get();
return result[0];
};
/**
* ```haskell
* fetchFile :: File -> TaskEither File Error
* ```
*/
export const fetchFile = pipe(fetchFileTask, TEUtils.fromTask);
/**
* ```haskell
* fetchFileFromStorage :: Storage -> ReaderTaskEither Path File Error
* ```
*/
export const fetchFileFromStorage = pipe(getFileFromStorage, R.map(fetchFile));
/**
* ```haskell
* getUploadUrlFromStorage :: Storage -> Path -> ReaderTaskEither WriteOnlyConfig String Error
* ```
*/
export const getUploadUrlFromStorage = pipe(getFileFromStorage, R.map(getUploadUrlFromFile));
/**
* ```haskell
* getBufferSingletonFromFilePromise :: File -> Task [Buffer]
* ```
*/
export const getBufferSingletonFromFileTask = (file) => () => file.download();
/**
* ```haskell
* getBufferSingletonFromFile :: File -> TaskEither [Buffer] Error
* ```
*/
export const getBufferSingletonFromFile = pipe(getBufferSingletonFromFileTask, partialRight(TE.tryCatch, [E.toError]));
/**
* ```haskell
* getBufferFromFile :: File -> TaskEither Buffer Error
* ```
*/
export const getBufferFromFile = pipe(getBufferSingletonFromFile, TE.map(head));
/**
* ```haskell
* getBufferFromStorage :: Storage -> ReaderTaskEither Path File Error
* ```
*/
export const getBufferFromStorage = pipe(getFileFromStorage, R.map(getBufferFromFile));
/**
* ```haskell
* storeBufferToFileTask :: File -> ReaderTask Buffer File
* ```
*/
export const storeBufferToFileTask = (file) => (buffer) => async () => {
await file.save(buffer);
return file;
};
/**
* ```haskell
* storeBufferToFile :: File -> ReaderTaskEither Buffer File Error
* ```
*/
export const storeBufferToFile = pipe(storeBufferToFileTask, R.map(getTaskEitherFromTask));
/**
* ```haskell
* storeBufferToStorage :: Storage -> Reader Path ReaderTaskEither Buffer File Error
* ```
*/
export const storeBufferToStorage = pipe(getFileFromStorage, R.map(storeBufferToFile));
/**
* ```haskell
* storeMetadataToFileTask :: File -> ReaderTask Metadata File
* ```
*/
export const storeMetadataToFileTask = (file) => (metadata) => async () => {
await file.setMetadata(metadata);
return file;
};
/**
* ```haskell
* storeMetadataToFile :: File -> ReaderTaskEither Metadata File Error
* ```
*/
export const storeMetadataToFile = pipe(storeMetadataToFileTask, R.map(getTaskEitherFromTask));
/**
* ```haskell
* storeMetadataToStorage :: Metadata -> Reader Path ReaderTaskEither Metadata File Error
* ```
*/
export const storeMetadataToStorage = pipe(getFileFromStorage, R.map(storeMetadataToFile));
/**
* ```haskell
* getBucketFromStorage :: Storage -> Reader String Bucket
* ```
*/
export const getBucketFromStorage = (storage) => (name) => storage.bucket(name);
/**
* ```haskell
* listFilesInBucketTask :: Bucket -> ReaderTask ListFilesOptions [File]
* ```
*/
const listFilesInBucketTask = (bucket) => (options) => async () => {
const [files] = await bucket.getFiles(options);
return files;
};
/**
* ```haskell
* listFilesInBucket :: Bucket -> ReaderTaskEither ListFilesOptions [File] Error
* ```
*/
export const listFilesInBucket = pipe(listFilesInBucketTask, R.map(TEUtils.fromTask));
/**
* ```haskell
* listFilesInStorage :: Storage -> Reader String (ReaderTaskEither ListFilesOptions [File] Error)
* ```
*/
export const listFilesInStorage = pipe(getBucketFromStorage, R.map(listFilesInBucket));
//# sourceMappingURL=index.js.map