@rcsb/rcsb-saguaro-app 6.0.0-development.1 → 6.0.0-development.2

package/lib/RcsbRequest/RcsbRequestClient.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+import { SearchRequest } from "@rcsb/rcsb-api-tools/build/RcsbSearch/SearchRequest";
+export declare const rcsbRequestClient: {
+    borrego: GraphQLRequest;
+    yosemite: GraphQLRequest;
+    arches: SearchRequest;
+};

package/lib/RcsbRequest/RcsbRequestClient.js

@@ -0,0 +1,7 @@
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+import { SearchRequest } from "@rcsb/rcsb-api-tools/build/RcsbSearch/SearchRequest";
+export const rcsbRequestClient = {
+    borrego: new GraphQLRequest("1d-coordinates"),
+    yosemite: new GraphQLRequest("data-api"),
+    arches: new SearchRequest()
+};

package/lib/RcsbRequest/RcsbRequestContextManager.d.ts

@@ -0,0 +1,62 @@
+import { PolymerEntityInstanceTranslate } from "../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { EntryAssemblyTranslate } from "../RcsbUtils/Translators/EntryAssemblyTranslate";
+import { GroupPropertiesProvider } from "../RcsbUtils/Groups/GroupPropertiesProvider";
+import { QueryResult } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchResultInterface";
+import { InterfaceInstanceTranslate } from "../RcsbUtils/Translators/InterfaceInstanceTranslate";
+import { PolymerEntityChromosomeTranslate } from "../RcsbUtils/Translators/PolymerEntityChromosomeTranslate";
+import { QueryPolymer_Entity_GroupArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { EntryPropertyIntreface } from "../RcsbCollectTools/DataCollectors/MultipleEntryPropertyCollector";
+import { FacetType } from "../RcsbSeacrh/FacetStore/FacetMemberInterface";
+import { ReturnType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { ResultsContentType, SearchQuery } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchQueryInterface";
+import { RequestConfig as GraphqlRequestInit } from "graphql-request/src/types";
+import { PolymerEntityInterface } from "../RcsbCollectTools/DataCollectors/MultiplePolymerEntityCollector";
+import { InstanceSequenceInterface } from "../RcsbCollectTools/DataCollectors/MultipleInstanceSequencesCollector";
+import { SearchQueryType } from "@rcsb/rcsb-search-tools/lib/SearchQueryTools/SearchQueryInterfaces";
+declare class RcsbRequestContextManager {
+    private readonly polymerEntityToInstanceMap;
+    private readonly entryToAssemblyMap;
+    private readonly groupPropertyMap;
+    private readonly searchRequestMap;
+    private readonly interfaceToInstanceMap;
+    private readonly assemblyInterfacesMap;
+    private readonly entryPropertyMap;
+    private readonly entityPropertyMap;
+    private readonly instanceSequenceMap;
+    private readonly instanceCollector;
+    private readonly assemblyCollector;
+    private readonly entityChrCollector;
+    private readonly groupMemberCollector;
+    private readonly multipleEntryPropertyCollector;
+    private readonly interfaceCollector;
+    private readonly assemblyInterfacesCollector;
+    private readonly multipleEntityCollector;
+    private readonly multipleInstanceSequenceCollector;
+    readonly modelKey: string;
+    getEntityProperties(entityIds: string | Array<string>): Promise<Array<PolymerEntityInterface>>;
+    getEntryProperties(entryIds: string | Array<string>): Promise<Array<EntryPropertyIntreface>>;
+    getInstanceSequences(instanceIds: string | string[]): Promise<InstanceSequenceInterface[]>;
+    getEntityToInstance(entryId: string): Promise<PolymerEntityInstanceTranslate>;
+    getEntryToAssembly(entryId: string): Promise<EntryAssemblyTranslate>;
+    getEntityToChromosome(entityIds: Array<string>): Promise<PolymerEntityChromosomeTranslate>;
+    getGroupMemberProperties(groupQuery: QueryPolymer_Entity_GroupArgs): Promise<GroupPropertiesProvider>;
+    getSearchQuery(searchQuery: SearchQuery): Promise<QueryResult | null>;
+    getSearchQueryFacets(query: SearchQueryType, facets: FacetType[], returnType: ReturnType, resultsContentType: ResultsContentType): Promise<QueryResult | null>;
+    getInterfaceToInstance(interfaceId: string): Promise<InterfaceInstanceTranslate>;
+    private getAssemblyInterfaces;
+    initializeBorregoClient(config: {
+        api?: string;
+        requestConfig?: GraphqlRequestInit;
+    }): void;
+    initializeYosemiteClient(config: {
+        api?: string;
+        requestConfig?: GraphqlRequestInit;
+    }): void;
+    initializeArchesClient(config: {
+        uri?: string;
+        fetch?: (input: RequestInfo, requestConfig?: RequestInit) => Promise<Response>;
+        requestConfig?: RequestInit;
+    }): void;
+}
+export declare const rcsbRequestCtxManager: RcsbRequestContextManager;
+export {};

package/lib/RcsbRequest/RcsbRequestContextManager.js

@@ -0,0 +1,153 @@
+import { __awaiter } from "tslib";
+import { PolymerEntityInstanceTranslate } from "../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { EntryAssemblyTranslate } from "../RcsbUtils/Translators/EntryAssemblyTranslate";
+import { GroupPropertiesProvider } from "../RcsbUtils/Groups/GroupPropertiesProvider";
+import { InterfaceInstanceTranslate } from "../RcsbUtils/Translators/InterfaceInstanceTranslate";
+import { AssemblyInterfacesTranslate } from "../RcsbUtils/Translators/AssemblyInterfacesTranslate";
+import { PolymerEntityInstancesCollector } from "../RcsbCollectTools/DataCollectors/PolymerEntityInstancesCollector";
+import { EntryAssembliesCollector } from "../RcsbCollectTools/DataCollectors/EntryAssembliesCollector";
+import { PolymerEntityChromosomeTranslate } from "../RcsbUtils/Translators/PolymerEntityChromosomeTranslate";
+import { PolymerEntityChromosomeCollector } from "../RcsbCollectTools/DataCollectors/PolymerEntityChromosomeCollector";
+import { GroupMemberCollector } from "../RcsbCollectTools/DataCollectors/GroupMemberCollector";
+import { MultipleEntryPropertyCollector } from "../RcsbCollectTools/DataCollectors/MultipleEntryPropertyCollector";
+import { Operator } from "../RcsbUtils/Helpers/Operator";
+import { searchRequestProperty } from "../RcsbSeacrh/SearchRequestProperty";
+import { sha1 } from "object-hash";
+import { InterfaceInstanceCollector } from "../RcsbCollectTools/DataCollectors/InterfaceInstanceCollector";
+import { AssemblyInterfacesCollector } from "../RcsbCollectTools/DataCollectors/AssemblyInterfacesCollector";
+import { RcsbRequestTools as RRT } from "./RcsbRequestTools";
+import { rcsbRequestClient } from "./RcsbRequestClient";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+import { SearchRequest } from "@rcsb/rcsb-api-tools/build/RcsbSearch/SearchRequest";
+import { Assertions } from "../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+import { MultiplePolymerEntityCollector } from "../RcsbCollectTools/DataCollectors/MultiplePolymerEntityCollector";
+import { MultipleInstanceSequencesCollector } from "../RcsbCollectTools/DataCollectors/MultipleInstanceSequencesCollector";
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+class RcsbRequestContextManager {
+    constructor() {
+        this.polymerEntityToInstanceMap = new Map();
+        this.entryToAssemblyMap = new Map();
+        this.groupPropertyMap = new Map();
+        this.searchRequestMap = new Map();
+        this.interfaceToInstanceMap = new Map();
+        this.assemblyInterfacesMap = new Map();
+        this.entryPropertyMap = new Map();
+        this.entityPropertyMap = new Map();
+        this.instanceSequenceMap = new Map();
+        this.instanceCollector = new PolymerEntityInstancesCollector();
+        this.assemblyCollector = new EntryAssembliesCollector();
+        this.entityChrCollector = new PolymerEntityChromosomeCollector();
+        this.groupMemberCollector = new GroupMemberCollector();
+        this.multipleEntryPropertyCollector = new MultipleEntryPropertyCollector();
+        this.interfaceCollector = new InterfaceInstanceCollector();
+        this.assemblyInterfacesCollector = new AssemblyInterfacesCollector();
+        this.multipleEntityCollector = new MultiplePolymerEntityCollector();
+        this.multipleInstanceSequenceCollector = new MultipleInstanceSequencesCollector();
+        this.modelKey = EntryAssembliesCollector.modelKey;
+    }
+    getEntityProperties(entityIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RRT.getMultipleObjectProperties(entityIds, this.entityPropertyMap, this.multipleEntityCollector, "entity_ids", (e) => (e.entryId + TagDelimiter.entity + e.entityId));
+        });
+    }
+    getEntryProperties(entryIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RRT.getMultipleObjectProperties(entryIds, this.entryPropertyMap, this.multipleEntryPropertyCollector, "entry_ids", (e) => (e.entryId));
+        });
+    }
+    getInstanceSequences(instanceIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RRT.getMultipleObjectProperties(instanceIds, this.instanceSequenceMap, this.multipleInstanceSequenceCollector, "instance_ids", (e) => (e.rcsbId));
+        });
+    }
+    getEntityToInstance(entryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = entryId.toUpperCase();
+            return RRT.getSingleObjectData(key, this.polymerEntityToInstanceMap, () => __awaiter(this, void 0, void 0, function* () { return (new PolymerEntityInstanceTranslate(yield this.instanceCollector.collect({ entry_id: key }))); }));
+        });
+    }
+    getEntryToAssembly(entryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RRT.getSingleObjectData(entryId, this.entryToAssemblyMap, () => __awaiter(this, void 0, void 0, function* () {
+                const result = yield this.assemblyCollector.collect({ entry_id: entryId });
+                const eti = this.polymerEntityToInstanceMap.get(entryId);
+                const etit = result.get(this.modelKey);
+                assertDefined(eti), assertDefined(etit);
+                return new EntryAssemblyTranslate(result);
+            }));
+        });
+    }
+    getEntityToChromosome(entityIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chrMap = yield this.entityChrCollector.collect(entityIds);
+            return new PolymerEntityChromosomeTranslate(chrMap);
+        });
+    }
+    getGroupMemberProperties(groupQuery) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const groupId = groupQuery.group_id.toUpperCase();
+            return RRT.getSingleObjectData(groupId, this.groupPropertyMap, () => __awaiter(this, void 0, void 0, function* () {
+                const result = yield this.groupMemberCollector.collect(groupQuery);
+                const entriesProperties = yield this.multipleEntryPropertyCollector.collect({ entry_ids: Operator.uniqueValues(result.map(r => r.entryId)) });
+                return new GroupPropertiesProvider({ entryProperties: entriesProperties });
+            }));
+        });
+    }
+    getSearchQuery(searchQuery) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = sha1(searchQuery);
+            return RRT.getSingleObjectData(key, this.searchRequestMap, () => __awaiter(this, void 0, void 0, function* () { return (yield searchRequestProperty.request(searchQuery)); }));
+        });
+    }
+    getSearchQueryFacets(query, facets, returnType, resultsContentType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = sha1(query) + "." + sha1(facets);
+            return RRT.getSingleObjectData(key, this.searchRequestMap, () => __awaiter(this, void 0, void 0, function* () { return (yield searchRequestProperty.requestFacets(query, facets, returnType, resultsContentType)); }));
+        });
+    }
+    getInterfaceToInstance(interfaceId) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = interfaceId;
+            const assemblyId = interfaceId.split(TagDelimiter.instance)[0];
+            if (this.interfaceToInstanceMap.get(key)) {
+                const d = this.interfaceToInstanceMap.get(key);
+                assertDefined(d);
+                return d;
+            }
+            else {
+                const assemblyInterfaces = yield this.getAssemblyInterfaces(assemblyId);
+                const interfaceIds = assemblyInterfaces.getInterfaces(assemblyId);
+                const result = interfaceIds ? yield this.interfaceCollector.collect({ interface_ids: interfaceIds }) : [];
+                const translator = new InterfaceInstanceTranslate(result);
+                if (((_a = assemblyInterfaces.getInterfaces(assemblyId)) === null || _a === void 0 ? void 0 : _a.length) == 0) {
+                    this.interfaceToInstanceMap.set(key, new Promise(resolve => resolve(translator)));
+                }
+                ((_b = assemblyInterfaces.getInterfaces(assemblyId)) !== null && _b !== void 0 ? _b : []).filter(id => !this.interfaceToInstanceMap.has(id)).forEach(id => {
+                    this.interfaceToInstanceMap.set(id, new Promise(resolve => resolve(translator)));
+                });
+                return translator;
+            }
+        });
+    }
+    getAssemblyInterfaces(assemblyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RRT.getSingleObjectData(assemblyId, this.assemblyInterfacesMap, () => __awaiter(this, void 0, void 0, function* () {
+                return (new AssemblyInterfacesTranslate(yield this.assemblyInterfacesCollector.collect({ assembly_ids: [assemblyId] })));
+            }));
+        });
+    }
+    initializeBorregoClient(config) {
+        var _a;
+        rcsbRequestClient.borrego = new GraphQLRequest((_a = config.api) !== null && _a !== void 0 ? _a : "1d-coordinates", config.requestConfig);
+    }
+    initializeYosemiteClient(config) {
+        var _a;
+        rcsbRequestClient.yosemite = new GraphQLRequest((_a = config.api) !== null && _a !== void 0 ? _a : "data-api", config.requestConfig);
+    }
+    initializeArchesClient(config) {
+        rcsbRequestClient.arches = new SearchRequest(config.uri, config.fetch, config.requestConfig);
+    }
+}
+export const rcsbRequestCtxManager = new RcsbRequestContextManager();

