@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -0,0 +1,263 @@
+import { getKeyValue } from '@openstax/ts-utils';
+import { stubAuthProvider, User } from '@openstax/ts-utils/services/authProvider';
+import { FileServerAdapter } from '@openstax/ts-utils/services/fileServer';
+import { createConsoleLogger } from '@openstax/ts-utils/services/logger/console';
+import { ApiRouteRequest, AppServices } from '../../core';
+import { apiV0Index, apiV0Routes, buildIndex, makeIndexHtmlBody } from '.';
+
+let appServices: AppServices;
+let request: ApiRouteRequest;
+
+beforeEach(async () => {
+  appServices = {} as AppServices;
+  request = {} as ApiRouteRequest;
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('apiV0Index', () => {
+  it('matches snapshot', async() => {
+    const requestServices = {
+      logger: createConsoleLogger(),
+      request,
+      environmentConfig: {
+        codeVersion: 'code-version-goes-here',
+        apiHost: '',
+        uiHost: '',
+        maintenanceMessage: '',
+        frontendConfig: {
+          roleApplication: 'test',
+          accountsBase: 'https://dev.openstax.org/accounts',
+          exampleMessage: 'hello from /api/v0/info',
+        },
+      },
+      authProvider: stubAuthProvider()
+    };
+    const response = await apiV0Index.handler(undefined, requestServices);
+    expect(response).toMatchInlineSnapshot(`
+{
+  "body": "{"message":"greetings from the api controller","code":"code-version-goes-here","config":{"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"}}",
+  "data": {
+    "code": "code-version-goes-here",
+    "config": {
+      "accountsBase": "https://dev.openstax.org/accounts",
+      "exampleMessage": "hello from /api/v0/info",
+      "releaseId": "code-version-goes-here",
+      "roleApplication": "test",
+    },
+    "message": "greetings from the api controller",
+  },
+  "headers": {
+    "content-type": "application/json",
+  },
+  "statusCode": 200,
+}
+`);
+  });
+
+  it('matches snapshot with user', async() => {
+    const requestServices = {
+      logger: createConsoleLogger(),
+      request,
+      environmentConfig: {
+        codeVersion: 'code-version-goes-here',
+        apiHost: '',
+        uiHost: '',
+        maintenanceMessage: '',
+        frontendConfig: {
+          roleApplication: 'test',
+          accountsBase: 'https://dev.openstax.org/accounts',
+          exampleMessage: 'hello from /api/v0/info',
+        },
+      },
+      authProvider: stubAuthProvider({name: 'test user', uuid: '5c9f7915-4abb-499b-805d-de29cdf67e2d'} as User)
+    };
+    appServices.getEnvironmentConfig = getKeyValue('deployed');
+    const response = await apiV0Index.handler(undefined, requestServices);
+    expect(response).toMatchInlineSnapshot(`
+{
+  "body": "{"message":"greetings from the api controller test user","code":"code-version-goes-here","config":{"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"}}",
+  "data": {
+    "code": "code-version-goes-here",
+    "config": {
+      "accountsBase": "https://dev.openstax.org/accounts",
+      "exampleMessage": "hello from /api/v0/info",
+      "releaseId": "code-version-goes-here",
+      "roleApplication": "test",
+    },
+    "message": "greetings from the api controller test user",
+  },
+  "headers": {
+    "content-type": "application/json",
+  },
+  "statusCode": 200,
+}
+`);
+  });
+});
+
+describe('buildIndex', () => {
+  it('matches snapshot without user', async() => {
+    const requestServices = {
+      authProvider: stubAuthProvider(),
+      environmentConfig: {
+        codeVersion: 'code-version-goes-here',
+        apiHost: '',
+        uiHost: '',
+        maintenanceMessage: '',
+        frontendConfig: {
+          roleApplication: 'test',
+          accountsBase: 'https://dev.openstax.org/accounts',
+          exampleMessage: 'hello from /api/v0/info',
+        },
+      },
+      frontendFileServer: {
+        putFileContent: jest.fn(),
+        getSignedViewerUrl: jest.fn(),
+        getFileContent: async() => Buffer.from(
+          '<html><head><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>'
+        )
+      } as unknown as FileServerAdapter,
+      logger: createConsoleLogger(),
+      request,
+    };
+    const response = await buildIndex.handler(undefined, requestServices);
+    expect(response).toMatchInlineSnapshot(`
+{
+  "body": "<html><head>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>",
+  "data": "<html><head>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>",
+  "headers": {
+    "cache-control": "no-cache",
+    "content-type": "text/html",
+  },
+  "statusCode": 200,
+}
+`);
+  });
+
+  it('matches snapshot with user', async() => {
+    const requestServices = {
+      authProvider: stubAuthProvider({
+        uuid: '5c9f7915-4abb-499b-805d-de29cdf67e2d',
+        consent_preferences: { accepted: ['test'], rejected: ['nothing'] },
+      } as User),
+      environmentConfig: {
+        codeVersion: 'code-version-goes-here',
+        apiHost: '',
+        uiHost: '',
+        maintenanceMessage: '',
+        frontendConfig: {
+          roleApplication: 'test',
+          accountsBase: 'https://dev.openstax.org/accounts',
+          exampleMessage: 'hello from /api/v0/info',
+        },
+      },
+      frontendFileServer: {
+        putFileContent: jest.fn(),
+        getSignedViewerUrl: jest.fn(),
+        getFileContent: async() => Buffer.from(
+          '<html><head><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>'
+        )
+      } as unknown as FileServerAdapter,
+      logger: createConsoleLogger(),
+      request,
+    };
+    const response = await buildIndex.handler(undefined, requestServices);
+    expect(response).toMatchInlineSnapshot(`
+{
+  "body": "<html><head>
+        <script>
+          window._OX_AUTH_TOKEN = 'authToken';
+          window._OX_USER_DATA = {"consentPreferences":{"accepted":["test"],"rejected":["nothing"]},"uuid":"5c9f7915-4abb-499b-805d-de29cdf67e2d"};
+        </script>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>",
+  "data": "<html><head>
+        <script>
+          window._OX_AUTH_TOKEN = 'authToken';
+          window._OX_USER_DATA = {"consentPreferences":{"accepted":["test"],"rejected":["nothing"]},"uuid":"5c9f7915-4abb-499b-805d-de29cdf67e2d"};
+        </script>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>",
+  "headers": {
+    "cache-control": "no-cache",
+    "content-type": "text/html",
+  },
+  "statusCode": 200,
+}
+`);
+  });
+
+  it('matches snapshot with subcontent queryStringParameter', async() => {
+    const requestServices = {
+      authProvider: stubAuthProvider(),
+      environmentConfig: {
+        codeVersion: 'code-version-goes-here',
+        apiHost: '',
+        uiHost: '',
+        maintenanceMessage: '',
+        frontendConfig: {
+          roleApplication: 'test',
+          accountsBase: 'https://dev.openstax.org/accounts',
+          exampleMessage: 'hello from /api/v0/info',
+        },
+      },
+      frontendFileServer: {
+        putFileContent: jest.fn(),
+        getSignedViewerUrl: jest.fn(),
+        getFileContent: async() => Buffer.from(
+          '<html><head><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>'
+        )
+      } as unknown as FileServerAdapter,
+      logger: createConsoleLogger(),
+      request: { queryStringParameters: { subcontent: 'true' } } as unknown as ApiRouteRequest,
+    };
+    const response = await buildIndex.handler(undefined, requestServices);
+    expect(response).toMatchInlineSnapshot(`
+{
+  "body": "<html><head>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body class="os-subcontent"><!-- Static body stuff --></body></html>",
+  "data": "<html><head>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body class="os-subcontent"><!-- Static body stuff --></body></html>",
+  "headers": {
+    "cache-control": "no-cache",
+    "content-type": "text/html",
+  },
+  "statusCode": 200,
+}
+`);
+  });
+});
+
+describe('makeIndexHtmlBody', () => {
+  it('matches snapshot with maintenance message', async () => {
+    const response = await makeIndexHtmlBody({
+      putFileContent: jest.fn(),
+      getSignedViewerUrl: jest.fn(),
+      getFileContent: async () => Buffer.from(
+        '<html><head><!-- Static head stuff --></head><body><!-- Static body stuff --></body></html>'
+      )
+    } as unknown as FileServerAdapter, {
+      codeVersion: 'code-version-goes-here',
+      maintenanceMessage: 'Down for maintenance',
+      frontendConfig: {
+        roleApplication: 'test',
+        accountsBase: 'https://dev.openstax.org/accounts',
+        exampleMessage: 'hello from /api/v0/info',
+      }
+    }
+    );
+    expect(response).toMatchInlineSnapshot(`
+"<html><head>
+      <script>window._OX_FRONTEND_CONFIG = {"roleApplication":"test","accountsBase":"https://dev.openstax.org/accounts","exampleMessage":"hello from /api/v0/info","releaseId":"code-version-goes-here"};</script><!-- Static head stuff --></head><body>Down for maintenance<!-- Static body stuff --></body></html>"
+`);
+  });
+});
+
+describe('apiV0Routes', () => {
+  it('collects routes', () => {
+    expect(() => apiV0Routes()).not.toThrow();
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/index.ts

@@ -0,0 +1,134 @@
+import { ConfigForConfigProvider, ConfigValueProvider, envConfig, resolveConfigValue } from '@openstax/ts-utils/config';
+import { once } from '@openstax/ts-utils/misc/helpers';
+import { apiHtmlResponse, apiJsonResponse, METHOD, routesList } from '@openstax/ts-utils/routing';
+import { TokenUser } from '@openstax/ts-utils/services/authProvider';
+import { FileServerAdapter } from '@openstax/ts-utils/services/fileServer';
+import { composeServiceMiddleware, createRoute } from '../../core/services';
+import { apiV0ExampleRoutes } from './example/routes';
+import { authMiddleware } from './middleware/authMiddleware';
+import { getEnvironmentConfig } from './middleware/configMiddleware';
+import { frontendFileServerMiddleware } from './middleware/frontendFileServerMiddleware';
+import { roleValidatorConfig } from './middleware/userRoleValidatorMiddleware';
+
+// frontendConfig values are visible to all users
+const configProvider = getEnvironmentConfig({
+  local: {
+    codeVersion: 'dev',
+    maintenanceMessage: envConfig('MAINTENANCE_MESSAGE', 'runtime', ''),
+    frontendConfig: {
+      roleApplication: roleValidatorConfig.application,
+      accountsBase: envConfig('ACCOUNTS_BASE', 'runtime', '/accounts'),
+      exampleMessage: envConfig('EXAMPLE_MESSAGE', 'runtime', 'hello from /api/v0/info'),
+    },
+  },
+  deployed: {
+    codeVersion: envConfig('CODE_VERSION'),
+    maintenanceMessage: envConfig('MAINTENANCE_MESSAGE', 'runtime', ''),
+    frontendConfig: {
+      roleApplication: roleValidatorConfig.application,
+      accountsBase: envConfig('ACCOUNTS_BASE', 'runtime'),
+      exampleMessage: envConfig('EXAMPLE_MESSAGE', 'runtime', 'hello from /api/v0/info'),
+    },
+  },
+});
+
+const requestServiceProvider = composeServiceMiddleware(
+  authMiddleware,
+  configProvider,
+);
+
+type EnvironmentConfigProvider = ReturnType<ReturnType<typeof configProvider>>['environmentConfig'];
+export type FrontendConfigProvider = EnvironmentConfigProvider['frontendConfig'];
+
+const resolveFrontendConfig = once(async(frontendConfig: FrontendConfigProvider, codeVersion: ConfigValueProvider<string>) => {
+  const config: Record<string, ConfigValueProvider<string>> = {};
+
+  await Promise.all(Object.entries({...frontendConfig, releaseId: codeVersion}).map(
+    async([name, value]) => config[name] = await resolveConfigValue(value)
+  ));
+
+  return config as ConfigForConfigProvider<FrontendConfigProvider>;
+});
+
+export const makeIndexHtmlBody = async(fileServer: FileServerAdapter, config: EnvironmentConfigProvider) => {
+  const frontendConfig = await resolveFrontendConfig(config.frontendConfig, config.codeVersion);
+  const maintenanceMessage = await resolveConfigValue(config.maintenanceMessage);
+  const bodyFile = maintenanceMessage ? 'maintenance' : 'index';
+
+  let body = (await fileServer.getFileContent({
+    dataType: 'file',
+    mimeType: 'text/html',
+    path: `build/${bodyFile}.html`,
+    label: `${bodyFile}.html`,
+  })).toString();
+
+  if (maintenanceMessage) {
+    body = body.replace('<body>', `<body>${maintenanceMessage}`);
+  }
+
+  return body.replace(
+    '<head>',
+    `<head>
+      <script>window._OX_FRONTEND_CONFIG = ${JSON.stringify(frontendConfig)};</script>`
+  );
+};
+
+const indexHtmlBody = once(makeIndexHtmlBody);
+
+export const apiV0Index = createRoute({name: 'apiV0Info', method: METHOD.GET, path: '/api/v0/info',
+  requestServiceProvider},
+  async(_params: undefined, services) => {
+    const user = await services.authProvider.getUser();
+    const environmentConfig = services.environmentConfig;
+    // This config is here for backwards compatibility and can eventually be removed
+    const config = await resolveFrontendConfig(environmentConfig.frontendConfig, environmentConfig.codeVersion);
+
+    return apiJsonResponse(200, {
+      message: `greetings from the api controller${user ? ` ${user.name}`: ''}`,
+      code: await resolveConfigValue(services.environmentConfig.codeVersion),
+      config: config,
+    });
+  }
+);
+
+const oxUserData = (user: TokenUser, consentPreferences: { accepted?: string[]; rejected?: string[] } | undefined) => {
+  const { uuid } = user;
+  return JSON.stringify({ consentPreferences, uuid });
+};
+
+export const buildIndex = createRoute({name: 'buildIndex', method: METHOD.GET, path: '/build/index.html',
+  requestServiceProvider: composeServiceMiddleware(
+    requestServiceProvider,
+    frontendFileServerMiddleware,
+  )},
+  async(_params: undefined, services) => {
+    const token = await services.authProvider.getAuthToken();
+    const user = await services.authProvider.loadUserData();
+
+    // Frontend config is already included
+    const originalBody = await indexHtmlBody(services.frontendFileServer, services.environmentConfig);
+
+    // Add os-subcontent body class if subcontent queryStringParameter is set to true
+    const bodyWithSubcontent = services.request.queryStringParameters?.subcontent === 'true' ? originalBody.replace(
+      '<body>', '<body class="os-subcontent">'
+    ) : originalBody;
+
+    // Add _OX_USER_DATA if logged in
+    const body = user ? bodyWithSubcontent.replace(
+      '<head>',
+      `<head>
+        <script>
+          window._OX_AUTH_TOKEN = '${token}';
+          window._OX_USER_DATA = ${oxUserData(user, user.consent_preferences)};
+        </script>`
+    ): bodyWithSubcontent;
+
+    return apiHtmlResponse(200, body, { 'cache-control': 'no-cache' });
+  }
+);
+
+export const apiV0Routes = () => routesList([
+  apiV0Index,
+  buildIndex,
+  ...apiV0ExampleRoutes(),
+]);

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/authMiddleware.spec.ts

@@ -0,0 +1,23 @@
+import { createCoreLogger } from '@openstax/ts-utils/services/logger';
+import { ApiRouteRequest, AppServices } from '../../../core';
+import { authMiddleware } from './authMiddleware';
+
+describe('authMiddleware', () => {
+  it('adds request cookies to auth provider', () => {
+    const createAuthProvider = jest.fn();
+    const request = {headers: {}, cookies: ['one=cookieOne', 'two=cookieTwo']} as unknown as ApiRouteRequest;
+    const logger = createCoreLogger(jest.fn());
+    const middleware = {request, logger};
+    authMiddleware({createAuthProvider: () => createAuthProvider} as unknown as AppServices)(middleware);
+    expect(createAuthProvider).toHaveBeenCalledWith(expect.objectContaining({request}));
+  });
+
+  it('works if there are no cookies', () => {
+    const createAuthProvider = jest.fn();
+    const request = {headers: {}} as unknown as ApiRouteRequest;
+    const logger = createCoreLogger(jest.fn());
+    const middleware = {request, logger};
+    authMiddleware({createAuthProvider: () => createAuthProvider} as unknown as AppServices)(middleware);
+    expect(createAuthProvider).toHaveBeenCalledWith(expect.objectContaining({request}));
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/authMiddleware.ts

@@ -0,0 +1,32 @@
+import { envConfig, lambdaParameterConfig, replaceConfig } from '@openstax/ts-utils/config';
+import type { Logger } from '@openstax/ts-utils/services/logger';
+import { ApiRouteRequest, AppServices } from '../../../core';
+
+const config = {
+  local: {
+    accountsBase: 'https://dev.openstax.org/accounts',
+    cookieName: 'oxa_dev',
+  },
+  deployed: {
+    accountsBase: envConfig('ACCOUNTS_BASE', 'runtime'),
+    cookieName: envConfig('COOKIE_NAME', 'runtime'),
+    encryptionPrivateKey: lambdaParameterConfig(
+      replaceConfig('/[app]/[env]/api/EncryptionPrivateKey', {
+        '[app]': envConfig('APPLICATION'),
+        '[env]': envConfig('ENV_NAME', 'runtime')
+      })
+    ),
+    signaturePublicKey: envConfig('SIGNATURE_PUBLIC_KEY', 'runtime'),
+  },
+};
+
+export const authMiddleware = ({createAuthProvider}: AppServices) => {
+  const authProvider = createAuthProvider(config);
+
+  return <M extends {request: ApiRouteRequest; logger: Logger}>(middleware: M) => {
+    return {
+      ...middleware,
+      authProvider: authProvider(middleware)
+    };
+  };
+};

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/configMiddleware.spec.ts

@@ -0,0 +1,10 @@
+import { getKeyValue } from '@openstax/ts-utils';
+import { AppServices } from '../../../core/types';
+import { getEnvironmentConfig } from './configMiddleware';
+
+describe('getEnvironmentConfig', () => {
+  it('gets the environment config', () => {
+    const result = getEnvironmentConfig({local: {test: 'local'}, deployed: {test: 'deployed'}})({getEnvironmentConfig: getKeyValue('local')} as AppServices)({});
+    expect(result.environmentConfig.test).toBe('local');
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/configMiddleware.ts

@@ -0,0 +1,7 @@
+// TODO - if we make this even more generic so that it doesn't rely on the app specific base config type, we can move it to ts-utils/config
+import { AppServices, BaseEnvironmentConfig } from '../../../core/types';
+
+export const getEnvironmentConfig = <P extends BaseEnvironmentConfig>(config: P) => ({getEnvironmentConfig}: AppServices) => <M extends {}>(middleware: M) => {
+  const environmentConfig = getEnvironmentConfig(config);
+  return {...middleware, environmentConfig};
+};

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/frontendFileServerMiddleware.spec.ts

@@ -0,0 +1,13 @@
+import { ApiRouteRequest, AppServices } from '../../../core';
+import { frontendFileServerMiddleware } from './frontendFileServerMiddleware';
+
+describe('frontendFileServerMiddleware', () => {
+  it('adds frontendFileServer to middleware stack', () => {
+    const frontendFileServer = {};
+    const createFileServer = jest.fn().mockReturnValue(frontendFileServer);
+    const request = {} as unknown as ApiRouteRequest;
+    const middleware = frontendFileServerMiddleware({ createFileServer } as unknown as AppServices)({request});
+    expect(createFileServer).toHaveBeenCalledWith(expect.objectContaining({ local: { storagePrefix: '../../frontend' } }));
+    expect(middleware.frontendFileServer).toBe(frontendFileServer);
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/frontendFileServerMiddleware.ts

@@ -0,0 +1,23 @@
+import { envConfig } from '@openstax/ts-utils/config';
+import { ApiRouteRequest, AppServices } from '../../../core';
+
+const config = {
+  local: {
+    storagePrefix: '../../frontend',
+  },
+  deployed: {
+    bucketName: envConfig('FRONTEND_BUILD_BUCKET', 'runtime'),
+    bucketRegion: envConfig('AWS_REGION', 'runtime'),
+  },
+};
+
+export const frontendFileServerMiddleware = ({ createFileServer }: AppServices) => {
+  const frontendFileServer = createFileServer(config);
+
+  return <M extends {request: ApiRouteRequest}>(middleware: M) => {
+    return {
+      ...middleware,
+      frontendFileServer
+    };
+  };
+};

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/paginationMiddleware.spec.ts

@@ -0,0 +1,9 @@
+import { loadMorePaginationMiddleware, pageNumberPaginationMiddleware } from './paginationMiddleware';
+
+it('is defined', () => {
+  expect(loadMorePaginationMiddleware).toBeDefined();
+});
+
+it('is also defined', () => {
+  expect(pageNumberPaginationMiddleware).toBeDefined();
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/paginationMiddleware.ts

@@ -0,0 +1,9 @@
+import { getKeyValueOr, putKeyValue } from '@openstax/ts-utils';
+import { createPaginationMiddleware, loadMorePagination, pageNumberPagination } from '@openstax/ts-utils/pagination';
+import { ApiRouteRequest } from '../../../core';
+
+const getQueryParams = getKeyValueOr('queryStringParameters', {} as NonNullable<ApiRouteRequest['queryStringParameters']>);
+const setUnusedQueryParams = putKeyValue('queryStringParameters');
+
+export const loadMorePaginationMiddleware = createPaginationMiddleware<ApiRouteRequest>()({getQueryParams, setUnusedQueryParams, paginator: loadMorePagination});
+export const pageNumberPaginationMiddleware = createPaginationMiddleware<ApiRouteRequest>()({getQueryParams, setUnusedQueryParams, paginator: pageNumberPagination});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/searchMiddleware.spec.ts

@@ -0,0 +1,12 @@
+import { AppServices } from '../../../core/types';
+import { searchMiddleware } from './searchMiddleware';
+
+describe('searchMiddleware', () => {
+  it('works', async () => {
+    const provider = {};
+    const createSearchProvider = jest.fn().mockReturnValue(provider);
+    const middleware = searchMiddleware({createSearchProvider} as unknown as AppServices)({});
+    expect(middleware).toHaveProperty('createSearchProvider');
+    expect(middleware.createSearchProvider).toBe(provider);
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/searchMiddleware.ts

@@ -0,0 +1,21 @@
+import { envConfig, replaceConfig } from '@openstax/ts-utils/config';
+import { AppServices } from '../../../core/types';
+
+const config = {
+  deployed: {
+    region: envConfig('OPEN_SEARCH_REGION', 'runtime', 'us-east-1'),
+    node: replaceConfig('https://[host]', {
+      '[host]': envConfig('OPEN_SEARCH_HOST', 'runtime'),
+    }),
+  },
+  local: { },
+};
+
+export const searchMiddleware = <M extends {}>(app: AppServices) => (middleware: M) => {
+  return {
+    ...middleware,
+    createSearchProvider: app.createSearchProvider(config),
+  };
+};
+
+export type CreateSearchProvider = ReturnType<ReturnType<typeof searchMiddleware>>['createSearchProvider'];

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/userRoleValidatorMiddleware.spec.ts

@@ -0,0 +1,21 @@
+import { stubAuthProvider } from '@openstax/ts-utils/services/authProvider';
+import { userRoleValidatorMiddleware } from './userRoleValidatorMiddleware';
+
+describe('userRoleValidatorMiddleware', () => {
+  const envBack = process.env;
+
+  beforeEach(() => {
+    process.env = {...process.env};
+  });
+
+  afterEach(() => {
+    process.env = envBack;
+  });
+
+  it('works', async () => {
+    process.env.APPLICATION = 'test';
+    const authProvider = stubAuthProvider(undefined);
+    const middleware = userRoleValidatorMiddleware()({authProvider});
+    await expect(() => middleware.roleValidator.assertUserRole(['admin'])).rejects.toThrowErrorMatchingInlineSnapshot('"UnauthorizedError"');
+  });
+});

package/packages/lambda/src/functions/serviceApi/versions/v0/middleware/userRoleValidatorMiddleware.ts

@@ -0,0 +1,18 @@
+import { envConfig } from '@openstax/ts-utils/config';
+import { AuthProvider } from '@openstax/ts-utils/services/authProvider';
+import { createUserRoleValidator } from '@openstax/ts-utils/services/authProvider/utils/userRoleValidator';
+
+const config = {
+  application: envConfig('APPLICATION')
+};
+
+export const roleValidatorConfig = config;
+
+export const userRoleValidatorMiddleware = () => {
+  return <M extends {authProvider: AuthProvider}>(middleware: M) => {
+    return {
+      ...middleware,
+      roleValidator: createUserRoleValidator(middleware.authProvider, config),
+    };
+  };
+};

package/packages/lambda/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "incremental": true,
+    "allowJs": false,
+    "allowSyntheticDefaultImports": true,
+    "alwaysStrict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noEmit": true,
+    "noImplicitAny": true,
+    "listEmittedFiles": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "es2019",
+    "lib": [
+      "es2020"
+    ],
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": [
+    "src",
+    "script"
+  ]
+}