@openstax/ts-utils 1.26.2 → 1.27.2

package/dist/esm/services/documentStore/versioned/dynamodb.js

@@ -3,135 +3,137 @@ import { once } from '../../..';
 import { resolveConfigValue } from '../../../config';
 import { ifDefined } from '../../../guards';
 import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
-const dynamodb = once(() => new DynamoDB({ apiVersion: '2012-08-10' }));
 // i'm not really excited about getAuthor being required, but ts is getting confused about the type when unspecified
-export const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
+export const dynamoVersionedDocumentStore = (initializer) => {
     const init = ifDefined(initializer, {});
-    const tableName = once(() => resolveConfigValue(configProvider[ifDefined(init.configSpace, 'dynamodb')].tableName));
-    return {
-        loadAllDocumentsTheBadWay: async () => {
-            const loadAllResults = async (ExclusiveStartKey) => {
-                var _a;
-                const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
-                const result = await dynamodb().send(cmd);
-                const resultItems = ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)) || [];
-                if (result.LastEvaluatedKey) {
-                    return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
-                }
-                return resultItems;
-            };
-            const allResults = await loadAllResults().then(results => results.reduce((result, document) => {
-                const current = result.get(document[hashKey]);
-                if (!current || current.timestamp < document.timestamp) {
-                    return result.set(document[hashKey], document);
-                }
-                return result;
-            }, new Map()));
-            return Array.from(allResults.values());
-        },
-        getVersions: async (id, startVersion) => {
-            const cmd = new QueryCommand({
-                TableName: await tableName(),
-                KeyConditionExpression: '#hk = :hkv',
-                ExpressionAttributeValues: {
-                    ':hkv': encodeDynamoAttribute(id)
-                },
-                ExpressionAttributeNames: {
+    const dynamodb = once(() => { var _a; return (_a = init.dynamoClient) !== null && _a !== void 0 ? _a : new DynamoDB({ apiVersion: '2012-08-10' }); });
+    return () => (configProvider) => (_, hashKey, options) => {
+        const tableName = once(() => resolveConfigValue(configProvider[ifDefined(init.configSpace, 'dynamodb')].tableName));
+        return {
+            loadAllDocumentsTheBadWay: async () => {
+                const loadAllResults = async (ExclusiveStartKey) => {
+                    var _a;
+                    const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                    const result = await dynamodb().send(cmd);
+                    const resultItems = ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)) || [];
+                    if (result.LastEvaluatedKey) {
+                        return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                    }
+                    return resultItems;
+                };
+                const allResults = await loadAllResults().then(results => results.reduce((result, document) => {
+                    const current = result.get(document[hashKey]);
+                    if (!current || current.timestamp < document.timestamp) {
+                        return result.set(document[hashKey], document);
+                    }
+                    return result;
+                }, new Map()));
+                return Array.from(allResults.values());
+            },
+            getVersions: async (id, startVersion) => {
+                const cmd = new QueryCommand({
+                    TableName: await tableName(),
+                    KeyConditionExpression: '#hk = :hkv',
+                    ExpressionAttributeValues: {
+                        ':hkv': encodeDynamoAttribute(id)
+                    },
+                    ExpressionAttributeNames: {
+                        '#hk': hashKey.toString()
+                    },
+                    ...(startVersion
+                        ? { ExclusiveStartKey: {
+                                [hashKey]: encodeDynamoAttribute(id),
+                                timestamp: { N: startVersion.toString() }
+                            } }
+                        : {}),
+                    ScanIndexForward: false,
+                });
+                return dynamodb().send(cmd).then(result => {
+                    var _a;
+                    const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument);
+                    if (!items || items.length === 0) {
+                        return undefined;
+                    }
+                    return {
+                        items,
+                        nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                    };
+                });
+            },
+            getItem: async (id, timestamp) => {
+                let keyConditionExpression = '#hk = :hkv';
+                const expressionAttributeNames = {
                     '#hk': hashKey.toString()
-                },
-                ...(startVersion
-                    ? { ExclusiveStartKey: {
-                            [hashKey]: encodeDynamoAttribute(id),
-                            timestamp: { N: startVersion.toString() }
-                        } }
-                    : {}),
-                ScanIndexForward: false,
-            });
-            return dynamodb().send(cmd).then(result => {
-                var _a;
-                const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument);
-                if (!items || items.length === 0) {
-                    return undefined;
+                };
+                const expressionAttributeValues = {
+                    ':hkv': encodeDynamoAttribute(id)
+                };
+                if (timestamp) {
+                    keyConditionExpression += ' and #ts = :tsv';
+                    expressionAttributeNames['#ts'] = 'timestamp';
+                    expressionAttributeValues[':tsv'] = encodeDynamoAttribute(timestamp);
                 }
+                const cmd = new QueryCommand({
+                    TableName: await tableName(),
+                    KeyConditionExpression: keyConditionExpression,
+                    ExpressionAttributeNames: expressionAttributeNames,
+                    ExpressionAttributeValues: expressionAttributeValues,
+                    ScanIndexForward: false,
+                    Limit: 1
+                });
+                return dynamodb().send(cmd).then(result => {
+                    var _a;
+                    return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
+                });
+            },
+            /* prepares a new version of a document with the given data, then allows some additional
+             * changes to be input to a `save` function that actually saves it. useful for additional
+             * changes based on the new document version or author. the document version and author
+             * cannot be modified */
+            prepareItem: async (item, ...authorArgs) => {
+                // this getAuthor type is terrible
+                const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
+                const timestamp = new Date().getTime();
                 return {
-                    items,
-                    nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                    document: { ...item, timestamp, author },
+                    save: async (changes) => {
+                        var _a;
+                        const document = {
+                            ...item,
+                            ...changes,
+                            timestamp,
+                            author
+                        };
+                        const cmd = new PutItemCommand({
+                            TableName: await tableName(),
+                            Item: encodeDynamoDocument(document),
+                        });
+                        const updatedDoc = await dynamodb().send(cmd)
+                            .then(() => document);
+                        await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
+                        return updatedDoc;
+                    }
                 };
-            });
-        },
-        getItem: async (id, timestamp) => {
-            let keyConditionExpression = '#hk = :hkv';
-            const expressionAttributeNames = {
-                '#hk': hashKey.toString()
-            };
-            const expressionAttributeValues = {
-                ':hkv': encodeDynamoAttribute(id)
-            };
-            if (timestamp) {
-                keyConditionExpression += ' and #ts = :tsv';
-                expressionAttributeNames['#ts'] = 'timestamp';
-                expressionAttributeValues[':tsv'] = encodeDynamoAttribute(timestamp);
-            }
-            const cmd = new QueryCommand({
-                TableName: await tableName(),
-                KeyConditionExpression: keyConditionExpression,
-                ExpressionAttributeNames: expressionAttributeNames,
-                ExpressionAttributeValues: expressionAttributeValues,
-                ScanIndexForward: false,
-                Limit: 1
-            });
-            return dynamodb().send(cmd).then(result => {
+            },
+            /* saves a new version of a document with the given data */
+            putItem: async (item, ...authorArgs) => {
                 var _a;
-                return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
-            });
-        },
-        /* prepares a new version of a document with the given data, then allows some additional
-         * changes to be input to a `save` function that actually saves it. useful for additional
-         * changes based on the new document version or author. the document version and author
-         * cannot be modified */
-        prepareItem: async (item, ...authorArgs) => {
-            // this getAuthor type is terrible
-            const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
-            const timestamp = new Date().getTime();
-            return {
-                document: { ...item, timestamp, author },
-                save: async (changes) => {
-                    var _a;
-                    const document = {
-                        ...item,
-                        ...changes,
-                        timestamp,
-                        author
-                    };
-                    const cmd = new PutItemCommand({
-                        TableName: await tableName(),
-                        Item: encodeDynamoDocument(document),
-                    });
-                    const updatedDoc = await dynamodb().send(cmd)
-                        .then(() => document);
-                    await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
-                    return updatedDoc;
-                }
-            };
-        },
-        /* saves a new version of a document with the given data */
-        putItem: async (item, ...authorArgs) => {
-            var _a;
-            // this getAuthor type is terrible
-            const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
-            const document = {
-                ...item,
-                timestamp: new Date().getTime(),
-                author
-            };
-            const cmd = new PutItemCommand({
-                TableName: await tableName(),
-                Item: encodeDynamoDocument(document),
-            });
-            const updatedDoc = await dynamodb().send(cmd)
-                .then(() => document);
-            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
-            return updatedDoc;
-        },
+                // this getAuthor type is terrible
+                const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
+                const document = {
+                    ...item,
+                    timestamp: new Date().getTime(),
+                    author
+                };
+                const cmd = new PutItemCommand({
+                    TableName: await tableName(),
+                    Item: encodeDynamoDocument(document),
+                });
+                const updatedDoc = await dynamodb().send(cmd)
+                    .then(() => document);
+                await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
+                return updatedDoc;
+            },
+        };
     };
 };

