feat(lambda): Create split SPAs

lib/lambda/sinkChangelog.ts

@@ -6,6 +6,7 @@ import {
   transformUpdateValuesSchema,
   transformDeleteSchema,
   transformedUpdateIdSchema,
+  transformedSplitSPASchema,
 } from "./update/adminChangeSchemas";
 import { getPackageChangelog } from "libs/api/package";
 
@@ -64,26 +65,41 @@ const processAndIndex = async ({
       // Parse the kafka record's value
       const record = JSON.parse(decodeBase64WithUtf8(value));
 
-      // query all changelog entries for this ID and create copies of all entries with new ID
       if (record.isAdminChange) {
-        const schema = transformDeleteSchema(offset).or(
-          transformUpdateValuesSchema(offset).or(transformedUpdateIdSchema),
-        );
+        const schema = transformDeleteSchema(offset)
+          .or(transformUpdateValuesSchema(offset))
+          .or(transformedUpdateIdSchema)
+          .or(transformedSplitSPASchema);
 
         const result = schema.safeParse(record);
 
         if (result.success) {
           if (result.data.adminChangeType === "update-id") {
+            // Push doc with package being soft deleted
             docs.forEach((log) => {
               const recordOffset = log.id.split("-").at(-1);
-
               docs.push({
                 ...log,
                 id: `${result.data.id}-${recordOffset}`,
                 packageId: result.data.id,
               });
             });
+            // Get all changelog entries for this ID and create copies of all entries with new ID
+            const packageChangelogs = await getPackageChangelog(result.data.idToBeUpdated);
+
+            packageChangelogs.hits.hits.forEach((log) => {
+              const recordOffset = log._id.split("-").at(-1);
+              docs.push({
+                ...log._source,
+                id: `${result.data.id}-${recordOffset}`,
+                packageId: result.data.id,
+              });
+            });
+          } else if (result.data.adminChangeType === "split-spa") {
+            // Push doc with new split package
+            docs.push(result.data);
 
+            // Get all changelog entries for this ID and create copies of all entries with new ID
             const packageChangelogs = await getPackageChangelog(result.data.idToBeUpdated);
 
             packageChangelogs.hits.hits.forEach((log) => {

lib/lambda/sinkMainProcessors.ts

@@ -7,12 +7,14 @@ import {
   deleteAdminChangeSchema,
   updateValuesAdminChangeSchema,
   updateIdAdminChangeSchema,
+  splitSPAAdminChangeSchema,
 } from "./update/adminChangeSchemas";
 
 const removeDoubleQuotesSurroundingString = (str: string) => str.replace(/^"|"$/g, "");
 const adminRecordSchema = deleteAdminChangeSchema
   .or(updateValuesAdminChangeSchema)
-  .or(updateIdAdminChangeSchema);
+  .or(updateIdAdminChangeSchema)
+  .or(splitSPAAdminChangeSchema);
 
 type OneMacRecord = {
   id: string;

lib/lambda/submit/getNextSplitSPAId.ts

@@ -0,0 +1,32 @@
+import { search } from "libs/opensearch-lib";
+import { getDomainAndNamespace } from "libs/utils";
+import { cpocs } from "lib/packages/shared-types/opensearch";
+
+export const getNextSplitSPAId = async (spaId: string) => {
+  const { domain, index } = getDomainAndNamespace("main");
+  const query = {
+    query: {
+      regexp: {
+        "id.keyword": `${spaId}-[A-Z]`,
+      },
+    },
+  };
+  // Get existing split SPAs for this package id
+  const { hits } = await search(domain, index, query);
+  // Extract suffixes from existing split SPA IDs
+  // If there are no split SPAs yet, start at the ASCII character before "A" ("@")
+  // Convert to ASCII char codes to get latest suffix
+  const latestSuffixCharCode = hits.hits.reduce((maxCharCode: number, hit: cpocs.ItemResult) => {
+    const suffix = hit._source.id.toString().split("-").at(-1) ?? "@";
+    return Math.max(maxCharCode, suffix.charCodeAt(0));
+  }, "@".charCodeAt(0));
+
+  // Increment letter but not past "Z"
+  // "A-Z" is 65-90 in ASCII
+  if (latestSuffixCharCode >= 90) {
+    throw new Error("This package can't be further split.");
+  }
+  const nextSuffix = String.fromCharCode(latestSuffixCharCode + 1);
+
+  return `${spaId}-${nextSuffix}`;
+};

lib/lambda/submit/submitSplitSPA.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { handler } from "./submitSplitSPA";
+import { APIGatewayEvent } from "node_modules/shared-types";
+import { TEST_CHIP_SPA_ITEM, TEST_MED_SPA_ITEM } from "mocks";
+
+vi.mock("libs/handler-lib", () => ({
+  response: vi.fn((data) => data),
+}));
+
+// vi.mock("./getNextSplitSPAId", () => ({
+//   getNextSplitSPAId: vi.fn(),
+// }));
+
+describe("handler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.topicName = "test-topic";
+  });
+
+  it("should return 400 if event body is missing", async () => {
+    const event = {} as APIGatewayEvent;
+    const result = await handler(event);
+    expect(result?.statusCode).toEqual(400);
+  });
+
+  // it("should return 400 if package ID is not provided", async () => {
+  //   const emptyBody = {
+  //     body: JSON.stringify({ packageId: undefined }),
+  //   } as APIGatewayEvent;
+  //   const result = await handler(emptyBody);
+  //   expect(result?.statusCode).toEqual(400);
+  // });
+
+  it("should return 404 if package ID is not found", async () => {
+    const invalidPackage = {
+      body: JSON.stringify({ packageId: "MD-25-9999" }),
+    } as unknown as APIGatewayEvent;
+    const result = await handler(invalidPackage);
+    expect(result?.statusCode).toEqual(404);
+  });
+
+  it("should throw an error if not Medicaid SPA", async () => {
+    const chipSPAPackage = {
+      body: { packageId: TEST_CHIP_SPA_ITEM._id },
+    } as unknown as APIGatewayEvent;
+    const result = await handler(chipSPAPackage);
+    const expectedResult = {
+      statusCode: 400,
+      body: { message: "Record must be a Medicaid SPA" },
+    };
+    expect(result).toEqual(expectedResult);
+  });
+
+  it("should return 400 if package ID not provided", async () => {
+    const invalidPackage = {
+      body: JSON.stringify({}),
+    } as unknown as APIGatewayEvent;
+    const result = await handler(invalidPackage);
+    expect(result?.statusCode).toEqual(400);
+  });
+
+  it("should fail to split a package with no topic name", async () => {
+    process.env.topicName = "";
+    const noActionevent = {
+      body: JSON.stringify({
+        packageId: TEST_MED_SPA_ITEM._id,
+      }),
+    } as APIGatewayEvent;
+
+    const result = await handler(noActionevent);
+    const expectedResult = {
+      statusCode: 500,
+      body: { message: "Topic name is not defined" },
+    };
+    expect(result).toStrictEqual(expectedResult);
+  });
+
+  // it("should create a split SPA", async () => {
+  //   const medSPAPackage = {
+  //     body: { packageId: TEST_MED_SPA_ITEM._id },
+  //   } as unknown as APIGatewayEvent;
+  //   console.log(medSPAPackage, "HELLO??");
+  //   const result = await handler(medSPAPackage);
+  //   expect(result?.body).toEqual('{"message":"Record must be a Medicaid SPA"}');
+  // });
+});

lib/lambda/submit/submitSplitSPA.ts

@@ -0,0 +1,95 @@
+import { response } from "libs/handler-lib";
+import { APIGatewayEvent } from "aws-lambda";
+import { getPackage } from "libs/api/package";
+import { produceMessage } from "libs/api/kafka";
+import { ItemResult } from "shared-types/opensearch/main";
+import { events } from "shared-types/events";
+import { getNextSplitSPAId } from "./getNextSplitSPAId";
+import { z } from "zod";
+
+const sendSubmitSplitSPAMessage = async (currentPackage: ItemResult) => {
+  const topicName = process.env.topicName as string;
+  if (!topicName) {
+    throw new Error("Topic name is not defined");
+  }
+  const newId = await getNextSplitSPAId(currentPackage._id);
+  if (!newId) {
+    throw new Error("Error getting next Split SPA Id");
+  }
+
+  // ID and changeMade are excluded; the rest of the object has to be spread into the new package
+  const {
+    id: _id,
+    changeMade: _changeMade,
+    origin: _origin,
+    ...remainingFields
+  } = currentPackage._source;
+
+  await produceMessage(
+    topicName,
+    newId,
+    JSON.stringify({
+      id: newId,
+      idToBeUpdated: currentPackage._id,
+      ...remainingFields,
+      makoChangedDate: Date.now(),
+      changedDate: Date.now(),
+      origin: "OneMAC",
+      changeMade: "OneMAC Admin has added a package to OneMAC.",
+      changeReason: "Per request from CMS, this package was added to OneMAC.",
+      isAdminChange: true,
+      adminChangeType: "split-spa",
+    }),
+  );
+
+  return response({
+    statusCode: 200,
+    body: { message: `New Medicaid Split SPA ${newId} has been created.` },
+  });
+};
+
+const splitSPAEventBodySchema = z.object({
+  packageId: events["new-medicaid-submission"].baseSchema.shape.id,
+});
+
+export const handler = async (event: APIGatewayEvent) => {
+  if (!event.body) {
+    return response({
+      statusCode: 400,
+      body: { message: "Event body required" },
+    });
+  }
+  try {
+    const body = typeof event.body === "string" ? JSON.parse(event.body) : event.body;
+    const { packageId } = splitSPAEventBodySchema.parse(body);
+
+    const currentPackage = await getPackage(packageId);
+    if (!currentPackage || currentPackage.found == false) {
+      return response({
+        statusCode: 404,
+        body: { message: "No record found for the given id" },
+      });
+    }
+
+    if (currentPackage._source.authority !== "Medicaid SPA") {
+      return response({
+        statusCode: 400,
+        body: { message: "Record must be a Medicaid SPA" },
+      });
+    }
+
+    return sendSubmitSplitSPAMessage(currentPackage);
+  } catch (err) {
+    console.error("Error has occured modifying package:", err);
+    if (err instanceof z.ZodError) {
+      return response({
+        statusCode: 400,
+        body: { message: err.errors },
+      });
+    }
+    return response({
+      statusCode: 500,
+      body: { message: err.message || "Internal Server Error" },
+    });
+  }
+};

lib/lambda/update/adminChangeSchemas.ts

@@ -23,6 +23,14 @@ export const updateIdAdminChangeSchema = z
   })
   .and(z.record(z.string(), z.any()));
 
+export const splitSPAAdminChangeSchema = z
+  .object({
+    id: z.string(),
+    adminChangeType: z.literal("split-spa"),
+    idToBeUpdated: z.string(),
+  })
+  .and(z.record(z.string(), z.any()));
+
 export const transformDeleteSchema = (offset: number) =>
   deleteAdminChangeSchema.transform((data) => ({
     ...data,
@@ -48,3 +56,13 @@ export const transformedUpdateIdSchema = updateIdAdminChangeSchema.transform((da
   id: `${data.id}`,
   timestamp: Date.now(),
 }));
+
+export const transformedSplitSPASchema = splitSPAAdminChangeSchema.transform((data) => ({
+  ...data,
+  event: "split-spa",
+  packageId: data.id,
+  id: `${data.id}`,
+  timestamp: Date.now(),
+  makoChangedDate: Date.now(),
+  changedDate: Date.now(),
+}));

lib/lambda/update/updatePackage.ts

@@ -101,17 +101,15 @@ const sendUpdateIdMessage = async ({
     origin: _origin,
     ...remainingFields
   } = currentPackage._source;
-
   if (updatedId === currentPackage._id) {
     return response({
       statusCode: 400,
       body: { message: "New ID required to update package" },
     });
   }
-
   // check if a package with this new ID already exists
   const packageExists = await getPackage(updatedId);
-  if (packageExists?.found) {
+  if (packageExists) {
     return response({
       statusCode: 400,
       body: { message: "This ID already exists" },
@@ -132,6 +130,7 @@ const sendUpdateIdMessage = async ({
   }
 
   await sendDeleteMessage(currentPackage._id);
+
   await produceMessage(
     topicName,
     updatedId,

lib/packages/shared-types/opensearch/changelog/index.ts

@@ -82,7 +82,8 @@ export type Document = Omit<AppkDocument, "event"> &
       | "withdraw-rai"
       | "update-values"
       | "update-id"
-      | "delete";
+      | "delete"
+      | "split-spa";
   };
 
 export type Response = Res<Document>;

lib/stacks/api.ts

@@ -293,6 +293,17 @@ export class Api extends cdk.NestedStack {
           indexNamespace,
         },
       },
+      {
+        id: "submitSplitSPA",
+        entry: join(__dirname, "../lambda/submit/submitSplitSPA.ts"),
+        environment: {
+          topicName,
+          brokerString,
+          osDomain: `https://${openSearchDomainEndpoint}`,
+          indexNamespace,
+        },
+        provisionedConcurrency: 2,
+      },
       {
         id: "getSystemNotifs",
         entry: join(__dirname, "../lambda/getSystemNotifs.ts"),

react-app/src/features/package/admin-changes/index.tsx

@@ -49,7 +49,6 @@
 export const AC_Update: FC<opensearch.changelog.Document> = () => {
   return <p>Coming Soon</p>;
 };
-
 export const AdminChange: FC<opensearch.changelog.Document> = (props) => {
   const [label, Content] = useMemo(() => {
     switch (props.event) {
@@ -61,10 +60,12 @@
       }
       case "legacy-admin-change":
         return [props.changeType || "Manual Update", AC_LegacyAdminChange];
+      case "split-spa":
+        return ["Package Added", AC_LegacyAdminChange];
       default:
         return [BLANK_VALUE, AC_Update];
     }
   }, [props.actionType, props.changeType]);
 
   return (
     <AccordionItem key={props.id} value={props.id}>