@openstax/ts-utils 1.26.2 → 1.27.1

package/dist/esm/middleware/lambdaCorsResponseMiddleware.js

@@ -18,7 +18,7 @@ export const createLambdaCorsResponseMiddleware = (config) => () => (responsePro
                 '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/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

@@ -9,6 +9,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,4 +1,4 @@
-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';
@@ -22,6 +22,37 @@ export const dynamoUnversionedDocumentStore = (initializer) => () => (configProv
             };
             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();

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

@@ -1,13 +1,28 @@
 export declare type FieldType = string | string[] | number | boolean;
-export declare type Filter = {
-    key: string;
-    value: FieldType;
-} | {
+export declare type ESFilter = {
     terms: Record<string, FieldType>;
 } | {
     exists: {
         field: string;
     };
+} | {
+    nested: {
+        path: string;
+        query: Filter;
+    };
+} | {
+    bool: BoolFilter;
+};
+export declare type Filter = {
+    key: string;
+    value: FieldType;
+} | ESFilter;
+export declare type BoolFilter = {
+    must?: Filter[];
+    must_not?: Filter[];
+    should?: Filter[];
+    filter?: Filter[];
+    minimum_should_match?: number;
 };
 declare type Field = {
     key: string;
@@ -24,13 +39,17 @@ export interface IndexOptions<T> {
     body: T;
     id: string;
 }
+export declare type FieldMapping = {
+    type: 'keyword' | 'text' | 'boolean';
+} | {
+    type?: 'nested' | 'object';
+    properties: Record<string, FieldMapping>;
+};
+export declare type FieldMappings = Record<string, FieldMapping>;
 export interface SearchOptions {
     page?: number;
     query: string | undefined;
     fields: Field[];
-    /**
-     * @deprecated use `must` instead
-     */
     filter?: Filter[];
     must?: Filter[];
     must_not?: Filter[];

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

@@ -1,9 +1,11 @@
-import { IndexOptions, SearchOptions } from '.';
-export declare const memorySearchTheBadWay: () => <T>({ store }: {
+import { FieldMappings, IndexOptions, SearchOptions } from '.';
+export declare type Config<T> = {
+    mappings: FieldMappings;
     store: {
         loadAllDocumentsTheBadWay: () => Promise<T[]>;
     };
-}) => {
+};
+export declare const memorySearchTheBadWay: () => <T>({ store, mappings }: Config<T>) => {
     deleteIndexIfExists: () => Promise<undefined>;
     ensureIndexCreated: () => Promise<undefined>;
     index: (_options: IndexOptions<T>) => Promise<undefined>;

package/dist/esm/services/searchProvider/memorySearchTheBadWay.js

@@ -9,16 +9,58 @@ var MatchType;
     MatchType[MatchType["MustNot"] = 1] = "MustNot";
     MatchType[MatchType["Should"] = 2] = "Should";
 })(MatchType || (MatchType = {}));
-const resolveField = (document, field) => field.split('.').reduce((result, key) => result[key], document);
-const matchExists = (exists, document) => {
-    const value = resolveField(document, exists.field);
+const resolveField = (context, field) => {
+    const path = field.startsWith(context.scope + '.')
+        ? field.slice(context.scope.length + 1)
+        : field;
+    return path.split('.').reduce((result, key) => {
+        if (result === undefined) {
+            throw new Error(`Key "${key}" not found in document resolving ${field}`);
+        }
+        return result[key];
+    }, context.document);
+};
+const getFieldDefinition = (context, field) => {
+    let current = context.fields;
+    const parts = field.split('.');
+    const head = parts.slice(0, -1);
+    const tail = parts[parts.length - 1];
+    for (const part of head) {
+        const currentDefinition = current[part];
+        if (!currentDefinition || !('properties' in currentDefinition)) {
+            throw new Error(`Field "${field}" not found in mappings`);
+        }
+        current = currentDefinition.properties;
+    }
+    if (!current[tail]) {
+        throw new Error(`Field "${field}" not found in mappings`);
+    }
+    return current[tail];
+};
+const getFieldType = (context, field) => {
+    const definition = getFieldDefinition(context, field);
+    return definition.type;
+};
+const matchNested = (context, nested) => {
+    const nestedPath = nested.path;
+    const nestedDocuments = resolveField(context, nestedPath);
+    if (!Array.isArray(nestedDocuments)) {
+        throw new InvalidRequestError(`Nested path "${nestedPath}" is not an array`);
+    }
+    return nestedDocuments.some(nestedDocument => matchClause({
+        ...context,
+        scope: nestedPath,
+        document: nestedDocument
+    }, nested.query));
+};
+const matchExists = (context, exists) => {
+    const value = resolveField(context, exists.field);
     return value !== undefined && value !== null;
 };
-const matchTerms = (options, terms, document) => {
-    const getFieldType = (field) => { var _a; return (_a = options.fields.find(f => f.key == field)) === null || _a === void 0 ? void 0 : _a.type; };
+const matchTerms = (context, terms) => {
     for (const key in terms) {
-        const docValues = coerceArray(resolveField(document, key));
-        const coerceValue = getFieldType(key) === 'boolean'
+        const docValues = coerceArray(resolveField(context, key));
+        const coerceValue = getFieldType(context, key) === 'boolean'
             ? (input) => {
                 if ([true, 'true', '1', 1].includes(input)) {
                     return true;
@@ -36,7 +78,50 @@ const matchTerms = (options, terms, document) => {
     }
     return true;
 };
-export const memorySearchTheBadWay = () => ({ store }) => {
+const matchClause = (context, clause) => {
+    const filter = ('key' in clause && 'value' in clause)
+        ? { terms: { [clause.key]: clause.value } }
+        : clause;
+    if ('terms' in filter)
+        return matchTerms(context, filter.terms);
+    else if ('exists' in filter)
+        return matchExists(context, filter.exists);
+    else if ('bool' in filter)
+        return matchBool(context, filter.bool);
+    else if ('nested' in filter)
+        return matchNested(context, filter.nested);
+    else
+        throw new InvalidRequestError('invalid filter type');
+};
+const matchFilters = (context, filters, matchType) => {
+    for (const field of filters) {
+        const hasMatch = matchClause(context, field);
+        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
+            return false;
+        }
+        else if (matchType === MatchType.Should && hasMatch) {
+            return true;
+        }
+    }
+    return matchType !== MatchType.Should;
+};
+const matchBool = (context, filters) => {
+    const { must_not, should, must, filter } = filters;
+    if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(context, must, MatchType.Must)) {
+        return false;
+    }
+    if ((filter === null || filter === void 0 ? void 0 : filter.length) && !matchFilters(context, filter, MatchType.Must)) {
+        return false;
+    }
+    if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(context, must_not, MatchType.MustNot)) {
+        return false;
+    }
+    if ((should === null || should === void 0 ? void 0 : should.length) && !matchFilters(context, should, MatchType.Should)) {
+        return false;
+    }
+    return true;
+};
+export const memorySearchTheBadWay = () => ({ store, mappings }) => {
     return {
         // This method is intentionally stubbed because index deletion is not applicable for in-memory storage.
         deleteIndexIfExists: async () => undefined,
@@ -47,33 +132,12 @@ export const memorySearchTheBadWay = () => ({ store }) => {
             const results = (await store.loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
-                const matchFilters = (filters, matchType) => {
-                    for (const field of filters) {
-                        const filter = ('key' in field && 'value' in field)
-                            ? { terms: { [field.key]: field.value } }
-                            : field;
-                        let hasMatch;
-                        if ('terms' in filter)
-                            hasMatch = matchTerms(options, filter.terms, document);
-                        else if ('exists' in filter)
-                            hasMatch = matchExists(filter.exists, document);
-                        else
-                            throw new InvalidRequestError('invalid filter type');
-                        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
-                            return false;
-                        }
-                        else if (matchType === MatchType.Should && hasMatch) {
-                            return true;
-                        }
-                    }
-                    return matchType !== MatchType.Should;
-                };
                 if (options.query !== undefined) {
                     for (const field of options.fields) {
                         if (field.type !== undefined && field.type !== 'text') {
                             continue;
                         }
-                        const value = resolveField(document, field.key);
+                        const value = resolveField({ document, fields: mappings, scope: '' }, field.key);
                         if (value === undefined || value === null) {
                             continue;
                         }
@@ -87,15 +151,7 @@ export const memorySearchTheBadWay = () => ({ store }) => {
                         }
                     }
                 }
-                const { must_not, should } = options;
-                const must = 'filter' in options ? options.filter : options.must;
-                if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(must, MatchType.Must)) {
-                    return undefined;
-                }
-                if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(must_not, MatchType.MustNot)) {
-                    return undefined;
-                }
-                if ((should === null || should === void 0 ? void 0 : should.length) && !matchFilters(should, MatchType.Should)) {
+                if (!matchBool({ document, fields: mappings, scope: '' }, options)) {
                     return undefined;
                 }
                 return { document, weight };
@@ -104,8 +160,8 @@ export const memorySearchTheBadWay = () => ({ store }) => {
                 .filter(r => !options.query || r.weight >= MIN_MATCH);
             results.sort((a, b) => {
                 for (const sort of (options.sort || [])) {
-                    const aValue = resolveField(a.document, sort.key);
-                    const bValue = resolveField(b.document, sort.key);
+                    const aValue = resolveField({ document: a.document, fields: mappings, scope: '' }, sort.key);
+                    const bValue = resolveField({ document: b.document, fields: mappings, scope: '' }, sort.key);
                     if (aValue < bValue) {
                         return sort.order === 'asc' ? -1 : 1;
                     }

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

@@ -1,5 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
-import { IndexOptions, SearchOptions } from '.';
+import { FieldMappings, IndexOptions, SearchOptions } from '.';
 export declare type Config = {
     node: string;
     region: string;
@@ -9,7 +9,7 @@ export interface Initializer<C> {
 }
 export declare type IndexConfig = {
     name: string;
-    mappings: Record<string, any>;
+    mappings: FieldMappings;
     pageSize?: number;
 };
 export declare const openSearchService: <C extends string = "deployed">(initializer?: Initializer<C>) => (configProvider: { [key in C]: {

package/dist/esm/services/searchProvider/openSearch.js

@@ -72,23 +72,27 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
             });
         };
         const search = async (options) => {
+            var _a;
             const body = {
                 query: { bool: {} },
                 track_total_hits: true,
                 size: pageSize
             };
             if (options.query) {
-                body.query.bool.must = {
-                    multi_match: {
-                        fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
-                        query: options.query
-                    }
-                };
+                body.query.bool.must = [{
+                        multi_match: {
+                            fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
+                            query: options.query
+                        }
+                    }];
+            }
+            const { must_not, should, must, filter } = options;
+            if (filter && filter.length > 0) {
+                body.query.bool.filter = filter.map(mapFilter);
             }
-            const { must_not, should } = options;
-            const must = 'filter' in options ? options.filter : options.must;
             if (must && must.length > 0) {
-                body.query.bool.filter = must.map(mapFilter);
+                (_a = body.query.bool).must || (_a.must = []);
+                body.query.bool.must = body.query.bool.must.concat(must.map(mapFilter));
             }
             if (must_not && must_not.length > 0) {
                 body.query.bool.must_not = must_not.map(mapFilter);