@incident-io/backstage 0.0.15 → 0.2.0

package/src/alpha.tsx

@@ -0,0 +1,111 @@
+import {
+  ApiBlueprint,
+  createFrontendPlugin,
+  FrontendPlugin,
+} from "@backstage/frontend-plugin-api";
+import {
+  discoveryApiRef,
+  fetchApiRef,
+} from "@backstage/core-plugin-api";
+import { EntityCardBlueprint } from "@backstage/plugin-catalog-react/alpha";
+import { HomePageWidgetBlueprint } from "@backstage/plugin-home-react/alpha";
+import { IncidentApi, IncidentApiRef } from "./api/client";
+
+const incidentApi = ApiBlueprint.make({
+  params: defineParams =>
+    defineParams({
+      api: IncidentApiRef,
+      deps: {
+        discoveryApi: discoveryApiRef,
+        fetchApi: fetchApiRef,
+      },
+      factory: ({ discoveryApi, fetchApi }) =>{ 
+        return new IncidentApi({ 
+          discoveryApi: discoveryApi, 
+          fetchApi: fetchApi 
+        });
+      },
+    }),
+});
+
+const entityIncidentCard = EntityCardBlueprint.make({
+  name: "EntityIncidentCard",
+  params: {
+    loader: async () => 
+      import("./components/EntityIncidentCard").then(m=><m.EntityIncidentCard />),
+  },
+});
+
+const entityAlertCard = EntityCardBlueprint.make({
+  name: "EntityAlertCard",
+  params: {
+    loader: async () => 
+      import("./components/EntityAlertCard").then(m=><m.EntityAlertCard />),
+  }
+});
+
+const entityOnCallCard = EntityCardBlueprint.make({
+  name: "EntityOnCallCard",
+  params: {
+    loader: async () => 
+      import("./components/EntityOnCallCard").then(m=><m.EntityOnCallCard />),
+  },
+});
+
+const homePageIncidentCard = HomePageWidgetBlueprint.make({
+  name: "HomePageIncidentCard",
+  params: {
+    title: "Ongoing Incidents",    
+    components: () => import("./components/HomePageIncidentCard"),
+    settings: {
+      schema: {
+        type: "object",
+        properties: {
+          filterType: {
+            type: "string",
+            title: "Filter Type",
+            description: "Whether to filter on status category or status",
+            oneOf: [
+              { enum: ["status_category"], title: "Status Category" },
+              { enum: ["status"], title: "Status" },
+            ],
+            default: "status_category",
+          },
+          filter: {
+            type: "string",
+            title: "Filter",
+            description:
+              "The filter to use. This is a string that will be passed to the API.",
+            default: "active",
+          },
+        },
+      },
+    },
+  },
+});
+
+
+const homePageAlertCard = HomePageWidgetBlueprint.make({
+  name: "HomePageAlertCard",
+  params: {
+    title: "Ongoing Alerts",    
+    components: () => import("./components/HomePageAlertCard"),
+  },
+});
+
+
+   
+const homePageOnCallCard = HomePageWidgetBlueprint.make({
+  name: "HomePageOnCallCard",
+  params: {
+    title: "On-call",
+    components: () => import("./components/HomePageOnCallCard"),
+  },
+});
+
+const plugin: FrontendPlugin = createFrontendPlugin({
+    pluginId: "incident",
+    extensions: [incidentApi, entityIncidentCard, entityAlertCard, homePageIncidentCard, homePageAlertCard, homePageOnCallCard, entityOnCallCard],                                                                        
+  });
+
+export default plugin;

package/src/api/client.test.ts

@@ -0,0 +1,43 @@
+import { IncidentApi } from "./client";
+
+const mockDiscoveryApi = {
+  getBaseUrl: async () => "http://localhost:7007/api/proxy",
+};
+
+describe("IncidentApi", () => {
+  it("should call the correct URL and return parsed JSON", async () => {
+    const mockFetchApi = {
+      fetch: async () => ({
+        ok: true,
+        json: async () => ({ id: "123" }),
+      }),
+    };
+
+    const client = new IncidentApi({
+      discoveryApi: mockDiscoveryApi as any,
+      fetchApi: mockFetchApi as any,
+    });
+
+    const result = await client.request({ path: "/v2/incidents" });
+    expect(result).toEqual({ id: "123" });
+  });
+
+  it("should throw an error when the response is not ok", async () => {
+    const mockFetchApi = {
+      fetch: async () => ({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+      }),
+    };
+
+    const client = new IncidentApi({
+      discoveryApi: mockDiscoveryApi as any,
+      fetchApi: mockFetchApi as any,
+    });
+
+    await expect(client.request({ path: "/v2/incidents" })).rejects.toThrow(
+      "401 Unauthorized",
+    );
+  });
+});

package/src/api/types.test.ts

@@ -0,0 +1,15 @@
+import type { paths } from "./types";
+
+describe("types", () => {
+  it("should expose the incidents list path", () => {
+    type HasIncidentsPath = "/v2/incidents" extends keyof paths ? true : false;
+    const check: HasIncidentsPath = true;
+    expect(check).toBe(true);
+  });
+
+  it("should expose the identity path", () => {
+    type HasIdentityPath = "/v1/identity" extends keyof paths ? true : false;
+    const check: HasIdentityPath = true;
+    expect(check).toBe(true);
+  });
+});