@openstax/ts-utils 1.21.12 → 1.23.0

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/index.d.ts

@@ -12,8 +12,6 @@ export declare type FolderValue = {
 export declare const isFileValue: (thing: any) => thing is FileValue;
 export declare const isFolderValue: (thing: any) => thing is FolderValue;
 export interface FileServerAdapter {
-    putFileContent: (source: FileValue, content: string) => Promise<FileValue>;
-    getSignedViewerUrl: (source: FileValue) => Promise<string>;
     getFileContent: (source: FileValue) => Promise<Buffer>;
 }
 export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

package/dist/cjs/services/fileServer/localFileServer.d.ts

@@ -1,8 +1,6 @@
 import { ConfigProviderForConfig } from '../../config';
 import { FileServerAdapter } from '.';
 export declare type Config = {
-    port?: string;
-    host?: string;
     storagePrefix: string;
 };
 interface Initializer<C> {
@@ -10,8 +8,6 @@ interface Initializer<C> {
     configSpace?: C;
 }
 export declare const localFileServer: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    port?: import("../../config").ConfigValueProvider<string> | undefined;
-    host?: import("../../config").ConfigValueProvider<string> | undefined;
     storagePrefix: import("../../config").ConfigValueProvider<string>;
 }; }) => FileServerAdapter;
 export {};

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

@@ -8,73 +8,16 @@ const fs_1 = __importDefault(require("fs"));
 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");
-/* istanbul ignore next */
-const startServer = (0, helpers_1.once)((port, uploadDir) => {
-    // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
-    const upload = (0, multer_1.default)({ dest: uploadDir, preservePath: true });
-    const fileServerApp = (0, express_1.default)();
-    fileServerApp.use((0, cors_1.default)());
-    fileServerApp.use(express_1.default.static(uploadDir));
-    fileServerApp.post('/', upload.single('file'), async (req, res) => {
-        const file = req.file;
-        if (!file) {
-            return res.status(400).send({ message: 'file is required' });
-        }
-        const destinationName = req.body.key.replace('${filename}', file.originalname);
-        const destinationPath = path_1.default.join(uploadDir, destinationName);
-        const destinationDirectory = path_1.default.dirname(destinationPath);
-        await fs_1.default.promises.mkdir(destinationDirectory, { recursive: true });
-        await fs_1.default.promises.rename(file.path, destinationPath);
-        res.status(201).send();
-    });
-    const server = https_1.default.createServer({
-        key: fs_1.default.readFileSync((0, assertions_1.assertString)(process.env.SSL_KEY_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
-        cert: fs_1.default.readFileSync((0, assertions_1.assertString)(process.env.SSL_CRT_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
-    }, fileServerApp);
-    server.once('error', function (err) {
-        if (err.code === 'EADDRINUSE') {
-            // when the local dev server reloads files on every request it doesn't
-            // actually tear down the old modules, so this server only starts on the
-            // first execution and changes in its code will not be reloaded
-            return;
-        }
-        throw err;
-    });
-    server.listen(port);
-    return true;
-});
 const localFileServer = (initializer) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'local')];
-    const port = (0, config_1.resolveConfigValue)(config.port || '');
-    const host = (0, config_1.resolveConfigValue)(config.host || '');
     const storagePrefix = (0, config_1.resolveConfigValue)(config.storagePrefix);
     const fileDir = storagePrefix.then((prefix) => path_1.default.join(initializer.dataDir, prefix));
-    Promise.all([port, fileDir])
-        .then(([port, fileDir]) => port && startServer(port, fileDir));
-    const getSignedViewerUrl = async (source) => {
-        return `https://${await host}:${await port}/${source.path}`;
-    };
     const getFileContent = async (source) => {
         const filePath = path_1.default.join(await fileDir, source.path);
         return fs_1.default.promises.readFile(filePath);
     };
-    const putFileContent = async (source, content) => {
-        const filePath = path_1.default.join(await fileDir, source.path);
-        const directory = path_1.default.dirname(filePath);
-        await fs_1.default.promises.mkdir(directory, { recursive: true });
-        await fs_1.default.promises.writeFile(filePath, content);
-        return source;
-    };
     return {
-        getSignedViewerUrl,
         getFileContent,
-        putFileContent,
     };
 };
 exports.localFileServer = localFileServer;

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.s3FileServer = void 0;
 const client_s3_1 = require("@aws-sdk/client-s3");
-const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
 const __1 = require("../..");
 const assertions_1 = require("../../assertions");
 const config_1 = require("../../config");
@@ -13,37 +12,14 @@ const s3FileServer = (initializer) => (configProvider) => {
     const bucketRegion = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.bucketRegion));
     const client = (0, guards_1.ifDefined)(initializer.s3Client, client_s3_1.S3Client);
     const s3Service = (0, __1.once)(async () => new client({ apiVersion: '2012-08-10', region: await bucketRegion() }));
-    /*
-     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
-     */
-    const getSignedViewerUrl = async (source) => {
-        const bucket = (await bucketName());
-        const command = new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: source.path });
-        return (0, s3_request_presigner_1.getSignedUrl)(await s3Service(), command, {
-            expiresIn: 3600, // 1 hour
-        });
-    };
     const getFileContent = async (source) => {
         const bucket = await bucketName();
         const command = new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: source.path });
         const response = await (await s3Service()).send(command);
         return Buffer.from(await (0, assertions_1.assertDefined)(response.Body, new Error('Invalid Response from s3')).transformToByteArray());
     };
-    const putFileContent = async (source, content) => {
-        const bucket = await bucketName();
-        const command = new client_s3_1.PutObjectCommand({
-            Bucket: bucket,
-            Key: source.path,
-            Body: content,
-            ContentType: source.mimeType,
-        });
-        await (await s3Service()).send(command);
-        return source;
-    };
     return {
         getFileContent,
-        putFileContent,
-        getSignedViewerUrl,
     };
 };
 exports.s3FileServer = s3FileServer;

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/postgresConnection/index.js

@@ -18,9 +18,7 @@ const postgresConnection = (initializer) => (configProvider) => {
         database: await (0, config_1.resolveConfigValue)(config.database),
         username: await (0, config_1.resolveConfigValue)(config.username),
         password: await (0, config_1.resolveConfigValue)(config.password),
-        transform: {
-            column: { to: postgres_1.default.fromCamel, from: postgres_1.default.toCamel },
-        },
+        transform: postgres_1.default.camel,
     }));
     const connections = [];
     const sql = (0, helpers_1.once)(async () => {