@openstax/ts-utils 1.33.0 → 1.34.0

package/packages/frontend/src/routing/useQuery.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { useServices } from "../core/context/services";
+import { getQuery } from "./middleware";
+
+export const useQuery = () => {
+  const services = useServices();
+  const [query, setQuery] = React.useState(getQuery(services));
+
+  React.useEffect(() => 
+    services.history.listen(() => setQuery(getQuery(services)))
+  , [services, setQuery]);
+
+  return query;
+};

package/packages/frontend/src/setupProxy.js

@@ -0,0 +1,19 @@
+const proxy = require('http-proxy-middleware');
+const lambdaLocalProxy = require('@project/lambdas/build/script/lambdaLocalProxy');
+
+module.exports = function(app) {
+  accountsProxy(app);
+  lambdaLocalProxy(app, 'serviceApi');
+};
+
+function accountsProxy(app) {
+  app.use(proxy('/accounts', {
+    target: 'https://dev.openstax.org',
+    changeOrigin: true,
+    autoRewrite: true,
+    cookieDomainRewrite: "",
+    onProxyReq: (proxyRequest, request, response) => {
+      proxyRequest.setHeader('X-Forwarded-Host', request.headers.host);
+    }
+  }));
+}

package/packages/frontend/src/setupTests.ts

@@ -0,0 +1,9 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import '@testing-library/jest-dom';
+
+
+
+jest.mock('!!val-loader!@project/lambdas/build/script/utils/routeDataLoader', () => ({}), {virtual: true});

package/packages/frontend/src/tests/testServices.tsx

@@ -0,0 +1,23 @@
+import React from 'react';
+import { createUserRoleValidator } from "@openstax/ts-utils/services/authProvider/utils/userRoleValidator";
+import { createMemoryHistory } from "history";
+import { stubAuthProvider } from '@openstax/ts-utils/services/authProvider';
+import { ServiceContext } from "../core/context/services";
+import { AppServices } from "../core/types";
+
+export const testApiGateway: {[key: string]: any} = {};
+
+const authProvider = stubAuthProvider();
+export const testServices = {
+  createApiGateway: () => testApiGateway,
+  history: createMemoryHistory(),
+  authProvider,
+  roleValidator: createUserRoleValidator(authProvider, {application: 'test'}),
+  configProvider: { getConfig: async() => {}, getValue: async(_name: string) => undefined }
+} as any as AppServices;
+
+export const TestServiceProvider = ({children, ...services}: React.PropsWithChildren<Partial<AppServices>>) =>
+  <ServiceContext.Provider value={() => ({...testServices, ...services})}>
+    {children}
+  </ServiceContext.Provider>
+;

package/packages/frontend/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "baseUrl": "src",
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": [
+    "src"
+  ]
+}

package/packages/lambda/.eslintrc.js

@@ -0,0 +1,64 @@
+module.exports = {
+  root: true,
+  env: { node: true, es6: true },
+  parserOptions: {
+    ecmaVersion: 2018
+  },
+  overrides: [
+    {
+      files: ['**/*.ts?(x)'],
+      parser: '@typescript-eslint/parser',
+      parserOptions: {
+        project: 'tsconfig.json',
+        tsconfigRootDir: __dirname,
+        ecmaVersion: 2018,
+        sourceType: 'module',
+        warnOnUnsupportedTypeScriptVersion: true
+      },
+      plugins: ['@typescript-eslint'],
+      extends: [
+        'eslint:recommended',
+        'plugin:import/typescript'
+      ],
+      rules: {
+        '@typescript-eslint/ban-ts-comment': 'off',
+        '@typescript-eslint/no-inferrable-types': [
+          'warn',
+          { ignoreParameters: true }
+        ],
+        semi: 'off',
+        '@typescript-eslint/semi': ['warn'],
+        '@typescript-eslint/member-delimiter-style': ['warn'],
+        'no-unused-vars': 'off',
+        '@typescript-eslint/no-unused-vars': [
+          'warn',
+          {
+            args: 'none',
+            ignoreRestSiblings: true,
+            varsIgnorePattern: '^_',
+          }
+        ],
+        '@typescript-eslint/no-explicit-any': 'off'
+      }
+    }
+  ],
+  ignorePatterns: ['node_modules', 'dist', 'build', 'coverage'],
+  plugins: ['import', 'jest'],
+  extends: [
+    'eslint:recommended',
+    'plugin:jest/recommended',
+    'plugin:jest/style'
+  ],
+  rules: {
+    quotes: ['warn', 'single'],
+    'quote-props': ['warn', 'as-needed'],
+    'import/order': [
+      'warn',
+      { 'newlines-between': 'never', alphabetize: { order: 'asc' } }
+    ],
+    'sort-imports': [
+      'warn',
+      { ignoreDeclarationSort: true, ignoreCase: true }
+    ]
+  }
+}

