@openstax/ts-utils 1.26.2 → 1.27.2

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,14 +12,15 @@ 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,
                 'Access-Control-Allow-Credentials': 'true',
                 'Access-Control-Allow-Headers': 'content-type, x-request-id',
-                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                'Access-Control-Allow-Methods': 'POST, GET, PUT, PATCH, DELETE, OPTIONS',
             };
         }
     };

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/authProvider/decryption.js

@@ -11,6 +11,7 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
     const signaturePublicKey = once(() => resolveConfigValue(config.signaturePublicKey));
     return ({ request, logger }) => {
         let user;
+        const getAuthToken = async () => getAuthTokenOrCookie(request, await cookieName())[0];
         const getAuthorizedFetchConfig = async () => {
             const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
             if (!token) {
@@ -19,7 +20,7 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
             return { headers };
         };
         const getPayload = async (tokenString) => {
-            const token = tokenString !== null && tokenString !== void 0 ? tokenString : getAuthTokenOrCookie(request, await cookieName())[0];
+            const token = tokenString !== null && tokenString !== void 0 ? tokenString : await getAuthToken();
             if (!token) {
                 return undefined;
             }
@@ -40,6 +41,7 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
             return undefined;
         };
         return {
+            getAuthToken,
             getAuthorizedFetchConfig,
             getTokenExpiration: async (tokenString) => {
                 var _a;

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

@@ -37,6 +37,7 @@ export interface ApiUser extends TokenUser {
 }
 export declare type User = TokenUser | ApiUser;
 export declare type AuthProvider = {
+    getAuthToken: () => Promise<string | null>;
     getUser: () => Promise<User | undefined>;
     /**
      * gets second argument for `fetch` that has authentication token or cookie
@@ -58,4 +59,4 @@ export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest,
     Authorization: string;
 }] | [string, {
     cookie: string;
-}];
+}] | [null, {}];

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

@@ -2,6 +2,7 @@ import cookie from 'cookie';
 import { tuple } from '../../misc/helpers';
 import { getHeader } from '../../routing/helpers';
 export const stubAuthProvider = (user) => ({
+    getAuthToken: () => Promise.resolve('authToken'),
     getUser: () => Promise.resolve(user),
     getAuthorizedFetchConfig: () => Promise.resolve(user ? { headers: { Authorization: user.uuid } } : {})
 });
@@ -14,5 +15,7 @@ export const getAuthTokenOrCookie = (request, cookieName, queryKey = 'auth') =>
         ? tuple(authParam, { Authorization: `Bearer ${authParam}` })
         : authHeader && authHeader.length >= 8 && authHeader.startsWith('Bearer ')
             ? tuple(authHeader.slice(7), { Authorization: authHeader })
-            : tuple(cookieValue, { cookie: cookie.serialize(cookieName, cookieValue) });
+            : cookieValue
+                ? tuple(cookieValue, { cookie: cookie.serialize(cookieName, cookieValue) })
+                : tuple(null, {});
 };

package/dist/esm/services/authProvider/subrequest.js

@@ -9,6 +9,7 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
     const accountsBase = once(() => resolveConfigValue(config.accountsBase));
     return ({ request, logger }) => {
         let user;
+        const getAuthToken = async () => getAuthTokenOrCookie(request, await cookieName())[0];
         const getAuthorizedFetchConfig = async () => {
             const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
             if (!token) {
@@ -31,6 +32,7 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
             return user;
         };
         return {
+            getAuthToken,
             getAuthorizedFetchConfig,
             getUser: async () => {
                 if (!user) {

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>;
@@ -9,6 +11,10 @@ export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamo
     afterWrite?: ((item: T) => void | Promise<void>) | undefined;
 } | undefined) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getItemsByField: (key: keyof T, value: T[K], pageKey?: string | undefined) => Promise<{
+        items: T[];
+        nextPageToken: string | undefined;
+    }>;
     batchGetItem: (ids: T[K][]) => Promise<T[]>;
     getItem: (id: T[K]) => Promise<T | undefined>;
     incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;

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

@@ -1,129 +1,162 @@
-import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, ScanCommand, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
+import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, QueryCommand, ScanCommand, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
 import { once } from '../../..';
 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();
-        },
-        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/unversioned/file-system.d.ts

@@ -9,6 +9,10 @@ export declare const fileSystemUnversionedDocumentStore: <C extends string = "fi
     tableName: import("../../../config").ConfigValueProvider<string>;
 }; }) => <K extends keyof T>(_: {}, hashKey: K) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getItemsByField: (key: keyof T, value: T[K], pageKey?: string | undefined) => Promise<{
+        items: T[];
+        nextPageToken: string | undefined;
+    }>;
     batchGetItem: (ids: T[K][]) => Promise<Exclude<Awaited<T>, undefined>[]>;
     getItem: (id: T[K]) => Promise<T | undefined>;
     incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;

package/dist/esm/services/documentStore/unversioned/file-system.js

@@ -31,14 +31,26 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             });
         });
     };
+    const loadAllDocumentsTheBadWay = async () => {
+        const path = await tablePath;
+        await mkTableDir;
+        return new Promise((resolve, reject) => readdir(path, (err, files) => err ?
+            reject(err) :
+            Promise.all(files.map((file) => load(file)))
+                .then((allData) => resolve(allData.filter(isDefined)), (err) => reject(err))));
+    };
     return {
-        loadAllDocumentsTheBadWay: async () => {
-            const path = await tablePath;
-            await mkTableDir;
-            return new Promise((resolve, reject) => readdir(path, (err, files) => err ?
-                reject(err) :
-                Promise.all(files.map((file) => load(file)))
-                    .then((allData) => resolve(allData.filter(isDefined)), (err) => reject(err))));
+        loadAllDocumentsTheBadWay,
+        getItemsByField: async (key, value, pageKey) => {
+            const pageSize = 10;
+            const items = await loadAllDocumentsTheBadWay();
+            const filteredItems = items.filter((item) => item[key] === value);
+            const startIndex = pageKey ? parseInt(pageKey, 10) : 0;
+            const paginatedItems = filteredItems.slice(startIndex, startIndex + pageSize);
+            const nextPageToken = startIndex + pageSize < filteredItems.length
+                ? (startIndex + pageSize).toString()
+                : undefined;
+            return { items: paginatedItems, nextPageToken };
         },
         batchGetItem: async (ids) => {
             const items = await Promise.all(ids.map((id) => load(hashFilename(id))));

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>;