package/lib/RcsbRequest/RcsbRequestTools.d.ts

@@ -0,0 +1,5 @@
+import { MultipleDocumentPropertyCollectorInterface } from "../RcsbCollectTools/DataCollectors/DataCollectorInterface";
+export declare namespace RcsbRequestTools {
+    function getSingleObjectData<T>(id: string, map: Map<string, Promise<T>>, collector: () => Promise<T>): Promise<T>;
+    function getMultipleObjectProperties<K extends string, T>(ids: string | Array<string>, map: Map<string, Promise<T>>, collector: MultipleDocumentPropertyCollectorInterface<K, T>, collectorKey: K, propertyKey: (e: T) => string): Promise<Array<T>>;
+}

package/lib/RcsbRequest/RcsbRequestTools.js

@@ -0,0 +1,36 @@
+import { __awaiter } from "tslib";
+export var RcsbRequestTools;
+(function (RcsbRequestTools) {
+    function getSingleObjectData(id, map, collector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promise = map.get(id);
+            if (promise)
+                return promise;
+            const t = collector();
+            map.set(id, t);
+            return t;
+        });
+    }
+    RcsbRequestTools.getSingleObjectData = getSingleObjectData;
+    function getMultipleObjectProperties(ids, map, collector, collectorKey, propertyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Array.isArray(ids))
+                ids = [ids];
+            const missing = ids.filter(id => !map.has(id));
+            const collectorPromise = collector.collect({ [collectorKey]: missing });
+            missing.forEach(id => {
+                map.set(id, new Promise((resolve, reject) => {
+                    collectorPromise.then(t => {
+                        const d = t.find(t => propertyKey(t) == id);
+                        if (d)
+                            resolve(d);
+                        else
+                            reject(`${id} not available`);
+                    });
+                }));
+            });
+            return Promise.all(ids.map(i => map.get(i)).filter((x) => typeof x !== undefined));
+        });
+    }
+    RcsbRequestTools.getMultipleObjectProperties = getMultipleObjectProperties;
+})(RcsbRequestTools || (RcsbRequestTools = {}));

