@sourcegraph/extensions-client-common/lib/controller.js

import { combineLatest, from, of, throwError } from 'rxjs';
import { catchError, filter, map, startWith, switchMap } from 'rxjs/operators';
import { asError, createAggregateError, isErrorLike } from './errors';
import { gql, graphQLContent } from './graphql';
import { parseJSONCOrError } from './util';
/**
 * A controller that exposes functionality for a configuration cascade and querying extensions from the remote
 * registry.
 */
export class Controller {
    constructor(context) {
        this.context = context;
        this.viewerConfiguredExtensionsOrLoading = from(this.context.configurationCascade).pipe(switchMap(cascade => isErrorLike(cascade.merged)
            ? [cascade.merged]
            : this.withRegistryMetadata(cascade).pipe(catchError(error => [asError(error)]), startWith(Controller.LOADING))));
        this.viewerConfiguredExtensions = this.viewerConfiguredExtensionsOrLoading.pipe(filter((extensions) => extensions !== Controller.LOADING), switchMap(extensions => (isErrorLike(extensions) ? throwError(extensions) : [extensions])));
    }
    forExtensionID(extensionID, registryExtensionFragment) {
        return from(this.context.queryGraphQL(gql `
                    query RegistryExtension($extensionID: String!) {
                        extensionRegistry {
                            extension(extensionID: $extensionID) {
                                ...RegistryExtensionFields
                            }
                        }
                    }
                    ${registryExtensionFragment}
                `[graphQLContent], { extensionID }))
            .pipe(map(({ data, errors }) => {
            if (!data || !data.extensionRegistry || !data.extensionRegistry.extension) {
                throw createAggregateError(errors);
            }
            return data.extensionRegistry.extension;
        }))
            .pipe(switchMap(registryExtension => this.withConfiguration(of([registryExtension]))), map(configuredExtensions => configuredExtensions[0]));
    }
    withRegistryMetadata(cascade) {
        if (isErrorLike(cascade.merged)) {
            return throwError(cascade.merged);
        }
        if (!cascade.merged || !cascade.merged.extensions) {
            return of([]);
        }
        const extensionIDs = Object.keys(cascade.merged.extensions);
        return from(this.context.queryGraphQL(gql `
                    query Extensions($first: Int!, $prioritizeExtensionIDs: [String!]!) {
                        extensionRegistry {
                            extensions(first: $first, prioritizeExtensionIDs: $prioritizeExtensionIDs) {
                                nodes {
                                    id
                                    extensionID
                                    url
                                    manifest {
                                        raw
                                    }
                                    viewerCanAdminister
                                }
                            }
                        }
                    }
                `[graphQLContent], {
            first: extensionIDs.length,
            prioritizeExtensionIDs: extensionIDs,
        })).pipe(map(({ data, errors }) => {
            if (!data ||
                !data.extensionRegistry ||
                !data.extensionRegistry.extensions ||
                !data.extensionRegistry.extensions.nodes) {
                throw createAggregateError(errors);
            }
            return data.extensionRegistry.extensions.nodes.map(({ id, extensionID, url, manifest, viewerCanAdminister }) => ({
                id,
                extensionID,
                url,
                manifest: manifest ? { raw: manifest.raw } : null,
                viewerCanAdminister,
            }));
        }), map(registryExtensions => {
            const configuredExtensions = [];
            for (const extensionID of extensionIDs) {
                const registryExtension = registryExtensions.find(x => x.extensionID === extensionID);
                configuredExtensions.push({
                    id: extensionID,
                    manifest: registryExtension && registryExtension.manifest
                        ? parseJSONCOrError(registryExtension.manifest.raw)
                        : null,
                    rawManifest: (registryExtension && registryExtension.manifest && registryExtension.manifest.raw) || null,
                    registryExtension,
                });
            }
            return configuredExtensions;
        }));
    }
    withConfiguration(registryExtensions) {
        return combineLatest(registryExtensions, this.context.configurationCascade).pipe(map(([registryExtensions, cascade]) => {
            const configuredExtensions = [];
            for (const registryExtension of registryExtensions) {
                configuredExtensions.push({
                    id: registryExtension.extensionID,
                    manifest: registryExtension.manifest
                        ? parseJSONCOrError(registryExtension.manifest.raw)
                        : null,
                    rawManifest: (registryExtension && registryExtension.manifest && registryExtension.manifest.raw) || null,
                    registryExtension,
                });
            }
            return configuredExtensions;
        }));
    }
}
Controller.LOADING = 'loading';
//# sourceMappingURL=controller.js.map