package/dist/esm/services/fileServer/s3FileServer.d.ts

@@ -7,7 +7,7 @@ export declare type Config = {
 };
 interface Initializer<C> {
     configSpace?: C;
-    s3Client?: typeof S3Client;
+    getS3Client?: (...args: ConstructorParameters<typeof S3Client>) => S3Client;
 }
 export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
     bucketName: import("../../config").ConfigValueProvider<string>;

package/dist/esm/services/fileServer/s3FileServer.js

@@ -9,8 +9,11 @@ export const s3FileServer = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
     const bucketName = once(() => resolveConfigValue(config.bucketName));
     const bucketRegion = once(() => resolveConfigValue(config.bucketRegion));
-    const client = ifDefined(initializer.s3Client, S3Client);
-    const s3Service = once(async () => new client({ apiVersion: '2012-08-10', region: await bucketRegion() }));
+    const s3Service = once(async () => {
+        var _a, _b;
+        const args = { apiVersion: '2012-08-10', region: await bucketRegion() };
+        return (_b = (_a = initializer.getS3Client) === null || _a === void 0 ? void 0 : _a.call(initializer, args)) !== null && _b !== void 0 ? _b : new S3Client(args);
+    });
     /*
      * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
      */

package/dist/esm/services/launchParams/verifier.js

