@openstax/ts-utils 1.27.1 → 1.27.3

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

@@ -3,135 +3,137 @@ import { once } from '../../..';
 import { resolveConfigValue } from '../../../config';
 import { ifDefined } from '../../../guards';
 import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
-const dynamodb = once(() => new DynamoDB({ apiVersion: '2012-08-10' }));
 // i'm not really excited about getAuthor being required, but ts is getting confused about the type when unspecified
-export const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
+export const dynamoVersionedDocumentStore = (initializer) => {
     const init = ifDefined(initializer, {});
-    const tableName = once(() => resolveConfigValue(configProvider[ifDefined(init.configSpace, 'dynamodb')].tableName));
-    return {
-        loadAllDocumentsTheBadWay: async () => {
-            const loadAllResults = async (ExclusiveStartKey) => {
-                var _a;
-                const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
-                const result = await dynamodb().send(cmd);
-                const resultItems = ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)) || [];
-                if (result.LastEvaluatedKey) {
-                    return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
-                }
-                return resultItems;
-            };
-            const allResults = await loadAllResults().then(results => results.reduce((result, document) => {
-                const current = result.get(document[hashKey]);
-                if (!current || current.timestamp < document.timestamp) {
-                    return result.set(document[hashKey], document);
-                }
-                return result;
-            }, new Map()));
-            return Array.from(allResults.values());
-        },
-        getVersions: async (id, startVersion) => {
-            const cmd = new QueryCommand({
-                TableName: await tableName(),
-                KeyConditionExpression: '#hk = :hkv',
-                ExpressionAttributeValues: {
-                    ':hkv': encodeDynamoAttribute(id)
-                },
-                ExpressionAttributeNames: {
+    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;
+                    const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                    const result = await dynamodb().send(cmd);
+                    const resultItems = ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)) || [];
+                    if (result.LastEvaluatedKey) {
+                        return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                    }
+                    return resultItems;
+                };
+                const allResults = await loadAllResults().then(results => results.reduce((result, document) => {
+                    const current = result.get(document[hashKey]);
+                    if (!current || current.timestamp < document.timestamp) {
+                        return result.set(document[hashKey], document);
+                    }
+                    return result;
+                }, new Map()));
+                return Array.from(allResults.values());
+            },
+            getVersions: async (id, startVersion) => {
+                const cmd = new QueryCommand({
+                    TableName: await tableName(),
+                    KeyConditionExpression: '#hk = :hkv',
+                    ExpressionAttributeValues: {
+                        ':hkv': encodeDynamoAttribute(id)
+                    },
+                    ExpressionAttributeNames: {
+                        '#hk': hashKey.toString()
+                    },
+                    ...(startVersion
+                        ? { ExclusiveStartKey: {
+                                [hashKey]: encodeDynamoAttribute(id),
+                                timestamp: { N: startVersion.toString() }
+                            } }
+                        : {}),
+                    ScanIndexForward: false,
+                });
+                return dynamodb().send(cmd).then(result => {
+                    var _a;
+                    const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument);
+                    if (!items || items.length === 0) {
+                        return undefined;
+                    }
+                    return {
+                        items,
+                        nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                    };
+                });
+            },
+            getItem: async (id, timestamp) => {
+                let keyConditionExpression = '#hk = :hkv';
+                const expressionAttributeNames = {
                     '#hk': hashKey.toString()
-                },
-                ...(startVersion
-                    ? { ExclusiveStartKey: {
-                            [hashKey]: encodeDynamoAttribute(id),
-                            timestamp: { N: startVersion.toString() }
-                        } }
-                    : {}),
-                ScanIndexForward: false,
-            });
-            return dynamodb().send(cmd).then(result => {
-                var _a;
-                const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument);
-                if (!items || items.length === 0) {
-                    return undefined;
+                };
+                const expressionAttributeValues = {
+                    ':hkv': encodeDynamoAttribute(id)
+                };
+                if (timestamp) {
+                    keyConditionExpression += ' and #ts = :tsv';
+                    expressionAttributeNames['#ts'] = 'timestamp';
+                    expressionAttributeValues[':tsv'] = encodeDynamoAttribute(timestamp);
                 }
+                const cmd = new QueryCommand({
+                    TableName: await tableName(),
+                    KeyConditionExpression: keyConditionExpression,
+                    ExpressionAttributeNames: expressionAttributeNames,
+                    ExpressionAttributeValues: expressionAttributeValues,
+                    ScanIndexForward: false,
+                    Limit: 1
+                });
+                return dynamodb().send(cmd).then(result => {
+                    var _a;
+                    return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
+                });
+            },
+            /* prepares a new version of a document with the given data, then allows some additional
+             * changes to be input to a `save` function that actually saves it. useful for additional
+             * changes based on the new document version or author. the document version and author
+             * cannot be modified */
+            prepareItem: async (item, ...authorArgs) => {
+                // this getAuthor type is terrible
+                const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
+                const timestamp = new Date().getTime();
                 return {
-                    items,
-                    nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                    document: { ...item, timestamp, author },
+                    save: async (changes) => {
+                        var _a;
+                        const document = {
+                            ...item,
+                            ...changes,
+                            timestamp,
+                            author
+                        };
+                        const cmd = new PutItemCommand({
+                            TableName: await tableName(),
+                            Item: encodeDynamoDocument(document),
+                        });
+                        const updatedDoc = await dynamodb().send(cmd)
+                            .then(() => document);
+                        await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
+                        return updatedDoc;
+                    }
                 };
-            });
-        },
-        getItem: async (id, timestamp) => {
-            let keyConditionExpression = '#hk = :hkv';
-            const expressionAttributeNames = {
-                '#hk': hashKey.toString()
-            };
-            const expressionAttributeValues = {
-                ':hkv': encodeDynamoAttribute(id)
-            };
-            if (timestamp) {
-                keyConditionExpression += ' and #ts = :tsv';
-                expressionAttributeNames['#ts'] = 'timestamp';
-                expressionAttributeValues[':tsv'] = encodeDynamoAttribute(timestamp);
-            }
-            const cmd = new QueryCommand({
-                TableName: await tableName(),
-                KeyConditionExpression: keyConditionExpression,
-                ExpressionAttributeNames: expressionAttributeNames,
-                ExpressionAttributeValues: expressionAttributeValues,
-                ScanIndexForward: false,
-                Limit: 1
-            });
-            return dynamodb().send(cmd).then(result => {
+            },
+            /* saves a new version of a document with the given data */
+            putItem: async (item, ...authorArgs) => {
                 var _a;
-                return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
-            });
-        },
-        /* prepares a new version of a document with the given data, then allows some additional
-         * changes to be input to a `save` function that actually saves it. useful for additional
-         * changes based on the new document version or author. the document version and author
-         * cannot be modified */
-        prepareItem: async (item, ...authorArgs) => {
-            // this getAuthor type is terrible
-            const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
-            const timestamp = new Date().getTime();
-            return {
-                document: { ...item, timestamp, author },
-                save: async (changes) => {
-                    var _a;
-                    const document = {
-                        ...item,
-                        ...changes,
-                        timestamp,
-                        author
-                    };
-                    const cmd = new PutItemCommand({
-                        TableName: await tableName(),
-                        Item: encodeDynamoDocument(document),
-                    });
-                    const updatedDoc = await dynamodb().send(cmd)
-                        .then(() => document);
-                    await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
-                    return updatedDoc;
-                }
-            };
-        },
-        /* saves a new version of a document with the given data */
-        putItem: async (item, ...authorArgs) => {
-            var _a;
-            // this getAuthor type is terrible
-            const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
-            const document = {
-                ...item,
-                timestamp: new Date().getTime(),
-                author
-            };
-            const cmd = new PutItemCommand({
-                TableName: await tableName(),
-                Item: encodeDynamoDocument(document),
-            });
-            const updatedDoc = await dynamodb().send(cmd)
-                .then(() => document);
-            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
-            return updatedDoc;
-        },
+                // this getAuthor type is terrible
+                const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
+                const document = {
+                    ...item,
+                    timestamp: new Date().getTime(),
+                    author
+                };
+                const cmd = new PutItemCommand({
+                    TableName: await tableName(),
+                    Item: encodeDynamoDocument(document),
+                });
+                const updatedDoc = await dynamodb().send(cmd)
+                    .then(() => document);
+                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/fileServer/s3FileServer.d.ts