package/packages/lambda/jest-global-setup.js

@@ -0,0 +1,3 @@
+module.exports = async () => {
+  process.env.TZ = 'UTC';
+};

package/packages/lambda/jest-setup-after-env.js

@@ -0,0 +1 @@
+// use this file for any global mocks or shared setup

package/packages/lambda/jest.config.js

@@ -0,0 +1,31 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  globalSetup: './jest-global-setup.js',
+  setupFilesAfterEnv: ['./jest-setup-after-env.js'],
+  testMatch: [
+    '**/(src|script)/**/?(*.)+(spec).ts'
+  ],
+  collectCoverageFrom: [
+    'src/**/*.{js,ts}',
+    'script/**/*.{js,ts}',
+  ],
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/test/',
+  ],
+  coverageReporters: [
+    'text-summary',
+    'html',
+    'lcovonly'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 100,
+      functions: 100,
+      lines: 100,
+      statements: 100
+    }
+  },
+  resolver: './jest.resolver.js'
+};

package/packages/lambda/jest.resolver.js

@@ -0,0 +1,17 @@
+// https://github.com/cloudflare/miniflare/issues/271#issuecomment-1255544333
+//
+// the uuid package says that it fixed this in v9 here https://github.com/uuidjs/uuid/pull/616#issuecomment-1237428554
+// but i tired it and was still getting the error. try removing this hack in the future and
+// see if it got figured out.
+module.exports = (path, options) => {
+  return options.defaultResolver(path, {
+    ...options,
+    packageFilter: pkg => {
+      if (pkg.name === 'uuid') {
+        delete pkg['exports'];
+        delete pkg['module'];
+      }
+      return pkg;
+    },
+  });
+};