package/lib/RcsbSeacrh/FacetStore/DepositionGroupFacetStore.d.ts

@@ -0,0 +1,15 @@
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { FacetMemberInterface } from "./FacetMemberInterface";
+import { FacetStoreInterface } from "./FacetStoreInterface";
+declare class DepositionGroupFacetStore implements FacetStoreInterface {
+    private readonly entryFacet;
+    private readonly instanceFacet;
+    private readonly entityFacet;
+    private readonly nonPolymerFacet;
+    getServices(): (Service.Text | Service.TextChem)[];
+    getFacetService(service: Service | "all"): FacetMemberInterface[];
+    readonly facetLayoutGrid: string[];
+    readonly returnType: ReturnType;
+}
+export declare const depositionGroupFacetStore: DepositionGroupFacetStore;
+export {};

package/lib/RcsbSeacrh/FacetStore/DepositionGroupFacetStore.js

@@ -0,0 +1,57 @@
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { RcsbSearchMetadata } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+import { CHEM_COMP_FACET, ENTITY_NAME_FACET, EXPERIMENTAL_METHOD_FACET, LIGAND_FACET, ORGANISM_FACET, PFAM_FACET, RELEASE_DATE_FACET, RESOLUTION_FACET, SCOP_FACET, TAXONOMY_FACET, CATH_FACET, ECOD_FACET, ENZYME_CLASS_FACET, GO_FUNCTION_FACET, GO_PROCESS_FACET, GO_COMPONENT_FACET, LIGAND_OF_INTEREST_FACET } from "./SingleFacets";
+import { cloneDeep } from "lodash";
+class DepositionGroupFacetStore {
+    constructor() {
+        this.entryFacet = [
+            cloneDeep(EXPERIMENTAL_METHOD_FACET),
+            cloneDeep(RESOLUTION_FACET),
+            cloneDeep(RELEASE_DATE_FACET),
+            cloneDeep(ENZYME_CLASS_FACET)
+        ];
+        this.instanceFacet = [
+            cloneDeep(SCOP_FACET),
+            cloneDeep(CATH_FACET),
+            cloneDeep(ECOD_FACET),
+            cloneDeep(LIGAND_FACET),
+            cloneDeep(LIGAND_OF_INTEREST_FACET)
+        ];
+        this.entityFacet = [
+            cloneDeep(ORGANISM_FACET),
+            cloneDeep(TAXONOMY_FACET),
+            cloneDeep(PFAM_FACET),
+            cloneDeep(ENTITY_NAME_FACET),
+            cloneDeep(GO_FUNCTION_FACET),
+            cloneDeep(GO_PROCESS_FACET),
+            cloneDeep(GO_COMPONENT_FACET)
+        ];
+        this.nonPolymerFacet = [
+            cloneDeep(CHEM_COMP_FACET)
+        ];
+        this.facetLayoutGrid = [
+            RcsbSearchMetadata.RcsbAccessionInfo.DepositDate.path,
+            RcsbSearchMetadata.RcsbEntryInfo.ResolutionCombined.path, RcsbSearchMetadata.Exptl.Method.path,
+            RcsbSearchMetadata.ChemComp.Type.path,
+            RcsbSearchMetadata.RcsbEntitySourceOrganism.NcbiScientificName.path, RcsbSearchMetadata.RcsbEntitySourceOrganism.NcbiParentScientificName.path,
+            RcsbSearchMetadata.RcsbPolymerEntityAnnotation.Name.path, RcsbSearchMetadata.RcsbPolymerInstanceAnnotation.AnnotationLineage.Name.path
+        ];
+        this.returnType = ReturnType.PolymerEntity;
+    }
+    getServices() {
+        return [Service.Text];
+    }
+    getFacetService(service) {
+        switch (service) {
+            case Service.Text:
+                return this.entryFacet.concat(this.instanceFacet).concat(this.entityFacet);
+            case Service.TextChem:
+                return this.nonPolymerFacet;
+            case "all":
+                return this.entryFacet.concat(this.instanceFacet).concat(this.entityFacet).concat(this.nonPolymerFacet);
+            default:
+                return [];
+        }
+    }
+}
+export const depositionGroupFacetStore = new DepositionGroupFacetStore();