@@ -7,7 +7,7 @@ export declare type Config = {
 };
 interface Initializer<C> {
     configSpace?: C;
-    s3Client?: typeof S3Client;
+    getS3Client?: (...args: ConstructorParameters<typeof S3Client>) => S3Client;
 }
 export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
     bucketName: import("../../config").ConfigValueProvider<string>;

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

@@ -9,8 +9,11 @@ export const s3FileServer = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
     const bucketName = once(() => resolveConfigValue(config.bucketName));
     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() }));
+    const s3Service = once(async () => {
+        var _a, _b;
+        const args = { apiVersion: '2012-08-10', region: await bucketRegion() };
+        return (_b = (_a = initializer.getS3Client) === null || _a === void 0 ? void 0 : _a.call(initializer, args)) !== null && _b !== void 0 ? _b : new S3Client(args);
+    });
     /*
      * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
      */

package/dist/esm/services/launchParams/verifier.js

@@ -4,11 +4,13 @@ import { memoize } from '../..';
 import { resolveConfigValue } from '../../config';
 import { InvalidRequestError, SessionExpiredError } from '../../errors';
 import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
 /**
  * Creates a class that can verify launch params
  */
 export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
     const config = configProvider[ifDefined(configSpace, 'launch')];
+    const getTrustedDomain = once(() => resolveConfigValue(config.trustedDomain));
     const getJwksClient = memoize((jwksUri) => new JwksClient({ fetcher, jwksUri }));
     const getJwksKey = memoize(async (jwksUri, kid) => {
         const client = getJwksClient(jwksUri);
@@ -24,7 +26,7 @@ export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvide
         try {
             const jwksUrl = new URL('/.well-known/jwks.json', iss);
             const launchDomain = jwksUrl.hostname;
-            const trustedDomain = await resolveConfigValue(config.trustedDomain);
+            const trustedDomain = await getTrustedDomain();
             if (launchDomain !== trustedDomain && !launchDomain.endsWith(`.${trustedDomain}`)) {
                 return callback(new Error(`Untrusted launch domain: "${launchDomain}"`));
             }

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

@@ -31,6 +31,10 @@ declare type Field = {
 } | {
     key: string;
     type: 'keyword';
+} | {
+    key: string;
+    type: 'date';
+    format?: string;
 } | {
     key: string;
     type: 'boolean';