package/packages/lambda/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@project/lambdas",
+  "version": "1.0.0",
+  "dependencies": {
+    "@openstax/ts-utils": "1.33.0",
+    "aws-sdk": "^2.1145.0",
+    "aws-xray-sdk": "^3.6.0",
+    "body-parser": "^1.19.2",
+    "node-fetch": "^2.7.0",
+    "path-to-regexp": "^6.2.0",
+    "query-string": "^7.1.1",
+    "url": "^0.11.0"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.92",
+    "@types/cors": "^2.8.13",
+    "@types/express": "^4.17.13",
+    "@types/jest": "^29.5.14",
+    "@types/multer": "^1.4.7",
+    "@types/node": "^24.2.0",
+    "@types/node-fetch": "^2.6.11",
+    "@types/supertest": "^2.0.12",
+    "@types/uuid": "^8.3.4",
+    "@typescript-eslint/eslint-plugin": "^5.13.0",
+    "@typescript-eslint/parser": "^8.39.0",
+    "builtin-modules": "^3.2.0",
+    "cors": "^2.8.5",
+    "cspell": "^5.18.5",
+    "eslint": "^8.10.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jest": "^26.1.1",
+    "express": "^4.17.3",
+    "jest": "^29.7.0",
+    "multer": "^1.4.5-lts.1",
+    "nock": "^13.2.9",
+    "npm-run-all": "^4.1.5",
+    "supertest": "^6.3.3",
+    "ts-jest": "^29.4.1",
+    "ts-loader": "^9.3.0",
+    "typescript": "5.9.2",
+    "webpack": "^5.69.1",
+    "webpack-bundle-analyzer": "^4.10.2",
+    "webpack-cli": "^4.9.2",
+    "yargs": "^17.5.1"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "archive": "yarn archive:bundle && yarn archive:zip",
+    "archive:bundle": "yarn webpack --mode production",
+    "archive:clean": "yarn clean && yarn archive",
+    "archive:zip": "./script/bundle-functions.bash",
+    "build": "./script/build.bash",
+    "build:clean": "yarn clean && yarn build",
+    "ci": "CI=true npm-run-all ci:*",
+    "ci:lint": "eslint --max-warnings=0 .",
+    "ci:spelling": "git ls-files | yarn cspell -c ../../cspell.json --file-list stdin",
+    "ci:test": "yarn jest --coverage",
+    "ci:typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist build",
+    "coverage-report": "open coverage/index.html",
+    "data:clean": "find data/ -maxdepth 1 -type f -delete",
+    "data:reset": "yarn data:clean && yarn data:seed",
+    "data:seed": "cp -n ./data/seeds/* ./data/ || true",
+    "start": "./script/build.bash --watch",
+    "test": "yarn jest"
+  }
+}

package/packages/lambda/script/build.bash

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# spell-checker: ignore pipefail yargs
+set -euo pipefail; if [ -n "${DEBUG-}" ]; then set -x; fi
+
+project_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." >/dev/null 2>&1 && pwd )"
+
+cd "$project_dir";
+
+build_dir="build"
+tsc_args=(--noEmit false --outDir "$build_dir" --declaration --allowJs )
+
+if yarn -s ts-utils has-flag watch "$@"; then
+  tsc_args+=(--watch)
+fi
+if yarn -s ts-utils has-flag clean "$@"; then
+  rm -rf "${build_dir:?}"/*
+fi
+
+yarn -s tsc "${tsc_args[@]}"

package/packages/lambda/script/bundle-functions.bash

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+base=$(pwd)
+
+for fn in dist/*; do
+  cd "$base/$fn"
+  zip="../$(basename "$fn").zip"
+  zip -r "$zip" .
+done

package/packages/lambda/script/lambdaLocalProxy.js

@@ -0,0 +1,16 @@
+// TODO - convert this file to ts
+const bodyParser = require('body-parser')
+
+const noCacheRequire = (module) => {
+  Object.keys(require.cache).forEach((key) => { delete require.cache[key] })
+  return require(module);
+}
+
+module.exports = function lambdaLocalProxy(app, fn) {
+  app.use(bodyParser.raw({type: '*/*'}));
+  app.use((...args) => {
+    // this is included here so that you don't have to restart the server to get code changes
+    const {handler} = noCacheRequire(`../src/functions/${fn}/entry/local`);
+    handler(...args);
+  })
+}

package/packages/lambda/script/lambdaLocalProxy.spec.ts

