Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
export const saveStagedBookmarksAsNewGroupToLocalStorage = (newStagedBookmarks: NonEmptyArray): TaskEither => {
const stagedBookmarksGroups = pipe(
getStagedBookmarksGroupsFromLocalStorage,
TE.map(O.getOrElse((): Array => [])),
);
const newGroup = pipe(
stagedBookmarksGroups,
TE.map(flow(
flow(A.map(group => group.id), createUuid, runIO),
(id): StagedBookmarksGroup => ({
id,
time: new Date().getTime(),
// Assign each bookmark a generated ID, and ensure they don't clash with
// one another
bookmarks: newStagedBookmarks.reduce>((acc, bm) => [...acc, {
...bm,
id: createUuid(acc.map(b => b.id))(),
}], []),
}),
)),
);
return pipe(
sequenceTTE(stagedBookmarksGroups, newGroup),
describe('composition', () => {
const double = (a: number): number => a * 2;
const quad = flow(
double,
double,
);
it('initial', () => {
expect(remoteData.map(initial, quad)).toBe(
pipe(
initial,
RD.map(double),
RD.map(double),
),
);
});
it('pending', () => {
expect(remoteData.map(pending, quad)).toBe(
pipe(
pending,
function xhr<a>(req: Request</a><a>): Observable> {
return ajax(toXHRRequest(req)).pipe(
map(
flow(
toResponse(req),
decodeWith(req.expect)
)
),
catchError((e: any): Observable> => of(E.left(toHttpError(e))))
)
}
</a>
msg$,
)),
map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
);
const processEffects: ProcessOperator = flow(
publish(msg$ => zip(
combinedEffects(msg$.pipe(map(m => m.data)), ctx).pipe(
catchError(toUnhandledErrorEvent),
),
msg$,
)),
map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
);
const processOutput: ProcessOperator = flow(
publish(msg$ => zip(
outputLogger$(msg$.pipe(map(m => ({ event: m.data, initiator: m }))), ctx).pipe(
catchError(toUnhandledErrorEvent),
),
msg$,
)),
map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
publish(msg$ => zip(
output$(msg$.pipe(map(m => ({ event: m.data, initiator: m }))), ctx).pipe(
catchError(toUnhandledErrorEvent),
),
msg$,
)),
map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
);
export function bimap(io: WaveR, leftMap: FunctionN<[E1], E2>, rightMap: FunctionN<[A], B>): WaveR {
return foldExit(io,
(cause) => cause._tag === exit.ExitTag.Raise ? raiseError(leftMap(cause.error)) : completed(cause),
flow(rightMap, pure)
);
}
export function mapError(io: Wave, f: FunctionN<[E1], E2>): Wave {
return chainError(io, flow(f, raiseError));
}
Vault.config(vaultConfiguration)
await Vault.mountAuthTune()
} catch (e) {
logger.fatal(e, 'Error with Vault')
return
}
const encryptWithKey = encrypt(configuration.privateKeyEncryptionKey)
const decryptWithKey = decrypt(configuration.privateKeyEncryptionKey)
const decryptBackwardsCompatible = (plaintext: string) =>
plaintext.startsWith('vault')
? Vault.decrypt(plaintext)
: decryptWithKey(plaintext)
const encryptApiToken = flow(tokenObjectToToken, encryptWithKey, tokenToTokenObject)
const decryptApiTokens = async (tokens: ReadonlyArray): Promise> =>
Promise.all(tokens.map(tokenObjectToToken).map(decryptBackwardsCompatible)).then(tokensToTokenObjects)
const mongoClient = await MongoClient.connect(configuration.mongodbUrl)
const dbConnection = await mongoClient.db()
const accountCollection = dbConnection.collection('accounts')
const accounts = await accountCollection.find({}).toArray()
logger.info(
{ count: accounts.length, emails: accounts.map(_ => _.email) },
'Loaded all accounts.',
)
const decryptedAccounts = await Promise.all(accounts.map(async account => {
const mapLeft_: EffectMonad["mapLeft"] = (io, f) =>
chainError_(io, flow(f, raiseError));
export function map(
sink: Sink,
f: FunctionN<[B], C>
): Sink {
return {
...sink,
extract: flow(sink.extract, T.map(f))
};
}
export function map(base: Wave, f: FunctionN<[A], B>): Wave {
return chain(base, flow(f, pure));
}