@@ -4,11 +4,13 @@ import { memoize } from '../..';
 import { resolveConfigValue } from '../../config';
 import { InvalidRequestError, SessionExpiredError } from '../../errors';
 import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
 /**
  * Creates a class that can verify launch params
  */
 export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
     const config = configProvider[ifDefined(configSpace, 'launch')];
+    const getTrustedDomain = once(() => resolveConfigValue(config.trustedDomain));
     const getJwksClient = memoize((jwksUri) => new JwksClient({ fetcher, jwksUri }));
     const getJwksKey = memoize(async (jwksUri, kid) => {
         const client = getJwksClient(jwksUri);
@@ -24,7 +26,7 @@ export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvide
         try {
             const jwksUrl = new URL('/.well-known/jwks.json', iss);
             const launchDomain = jwksUrl.hostname;
-            const trustedDomain = await resolveConfigValue(config.trustedDomain);
+            const trustedDomain = await getTrustedDomain();
             if (launchDomain !== trustedDomain && !launchDomain.endsWith(`.${trustedDomain}`)) {
                 return callback(new Error(`Untrusted launch domain: "${launchDomain}"`));
             }

package/dist/esm/services/searchProvider/index.d.ts

@@ -1,13 +1,28 @@
 export declare type FieldType = string | string[] | number | boolean;
-export declare type Filter = {
-    key: string;
-    value: FieldType;
-} | {
+export declare type ESFilter = {
     terms: Record<string, FieldType>;
 } | {
     exists: {
         field: string;
     };
+} | {
+    nested: {
+        path: string;
+        query: Filter;
+    };
+} | {
+    bool: BoolFilter;
+};
+export declare type Filter = {
+    key: string;
+    value: FieldType;
+} | ESFilter;
+export declare type BoolFilter = {
+    must?: Filter[];
+    must_not?: Filter[];
+    should?: Filter[];
+    filter?: Filter[];
+    minimum_should_match?: number;
 };
 declare type Field = {
     key: string;
@@ -24,13 +39,17 @@ export interface IndexOptions<T> {
     body: T;
     id: string;
 }
+export declare type FieldMapping = {
+    type: 'keyword' | 'text' | 'boolean';
+} | {
+    type?: 'nested' | 'object';
+    properties: Record<string, FieldMapping>;
+};
+export declare type FieldMappings = Record<string, FieldMapping>;
 export interface SearchOptions {
     page?: number;
     query: string | undefined;
     fields: Field[];
-    /**
-     * @deprecated use `must` instead
-     */
     filter?: Filter[];
     must?: Filter[];
     must_not?: Filter[];

package/dist/esm/services/searchProvider/memorySearchTheBadWay.d.ts

@@ -1,9 +1,11 @@
-import { IndexOptions, SearchOptions } from '.';
-export declare const memorySearchTheBadWay: () => <T>({ store }: {
+import { FieldMappings, IndexOptions, SearchOptions } from '.';
+export declare type Config<T> = {
+    mappings: FieldMappings;
     store: {
         loadAllDocumentsTheBadWay: () => Promise<T[]>;
     };
-}) => {
+};
+export declare const memorySearchTheBadWay: () => <T>({ store, mappings }: Config<T>) => {
     deleteIndexIfExists: () => Promise<undefined>;
     ensureIndexCreated: () => Promise<undefined>;
     index: (_options: IndexOptions<T>) => Promise<undefined>;

package/dist/esm/services/searchProvider/memorySearchTheBadWay.js

@@ -9,16 +9,58 @@ var MatchType;
     MatchType[MatchType["MustNot"] = 1] = "MustNot";
     MatchType[MatchType["Should"] = 2] = "Should";
 })(MatchType || (MatchType = {}));
-const resolveField = (document, field) => field.split('.').reduce((result, key) => result[key], document);
-const matchExists = (exists, document) => {
-    const value = resolveField(document, exists.field);
+const resolveField = (context, field) => {
+    const path = field.startsWith(context.scope + '.')
+        ? field.slice(context.scope.length + 1)
+        : field;
+    return path.split('.').reduce((result, key) => {
+        if (result === undefined) {
+            throw new Error(`Key "${key}" not found in document resolving ${field}`);
+        }
+        return result[key];
+    }, context.document);
+};
+const getFieldDefinition = (context, field) => {
+    let current = context.fields;
+    const parts = field.split('.');
+    const head = parts.slice(0, -1);
+    const tail = parts[parts.length - 1];
+    for (const part of head) {
+        const currentDefinition = current[part];
+        if (!currentDefinition || !('properties' in currentDefinition)) {
+            throw new Error(`Field "${field}" not found in mappings`);
+        }
+        current = currentDefinition.properties;
+    }
+    if (!current[tail]) {
+        throw new Error(`Field "${field}" not found in mappings`);
+    }
+    return current[tail];
+};
+const getFieldType = (context, field) => {
+    const definition = getFieldDefinition(context, field);
+    return definition.type;
+};
+const matchNested = (context, nested) => {
+    const nestedPath = nested.path;
+    const nestedDocuments = resolveField(context, nestedPath);
+    if (!Array.isArray(nestedDocuments)) {
+        throw new InvalidRequestError(`Nested path "${nestedPath}" is not an array`);
+    }
+    return nestedDocuments.some(nestedDocument => matchClause({
+        ...context,
+        scope: nestedPath,
+        document: nestedDocument
+    }, nested.query));
+};
+const matchExists = (context, exists) => {
+    const value = resolveField(context, exists.field);
     return value !== undefined && value !== null;
 };
-const matchTerms = (options, terms, document) => {
-    const getFieldType = (field) => { var _a; return (_a = options.fields.find(f => f.key == field)) === null || _a === void 0 ? void 0 : _a.type; };
+const matchTerms = (context, terms) => {
     for (const key in terms) {
-        const docValues = coerceArray(resolveField(document, key));
-        const coerceValue = getFieldType(key) === 'boolean'
+        const docValues = coerceArray(resolveField(context, key));
+        const coerceValue = getFieldType(context, key) === 'boolean'
             ? (input) => {
                 if ([true, 'true', '1', 1].includes(input)) {
                     return true;
@@ -36,7 +78,50 @@ const matchTerms = (options, terms, document) => {
     }
     return true;
 };
-export const memorySearchTheBadWay = () => ({ store }) => {
+const matchClause = (context, clause) => {
+    const filter = ('key' in clause && 'value' in clause)
+        ? { terms: { [clause.key]: clause.value } }
+        : clause;
+    if ('terms' in filter)
+        return matchTerms(context, filter.terms);
+    else if ('exists' in filter)
+        return matchExists(context, filter.exists);
+    else if ('bool' in filter)
+        return matchBool(context, filter.bool);
+    else if ('nested' in filter)
+        return matchNested(context, filter.nested);
+    else
+        throw new InvalidRequestError('invalid filter type');
+};
+const matchFilters = (context, filters, matchType) => {
+    for (const field of filters) {
+        const hasMatch = matchClause(context, field);
+        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
+            return false;
+        }
+        else if (matchType === MatchType.Should && hasMatch) {
+            return true;
+        }
+    }
+    return matchType !== MatchType.Should;
+};
+const matchBool = (context, filters) => {
+    const { must_not, should, must, filter } = filters;
+    if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(context, must, MatchType.Must)) {
+        return false;
+    }
+    if ((filter === null || filter === void 0 ? void 0 : filter.length) && !matchFilters(context, filter, MatchType.Must)) {
+        return false;
+    }
+    if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(context, must_not, MatchType.MustNot)) {
+        return false;
+    }
+    if ((should === null || should === void 0 ? void 0 : should.length) && !matchFilters(context, should, MatchType.Should)) {
+        return false;
+    }
+    return true;
+};
+export const memorySearchTheBadWay = () => ({ store, mappings }) => {
     return {
         // This method is intentionally stubbed because index deletion is not applicable for in-memory storage.
         deleteIndexIfExists: async () => undefined,
@@ -47,33 +132,12 @@ export const memorySearchTheBadWay = () => ({ store }) => {
             const results = (await store.loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
-                const matchFilters = (filters, matchType) => {
-                    for (const field of filters) {
-                        const filter = ('key' in field && 'value' in field)
-                            ? { terms: { [field.key]: field.value } }
-                            : field;
-                        let hasMatch;
-                        if ('terms' in filter)
-                            hasMatch = matchTerms(options, filter.terms, document);
-                        else if ('exists' in filter)
-                            hasMatch = matchExists(filter.exists, document);
-                        else
-                            throw new InvalidRequestError('invalid filter type');
-                        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
-                            return false;
-                        }
-                        else if (matchType === MatchType.Should && hasMatch) {
-                            return true;
-                        }
-                    }
-                    return matchType !== MatchType.Should;
-                };
                 if (options.query !== undefined) {
                     for (const field of options.fields) {
                         if (field.type !== undefined && field.type !== 'text') {
                             continue;
                         }
-                        const value = resolveField(document, field.key);
+                        const value = resolveField({ document, fields: mappings, scope: '' }, field.key);
                         if (value === undefined || value === null) {
                             continue;
                         }
@@ -87,15 +151,7 @@ export const memorySearchTheBadWay = () => ({ store }) => {
                         }
                     }
                 }
-                const { must_not, should } = options;
-                const must = 'filter' in options ? options.filter : options.must;
-                if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(must, MatchType.Must)) {
-                    return undefined;
-                }
-                if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(must_not, MatchType.MustNot)) {
-                    return undefined;
-                }
-                if ((should === null || should === void 0 ? void 0 : should.length) && !matchFilters(should, MatchType.Should)) {
+                if (!matchBool({ document, fields: mappings, scope: '' }, options)) {
                     return undefined;
                 }
                 return { document, weight };
@@ -104,8 +160,8 @@ export const memorySearchTheBadWay = () => ({ store }) => {
                 .filter(r => !options.query || r.weight >= MIN_MATCH);
             results.sort((a, b) => {
                 for (const sort of (options.sort || [])) {
-                    const aValue = resolveField(a.document, sort.key);
-                    const bValue = resolveField(b.document, sort.key);
+                    const aValue = resolveField({ document: a.document, fields: mappings, scope: '' }, sort.key);
+                    const bValue = resolveField({ document: b.document, fields: mappings, scope: '' }, sort.key);
                     if (aValue < bValue) {
                         return sort.order === 'asc' ? -1 : 1;
                     }

package/dist/esm/services/searchProvider/openSearch.d.ts

@@ -1,5 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
-import { IndexOptions, SearchOptions } from '.';
+import { FieldMappings, IndexOptions, SearchOptions } from '.';
 export declare type Config = {
     node: string;
     region: string;
@@ -9,7 +9,7 @@ export interface Initializer<C> {
 }
 export declare type IndexConfig = {
     name: string;
-    mappings: Record<string, any>;
+    mappings: FieldMappings;
     pageSize?: number;
 };
 export declare const openSearchService: <C extends string = "deployed">(initializer?: Initializer<C>) => (configProvider: { [key in C]: {

package/dist/esm/services/searchProvider/openSearch.js

@@ -72,23 +72,27 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
             });
         };
         const search = async (options) => {
+            var _a;
             const body = {
                 query: { bool: {} },
                 track_total_hits: true,
                 size: pageSize
             };
             if (options.query) {
-                body.query.bool.must = {
-                    multi_match: {
-                        fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
-                        query: options.query
-                    }
-                };
+                body.query.bool.must = [{
+                        multi_match: {
+                            fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
+                            query: options.query
+                        }
+                    }];
+            }
+            const { must_not, should, must, filter } = options;
+            if (filter && filter.length > 0) {
+                body.query.bool.filter = filter.map(mapFilter);
             }
-            const { must_not, should } = options;
-            const must = 'filter' in options ? options.filter : options.must;
             if (must && must.length > 0) {
-                body.query.bool.filter = must.map(mapFilter);
+                (_a = body.query.bool).must || (_a.must = []);
+                body.query.bool.must = body.query.bool.must.concat(must.map(mapFilter));
             }
             if (must_not && must_not.length > 0) {
                 body.query.bool.must_not = must_not.map(mapFilter);