@openstax/ts-utils 1.21.12 → 1.24.1

package/dist/esm/errors/index.d.ts

@@ -42,6 +42,17 @@ export declare class UnauthorizedError extends Error {
     static matches: (e: any) => e is typeof UnauthorizedError;
     constructor(message?: string);
 }
+/**
+ * Forbidden error
+ *
+ * `ForbiddenError.matches(error)` is a reliable way to check if an error is a
+ * `ForbiddenError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ForbiddenError extends Error {
+    static readonly TYPE = "ForbiddenError";
+    static matches: (e: any) => e is typeof ForbiddenError;
+    constructor(message?: string);
+}
 /**
  * Not found error
  *

package/dist/esm/errors/index.js

@@ -58,6 +58,19 @@ export class UnauthorizedError extends Error {
 }
 UnauthorizedError.TYPE = 'UnauthorizedError';
 UnauthorizedError.matches = errorIsType(UnauthorizedError);
+/**
+ * Forbidden error
+ *
+ * `ForbiddenError.matches(error)` is a reliable way to check if an error is a
+ * `ForbiddenError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export class ForbiddenError extends Error {
+    constructor(message) {
+        super(message || ForbiddenError.TYPE);
+    }
+}
+ForbiddenError.TYPE = 'ForbiddenError';
+ForbiddenError.matches = errorIsType(ForbiddenError);
 /**
  * Not found error
  *

package/dist/esm/middleware/apiErrorHandler.d.ts

@@ -1,12 +1,13 @@
-import { InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
+import { ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
 import type { ApiResponse } from '../routing';
 import type { Logger } from '../services/logger';
 export declare type DefaultErrors = {
+    InvalidRequestError: InvalidRequestError;
     UnauthorizedError: UnauthorizedError;
-    SessionExpiredError: SessionExpiredError;
+    ForbiddenError: ForbiddenError;
     NotFoundError: NotFoundError;
-    InvalidRequestError: InvalidRequestError;
     ValidationError: ValidationError;
+    SessionExpiredError: SessionExpiredError;
 };
 export declare type Handlers<E> = {
     [T in keyof E]: (e: E[T], logger: Logger) => ApiResponse<number, any>;

package/dist/esm/middleware/apiErrorHandler.js

@@ -1,12 +1,13 @@
-import { isAppError } from '../errors';
+import { isAppError, } from '../errors';
 import { apiJsonResponse, apiTextResponse } from '../routing';
 import { Level } from '../services/logger';
 export const defaultHandlers = {
-    UnauthorizedError: () => apiTextResponse(401, '401 UnauthorizedError'),
-    SessionExpiredError: () => apiTextResponse(440, '440 SessionExpiredError'),
-    NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
     InvalidRequestError: (e) => apiTextResponse(400, `400 ${e.message}`),
+    UnauthorizedError: (e) => apiTextResponse(401, `401 ${e.message}`),
+    ForbiddenError: (e) => apiTextResponse(403, `403 ${e.message}`),
+    NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
     ValidationError: (e) => apiJsonResponse(422, e.getData()),
+    SessionExpiredError: (e) => apiTextResponse(440, `440 ${e.message}`),
 };
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,

package/dist/esm/misc/helpers.js

@@ -76,7 +76,7 @@ export const retryWithDelay = (fn, options) => {
             reject(e);
         }
         else {
-            (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.log(`failed try ${n} of ${retries}. ${e.message}`);
+            (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.log(`failed try ${n + 1} of ${retries}. ${e.message}`);
             setTimeout(() => retryWithDelay(fn, { ...options, n: n + 1 }).then(resolve, reject), timeout);
         }
     });

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

@@ -17,11 +17,10 @@ export const accountsGateway = (initializer) => (configProvider) => {
     const request = async (method, path, options, statuses = [200, 201]) => {
         const host = (await accountsBase).replace(/\/+$/, '');
         const url = `${host}/api/${path}`;
-        const token = options.token || await accountsAuthToken;
         const config = {
-            headers: token
-                ? { Authorization: `Bearer ${token}` }
-                : {},
+            headers: {
+                Authorization: `Bearer ${options.token || await accountsAuthToken}`,
+            },
             method,
         };
         if (options.body) {

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

@@ -3,6 +3,7 @@ import { ConfigProviderForConfig } from '../../config';
 import { ConfigForFetch, GenericFetch, Response } from '../../fetch';
 import { AnyRoute, ApiResponse, OutputForRoute, ParamsForRoute, PayloadForRoute, QueryParams } from '../../routing';
 import { UnwrapPromise } from '../../types';
+import { Logger } from '../logger';
 declare type TResponsePayload<R> = R extends ApiResponse<any, infer P> ? P : never;
 declare type TResponseStatus<R> = R extends ApiResponse<infer S, any> ? S : never;
 declare type RouteClient<R> = {
@@ -49,8 +50,11 @@ export declare const loadResponse: (response: Response) => () => Promise<any>;
 interface MakeApiGateway<F> {
     <Ru>(config: ConfigProviderForConfig<{
         apiBase: string;
-    }>, routes: MapRoutesToConfig<Ru>, authProvider?: {
-        getAuthorizedFetchConfig: () => Promise<ConfigForFetch<F>>;
+    }>, routes: MapRoutesToConfig<Ru>, appProvider?: {
+        authProvider?: {
+            getAuthorizedFetchConfig: () => Promise<ConfigForFetch<F>>;
+        };
+        logger?: Logger;
     }): MapRoutesToClient<Ru>;
 }
 export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, Response>>(initializer: {

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

@@ -1,9 +1,11 @@
 import * as pathToRegexp from 'path-to-regexp';
 import queryString from 'query-string';
+import { v4 as uuid } from 'uuid';
 import { merge } from '../..';
 import { resolveConfigValue } from '../../config';
-import { SessionExpiredError, UnauthorizedError } from '../../errors';
+import { ForbiddenError, SessionExpiredError, UnauthorizedError } from '../../errors';
 import { fetchStatusRetry } from '../../fetch/fetchStatusRetry';
+import { Level } from '../logger';
 /** Pulls the content out of a response based on the content type */
 export const loadResponse = (response) => () => {
     const [contentType] = (response.headers.get('content-type') || '').split(';');
@@ -16,7 +18,7 @@ export const loadResponse = (response) => () => {
             throw new Error(`unknown content type ${contentType}`);
     }
 };
