@openstax/ts-utils 1.21.12 → 1.23.0

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/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/esm/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/esm/services/fileServer/localFileServer.js

@@ -2,72 +2,15 @@ import fs from 'fs';
 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";
-/* istanbul ignore next */
-const startServer = once((port, uploadDir) => {
-    // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
-    const upload = multer({ dest: uploadDir, preservePath: true });
-    const fileServerApp = express();
-    fileServerApp.use(cors());
-    fileServerApp.use(express.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.join(uploadDir, destinationName);
-        const destinationDirectory = path.dirname(destinationPath);
-        await fs.promises.mkdir(destinationDirectory, { recursive: true });
-        await fs.promises.rename(file.path, destinationPath);
-        res.status(201).send();
-    });
-    const server = https.createServer({
-        key: fs.readFileSync(assertString(process.env.SSL_KEY_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
-        cert: fs.readFileSync(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;
-});
 export const localFileServer = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'local')];
-    const port = resolveConfigValue(config.port || '');
-    const host = resolveConfigValue(config.host || '');
     const storagePrefix = resolveConfigValue(config.storagePrefix);
     const fileDir = storagePrefix.then((prefix) => path.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.join(await fileDir, source.path);
         return fs.promises.readFile(filePath);
     };
-    const putFileContent = async (source, content) => {
-        const filePath = path.join(await fileDir, source.path);
-        const directory = path.dirname(filePath);
-        await fs.promises.mkdir(directory, { recursive: true });
-        await fs.promises.writeFile(filePath, content);
-        return source;
-    };
     return {
-        getSignedViewerUrl,
         getFileContent,
-        putFileContent,
     };
 };

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

@@ -1,5 +1,4 @@
-import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { once } from '../..';
 import { assertDefined } from '../../assertions';
 import { resolveConfigValue } from '../../config';
@@ -10,36 +9,13 @@ export const s3FileServer = (initializer) => (configProvider) => {
     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() }));
-    /*
-     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
-     */
-    const getSignedViewerUrl = async (source) => {
-        const bucket = (await bucketName());
-        const command = new GetObjectCommand({ Bucket: bucket, Key: source.path });
-        return getSignedUrl(await s3Service(), command, {
-            expiresIn: 3600, // 1 hour
-        });
-    };
     const getFileContent = async (source) => {
         const bucket = await bucketName();
         const command = new GetObjectCommand({ Bucket: bucket, Key: source.path });
         const response = await (await s3Service()).send(command);
         return Buffer.from(await assertDefined(response.Body, new Error('Invalid Response from s3')).transformToByteArray());
     };
-    const putFileContent = async (source, content) => {
-        const bucket = await bucketName();
-        const command = new PutObjectCommand({
-            Bucket: bucket,
-            Key: source.path,
-            Body: content,
-            ContentType: source.mimeType,
-        });
-        await (await s3Service()).send(command);
-        return source;
-    };
     return {
         getFileContent,
-        putFileContent,
-        getSignedViewerUrl,
     };
 };

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

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