@openstax/ts-utils 1.21.12 → 1.24.1

package/dist/cjs/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/cjs/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.ValidationError = exports.InvalidRequestError = exports.isAppError = void 0;
+exports.SessionExpiredError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.InvalidRequestError = exports.isAppError = void 0;
 /*
  * if code is split into multiple bundles, sometimes each bundle
  * will get its own definition of this module and then instanceof checks
@@ -65,6 +65,20 @@ class UnauthorizedError extends Error {
 exports.UnauthorizedError = UnauthorizedError;
 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
+ */
+class ForbiddenError extends Error {
+    constructor(message) {
+        super(message || ForbiddenError.TYPE);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+ForbiddenError.TYPE = 'ForbiddenError';
+ForbiddenError.matches = errorIsType(ForbiddenError);
 /**
  * Not found error
  *

package/dist/cjs/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/cjs/middleware/apiErrorHandler.js

@@ -5,11 +5,12 @@ const errors_1 = require("../errors");
 const routing_1 = require("../routing");
 const logger_1 = require("../services/logger");
 exports.defaultHandlers = {
-    UnauthorizedError: () => (0, routing_1.apiTextResponse)(401, '401 UnauthorizedError'),
-    SessionExpiredError: () => (0, routing_1.apiTextResponse)(440, '440 SessionExpiredError'),
-    NotFoundError: (e) => (0, routing_1.apiTextResponse)(404, `404 ${e.message}`),
     InvalidRequestError: (e) => (0, routing_1.apiTextResponse)(400, `400 ${e.message}`),
+    UnauthorizedError: (e) => (0, routing_1.apiTextResponse)(401, `401 ${e.message}`),
+    ForbiddenError: (e) => (0, routing_1.apiTextResponse)(403, `403 ${e.message}`),
+    NotFoundError: (e) => (0, routing_1.apiTextResponse)(404, `404 ${e.message}`),
     ValidationError: (e) => (0, routing_1.apiJsonResponse)(422, e.getData()),
+    SessionExpiredError: (e) => (0, routing_1.apiTextResponse)(440, `440 ${e.message}`),
 };
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,

package/dist/cjs/misc/helpers.js

@@ -84,7 +84,7 @@ 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(() => (0, exports.retryWithDelay)(fn, { ...options, n: n + 1 }).then(resolve, reject), timeout);
         }
     });

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

@@ -23,11 +23,10 @@ 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/cjs/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/cjs/services/apiGateway/index.js

@@ -29,10 +29,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createApiGateway = exports.loadResponse = void 0;
 const pathToRegexp = __importStar(require("path-to-regexp"));
 const query_string_1 = __importDefault(require("query-string"));
+const uuid_1 = require("uuid");
 const __1 = require("../..");
 const config_1 = require("../../config");
 const errors_1 = require("../../errors");
 const fetchStatusRetry_1 = require("../../fetch/fetchStatusRetry");
+const logger_1 = require("../logger");
 /** Pulls the content out of a response based on the content type */
 const loadResponse = (response) => () => {
     const [contentType] = (response.headers.get('content-type') || '').split(';');
@@ -46,7 +48,7 @@ const loadResponse = (response) => () => {
     }
 };
 exports.loadResponse = loadResponse;
-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 (0, config_1.resolveConfigValue)(config.apiBase);
@@ -55,21 +57,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 = (0, __1.merge)((await (authProvider === null || authProvider === void 0 ? void 0 : authProvider.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
-        const fetcher = (0, fetchStatusRetry_1.fetchStatusRetry)(initializer.fetch, { retries: 1, status: [502] });
+        const baseOptions = (0, __1.merge)((await ((_a = appProvider === null || appProvider === void 0 ? void 0 : appProvider.authProvider) === null || _a === void 0 ? void 0 : _a.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
+        const requestId = (0, uuid_1.v4)();
+        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 = (0, fetchStatusRetry_1.fetchStatusRetry)(fetch, { retries: 1, status: [502], logger: requestLogger });
+        requestLogger === null || requestLogger === void 0 ? void 0 : requestLogger.log('Request Initiated', logger_1.Level.Info);
         return fetcher(url, (0, __1.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 errors_1.UnauthorizedError();
             }
+            if (response.status === 403) {
+                throw new errors_1.ForbiddenError();
+            }
             if (response.status === 440) {
                 throw new errors_1.SessionExpiredError();
             }
@@ -89,8 +101,8 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
     routeClient.renderUrl = renderUrl;
     return routeClient;
 };
-const createApiGateway = (initializer) => (config, routes, authProvider) => {
+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)])));
 };
 exports.createApiGateway = createApiGateway;

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

@@ -4,16 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localFileServer = void 0;
+/* cspell:ignore originalname */
 const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
 const path_1 = __importDefault(require("path"));
-const config_1 = require("../../config");
-const guards_1 = require("../../guards");
 const cors_1 = __importDefault(require("cors"));
 const express_1 = __importDefault(require("express"));
 const multer_1 = __importDefault(require("multer"));
-const https_1 = __importDefault(require("https"));
-const helpers_1 = require("../../misc/helpers");
 const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const helpers_1 = require("../../misc/helpers");
 /* istanbul ignore next */
 const startServer = (0, helpers_1.once)((port, uploadDir) => {
     // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.s3FileServer = void 0;
+/* cspell:ignore presigner */
 const client_s3_1 = require("@aws-sdk/client-s3");
 const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
 const __1 = require("../..");

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

@@ -108,7 +108,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/cjs/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/cjs/services/openSearch.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSearchService = void 0;
+// cspell:ignore opensearch, Sigv
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const opensearch_1 = require("@opensearch-project/opensearch");
+const aws_1 = require("@opensearch-project/opensearch/aws");
+const config_1 = require("../config");
+const guards_1 = require("../guards");
+const helpers_1 = require("../misc/helpers");
+const openSearchService = (initializer = {}) => (indexConfig, configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'deployed')];
+    const pageSize = indexConfig.pageSize || 10;
+    const client = (0, helpers_1.once)(async () => new opensearch_1.Client({
+        ...(0, aws_1.AwsSigv4Signer)({
+            getCredentials: () => (0, credential_provider_node_1.defaultProvider)()(),
+            region: await (0, config_1.resolveConfigValue)(config.region),
+            service: 'es',
+        }),
+        node: await (0, config_1.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(guards_1.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 };
+};
+exports.openSearchService = openSearchService;

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

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

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

@@ -10,6 +10,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);
 const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
@@ -21,7 +22,7 @@ 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 = (0, __1.coerceArray)(resolveField(document, field));
                         const coerceValue = getFieldType(field) === 'boolean'
@@ -36,11 +37,14 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                             }
                             : (x) => x;
                         const hasMatch = (0, __1.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) {
@@ -61,7 +65,7 @@ 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;
@@ -69,6 +73,9 @@ 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(guards_1.isDefined)