package/lib/RcsbSeacrh/FacetStore/EntityGranularitySearchFacetStore.d.ts

@@ -0,0 +1,15 @@
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { FacetMemberInterface } from "./FacetMemberInterface";
+import { FacetStoreInterface } from "./FacetStoreInterface";
+declare class EntityGranularitySearchFacetStore implements FacetStoreInterface {
+    private readonly entryFacet;
+    private readonly instanceFacet;
+    private readonly entityFacet;
+    private readonly nonPolymerFacet;
+    getServices(): (Service.Text | Service.TextChem)[];
+    getFacetService(service: Service | "all"): FacetMemberInterface[];
+    readonly facetLayoutGrid: string[];
+    readonly returnType: ReturnType;
+}
+export declare const entityGranularityGroupFacetStore: EntityGranularitySearchFacetStore;
+export {};

package/lib/RcsbSeacrh/FacetStore/EntityGranularitySearchFacetStore.js

@@ -0,0 +1,34 @@
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { RcsbSearchMetadata } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+import { CATH_FACET, CHEM_COMP_FACET, RELEASE_DATE_FACET, ECOD_FACET, ENTITY_NAME_FACET, EXPERIMENTAL_METHOD_FACET, LIGAND_FACET, ORGANISM_FACET, PFAM_FACET, RESOLUTION_FACET, SCOP_FACET, TAXONOMY_FACET } from "./SingleFacets";
+import { cloneDeep } from "lodash";
+class EntityGranularitySearchFacetStore {
+    constructor() {
+        this.entryFacet = [cloneDeep(EXPERIMENTAL_METHOD_FACET), cloneDeep(RESOLUTION_FACET), cloneDeep(RELEASE_DATE_FACET)];
+        this.instanceFacet = [cloneDeep(SCOP_FACET), cloneDeep(CATH_FACET), cloneDeep(ECOD_FACET), cloneDeep(LIGAND_FACET)];
+        this.entityFacet = [cloneDeep(ORGANISM_FACET), cloneDeep(TAXONOMY_FACET), cloneDeep(PFAM_FACET), cloneDeep(ENTITY_NAME_FACET)];
+        this.nonPolymerFacet = [cloneDeep(CHEM_COMP_FACET)];
+        this.facetLayoutGrid = [
+            RcsbSearchMetadata.RcsbEntryInfo.DiffrnResolutionHigh.Value.path,
+            RcsbSearchMetadata.RcsbEntitySourceOrganism.NcbiScientificName.path, RcsbSearchMetadata.RcsbEntitySourceOrganism.NcbiParentScientificName.path,
+            RcsbSearchMetadata.Exptl.Method.path, RcsbSearchMetadata.RcsbPolymerInstanceAnnotation.AnnotationLineage.Name.path
+        ];
+        this.returnType = ReturnType.PolymerEntity;
+    }
+    getServices() {
+        return [Service.Text, Service.TextChem];
+    }
+    getFacetService(service) {
+        switch (service) {
+            case Service.Text:
+                return this.entryFacet.concat(this.instanceFacet).concat(this.entityFacet);
+            case Service.TextChem:
+                return this.nonPolymerFacet;
+            case "all":
+                return this.entryFacet.concat(this.instanceFacet).concat(this.entityFacet).concat(this.nonPolymerFacet);
+            default:
+                return [];
+        }
+    }
+}
+export const entityGranularityGroupFacetStore = new EntityGranularitySearchFacetStore();