@@ -0,0 +1,147 @@
+import express, {Request, Response} from 'express';
+import request from 'supertest';
+import * as requestModule from '../src/functions/serviceApi/core/request';
+// @ts-ignore-next-line
+import proxy from './lambdaLocalProxy.js';
+
+describe('proxy', () => {
+  let getRequestResponderSpy: jest.SpyInstance;
+  let requestResponderSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    getRequestResponderSpy = jest.spyOn(requestModule, 'getRequestResponder');
+    requestResponderSpy = jest.fn(() => undefined);
+    getRequestResponderSpy.mockReturnValue(requestResponderSpy);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('passes request to app responder', async() => {
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).post('/asdf/path/asdf')
+      .send({ foobar: 'body' })
+      .set('neatHeader', 'headerValue')
+    ;
+
+    expect(requestResponderSpy).toHaveBeenCalledWith(expect.objectContaining({
+      requestContext: {
+        http: {
+          method: 'POST',
+          path: '/asdf/path/asdf',
+        }
+      },
+      body: Buffer.from(JSON.stringify({ foobar: 'body' }), 'utf8'),
+      headers: expect.objectContaining({ neatheader: 'headerValue' }), // cspell:disable-line
+    }));
+  });
+
+  it('passes cookie to app responder', async() => {
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).get('/asdf/path/asdf').send()
+      .set('neatHeader', 'headerValue')
+      .set('cookie', 'one=cookie-one; two=cookie-two')
+    ;
+
+    expect(requestResponderSpy).toHaveBeenCalledWith(expect.objectContaining({
+      cookies: [
+        'one=cookie-one',
+        'two=cookie-two'
+      ],
+    }));
+  });
+
+  it('passes query params to app responder', async() => {
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).get('/asdf/path/asdf?param1=value1').send()
+      .set('neatHeader', 'headerValue')
+      .set('cookie', 'one=cookie-one; two=cookie-two')
+    ;
+
+    expect(requestResponderSpy).toHaveBeenCalledWith(expect.objectContaining({
+      queryStringParameters: {
+        param1: 'value1'
+      }
+    }));
+  });
+
+  it('passes multi value query params to app responder', async() => {
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).get('/asdf/path/asdf?param1=value1&param1=value2').send()
+      .set('neatHeader', 'headerValue')
+      .set('cookie', 'one=cookie-one; two=cookie-two')
+    ;
+
+    expect(requestResponderSpy).toHaveBeenCalledWith(expect.objectContaining({
+      queryStringParameters: {
+        param1: 'value1,value2'
+      }
+    }));
+  });
+
+  it('passes through when app has no response', async() => {
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    const fallback = jest.fn((_req: Request, res: Response) => res.send('hello'));
+    app.all('*', fallback);
+
+    await request(app).get('/asdf/path/asdf?param1=value1').send()
+      .set('neatHeader', 'headerValue')
+      .set('cookie', 'one=cookie-one; two=cookie-two')
+    ;
+
+    expect(fallback).toHaveBeenCalled();
+  });
+
+  it('responds when app has response', async() => {
+    const appResponse = {statusCode: 201, body: 'response' };
+    requestResponderSpy.mockReturnValue(Promise.resolve(appResponse));
+
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).get('/asdf/path/asdf').send()
+      .expect(201, 'response');
+
+    expect(requestResponderSpy).toHaveBeenCalled();
+  });
+
+  it('responds when app has encoded response', async() => {
+    const appResponse = {statusCode: 200, body: Buffer.from('response').toString('base64'), isBase64Encoded: true};
+    requestResponderSpy.mockReturnValue(Promise.resolve(appResponse));
+
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).get('/asdf/path/asdf').send()
+      .expect(200, 'response');
+
+    expect(requestResponderSpy).toHaveBeenCalled();
+  });
+
+  it('works for empty path and queryString', async() => {
+    const app = express();
+    proxy(app, 'serviceApi');
+
+    await request(app).get('');
+
+    expect(requestResponderSpy).toHaveBeenCalledWith(expect.objectContaining({
+      requestContext: {
+        http: {
+          method: 'GET',
+          path: '/',
+        }
+      },
+    }));
+  });
+});

package/packages/lambda/script/utils/getRouteData.ts

@@ -0,0 +1,7 @@
+export const getApiRouteData = (api: string) => require(`../../src/functions/${api}/core/routes`).apiRoutes().reduce((result: any, route: any) => ({
+  ...result,
+  [route.name]: {
+    path: route.path,
+    method: route.method,
+  }
+}), {});