-const makeRouteClient = (initializer, config, route, authProvider) => {
+const makeRouteClient = (initializer, config, route, appProvider) => {
     /* TODO this duplicates code with makeRenderRouteUrl, reuse that */
     const renderUrl = async ({ params, query }) => {
         const apiBase = await resolveConfigValue(config.apiBase);
@@ -25,21 +27,31 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
         return apiBase.replace(/\/+$/, '') + getPathForParams(params || {}) + (search ? `?${search}` : '');
     };
     const routeClient = async ({ params, payload, query, fetchConfig }) => {
+        var _a, _b;
+        const { fetch } = initializer;
         const url = await renderUrl({ params, query });
         const body = payload ? JSON.stringify(payload) : undefined;
-        const baseOptions = merge((await (authProvider === null || authProvider === void 0 ? void 0 : authProvider.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
-        const fetcher = fetchStatusRetry(initializer.fetch, { retries: 1, status: [502] });
+        const baseOptions = merge((await ((_a = appProvider === null || appProvider === void 0 ? void 0 : appProvider.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();
+        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);
         return fetcher(url, merge(baseOptions, {
             method: route.method,
             body,
             headers: {
                 ...fetchConfig === null || fetchConfig === void 0 ? void 0 : fetchConfig.headers,
                 ...(body ? { 'content-type': 'application/json' } : {}),
+                'X-Request-ID': requestId,
             }
         })).then(response => {
             if (response.status === 401) {
                 throw new UnauthorizedError();
             }
+            if (response.status === 403) {
+                throw new ForbiddenError();
+            }
             if (response.status === 440) {
                 throw new SessionExpiredError();
             }
@@ -59,7 +71,7 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
     routeClient.renderUrl = renderUrl;
     return routeClient;
 };
-export const createApiGateway = (initializer) => (config, routes, authProvider) => {
+export const createApiGateway = (initializer) => (config, routes, appProvider) => {
     return Object.fromEntries(Object.entries(routes)
-        .map(([key, routeConfig]) => ([key, makeRouteClient(initializer, config, routeConfig, authProvider)])));
+        .map(([key, routeConfig]) => ([key, makeRouteClient(initializer, config, routeConfig, appProvider)])));
 };

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

@@ -1,13 +1,14 @@
+/* cspell:ignore originalname */
 import fs from 'fs';
+import https from 'https';
 import path from 'path';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
 import cors from 'cors';
 import express from 'express';
 import multer from 'multer';
-import https from 'https';
-import { once } from "../../misc/helpers";
-import { assertString } from "../../assertions";
+import { assertString } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
 /* istanbul ignore next */
 const startServer = once((port, uploadDir) => {
     // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does

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

@@ -1,3 +1,4 @@
+/* cspell:ignore presigner */
 import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { once } from '../..';

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

@@ -82,7 +82,7 @@ ${await response.text()}`);
                     const response = await fetchXapiStatements(fetchParams).catch(abort);
                     const consistentThrough = response.headers.get('X-Experience-API-Consistent-Through');
                     if (!consistentThrough || new Date(consistentThrough) < date) {
-                        throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date}.`);
+                        throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date.toISOString()}.`);
                     }
                     return formatGetXapiStatementsResponse(response);
                 }, { retries: 4, logger });

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

@@ -0,0 +1,29 @@
+import { RequestBody } from '@opensearch-project/opensearch/lib/Transport';
+import { ConfigProviderForConfig } from '../config';
+import { IndexOptions, SearchOptions } from './searchProvider';
+export declare type Config = {
+    node: string;
+    region: string;
+};
+export interface Initializer<C> {
+    configSpace?: C;
+}
+export declare type IndexConfig = {
+    name: string;
+    mappings: Record<string, any>;
+    pageSize?: number;
+};
+export declare const openSearchService: <T extends RequestBody<Record<string, any>>, C extends string = "deployed">(initializer?: Initializer<C>) => (indexConfig: IndexConfig, configProvider: { [key in C]: {
+    node: import("../config").ConfigValueProvider<string>;
+    region: import("../config").ConfigValueProvider<string>;
+}; }) => {
+    ensureIndexCreated: () => Promise<void>;
+    index: (params: IndexOptions<T>) => Promise<void>;
+    search: (options: SearchOptions) => Promise<{
+        items: Exclude<T, undefined>[];
+        pageSize: number;
+        currentPage: number;
+        totalItems: number;
+        totalPages: number;
+    }>;
+};

package/dist/esm/services/openSearch.js

@@ -0,0 +1,103 @@
+// cspell:ignore opensearch, Sigv
+import { defaultProvider } from '@aws-sdk/credential-provider-node';
+import { Client } from '@opensearch-project/opensearch';
+import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
+import { resolveConfigValue } from '../config';
+import { ifDefined, isDefined } from '../guards';
+import { once } from '../misc/helpers';
+export const openSearchService = (initializer = {}) => (indexConfig, configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
+    const pageSize = indexConfig.pageSize || 10;
+    const client = once(async () => new Client({
+        ...AwsSigv4Signer({
+            getCredentials: () => defaultProvider()(),
+            region: await resolveConfigValue(config.region),
+            service: 'es',
+        }),
+        node: await resolveConfigValue(config.node),
+    }));
+    const createIndexIfNotExists = async (indices, params) => {
+        const { index } = params;
+        const { body } = await indices.exists({ index });
+        if (!body) {
+            await indices.create(params);
+        }
+    };
+    const ensureIndexCreated = async () => {
+        const { indices } = await client();
+        await createIndexIfNotExists(indices, {
+            index: indexConfig.name,
+            body: {
+                mappings: {
+                    dynamic: false,
+                    properties: indexConfig.mappings
+                }
+            }
+        });
+    };
+    const index = async (params) => {
+        const openSearchClient = await client();
+        await openSearchClient.index({
+            index: indexConfig.name,
+            body: params.body,
+            id: params.id,
+            refresh: true
+        });
+    };
+    const search = async (options) => {
+        const body = { query: { bool: {} } };
+        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
+                }
+            };
+        }
+        const { must_not } = options;
+        const must = 'filter' in options ? options.filter : options.must;
+        if (must && must.length > 0) {
+            body.query.bool.filter = [];
+            must.forEach((filter) => {
+                const { key } = filter;
+                const values = filter.value instanceof Array ? filter.value : [filter.value];
+                body.query.bool.filter.push({ terms: { [key]: values } });
+            });
+        }
+        if (must_not && must_not.length > 0) {
+            body.query.bool.must_not = [];
+            must_not.forEach((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 } }));
+            });
+        }
+        if (options.should && options.should.length > 0) {
+            body.query.bool.should = options.should.map(term => {
+                const { key } = term;
+                const values = term.value instanceof Array ? term.value : [term.value];
+                return { terms: { [key]: values } };
+            });
+            body.query.bool.minimum_should_match = 1;
+        }
+        if (options.page) {
+            body.size = pageSize;
+            body.from = (options.page - 1) * pageSize;
+        }
+        const response = await (await client()).search({
+            body,
+            index: indexConfig.name
+        });
+        if (response.statusCode !== 200) {
+            throw new Error(`Unexpected status code: ${response.statusCode} from OpenSearch`);
+        }
+        const hits = response.body.hits;
+        const items = hits.hits.map((hit) => hit._source).filter(isDefined);
+        const currentPage = options.page || 1;
+        const { total } = hits;
+        const totalItems = typeof total === 'number' ? total : total.value;
+        const totalPages = Math.ceil(totalItems / pageSize) || 1;
+        return { items, pageSize, currentPage, totalItems, totalPages };
+    };
+    return { ensureIndexCreated, index, search };
+};

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

@@ -27,5 +27,6 @@ export interface SearchOptions {
     filter?: Filter[];
     must?: Filter[];
     must_not?: Filter[];
+    should?: Filter[];
 }
 export {};

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

@@ -7,6 +7,7 @@ var MatchType;
 (function (MatchType) {
     MatchType[MatchType["Must"] = 0] = "Must";
     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);
 export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
@@ -18,7 +19,7 @@ export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
             const results = (await loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
-                const matchFilters = (filters, mustMatch) => {
+                const matchFilters = (filters, matchType) => {
                     for (const field of filters) {
                         const docValues = coerceArray(resolveField(document, field));
                         const coerceValue = getFieldType(field) === 'boolean'
@@ -33,11 +34,14 @@ export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                             }
                             : (x) => x;
                         const hasMatch = coerceArray(field.value).map(coerceValue).some(v => docValues.includes(v));
-                        if ((mustMatch === MatchType.Must && !hasMatch) || (mustMatch === MatchType.MustNot && hasMatch)) {
+                        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
                             return false;
                         }
+                        else if (matchType === MatchType.Should && hasMatch) {
+                            return true;
+                        }
                     }
-                    return true;
+                    return matchType !== MatchType.Should;
                 };
                 if (options.query !== undefined) {
                     for (const field of options.fields) {
@@ -58,7 +62,7 @@ export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                         }
                     }
                 }
-                const { must_not } = options;
+                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;
@@ -66,6 +70,9 @@ export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                 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)) {
+                    return undefined;
+                }
                 return { document, weight };
             })
                 .filter(isDefined)