// @flow		// @flow

import invariant from 'invariant';		import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';

import blobService from '../facts/blob-service.js';
import {		import {
type AuthMetadata,		type AuthMetadata,
IdentityClientContext,		IdentityClientContext,
} from '../shared/identity-client-context.js';		} from '../shared/identity-client-context.js';
import type {		import type {
BlobHashAndHolder,		BlobHashAndHolder,
BlobOperation,		BlobOperation,
} from '../types/holder-types.js';		} from '../types/holder-types.js';
import { toBase64URL } from '../utils/base64.js';		import { toBase64URL } from '../utils/base64.js';
import {		import {
makeBlobServiceEndpointURL,
generateBlobHolder,		generateBlobHolder,
		assignMultipleHolders,
		removeMultipleHolders,
} from '../utils/blob-service.js';		} from '../utils/blob-service.js';
import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';		import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
import { useSelector } from '../utils/redux-utils.js';		import { useSelector } from '../utils/redux-utils.js';
import { createDefaultHTTPRequestHeaders } from '../utils/services-utils.js';		import { createDefaultHTTPRequestHeaders } from '../utils/services-utils.js';

type MultipleBlobHolders = $ReadOnlyArray<BlobHashAndHolder>;		type MultipleBlobHolders = $ReadOnlyArray<BlobHashAndHolder>;

export const storeEstablishedHolderActionType = 'STORE_ESTABLISHED_HOLDER';		export const storeEstablishedHolderActionType = 'STORE_ESTABLISHED_HOLDER';
Show All 18 Lines	export type ProcessHoldersFinishedPayload = {
+notRemoved: MultipleBlobHolders,		+notRemoved: MultipleBlobHolders,
};		};

type BlobServiceActionsResult = {		type BlobServiceActionsResult = {
+succeeded: MultipleBlobHolders,		+succeeded: MultipleBlobHolders,
+failed: MultipleBlobHolders,		+failed: MultipleBlobHolders,
};		};

// This function can be simplified when batch holders operations
// are implemented on Blob Service
async function performBlobServiceHolderActions(		async function performBlobServiceHolderActions(
action: 'establish' \| 'remove',		action: 'establish' \| 'remove',
inputs: MultipleBlobHolders,		inputs: MultipleBlobHolders,
authMetadata: AuthMetadata,		authMetadata: AuthMetadata,
): Promise<BlobServiceActionsResult> {		): Promise<BlobServiceActionsResult> {
if (inputs.length === 0) {		if (inputs.length === 0) {
return { succeeded: [], failed: [] };		return { succeeded: [], failed: [] };
}		}

const endpoint =
action === 'establish'
? blobService.httpEndpoints.ASSIGN_HOLDER
: blobService.httpEndpoints.DELETE_BLOB;
const endpointURL = makeBlobServiceEndpointURL(endpoint);
const defaultHeaders = createDefaultHTTPRequestHeaders(authMetadata);		const defaultHeaders = createDefaultHTTPRequestHeaders(authMetadata);
		const blobServiceCall =
		action === 'establish' ? assignMultipleHolders : removeMultipleHolders;

const promises = inputs.map(async input => {		const requestInputs = inputs.map(({ blobHash, ...rest }) => ({
const blobHash = toBase64URL(input.blobHash);		...rest,
try {		blobHash: toBase64URL(blobHash),
const response = await fetch(endpointURL, {		}));
method: endpoint.method,		const response = await blobServiceCall(requestInputs, defaultHeaders);
body: JSON.stringify({		if (response.result === 'success') {
holder: input.holder,		return { succeeded: inputs, failed: [] };
blob_hash: blobHash,		}
}),		if (response.result === 'error') {
headers: {		return { succeeded: [], failed: inputs };
...defaultHeaders,		}
'content-type': 'application/json',
},		const failedRequestsSet = new Set(
});		response.failedRequests.map(({ blobHash, holder }) =>
const holderAlreadyEstablishedResponse =		JSON.stringify({ blobHash, holder }),
action === 'establish' && response.status === 409;		),
if (response.ok \|\| holderAlreadyEstablishedResponse) {		);
return { ...input, success: true };
}
return { ...input, success: false };
} catch (e) {
return { ...input, success: false };
}
});

const results = await Promise.all(promises);
const succeeded = [],		const succeeded = [],
failed = [];		failed = [];
for (const { success, ...holderEntry } of results) {		for (const item of inputs) {
if (success) {		const stringifiedItem = JSON.stringify({
succeeded.push(holderEntry);		blobHash: toBase64URL(item.blobHash),
		holder: item.holder,
		});
		if (failedRequestsSet.has(stringifiedItem)) {
		failed.push(item);
} else {		} else {
failed.push(holderEntry);		succeeded.push(item);
}		}
}		}

return {		return { succeeded, failed };
succeeded,
failed,
};
}		}

async function processHoldersAction(		async function processHoldersAction(
input: ProcessHoldersStartedPayload,		input: ProcessHoldersStartedPayload,
authMetadata: AuthMetadata,		authMetadata: AuthMetadata,
): Promise<ProcessHoldersFinishedPayload> {		): Promise<ProcessHoldersFinishedPayload> {
const [		const [
{ succeeded: added, failed: notAdded },		{ succeeded: added, failed: notAdded },
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

[lib] Use response validators in multiple-holder callsClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 45089

lib/utils/blob-service.js

[lib] Use response validators in multiple-holder calls
ClosedPublic
Actions

Revision Contents
Changeset List