package/packages/lambda/script/utils/routeDataLoader.js

@@ -0,0 +1,8 @@
+// TODO - convert this file to ts
+const routeData = require('./getRouteData').getApiRouteData('serviceApi');
+
+// TODO - use `options` to pass `serviceApi` instead of using it literally 
+/* eslint-disable no-unused-vars */
+module.exports = (options, loaderContext) => {
+  return { code: 'module.exports = ' + JSON.stringify(routeData) };
+};

package/packages/lambda/script/utils/routeDataLoader.spec.ts

@@ -0,0 +1,8 @@
+describe('routeDataLoader', () => {
+  it('works', () => {
+    expect(require('./routeDataLoader')).not.toThrow();
+  });
+});
+
+/* eslint-disable jest/no-export */
+export default null;

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

@@ -0,0 +1,7 @@
+/* istanbul ignore file */
+export * from './routes';
+export * from './services';
+export * from './types';
+export * from './request';
+
+// TODO - comment on the dependency loop issues or try to combine some of these files

package/packages/lambda/src/functions/serviceApi/core/request.spec.ts

@@ -0,0 +1,38 @@
+import { METHOD } from '@openstax/ts-utils/routing';
+import { logExtractor, pathExtractor, routeMatcher } from './request';
+import { ApiRouteRequest } from './types';
+
+describe('logExtractor', () => {
+  it('extracts path and queryStringParameters from request', () => {
+    expect(logExtractor(
+      { queryStringParameters: {}, requestContext: { http: { path: '/asdf/foo' } } } as unknown as ApiRouteRequest
+    )).toEqual({http: { path: '/asdf/foo' }, query: {}, requestId: undefined });
+  });
+
+  it('extracts path and headers from request', () => {
+    expect(logExtractor(
+      { queryStringParameters: {}, requestContext: { http: { path: '/asdf/foo' } }, headers: { 'x-request-id': 'test-id' } } as unknown as ApiRouteRequest
+    )).toEqual({http: { path: '/asdf/foo' }, query: {}, requestId: 'test-id'});
+  });
+
+  it('extracts path and headers is empty from request', () => {
+    expect(logExtractor(
+      { queryStringParameters: {}, requestContext: { http: { path: '/asdf/foo' } }, headers: {} } as unknown as ApiRouteRequest
+    )).toEqual({http: { path: '/asdf/foo' }, query: {}, requestId: undefined});
+  });
+});
+
+describe('pathExtractor', () => {
+  it('extracts path from request', () => {
+    expect(pathExtractor({requestContext: {http: {path: '/asdf/foo'}}} as ApiRouteRequest)).toBe('/asdf/foo');
+  });
+});
+
+describe('routeMatcher', () => {
+  it('positive matches', () => {
+    expect(routeMatcher({requestContext: {http: {method: 'GET'}}} as ApiRouteRequest, {method: METHOD.GET})).toBe(true);
+  });
+  it('negative matches', () => {
+    expect(routeMatcher({requestContext: {http: {method: 'GET'}}} as ApiRouteRequest, {method: METHOD.POST})).toBe(false);
+  });
+});

package/packages/lambda/src/functions/serviceApi/core/request.ts