package/lib/RcsbSeacrh/FacetStore/FacetMemberInterface.d.ts

@@ -0,0 +1,16 @@
+import { ChartConfigInterface, ChartType } from "@rcsb/rcsb-charts/lib/RcsbChartComponent/ChartConfigInterface";
+import { AttributeFacetType, FilterFacetType } from "@rcsb/rcsb-search-tools/lib/SearchParseTools/SearchFacetInterface";
+import { RcsbSearchAttributeType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+export type FacetType = AttributeFacetType | FilterFacetType;
+export interface FacetMemberInterface {
+    id: string;
+    title?: string;
+    attributeName: string;
+    attribute: RcsbSearchAttributeType;
+    chartType: ChartType;
+    chartConfig?: ChartConfigInterface & {
+        mergeDomainMaxValue?: number;
+    };
+    facet: FacetType;
+    contentType: "date" | "number" | "string";
+}

package/lib/RcsbSeacrh/FacetStore/FacetMemberInterface.js

@@ -0,0 +1 @@
+export {};

package/lib/RcsbSeacrh/FacetStore/FacetStoreInterface.d.ts

@@ -0,0 +1,8 @@
+import { FacetMemberInterface } from "./FacetMemberInterface";
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+export interface FacetStoreInterface {
+    getServices(): (Service.Text | Service.TextChem)[];
+    getFacetService(service: Service | "all"): FacetMemberInterface[];
+    readonly facetLayoutGrid: string[];
+    readonly returnType: ReturnType;
+}

package/lib/RcsbSeacrh/FacetStore/FacetStoreInterface.js

@@ -0,0 +1 @@
+export {};

package/lib/RcsbSeacrh/FacetStore/SequenceGroupFacetStore.d.ts

@@ -0,0 +1,15 @@
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { FacetMemberInterface } from "./FacetMemberInterface";
+import { FacetStoreInterface } from "./FacetStoreInterface";
+declare class SequenceGroupFacetStore implements FacetStoreInterface {
+    private readonly entryFacet;
+    private readonly instanceFacet;
+    private readonly entityFacet;
+    private readonly nonPolymerFacet;
+    getServices(): (Service.Text | Service.TextChem)[];
+    getFacetService(service: Service | "all"): FacetMemberInterface[];
+    readonly facetLayoutGrid: string[];
+    readonly returnType: ReturnType;
+}
+export declare const sequenceGroupFacetStore: SequenceGroupFacetStore;
+export {};

package/lib/RcsbSeacrh/FacetStore/SequenceGroupFacetStore.js

@@ -0,0 +1,57 @@
+import { ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { RcsbSearchMetadata } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+import { CHEM_COMP_FACET, ENTITY_NAME_FACET, EXPERIMENTAL_METHOD_FACET, LIGAND_FACET, ORGANISM_FACET, PFAM_FACET, RELEASE_DATE_FACET, RESOLUTION_FACET, SCOP_FACET, TAXONOMY_FACET, CATH_FACET, ECOD_FACET, ENZYME_CLASS_FACET, GO_FUNCTION_FACET, GO_PROCESS_FACET, GO_COMPONENT_FACET, METHODOLOGY_FACET } from "./SingleFacets";
+import { cloneDeep } from "lodash";
+class SequenceGroupFacetStore {
+    constructor() {
+        this.entryFacet = [
+            cloneDeep(EXPERIMENTAL_METHOD_FACET),
+            cloneDeep(RESOLUTION_FACET),
+            cloneDeep(METHODOLOGY_FACET),
+            cloneDeep(RELEASE_DATE_FACET),
+            cloneDeep(ENZYME_CLASS_FACET)
+        ];
+        this.instanceFacet = [
+            cloneDeep(SCOP_FACET),
+            cloneDeep(CATH_FACET),
+            cloneDeep(ECOD_FACET),
+            cloneDeep(LIGAND_FACET)
+        ];
+        this.entityFacet = [
+            cloneDeep(ORGANISM_FACET),
+            cloneDeep(TAXONOMY_FACET),
+            cloneDeep(PFAM_FACET),
+            cloneDeep(ENTITY_NAME_FACET),
+            cloneDeep(GO_FUNCTION_FACET),
+            cloneDeep(GO_PROCESS_FACET),
+            cloneDeep(GO_COMPONENT_FACET)
+        ];
+        this.nonPolymerFacet = [
+            cloneDeep(CHEM_COMP_FACET)
+        ];
+        this.facetLayoutGrid = [
+            RcsbSearchMetadata.RcsbAccessionInfo.DepositDate.path,
+            RcsbSearchMetadata.RcsbEntryInfo.ResolutionCombined.path, RcsbSearchMetadata.Exptl.Method.path, RcsbSearchMetadata.RcsbEntryInfo.StructureDeterminationMethodology.path,
+            RcsbSearchMetadata.ChemComp.Type.path,
+            RcsbSearchMetadata.RcsbEntitySourceOrganism.NcbiScientificName.path, RcsbSearchMetadata.RcsbEntitySourceOrganism.NcbiParentScientificName.path,
+            RcsbSearchMetadata.RcsbPolymerEntityAnnotation.Name.path, RcsbSearchMetadata.RcsbPolymerInstanceAnnotation.AnnotationLineage.Name.path
+        ];
+        this.returnType = ReturnType.PolymerEntity;
+    }
+    getServices() {
+        return [Service.Text];
+    }
+    getFacetService(service) {
+        switch (service) {
+            case Service.Text:
+                return this.entryFacet.concat(this.instanceFacet).concat(this.entityFacet);
+            case Service.TextChem:
+                return this.nonPolymerFacet;
+            case "all":
+                return this.entryFacet.concat(this.instanceFacet).concat(this.entityFacet).concat(this.nonPolymerFacet);
+            default:
+                return [];
+        }
+    }
+}
+export const sequenceGroupFacetStore = new SequenceGroupFacetStore();

package/lib/RcsbSeacrh/FacetStore/SingleFacets.d.ts

@@ -0,0 +1,39 @@
+import { FacetMemberInterface } from "./FacetMemberInterface";
+export declare const EXPERIMENTAL_METHOD_FACET: FacetMemberInterface;
+export declare const RESOLUTION_FACET: FacetMemberInterface;
+export declare const METHODOLOGY_FACET: FacetMemberInterface;
+export declare const RELEASE_DATE_FACET: FacetMemberInterface;
+export declare const SCOP_FACET: FacetMemberInterface;
+export declare const CATH_FACET: FacetMemberInterface;
+export declare const ECOD_FACET: FacetMemberInterface;
+export declare const LIGAND_FACET: FacetMemberInterface;
+export declare const LIGAND_OF_INTEREST_FACET: FacetMemberInterface;
+export declare const ORGANISM_FACET: FacetMemberInterface;
+export declare const TAXONOMY_FACET: FacetMemberInterface;
+export declare const PFAM_FACET: FacetMemberInterface;
+export declare const ENTITY_NAME_FACET: FacetMemberInterface;
+export declare const CHEM_COMP_FACET: FacetMemberInterface;
+export declare const ENZYME_CLASS_FACET: FacetMemberInterface;
+export declare const GO_FUNCTION_FACET: FacetMemberInterface;
+export declare const GO_PROCESS_FACET: FacetMemberInterface;
+export declare const GO_COMPONENT_FACET: FacetMemberInterface;
+export declare const SearchFacets: {
+    EXPERIMENTAL_METHOD_FACET: FacetMemberInterface;
+    RESOLUTION_FACET: FacetMemberInterface;
+    RELEASE_DATE_FACET: FacetMemberInterface;
+    SCOP_FACET: FacetMemberInterface;
+    LIGAND_FACET: FacetMemberInterface;
+    ORGANISM_FACET: FacetMemberInterface;
+    TAXONOMY_FACET: FacetMemberInterface;
+    PFAM_FACET: FacetMemberInterface;
+    ENTITY_NAME_FACET: FacetMemberInterface;
+    CHEM_COMP_FACET: FacetMemberInterface;
+    ECOD_FACET: FacetMemberInterface;
+    CATH_FACET: FacetMemberInterface;
+    ENZYME_CLASS_FACET: FacetMemberInterface;
+    GO_FUNCTION_FACET: FacetMemberInterface;
+    GO_PROCESS_FACET: FacetMemberInterface;
+    GO_COMPONENT_FACET: FacetMemberInterface;
+    LIGAND_OF_INTEREST_FACET: FacetMemberInterface;
+    METHODOLOGY_FACET: FacetMemberInterface;
+};