@openstax/ts-utils 1.27.1 → 1.27.3

package/dist/esm/middleware/lambdaCorsResponseMiddleware.js

@@ -1,4 +1,5 @@
 import { resolveConfigValue } from '../config/resolveConfigValue';
+import { once } from '../misc/helpers';
 import { apiTextResponse } from '../routing';
 /**
  * Creates response middleware that adds CORS headers to responses from approved hosts.
@@ -11,8 +12,9 @@ import { apiTextResponse } from '../routing';
  * }),
  */
 export const createLambdaCorsResponseMiddleware = (config) => () => (responsePromise, { request }) => {
+    const getAllowedHostRegex = once(() => resolveConfigValue(config.corsAllowedHostRegex));
     const cors = async () => {
-        const allowedHost = await resolveConfigValue(config.corsAllowedHostRegex);
+        const allowedHost = await getAllowedHostRegex();
         if (request.headers.origin && request.headers.origin !== 'null' && new URL(request.headers.origin).hostname.match(new RegExp(allowedHost))) {
             return {
                 'Access-Control-Allow-Origin': request.headers.origin,

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

@@ -2,6 +2,7 @@ import { chunk, isEqual } from 'lodash';
 import queryString from 'query-string';
 import { resolveConfigValue } from '../../config';
 import { ifDefined, isDefined } from '../../guards';
+import { once } from '../../misc/helpers';
 import { METHOD } from '../../routing';
 import { Level } from '../logger';
 class ApiError extends Error {
@@ -12,15 +13,15 @@ class ApiError extends Error {
 }
 export const accountsGateway = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'accounts')];
-    const accountsBase = resolveConfigValue(config.accountsBase);
-    const accountsAuthToken = resolveConfigValue(config.accountsAuthToken);
+    const accountsBase = once(() => resolveConfigValue(config.accountsBase));
+    const accountsAuthToken = once(() => resolveConfigValue(config.accountsAuthToken));
     return ({ logger }) => {
         const request = async (method, path, options, statuses = [200, 201]) => {
-            const host = (await accountsBase).replace(/\/+$/, '');
+            const host = (await accountsBase()).replace(/\/+$/, '');
             const url = `${host}/api/${path}`;
             const config = {
                 headers: {
-                    Authorization: `Bearer ${options.token || await accountsAuthToken}`,
+                    Authorization: `Bearer ${options.token || await accountsAuthToken()}`,
                 },
                 method,
             };

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

@@ -4,9 +4,9 @@ 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> = {
+export declare type TResponsePayload<R> = R extends ApiResponse<any, infer P> ? P : never;
+export declare type TResponseStatus<R> = R extends ApiResponse<infer S, any> ? S : never;
+export declare type RouteClient<R> = {
     (config: {
         fetchConfig?: any;
         query?: QueryParams;
@@ -21,25 +21,25 @@ declare type RouteClient<R> = {
         params: ParamsForRoute<R>;
     })) => Promise<string>;
 };
-interface AcceptStatus<Ro> {
+export interface AcceptStatus<Ro> {
     <S extends TResponseStatus<Ro>[]>(...args: S): Promise<ApiClientResponse<Extract<Ro, Record<'statusCode', S[number]>>>>;
     <S extends number[]>(...args: S): Promise<ApiClientResponse<any>>;
 }
-declare type UnsafeApiClientResponse<Ro> = {
+export declare type UnsafeApiClientResponse<Ro> = {
     headers: Headers;
     load: () => Promise<any>;
     status: number;
     acceptStatus: AcceptStatus<Ro>;
 };
-declare type ApiClientResponse<Ro> = Ro extends any ? {
+export declare type ApiClientResponse<Ro> = Ro extends any ? {
     headers: Headers;
     status: TResponseStatus<Ro>;
     load: () => Promise<TResponsePayload<Ro>>;
 } : never;
-declare type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
+export declare type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
     [N in Ru['name']]: RouteClient<Extract<Ru, Record<'name', N>>>;
 } : never;
-declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
+export declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
     [N in Ru['name']]: {
         path: string;
         method: string;
@@ -47,7 +47,7 @@ declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
 } : never;
 /** Pulls the content out of a response based on the content type */
 export declare const loadResponse: (response: Response) => () => Promise<any>;
-interface MakeApiGateway<F> {
+export interface MakeApiGateway<F> {
     <Ru>(config: ConfigProviderForConfig<{
         apiBase: string;
     }>, routes: MapRoutesToConfig<Ru>, app?: {
@@ -61,4 +61,3 @@ interface MakeApiGateway<F> {
 export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, Response>>(initializer: {
     fetch: F;
 }) => MakeApiGateway<F>;
-export {};

package/dist/esm/services/documentStore/unversioned/dynamodb.d.ts

@@ -1,7 +1,9 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
 import { Config, TDocument } from '..';
 import { ConfigProviderForConfig } from '../../../config';
 interface Initializer<C> {
     configSpace?: C;
+    dynamoClient?: DynamoDB;
 }
 export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
     tableName: import("../../../config").ConfigValueProvider<string>;

package/dist/esm/services/documentStore/unversioned/dynamodb.js

@@ -4,157 +4,159 @@ import { resolveConfigValue } from '../../../config';
 import { NotFoundError } from '../../../errors';
 import { ifDefined } from '../../../guards';
 import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
-const dynamodb = once(() => new DynamoDB({ apiVersion: '2012-08-10' }));
-export const dynamoUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
+export const dynamoUnversionedDocumentStore = (initializer) => {
     const init = ifDefined(initializer, {});
-    const tableName = once(() => resolveConfigValue(configProvider[ifDefined(init.configSpace, 'dynamodb')].tableName));
-    return {
-        loadAllDocumentsTheBadWay: async () => {
-            const loadAllResults = async (ExclusiveStartKey) => {
+    const dynamodb = once(() => { var _a; return (_a = init.dynamoClient) !== null && _a !== void 0 ? _a : new DynamoDB({ apiVersion: '2012-08-10' }); });
+    return () => (configProvider) => (_, hashKey, options) => {
+        const tableName = once(() => resolveConfigValue(configProvider[ifDefined(init.configSpace, 'dynamodb')].tableName));
+        return {
+            loadAllDocumentsTheBadWay: async () => {
+                const loadAllResults = async (ExclusiveStartKey) => {
+                    var _a, _b;
+                    const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                    const result = await dynamodb().send(cmd);
+                    const resultItems = (_b = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map((item) => decodeDynamoDocument(item))) !== null && _b !== void 0 ? _b : [];
+                    if (result.LastEvaluatedKey) {
+                        return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                    }
+                    return resultItems;
+                };
+                return loadAllResults();
+            },
+            /*
+             * requires that a global secondary index exist on the table
+             */
+            getItemsByField: async (key, value, pageKey) => {
                 var _a, _b;
-                const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
-                const result = await dynamodb().send(cmd);
-                const resultItems = (_b = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map((item) => decodeDynamoDocument(item))) !== null && _b !== void 0 ? _b : [];
-                if (result.LastEvaluatedKey) {
-                    return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
-                }
-                return resultItems;
-            };
-            return loadAllResults();
-        },
-        /*
-         * requires that a global secondary index exist on the table
-         */
-        getItemsByField: async (key, value, pageKey) => {
-            var _a, _b;
-            const ExclusiveStartKey = pageKey
-                ? JSON.parse(Buffer.from(pageKey, 'base64').toString('utf-8'))
-                : undefined;
-            const table = await tableName();
-            const cmd = new QueryCommand({
-                TableName: table,
-                IndexName: key.toString(),
-                ExclusiveStartKey,
-                KeyConditionExpression: '#hk = :hkv',
-                ExpressionAttributeValues: {
-                    ':hkv': encodeDynamoAttribute(value),
-                },
-                ExpressionAttributeNames: {
-                    '#hk': key.toString(),
-                },
-            });
-            const response = await dynamodb().send(cmd);
-            const items = (_b = (_a = response.Items) === null || _a === void 0 ? void 0 : _a.map((item) => decodeDynamoDocument(item))) !== null && _b !== void 0 ? _b : [];
-            const nextPageToken = response.LastEvaluatedKey;
-            return {
-                items,
-                nextPageToken: nextPageToken
-                    ? Buffer.from(JSON.stringify(nextPageToken)).toString('base64')
-                    : undefined,
-            };
-        },
-        batchGetItem: async (ids) => {
-            const table = await tableName();
-            const key = hashKey.toString();
-            const getBatches = async (requestItems) => {
-                const cmd = new BatchGetItemCommand({
-                    RequestItems: requestItems !== null && requestItems !== void 0 ? requestItems : { [table]: { Keys: ids.map((id) => ({ [key]: encodeDynamoAttribute(id) })) } },
+                const ExclusiveStartKey = pageKey
+                    ? JSON.parse(Buffer.from(pageKey, 'base64').toString('utf-8'))
+                    : undefined;
+                const table = await tableName();
+                const cmd = new QueryCommand({
+                    TableName: table,
+                    IndexName: key.toString(),
+                    ExclusiveStartKey,
+                    KeyConditionExpression: '#hk = :hkv',
+                    ExpressionAttributeValues: {
+                        ':hkv': encodeDynamoAttribute(value),
+                    },
+                    ExpressionAttributeNames: {
+                        '#hk': key.toString(),
+                    },
                 });
                 const response = await dynamodb().send(cmd);
-                const currentResponses = response.Responses ?
-                    response.Responses[table].map(response => decodeDynamoDocument(response)) : [];
-                return currentResponses.concat(response.UnprocessedKeys ? await getBatches(response.UnprocessedKeys) : []);
-            };
-            return getBatches();
-        },
-        getItem: async (id) => {
-            const cmd = new GetItemCommand({
-                Key: { [hashKey.toString()]: encodeDynamoAttribute(id) },
-                TableName: await tableName(),
-            });
-            return dynamodb().send(cmd).then(result => result.Item ? decodeDynamoDocument(result.Item) : undefined);
-        },
-        /* atomically increments the given item attribute by 1 */
-        incrementItemAttribute: async (id, attribute) => {
-            const key = hashKey.toString();
-            const field = attribute.toString();
-            const cmd = new UpdateItemCommand({
-                Key: { [key]: encodeDynamoAttribute(id) },
-                TableName: await tableName(),
-                UpdateExpression: 'ADD #f :one',
-                ConditionExpression: 'attribute_exists(#k)',
-                ExpressionAttributeNames: { '#k': hashKey.toString(), '#f': field },
-                ExpressionAttributeValues: { ':one': { N: '1' } },
-                ReturnValues: 'ALL_NEW',
-            });
-            return dynamodb().send(cmd).then(async (item) => {
-                var _a, _b, _c;
-                const result = (_b = (_a = item.Attributes) === null || _a === void 0 ? void 0 : _a[field]) === null || _b === void 0 ? void 0 : _b['N'];
-                if (!item.Attributes) {
-                    throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                const items = (_b = (_a = response.Items) === null || _a === void 0 ? void 0 : _a.map((item) => decodeDynamoDocument(item))) !== null && _b !== void 0 ? _b : [];
+                const nextPageToken = response.LastEvaluatedKey;
+                return {
+                    items,
+                    nextPageToken: nextPageToken
+                        ? Buffer.from(JSON.stringify(nextPageToken)).toString('base64')
+                        : undefined,
+                };
+            },
+            batchGetItem: async (ids) => {
+                const table = await tableName();
+                const key = hashKey.toString();
+                const getBatches = async (requestItems) => {
+                    const cmd = new BatchGetItemCommand({
+                        RequestItems: requestItems !== null && requestItems !== void 0 ? requestItems : { [table]: { Keys: ids.map((id) => ({ [key]: encodeDynamoAttribute(id) })) } },
+                    });
+                    const response = await dynamodb().send(cmd);
+                    const currentResponses = response.Responses ?
+                        response.Responses[table].map(response => decodeDynamoDocument(response)) : [];
+                    return currentResponses.concat(response.UnprocessedKeys ? await getBatches(response.UnprocessedKeys) : []);
+                };
+                return getBatches();
+            },
+            getItem: async (id) => {
+                const cmd = new GetItemCommand({
+                    Key: { [hashKey.toString()]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                });
+                return dynamodb().send(cmd).then(result => result.Item ? decodeDynamoDocument(result.Item) : undefined);
+            },
+            /* atomically increments the given item attribute by 1 */
+            incrementItemAttribute: async (id, attribute) => {
+                const key = hashKey.toString();
+                const field = attribute.toString();
+                const cmd = new UpdateItemCommand({
+                    Key: { [key]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                    UpdateExpression: 'ADD #f :one',
+                    ConditionExpression: 'attribute_exists(#k)',
+                    ExpressionAttributeNames: { '#k': hashKey.toString(), '#f': field },
+                    ExpressionAttributeValues: { ':one': { N: '1' } },
+                    ReturnValues: 'ALL_NEW',
+                });
+                return dynamodb().send(cmd).then(async (item) => {
+                    var _a, _b, _c;
+                    const result = (_b = (_a = item.Attributes) === null || _a === void 0 ? void 0 : _a[field]) === null || _b === void 0 ? void 0 : _b['N'];
+                    if (!item.Attributes) {
+                        throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                    }
+                    if (!result) {
+                        throw new NotFoundError(`Item with ${key} "${id}" did not produce field "${field}"`);
+                    }
+                    const updatedDoc = decodeDynamoDocument(item.Attributes);
+                    await ((_c = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _c === void 0 ? void 0 : _c.call(options, updatedDoc));
+                    return parseFloat(result);
+                }).catch((error) => {
+                    throw error.name === 'ConditionalCheckFailedException' ?
+                        new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
+                });
+            },
+            /* replaces only specified attributes with the given data */
+            patchItem: async (item) => {
+                const id = item[hashKey];
+                const key = hashKey.toString();
+                if (!id) {
+                    throw new Error(`Key attribute "${key}" is required for patchItem`);
                 }
-                if (!result) {
-                    throw new NotFoundError(`Item with ${key} "${id}" did not produce field "${field}"`);
+                const entries = Object.entries(item).filter(([field]) => field !== key);
+                if (entries.length === 0) {
+                    throw new Error('No attributes to update');
                 }
-                const updatedDoc = decodeDynamoDocument(item.Attributes);
-                await ((_c = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _c === void 0 ? void 0 : _c.call(options, updatedDoc));
-                return parseFloat(result);
-            }).catch((error) => {
-                throw error.name === 'ConditionalCheckFailedException' ?
-                    new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
-            });
-        },
-        /* replaces only specified attributes with the given data */
-        patchItem: async (item) => {
-            const id = item[hashKey];
-            const key = hashKey.toString();
-            if (!id) {
-                throw new Error(`Key attribute "${key}" is required for patchItem`);
-            }
-            const entries = Object.entries(item).filter(([field]) => field !== key);
-            if (entries.length === 0) {
-                throw new Error('No attributes to update');
-            }
-            const updates = [];
-            const expressionAttributeNames = { '#k': key };
-            const expressionAttributeValues = {};
-            entries.forEach(([field, value], index) => {
-                updates.push(`#f${index} = :f${index}`);
-                expressionAttributeNames[`#f${index}`] = field;
-                expressionAttributeValues[`:f${index}`] = encodeDynamoAttribute(value);
-            });
-            const cmd = new UpdateItemCommand({
-                Key: { [key]: encodeDynamoAttribute(id) },
-                TableName: await tableName(),
-                UpdateExpression: `SET ${updates.join(', ')}`,
-                ConditionExpression: 'attribute_exists(#k)',
-                ExpressionAttributeNames: expressionAttributeNames,
-                ExpressionAttributeValues: expressionAttributeValues,
-                ReturnValues: 'ALL_NEW',
-            });
-            return dynamodb().send(cmd).then(async (item) => {
+                const updates = [];
+                const expressionAttributeNames = { '#k': key };
+                const expressionAttributeValues = {};
+                entries.forEach(([field, value], index) => {
+                    updates.push(`#f${index} = :f${index}`);
+                    expressionAttributeNames[`#f${index}`] = field;
+                    expressionAttributeValues[`:f${index}`] = encodeDynamoAttribute(value);
+                });
+                const cmd = new UpdateItemCommand({
+                    Key: { [key]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                    UpdateExpression: `SET ${updates.join(', ')}`,
+                    ConditionExpression: 'attribute_exists(#k)',
+                    ExpressionAttributeNames: expressionAttributeNames,
+                    ExpressionAttributeValues: expressionAttributeValues,
+                    ReturnValues: 'ALL_NEW',
+                });
+                return dynamodb().send(cmd).then(async (item) => {
+                    var _a;
+                    if (!item.Attributes) {
+                        throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                    }
+                    const updatedDoc = decodeDynamoDocument(item.Attributes);
+                    await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
+                    return updatedDoc;
+                }).catch((error) => {
+                    throw error.name === 'ConditionalCheckFailedException' ?
+                        new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
+                });
+            },
+            /* replaces the entire document with the given data */
+            putItem: async (item) => {
                 var _a;
-                if (!item.Attributes) {
-                    throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
-                }
-                const updatedDoc = decodeDynamoDocument(item.Attributes);
+                const cmd = new PutItemCommand({
+                    TableName: await tableName(),
+                    Item: encodeDynamoDocument(item),
+                });
+                const updatedDoc = await dynamodb().send(cmd).then(() => item);
                 await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
                 return updatedDoc;
-            }).catch((error) => {
-                throw error.name === 'ConditionalCheckFailedException' ?
-                    new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
-            });
-        },
-        /* replaces the entire document with the given data */
-        putItem: async (item) => {
-            var _a;
-            const cmd = new PutItemCommand({
-                TableName: await tableName(),
-                Item: encodeDynamoDocument(item),
-            });
-            const updatedDoc = await dynamodb().send(cmd).then(() => item);
-            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
-            return updatedDoc;
-        },
+            },
+        };
     };
 };

package/dist/esm/services/documentStore/versioned/dynamodb.d.ts

@@ -1,8 +1,10 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
 import { Config } from '..';
 import { ConfigProviderForConfig } from '../../../config';
 import { VersionedDocumentAuthor, VersionedTDocument } from '.';
 interface Initializer<C> {
     configSpace?: C;
+    dynamoClient?: DynamoDB;
 }
 export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends VersionedTDocument<T>>() => (configProvider: { [key in C]: {
     tableName: import("../../../config").ConfigValueProvider<string>;