@openstax/ts-utils 1.25.5 → 1.26.2

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

@@ -50,11 +50,12 @@ export declare const loadResponse: (response: Response) => () => Promise<any>;
 interface MakeApiGateway<F> {
     <Ru>(config: ConfigProviderForConfig<{
         apiBase: string;
-    }>, routes: MapRoutesToConfig<Ru>, appProvider?: {
+    }>, routes: MapRoutesToConfig<Ru>, app?: {
         authProvider?: {
             getAuthorizedFetchConfig: () => Promise<ConfigForFetch<F>>;
         };
         logger?: Logger;
+        launchToken?: string;
     }): MapRoutesToClient<Ru>;
 }
 export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, Response>>(initializer: {

package/dist/esm/services/apiGateway/index.js

@@ -18,7 +18,7 @@ export const loadResponse = (response) => () => {
             throw new Error(`unknown content type ${contentType}`);
     }
 };
-const makeRouteClient = (initializer, config, route, appProvider) => {
+const makeRouteClient = (initializer, config, route, app) => {
     /* TODO this duplicates code with makeRenderRouteUrl, reuse that */
     const renderUrl = async ({ params, query }) => {
         const apiBase = await resolveConfigValue(config.apiBase);
@@ -31,9 +31,9 @@ const makeRouteClient = (initializer, config, route, appProvider) => {
         const { fetch } = initializer;
         const url = await renderUrl({ params, query });
         const body = payload ? JSON.stringify(payload) : undefined;
-        const baseOptions = merge((await ((_a = appProvider === null || appProvider === void 0 ? void 0 : appProvider.authProvider) === null || _a === void 0 ? void 0 : _a.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
+        const baseOptions = merge((await ((_a = app === null || app === void 0 ? void 0 : app.authProvider) === null || _a === void 0 ? void 0 : _a.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
         const requestId = uuid();
-        const requestLogger = (_b = appProvider === null || appProvider === void 0 ? void 0 : appProvider.logger) === null || _b === void 0 ? void 0 : _b.createSubContext();
+        const requestLogger = (_b = app === null || app === void 0 ? void 0 : app.logger) === null || _b === void 0 ? void 0 : _b.createSubContext();
         requestLogger === null || requestLogger === void 0 ? void 0 : requestLogger.setContext({ requestId, url, timeStamp: new Date().getTime() });
         const fetcher = fetchStatusRetry(fetch, { retries: 1, status: [502], logger: requestLogger });
         requestLogger === null || requestLogger === void 0 ? void 0 : requestLogger.log('Request Initiated', Level.Info);
@@ -43,7 +43,10 @@ const makeRouteClient = (initializer, config, route, appProvider) => {
             headers: {
                 ...fetchConfig === null || fetchConfig === void 0 ? void 0 : fetchConfig.headers,
                 ...(body ? { 'content-type': 'application/json' } : {}),
-                'X-Request-ID': requestId,
+                'x-request-id': requestId,
+                ...((app === null || app === void 0 ? void 0 : app.launchToken) ? {
+                    'x-launch-token': app.launchToken,
+                } : {}),
             }
         })).then(response => {
             if (response.status === 401) {
@@ -68,7 +71,7 @@ const makeRouteClient = (initializer, config, route, appProvider) => {
     routeClient.renderUrl = renderUrl;
     return routeClient;
 };
-export const createApiGateway = (initializer) => (config, routes, appProvider) => {
+export const createApiGateway = (initializer) => (config, routes, app) => {
     return Object.fromEntries(Object.entries(routes)
-        .map(([key, routeConfig]) => ([key, makeRouteClient(initializer, config, routeConfig, appProvider)])));
+        .map(([key, routeConfig]) => ([key, makeRouteClient(initializer, config, routeConfig, app)])));
 };

package/dist/esm/services/launchParams/verifier.d.ts

@@ -15,8 +15,8 @@ interface Initializer<C> {
  */
 export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [key in C]: {
     trustedDomain: import("../../config").ConfigValueProvider<string>;
-}; }) => {
-    verify: <T = undefined>(...[token, validator]: T extends undefined ? [string] : [string, (input: any) => T]) => Promise<T extends undefined ? jwt.JwtPayload : T>;
+}; }) => (_services: {}, getDefaultToken?: (() => string) | undefined) => {
+    verify: <T = undefined>(...args: T extends undefined ? [] | [string] : [(input: any) => T] | [string, (input: any) => T]) => Promise<T extends undefined ? jwt.JwtPayload : T>;
 };
-export declare type LaunchVerifier = ReturnType<ReturnType<typeof createLaunchVerifier>>;
+export declare type LaunchVerifier = ReturnType<ReturnType<ReturnType<typeof createLaunchVerifier>>>;
 export {};

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

@@ -2,7 +2,7 @@ import jwt, { TokenExpiredError } from 'jsonwebtoken';
 import { JwksClient } from 'jwks-rsa';
 import { memoize } from '../..';
 import { resolveConfigValue } from '../../config';
-import { SessionExpiredError } from '../../errors';
+import { InvalidRequestError, SessionExpiredError } from '../../errors';
 import { ifDefined } from '../../guards';
 /**
  * Creates a class that can verify launch params
@@ -34,34 +34,49 @@ export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvide
             callback(error);
         }
     };
-    const verify = (...[token, validator]) => new Promise((resolve, reject) => jwt.verify(token, getKey, {}, (err, payload) => {
-        if (err && err instanceof TokenExpiredError) {
-            reject(new SessionExpiredError());
-        }
-        else if (err) {
-            reject(err);
-        }
-        else if (typeof payload !== 'object') {
-            reject(new Error('received JWT token with unexpected non-JSON payload'));
-        }
-        else if (!payload.sub) {
-            reject(new Error('JWT payload missing sub claim'));
-        }
-        else {
-            // we are migrating away from json encoding all the parameters into the `sub` claim
-            // and into using separate claims for each parameter. in transition, we check if the sub
-            // is json and return it if it is. this is still a breaking change when using this
-            // utility because applications no longer need to independently json parse the result
-            // starting now.
-            const parsed = payload;
-            try {
-                const jsonSubContents = JSON.parse(payload.sub);
-                Object.assign(parsed, jsonSubContents);
-            }
-            catch (e) { } // eslint-disable-line no-empty
-            // conditional return types are annoying
-            resolve((validator ? validator(parsed) : parsed));
-        }
-    }));
-    return { verify };
+    return (_services, getDefaultToken) => {
+        const verify = (...args) => {
+            const [inputToken, validator] = args.length === 1
+                ? typeof args[0] === 'string'
+                    ? [args[0], undefined]
+                    : [undefined, args[0]]
+                : args;
+            return new Promise((resolve, reject) => {
+                const token = inputToken !== null && inputToken !== void 0 ? inputToken : getDefaultToken === null || getDefaultToken === void 0 ? void 0 : getDefaultToken();
+                if (!token) {
+                    return reject(new InvalidRequestError('Missing token for launch verification'));
+                }
+                return jwt.verify(token, getKey, {}, (err, payload) => {
+                    if (err && err instanceof TokenExpiredError) {
+                        reject(new SessionExpiredError());
+                    }
+                    else if (err) {
+                        reject(err);
+                    }
+                    else if (typeof payload !== 'object') {
+                        reject(new Error('received JWT token with unexpected non-JSON payload'));
+                    }
+                    else if (!payload.sub) {
+                        reject(new Error('JWT payload missing sub claim'));
+                    }
+                    else {
+                        // we are migrating away from json encoding all the parameters into the `sub` claim
+                        // and into using separate claims for each parameter. in transition, we check if the sub
+                        // is json and return it if it is. this is still a breaking change when using this
+                        // utility because applications no longer need to independently json parse the result
+                        // starting now.
+                        const parsed = payload;
+                        try {
+                            const jsonSubContents = JSON.parse(payload.sub);
+                            Object.assign(parsed, jsonSubContents);
+                        }
+                        catch (e) { } // eslint-disable-line no-empty
+                        // conditional return types are annoying
+                        resolve((validator ? validator(parsed) : parsed));
+                    }
+                });
+            });
+        };
+        return { verify };
+    };
 };

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

@@ -1,8 +1,9 @@
+export declare type FieldType = string | string[] | number | boolean;
 export declare type Filter = {
     key: string;
-    value: string | string[] | boolean;
+    value: FieldType;
 } | {
-    terms: Record<string, string | string[] | number | boolean>;
+    terms: Record<string, FieldType>;
 } | {
     exists: {
         field: string;

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

@@ -7,6 +7,7 @@ export declare const memorySearchTheBadWay: () => <T>({ store }: {
     deleteIndexIfExists: () => Promise<undefined>;
     ensureIndexCreated: () => Promise<undefined>;
     index: (_options: IndexOptions<T>) => Promise<undefined>;
+    bulkIndex: (_items: IndexOptions<T>[]) => Promise<undefined>;
     search: (options: SearchOptions) => Promise<{
         items: T[];
         pageSize: number;

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

@@ -9,37 +9,56 @@ var MatchType;
     MatchType[MatchType["MustNot"] = 1] = "MustNot";
     MatchType[MatchType["Should"] = 2] = "Should";
 })(MatchType || (MatchType = {}));
-const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
+const resolveField = (document, field) => field.split('.').reduce((result, key) => result[key], document);
+const matchExists = (exists, document) => {
+    const value = resolveField(document, 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; };
+    for (const key in terms) {
+        const docValues = coerceArray(resolveField(document, key));
+        const coerceValue = getFieldType(key) === 'boolean'
+            ? (input) => {
+                if ([true, 'true', '1', 1].includes(input)) {
+                    return true;
+                }
+                if ([false, 'false', '0', 0, ''].includes(input)) {
+                    return false;
+                }
+                throw new InvalidRequestError('input is not a valid boolean filter');
+            }
+            : (x) => x;
+        const hasMatch = coerceArray(terms[key]).map(coerceValue).some(v => docValues.includes(v));
+        if (!hasMatch) {
+            return false;
+        }
+    }
+    return true;
+};
 export const memorySearchTheBadWay = () => ({ store }) => {
     return {
         // This method is intentionally stubbed because index deletion is not applicable for in-memory storage.
         deleteIndexIfExists: async () => undefined,
         ensureIndexCreated: async () => undefined,
         index: async (_options) => undefined,
+        bulkIndex: async (_items) => undefined,
         search: async (options) => {
-            const getFieldType = (field) => { var _a; return (_a = options.fields.find(f => f.key == field.key)) === null || _a === void 0 ? void 0 : _a.type; };
             const results = (await store.loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
                 const matchFilters = (filters, matchType) => {
                     for (const field of filters) {
-                        if (!('key' in field && 'value' in field)) {
-                            console.warn('local search only supports key/value filters');
-                            continue;
-                        }
-                        const docValues = coerceArray(resolveField(document, field));
-                        const coerceValue = getFieldType(field) === 'boolean'
-                            ? (input) => {
-                                if ([true, 'true', '1', 1].includes(input)) {
-                                    return true;
-                                }
-                                if ([false, 'false', '0', 0, ''].includes(input)) {
-                                    return false;
-                                }
-                                throw new InvalidRequestError('input is not a valid boolean filter');
-                            }
-                            : (x) => x;
-                        const hasMatch = coerceArray(field.value).map(coerceValue).some(v => docValues.includes(v));
+                        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;
                         }
@@ -54,7 +73,7 @@ export const memorySearchTheBadWay = () => ({ store }) => {
                         if (field.type !== undefined && field.type !== 'text') {
                             continue;
                         }
-                        const value = resolveField(document, field);
+                        const value = resolveField(document, field.key);
                         if (value === undefined || value === null) {
                             continue;
                         }
@@ -85,8 +104,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, { key: sort.key });
-                    const bValue = resolveField(b.document, { key: sort.key });
+                    const aValue = resolveField(a.document, sort.key);
+                    const bValue = resolveField(b.document, sort.key);
                     if (aValue < bValue) {
                         return sort.order === 'asc' ? -1 : 1;
                     }

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

@@ -19,6 +19,7 @@ export declare const openSearchService: <C extends string = "deployed">(initiali
     ensureIndexCreated: () => Promise<void>;
     deleteIndexIfExists: () => Promise<void>;
     index: (params: IndexOptions<T>) => Promise<void>;
+    bulkIndex: (items: IndexOptions<T>[]) => Promise<void>;
     search: (options: SearchOptions) => Promise<{
         items: Exclude<T, undefined>[];
         pageSize: number;

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

@@ -5,6 +5,16 @@ import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
 import { resolveConfigValue } from '../../config';
 import { ifDefined, isDefined } from '../../guards';
 import { once } from '../../misc/helpers';
+const mapFilter = (filter) => {
+    if ('key' in filter && 'value' in filter) {
+        const { key } = filter;
+        const values = filter.value instanceof Array ? filter.value : [filter.value];
+        return { terms: { [key]: values } };
+    }
+    else {
+        return filter;
+    }
+};
 export const openSearchService = (initializer = {}) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
     const client = once(async () => new Client({
@@ -50,6 +60,17 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
                 refresh: true
             });
         };
+        const bulkIndex = async (items) => {
+            const openSearchClient = await client();
+            await openSearchClient.bulk({
+                index: indexConfig.name,
+                body: items.flatMap((item) => [
+                    { index: { _id: item.id } },
+                    item.body
+                ]),
+                refresh: true
+            });
+        };
         const search = async (options) => {
             const body = {
                 query: { bool: {} },
@@ -64,45 +85,16 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
                     }
                 };
             }
-            const { must_not } = options;
+            const { must_not, should } = options;
             const must = 'filter' in options ? options.filter : options.must;
             if (must && must.length > 0) {
-                body.query.bool.filter = [];
-                must.forEach((filter) => {
-                    if ('key' in filter && 'value' in filter) {
-                        const { key } = filter;
-                        const values = filter.value instanceof Array ? filter.value : [filter.value];
-                        body.query.bool.filter.push({ terms: { [key]: values } });
-                    }
-                    else {
-                        body.query.bool.filter.push(filter);
-                    }
-                });
+                body.query.bool.filter = must.map(mapFilter);
             }
             if (must_not && must_not.length > 0) {
-                body.query.bool.must_not = [];
-                must_not.forEach((filter) => {
-                    if ('key' in filter && 'value' in filter) {
-                        const { key } = filter;
-                        const values = filter.value instanceof Array ? filter.value : [filter.value];
-                        values.forEach((value) => body.query.bool.must_not.push({ term: { [key]: value } }));
-                    }
-                    else {
-                        body.query.bool.must_not.push(filter);
-                    }
-                });
+                body.query.bool.must_not = must_not.map(mapFilter);
             }
-            if (options.should && options.should.length > 0) {
-                body.query.bool.should = options.should.map(filter => {
-                    if ('key' in filter && 'value' in filter) {
-                        const { key } = filter;
-                        const values = filter.value instanceof Array ? filter.value : [filter.value];
-                        return { terms: { [key]: values } };
-                    }
-                    else {
-                        return filter;
-                    }
-                });
+            if (should && should.length > 0) {
+                body.query.bool.should = should.map(mapFilter);
                 body.query.bool.minimum_should_match = 1;
             }
             if (options.sort && options.sort.length > 0) {
@@ -128,6 +120,6 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
             const totalPages = Math.ceil(totalItems / pageSize) || 1;
             return { items, pageSize, currentPage, totalItems, totalPages };
         };
-        return { ensureIndexCreated, deleteIndexIfExists, index, search };
+        return { ensureIndexCreated, deleteIndexIfExists, index, bulkIndex, search };
     };
 };