[DEV-1362] Add BuildEnv and Strapi utilities (#614)

.changeset/twenty-spoons-prove.md

@@ -0,0 +1,5 @@
+---
+"nextjs-website": minor
+---
+
+[DEV-1362] Create BuildEnv and create function to use to make API calls to Strapi

apps/nextjs-website/src/BuildConfig.ts

@@ -0,0 +1,23 @@
+import { pipe } from 'fp-ts/lib/function';
+import * as E from 'fp-ts/lib/Either';
+import * as PR from 'io-ts/lib/PathReporter';
+import * as t from 'io-ts';
+import * as tt from 'io-ts-types';
+import { StrapiConfig } from '@/lib/strapi/StrapiConfig';
+
+const BuildConfigCodec = t.intersection([
+  t.type({
+    FETCH_FROM_STRAPI: t.string.pipe(tt.BooleanFromString),
+  }),
+  StrapiConfig,
+]);
+
+export type BuildConfig = t.TypeOf<typeof BuildConfigCodec>;
+
+export const makeBuildConfig = (
+  env: Record<string, undefined | string>
+): E.Either<string, BuildConfig> =>
+  pipe(
+    BuildConfigCodec.decode(env),
+    E.mapLeft((errors) => PR.failure(errors).join('\n'))
+  );

apps/nextjs-website/src/BuildEnv.ts

@@ -0,0 +1,13 @@
+import { BuildConfig } from '@/BuildConfig';
+import { StrapiEnv } from '@/lib/strapi/StapiEnv';
+
+// BuildEnv
+export type BuildEnv = {
+  readonly config: BuildConfig;
+} & StrapiEnv;
+
+// given environment variables produce an BuildEnv
+export const makeBuildEnv = (config: BuildConfig): BuildEnv => ({
+  config,
+  fetchFun: fetch,
+});

apps/nextjs-website/src/lib/strapi/StapiEnv.ts

@@ -0,0 +1,7 @@
+import { StrapiConfig } from '@/lib/strapi/StrapiConfig';
+
+// This type represents the environment of Strapi.
+export type StrapiEnv = {
+  readonly config: StrapiConfig;
+  readonly fetchFun: typeof fetch;
+};

apps/nextjs-website/src/lib/strapi/StrapiConfig.ts

@@ -0,0 +1,8 @@
+import * as t from 'io-ts';
+
+export const StrapiConfig = t.type({
+  STRAPI_ENDPOINT: t.string,
+  STRAPI_API_TOKEN: t.string,
+});
+
+export type StrapiConfig = t.TypeOf<typeof StrapiConfig>;

apps/nextjs-website/src/lib/strapi/__tests__/fetchFromStrapi.test.ts

@@ -0,0 +1,116 @@
+import * as t from 'io-ts';
+import { fetchFromStrapi } from '@/lib/strapi/fetchFromStrapi';
+
+const makeTestEnv = () => {
+  const fetchMock = jest.fn();
+  return {
+    fetchMock,
+    env: {
+      config: {
+        STRAPI_ENDPOINT: 'aStrapiEndpoint',
+        STRAPI_API_TOKEN: 'aStrapiApiToken',
+      },
+      fetchFun: fetchMock,
+    },
+  };
+};
+
+const strapiResponses = {
+  200: {
+    data: {
+      id: 1,
+      attributes: {
+        createdAt: '2024-02-08T11:12:02.142Z',
+        updatedAt: '2024-02-08T11:12:21.438Z',
+        publishedAt: '2024-02-08T11:12:21.436Z',
+      },
+    },
+    meta: {},
+  },
+  404: {
+    data: null,
+    error: {
+      status: 404,
+      name: 'NotFoundError',
+      message: 'Not Found',
+      details: {},
+    },
+  },
+  401: {
+    data: null,
+    error: {
+      status: 401,
+      name: 'UnauthorizedError',
+      message: 'Missing or invalid credentials',
+      details: {},
+    },
+  },
+};
+
+const codec = t.strict({
+  data: t.strict({
+    id: t.number,
+  }),
+});
+// This codec is used to test cases when the decode function fails
+const badCodec = t.strict({
+  data: t.strict({
+    id: t.string,
+  }),
+});
+
+describe('fetchFromStrapi', () => {
+  it('should return strapi response given a 200 response', async () => {
+    const { env, fetchMock } = makeTestEnv();
+    fetchMock.mockResolvedValueOnce({
+      status: 200,
+      statusText: 'OK',
+      json: () => Promise.resolve(strapiResponses[200]),
+    });
+    const actual = fetchFromStrapi('aPath', 'aPopulate', codec)(env);
+    const expected = { data: { id: 1 } };
+    expect(await actual).toStrictEqual(expected);
+  });
+  it('should return error given a 401 response', async () => {
+    const { env, fetchMock } = makeTestEnv();
+    fetchMock.mockResolvedValueOnce({
+      status: 401,
+      statusText: 'Unauthorized',
+      json: () => Promise.resolve(strapiResponses[401]),
+    });
+    const actual = fetchFromStrapi('aPath', 'aPopulate', codec)(env);
+    const expected = new Error('401 - Unauthorized');
+    await expect(actual).rejects.toStrictEqual(expected);
+  });
+  it('should return error given a 404 response', async () => {
+    const { env, fetchMock } = makeTestEnv();
+    fetchMock.mockResolvedValueOnce({
+      status: 404,
+      statusText: 'Not Found',
+      json: () => Promise.resolve(strapiResponses[404]),
+    });
+    const actual = fetchFromStrapi('aPath', 'aPopulate', codec)(env);
+    const expected = new Error('404 - Not Found');
+    await expect(actual).rejects.toStrictEqual(expected);
+  });
+  it('should return error given a reject', async () => {
+    const { env, fetchMock } = makeTestEnv();
+    fetchMock.mockRejectedValueOnce({});
+    const actual = fetchFromStrapi('aPath', 'aPopulate', codec)(env);
+    const expected = new Error('[object Object]');
+    await expect(actual).rejects.toStrictEqual(expected);
+  });
+  it('should return error given a decode error', async () => {
+    const { env, fetchMock } = makeTestEnv();
+    fetchMock.mockResolvedValueOnce({
+      status: 200,
+      statusText: 'OK',
+      json: () => Promise.resolve(strapiResponses[200]),
+    });
+    const actual = fetchFromStrapi('aPath', 'aPopulate', badCodec)(env);
+    const expected = new Error(
+      'Invalid value 1 supplied to : {| data: {| id: string |} |}/data: {| id: string |}/id: string'
+    );
+    await expect(actual).rejects.toStrictEqual(expected);
+  });
+});

apps/nextjs-website/src/lib/strapi/fetchFromStrapi.ts

@@ -0,0 +1,62 @@
+import * as t from 'io-ts';
+import { pipe } from 'fp-ts/lib/function';
+import * as R from 'fp-ts/lib/Reader';
+import * as E from 'fp-ts/lib/Either';
+import * as TE from 'fp-ts/lib/TaskEither';
+import * as PR from 'io-ts/lib/PathReporter';
+import { StrapiEnv } from '@/lib/strapi/StapiEnv';
+
+// Function to invoke in order to retrieve data from Strapi.
+export const fetchFromStrapi = <A, O, I>(
+  path: string,
+  populate: '*' | string,
+  codec: t.Type<A, O, I>
+) =>
+  pipe(
+    R.ask<StrapiEnv>(),
+    R.map(
+      ({
+        config: {
+          STRAPI_ENDPOINT: strapiEndpoint,
+          STRAPI_API_TOKEN: strapiApiToken,
+        },
+        fetchFun,
+      }) =>
+        pipe(
+          // handle any promise result
+          TE.tryCatch(
+            () =>
+              fetchFun(`${strapiEndpoint}/api/${path}/?populate=${populate}`, {
+                method: 'GET',
+                headers: {
+                  Authorization: `Bearer ${strapiApiToken}`,
+                },
+              }),
+            E.toError
+          ),
+          TE.chain((response) => {
+            if (response.status === 200) {
+              return TE.tryCatch(() => response.json(), E.toError);
+            } else {
+              return TE.left(makeError(response));
+            }
+          }),
+          TE.chainEitherK((json) =>
+            // decode the response with the given codec
+            pipe(
+              codec.decode(json),
+              E.mapLeft((errors) => new Error(PR.failure(errors).join('\n')))
+            )
+          ),
+          TE.fold(
+            // eslint-disable-next-line functional/no-promise-reject
+            (errors) => () => Promise.reject(errors),
+            (result) => () => Promise.resolve(result)
+          )
+        )()
+    )
+  );
+
+const makeError = ({ status, statusText }: Response) => {
+  return new Error(`${status} - ${statusText}`);
+};