@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/lambda/src/functions/serviceApi/entry/lambda/index.spec.ts

@@ -0,0 +1,48 @@
+import { APIGatewayProxyEventV2 } from 'aws-lambda/trigger/api-gateway-proxy';
+import { setContextMissingStrategy } from 'aws-xray-sdk';
+import * as coreModule from '../../core';
+import { handler } from '.';
+
+setContextMissingStrategy('IGNORE_ERROR');
+
+jest.mock('../../core', () => {
+  const getRequestResponse = jest.fn();
+  return {
+    getRequestResponse,
+    getRequestResponder: jest.fn(() => getRequestResponse)
+  };
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('handler', () => {
+  let getRequestResponseSpy: jest.SpyInstance;
+  let mockResponse: coreModule.ApiRouteResponse | undefined;
+
+  beforeEach(async() => {
+    mockResponse = {body: 'foobar body', statusCode: 200, data: 'foobar body'};
+    getRequestResponseSpy = (coreModule as any).getRequestResponse.mockImplementation(() => Promise.resolve(mockResponse));
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns response', async() => {
+    const request = {
+      cookies: [],
+      headers: { },
+      requestContext: {
+        http: {
+          method: 'GET'
+        }
+      }
+    } as unknown as APIGatewayProxyEventV2;
+    const response = await handler(request);
+
+    expect(getRequestResponseSpy).toHaveBeenCalledWith(request);
+    expect(response.body).toBe('foobar body');
+  });
+});

package/packages/lambda/src/functions/serviceApi/entry/lambda/index.ts

@@ -0,0 +1,58 @@
+/* spell-checker: ignore avif apng thbs KHTML */
+import './https-xray';
+
+import { APIGatewayProxyEventV2 } from 'aws-lambda/trigger/api-gateway-proxy';
+import { getRequestResponder } from '../../core';
+import { ApiRouteResponse } from '../../core/types';
+import { lambdaMiddleware, lambdaServices } from './services';
+
+/*
+ * for posterity, the payload format looks like this
+ * {
+ *  version: '2.0',
+ *  routeKey: '$default',
+ *  rawPath: '/favicon.ico',
+ *  rawQueryString: '',
+ *  headers: {
+ *    accept: 'image/avif,image/webp,image/apng,image/svg+xml;q=0.8',
+ *    'accept-encoding': 'gzip, deflate, br',
+ *    'accept-language': 'en-US,en;q=0.9',
+ *    'content-length': '0',
+ *    host: 'o8thbs5d45.execute-api.us-east-1.amazonaws.com',
+ *    referer: 'https://o8thbs5d45.execute-api.us-east-1.amazonaws.com/api/foobar',
+ *    'sec-ch-ua': '" Not;A Brand";v="99", "Google Chrome";v="97", "Chromium";v="97"',
+ *    'sec-ch-ua-mobile': '?0',
+ *    'sec-ch-ua-platform': '"macOS"',
+ *    'sec-fetch-dest': 'image',
+ *    'sec-fetch-mode': 'no-cors',
+ *    'sec-fetch-site': 'same-origin',
+ *    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36',
+ *    'x-amzn-trace-id': 'Root=1-6213f295-165a47a57d98e524555003ce',
+ *    'x-forwarded-for': '100.37.48.117',
+ *    'x-forwarded-port': '443',
+ *    'x-forwarded-proto': 'https'
+ *  },
+ *  requestContext: {
+ *    accountId: '373045849756',
+ *    apiId: 'o8thbs5d45',
+ *    domainName: 'o8thbs5d45.execute-api.us-east-1.amazonaws.com',
+ *    domainPrefix: 'o8thbs5d45',
+ *    http: {
+ *      method: 'GET',
+ *      path: '/favicon.ico',
+ *      protocol: 'HTTP/1.1',
+ *      sourceIp: '100.37.48.117',
+ *      userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36'
+ *    },
+ *    requestId: 'N6LXVhOjoAMEMkQ=',
+ *    routeKey: '$default',
+ *    stage: '$default',
+ *    time: '21/Feb/2022:20:14:13 +0000',
+ *    timeEpoch: 1645474453192
+ *  },
+ *  isBase64Encoded: false
+ * }
+ */
+
+export const handler: (request: APIGatewayProxyEventV2) => Promise<ApiRouteResponse> =
+  getRequestResponder(lambdaServices, lambdaMiddleware);

package/packages/lambda/src/functions/serviceApi/entry/lambda/services.ts

@@ -0,0 +1,36 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { S3Client } from '@aws-sdk/client-s3';
+import { getKeyValue } from '@openstax/ts-utils';
+import { createLambdaCorsResponseMiddleware } from '@openstax/ts-utils/middleware/lambdaCorsResponseMiddleware';
+import { createThrowNotFoundMiddleware } from '@openstax/ts-utils/middleware/throwNotFoundMiddleware';
+import { decryptionAuthProvider } from '@openstax/ts-utils/services/authProvider/decryption';
+import { dynamoVersionedDocumentStore } from '@openstax/ts-utils/services/documentStore/versioned/dynamodb';
+import { s3FileServer } from '@openstax/ts-utils/services/fileServer/s3FileServer';
+import { openSearchService } from '@openstax/ts-utils/services/searchProvider/openSearch';
+import { captureAWSv3Client } from 'aws-xray-sdk';
+import fetch from 'node-fetch';
+import { composeResponseMiddleware, slowResponseMiddleware } from '../../core/request';
+import { ApiRouteResponse } from '../../core/types';
+
+const dynamoClient = captureAWSv3Client(new DynamoDB({apiVersion: '2012-08-10'}));
+
+export const lambdaServices = {
+  createAuthProvider: decryptionAuthProvider({configSpace: 'deployed', fetch}),
+  createFileServer: s3FileServer({
+    configSpace: 'deployed',
+    getS3Client: /* istanbul ignore next */ (...args) => captureAWSv3Client(new S3Client(...args))
+  }),
+  getEnvironmentConfig: getKeyValue('deployed'),
+  versionedDocumentStore: dynamoVersionedDocumentStore({dynamoClient}),
+  createSearchProvider: openSearchService({configSpace: 'deployed'}),
+};
+
+export type LambdaServices = typeof lambdaServices;
+
+export const lambdaMiddleware = composeResponseMiddleware(
+  createLambdaCorsResponseMiddleware({
+    corsAllowedHostRegex: '(openstax.org|herokuapp.com)$'
+  }),
+  slowResponseMiddleware,
+  createThrowNotFoundMiddleware<ApiRouteResponse>()
+);

package/packages/lambda/src/functions/serviceApi/entry/local.ts

@@ -0,0 +1,71 @@
+import path from 'path';
+import url from 'url';
+import { getKeyValue } from '@openstax/ts-utils';
+import { assertString } from '@openstax/ts-utils/assertions';
+import { ifDefined } from '@openstax/ts-utils/guards';
+import { subrequestAuthProvider } from '@openstax/ts-utils/services/authProvider/subrequest';
+import { fileSystemVersionedDocumentStore } from '@openstax/ts-utils/services/documentStore/versioned/file-system';
+import { localFileServer } from '@openstax/ts-utils/services/fileServer/localFileServer';
+import { memorySearchTheBadWay } from '@openstax/ts-utils/services/searchProvider/memorySearchTheBadWay';
+import {NextFunction, Request, Response} from 'express';
+import fetch from 'node-fetch';
+import queryString from 'query-string';
+import { composeResponseMiddleware, getRequestResponder, slowResponseMiddleware } from '../core/request';
+import { ApiRouteRequest } from '../core/types';
+
+// when this runs its from the /build/src dir, so theres an extra up here
+const dataDir = path.join(__dirname, '../../../../../data');
+
+const services = {
+  createAuthProvider: subrequestAuthProvider({configSpace: 'local', fetch}),
+  createFileServer: localFileServer({configSpace: 'local', dataDir}),
+  getEnvironmentConfig: getKeyValue('local'),
+  versionedDocumentStore: fileSystemVersionedDocumentStore({ dataDir }),
+  createSearchProvider: memorySearchTheBadWay,
+};
+
+export type LocalServices = typeof services;
+
+export const handler = (request: Request, response: Response, next: NextFunction) => {
+  const getRequestResponse = getRequestResponder(services, composeResponseMiddleware(
+    slowResponseMiddleware,
+  ));
+  const {pathname, search} = url.parse(request.url);
+
+  // https://docs.aws.amazon.com/lambda/latest/dg/services-apigateway.html#apigateway-example-event
+  const payload = {
+    cookies: request.headers.cookie ? request.headers.cookie.split('; ') : [],
+    headers: request.headers,
+    body: request.body,
+    // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+    // APIGatewayProxyEventV2 no longer has multiValueQueryStringParameters, instead it joins multiple values on comma
+    queryStringParameters: search
+      ? Object.fromEntries(
+        Object.entries(queryString.parse(search)).map(([key, entry]) => [key, entry instanceof Array ? entry.join(',') : entry])
+      )
+      : undefined,
+    requestContext: {
+      http: {
+        method: request.method,
+        path: decodeURIComponent(assertString(pathname, new Error('invalid request.url'))),
+      }
+    }
+  } as ApiRouteRequest;
+
+  const responsePromise = getRequestResponse(payload);
+
+  if (!responsePromise) {
+    return next();
+  }
+
+  responsePromise.then(apiResponse => {
+    // TODO - other stuff in the response
+    response.status(ifDefined(apiResponse.statusCode, 200));
+    response.set(apiResponse.headers);
+
+    response.end(apiResponse.isBase64Encoded
+      ? Buffer.from(apiResponse.body, 'base64')
+      : apiResponse.body
+    );
+  });
+};

package/packages/lambda/src/functions/serviceApi/versions/v0/example/documentSearchMiddleware.spec.ts

@@ -0,0 +1,16 @@
+import { CreateSearchProvider } from '../middleware/searchMiddleware';
+import { documentSearchMiddleware } from './documentSearchMiddleware';
+import { ExampleDocumentStore } from './documentStoreMiddleware';
+
+describe('documentSearchMiddleware', () => {
+  it('creates it', () => {
+    const createSearchProviderSpy = jest.fn();
+    const services = {
+      createSearchProvider: createSearchProviderSpy as unknown as CreateSearchProvider,
+      exampleDocumentStore: {} as ExampleDocumentStore,
+    };
+    const middleware = documentSearchMiddleware()(services);
+    expect(middleware).toHaveProperty('exampleDocumentSearch');
+    expect(services.createSearchProvider).toHaveBeenCalled();
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/example/documentSearchMiddleware.ts

@@ -0,0 +1,41 @@
+import { IndexConfig } from '@openstax/ts-utils/services/searchProvider/openSearch';
+import { CreateSearchProvider } from '../middleware/searchMiddleware';
+import { ExampleDocumentStore } from './documentStoreMiddleware';
+
+const indexConfig: IndexConfig = {
+  name: 'example_example_document',
+  mappings: {
+    id: { type: 'keyword' },
+    name: { type: 'text' },
+    description: { type: 'text' },
+    author: {
+      properties: {
+        uuid: {type: 'keyword'},
+      },
+    },
+  },
+  pageSize: 10,
+};
+
+/*
+ * this is an example of a dedicated search provider middleware,
+ * however because of the dependency loop created by the local
+ * memory search, the document store middleware also has the search
+ * provider embedded (so that it can update documents when they're
+ * mutated) and in general it will be easier to just search through
+ * the document store directly
+ */
+export const documentSearchMiddleware = <M extends {
+  exampleDocumentStore: ExampleDocumentStore;
+  createSearchProvider: CreateSearchProvider;
+}>() => (middleware: M) => {
+  const exampleDocumentSearch = middleware.createSearchProvider({
+    store: middleware.exampleDocumentStore,
+    ...indexConfig
+  });
+
+  return {
+    ...middleware,
+    exampleDocumentSearch,
+  };
+};

package/packages/lambda/src/functions/serviceApi/versions/v0/example/documentStoreMiddleware.spec.ts

@@ -0,0 +1,78 @@
+import { stubAuthProvider, User } from '@openstax/ts-utils/services/authProvider';
+import { AppServices } from '../../../core';
+import { CreateSearchProvider } from '../middleware/searchMiddleware';
+import { documentStoreMiddleware } from './documentStoreMiddleware';
+
+describe('documentStoreMiddleware', () => {
+  const envBack = process.env;
+
+  beforeEach(() => {
+    process.env = {...process.env};
+  });
+
+  afterEach(() => {
+    process.env = envBack;
+  });
+
+  it('getAuthor produces audit entry', async() => {
+    process.env.ExampleDocumentTableName = 'some_name';
+    const authProvider = stubAuthProvider({uuid: 'a uuid', name: 'a name'} as User);
+    const searchSpy = jest.fn();
+    const createSearchProviderSpy = jest.fn().mockReturnValue({search: searchSpy});
+
+    let getAuthor: any;
+
+    const versionedDocumentStoreInner = jest.fn((_1, _2, options) => { getAuthor = options.getAuthor;});
+    const versionedDocumentStore = jest.fn().mockReturnValue(jest.fn().mockReturnValue(versionedDocumentStoreInner));
+    const services = {authProvider, createSearchProvider: createSearchProviderSpy as CreateSearchProvider};
+    documentStoreMiddleware({versionedDocumentStore} as unknown as AppServices)(services);
+
+    expect(getAuthor).toBeDefined();
+    expect(await getAuthor()).toEqual({
+      type: 'user',
+      uuid: 'a uuid',
+      name: 'a name',
+    });
+    expect(await getAuthor('a reason')).toEqual({
+      type: 'user',
+      uuid: 'a uuid',
+      name: 'a name',
+      reason: 'a reason',
+    });
+  });
+
+  it('getAuthor throws without user', async() => {
+    process.env.ExampleDocumentTableName = 'some_name';
+    const authProvider = stubAuthProvider();
+    const searchSpy = jest.fn();
+    const createSearchProviderSpy = jest.fn().mockReturnValue({search: searchSpy});
+
+    let getAuthor: any;
+
+    const versionedDocumentStoreInner = jest.fn((_1, _2, options) => { getAuthor = options.getAuthor;});
+    const versionedDocumentStore = jest.fn().mockReturnValue(jest.fn().mockReturnValue(versionedDocumentStoreInner));
+    const services = {authProvider, createSearchProvider: createSearchProviderSpy as CreateSearchProvider};
+    documentStoreMiddleware({versionedDocumentStore} as unknown as AppServices)(services);
+
+    expect(getAuthor).toBeDefined();
+    await expect(getAuthor()).rejects.toThrow();
+  });
+
+  it('indexes search on afterWrite', async() => {
+    const authProvider = stubAuthProvider({uuid: 'a uuid', name: 'a name'} as User);
+    const searchSpy = jest.fn();
+    const indexSpy = jest.fn();
+    const createSearchProviderSpy = jest.fn().mockReturnValue({search: searchSpy, index: indexSpy});
+    
+    let afterWrite: any;
+
+    const versionedDocumentStoreInner = jest.fn((_1, _2, options) => { afterWrite = options.afterWrite;});
+    const versionedDocumentStore = jest.fn().mockReturnValue(jest.fn().mockReturnValue(versionedDocumentStoreInner));
+    const services = {authProvider, createSearchProvider: createSearchProviderSpy as CreateSearchProvider};
+    documentStoreMiddleware({versionedDocumentStore} as unknown as AppServices)(services);
+
+    const payload = {id: 'some id', name: 'some name', description: 'some description'};
+    await afterWrite(payload);
+    expect(indexSpy).toHaveBeenCalledWith(expect.objectContaining({id: 'some id', body: payload})); 
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/example/documentStoreMiddleware.ts

@@ -0,0 +1,70 @@
+import { assertDefined } from '@openstax/ts-utils/assertions';
+import { envConfig } from '@openstax/ts-utils/config';
+import { UnauthorizedError } from '@openstax/ts-utils/errors';
+import { AuthProvider } from '@openstax/ts-utils/services/authProvider';
+import { VersionedDocumentRequiredFields } from '@openstax/ts-utils/services/documentStore/versioned';
+import { IndexConfig } from '@openstax/ts-utils/services/searchProvider/openSearch';
+import { AppServices } from '../../../core';
+import { CreateSearchProvider } from '../middleware/searchMiddleware';
+
+const searchIndexConfig: IndexConfig = {
+  name: 'example_example_document',
+  mappings: {
+    id: { type: 'keyword' },
+    name: { type: 'text' },
+    description: { type: 'text' },
+    author: {
+      properties: {
+        uuid: {type: 'keyword'},
+      },
+    },
+  },
+  pageSize: 10,
+};
+
+export type ExampleDocument = {
+  id: string;
+  name: string;
+  description: string;
+} & VersionedDocumentRequiredFields;
+
+const config = {
+  fileSystem: {
+    tableName: 'example-document'
+  },
+  dynamodb: {
+    tableName: envConfig('EXAMPLE_TABLE_NAME', 'runtime'),
+  }
+};
+
+export const documentStoreMiddleware = <M extends {
+  authProvider: AuthProvider;
+  createSearchProvider: CreateSearchProvider;
+}>(app: AppServices) => {
+  const makeExampleDocumentStore = app.versionedDocumentStore<ExampleDocument>()(config);
+
+  return (middleware: M) => {
+    const getAuthor = async(reason?: string) => {
+      const user = assertDefined(await middleware.authProvider.getUser(), new UnauthorizedError());
+      return {type: 'user' as const, uuid: user.uuid, name: user.name, ...(reason ? {reason} : {})};
+    };
+    const afterWrite = async(item: ExampleDocument) => {
+      await exampleDocumentSearch.index({id: item.id, body: item});
+    };
+    const exampleDocumentStore = makeExampleDocumentStore(middleware, 'id', {getAuthor, afterWrite});
+    const exampleDocumentSearch = middleware.createSearchProvider({
+      store: exampleDocumentStore,
+      ...searchIndexConfig
+    });
+
+    return {
+      ...middleware,
+      exampleDocumentStore: {
+        ...exampleDocumentStore,
+        search: exampleDocumentSearch.search,
+      },
+    };
+  };
+};
+
+export type ExampleDocumentStore = ReturnType<ReturnType<typeof documentStoreMiddleware>>['exampleDocumentStore'];