@@ -0,0 +1,42 @@
+/* spell-checker: ignore herokuapp */
+import { envConfig } from '@openstax/ts-utils/config';
+import { makeComposeMiddleware } from '@openstax/ts-utils/middleware';
+import { createErrorHandler } from '@openstax/ts-utils/middleware/apiErrorHandler';
+import { createSlowResponseMiddleware } from '@openstax/ts-utils/middleware/apiSlowResponseMiddleware';
+import { makeGetRequestResponder, METHOD } from '@openstax/ts-utils/routing';
+import { apiRoutes, TRoutes } from './routes';
+import { ApiRouteRequest, ApiRouteResponse, AppServices } from './types';
+
+export const errorHandler = createErrorHandler();
+
+export const slowResponseMiddleware = createSlowResponseMiddleware({
+  logResponseSlowerThan: envConfig('LOG_SLOW_RESPONSE', 'runtime', '1000'),
+  timeoutResponseAfter: envConfig('RESPONSE_TIMEOUT', 'runtime', '28000'),
+});
+
+export const pathExtractor = (request: ApiRouteRequest) =>
+  request.requestContext.http.path
+;
+
+export const logExtractor = (request: ApiRouteRequest) => {
+  const { queryStringParameters, requestContext } = request;
+  return {
+    http: requestContext.http,
+    query: queryStringParameters,
+    requestId: request.headers?.['x-request-id'],
+  };
+};
+
+export const routeMatcher = (request: ApiRouteRequest, route: {method: METHOD}) => {
+  return request.requestContext.http.method === route.method;
+};
+
+export const composeResponseMiddleware = makeComposeMiddleware<AppServices, Promise<ApiRouteResponse> | undefined>();
+
+export const getRequestResponder = makeGetRequestResponder<AppServices, TRoutes, ApiRouteRequest, Promise<ApiRouteResponse>>()({
+  routes: apiRoutes,
+  pathExtractor,
+  routeMatcher,
+  errorHandler,
+  logExtractor,
+});

package/packages/lambda/src/functions/serviceApi/core/routes.spec.ts

@@ -0,0 +1,7 @@
+import { apiRoutes } from './routes';
+
+describe('routes', () => {
+  it('aggregates api routes', () => {
+    expect(apiRoutes()).toEqual(expect.any(Array));
+  });
+});

package/packages/lambda/src/functions/serviceApi/core/routes.ts

@@ -0,0 +1,10 @@
+import { makeRenderRouteUrl } from '@openstax/ts-utils/routing';
+import { apiV0Routes } from '../versions/v0';
+
+export const apiRoutes = () => ([
+  ...apiV0Routes(),
+]);
+
+export type TRoutes = (ReturnType<typeof apiRoutes>)[number];
+
+export const renderRouteUrl = makeRenderRouteUrl<TRoutes>();

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

@@ -0,0 +1,9 @@
+import { makeComposeMiddleware } from '@openstax/ts-utils/middleware';
+import { makeCreateRoute, METHOD } from '@openstax/ts-utils/routing';
+import { Logger } from '@openstax/ts-utils/services/logger';
+import { ApiRouteRequest, AppServices } from './types';
+
+export const composeServiceMiddleware = makeComposeMiddleware<AppServices, {request: ApiRouteRequest; logger: Logger}>();
+export const createRoute = makeCreateRoute<AppServices, ApiRouteRequest, {
+  method: METHOD;
+}>();

package/packages/lambda/src/functions/serviceApi/core/types.ts

@@ -0,0 +1,13 @@
+import { ConfigProvider } from '@openstax/ts-utils/config';
+import { ApiResponse } from '@openstax/ts-utils/routing';
+import { APIGatewayProxyEventV2 } from 'aws-lambda';
+import { LambdaServices } from '../entry/lambda/services';
+import { LocalServices } from '../entry/local';
+
+export type ApiRouteRequest = APIGatewayProxyEventV2;
+export type ApiRouteResponse = ApiResponse<number, any>;
+
+export type BaseEnvironmentConfig = {local: ConfigProvider; deployed: ConfigProvider};
+type GetEnvironmentConfig = <C extends BaseEnvironmentConfig>(config: C) => C['local'] | C['deployed'];
+
+export type AppServices = {getEnvironmentConfig: GetEnvironmentConfig} & (LambdaServices | LocalServices);

package/packages/lambda/src/functions/serviceApi/entry/lambda/https-xray.ts

@@ -0,0 +1,4 @@
+import { captureHTTPsGlobal } from 'aws-xray-sdk';
+
+captureHTTPsGlobal(require('http'), true);
+captureHTTPsGlobal(require('https'), true);