@openmrs/esm-metadataexport-app 4.4.1-pre.799 → 4.4.1-pre.803

package/src/components/metadata-package-form/metadata-package-form-utils.ts

@@ -0,0 +1,9 @@
+import { type TFunction } from 'i18next';
+import { launchWorkspace } from '@openmrs/esm-framework';
+
+export const launchPackageFormWorkspace = (t: TFunction, uuid?: string) => {
+  launchWorkspace('metadata-package-form-workspace', {
+    workspaceTitle: uuid ? t('editpackage', 'Edit package') : t('newpackage', 'New package'),
+    uuid,
+  });
+};

package/src/components/{new-package/new-package.workspace.test.tsx → metadata-package-form/metadata-package-form.workspace.test.tsx}

@@ -4,8 +4,8 @@ import userEvent from '@testing-library/user-event';
 import { OpenmrsFetchError, showSnackbar } from '@openmrs/esm-framework';
 import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
 import { useDomains } from '../../domain-lookups/domain-lookups.resource';
-import { createPackage } from '../../packages/packages.resource';
-import NewPackageWorkspace from './new-package.workspace';
+import { createPackage, editPackage, usePackage } from '../../packages/packages.resource';
+import MetadataPackageFormWorkspace from './metadata-package-form.workspace';
 
 vi.mock('../../domain-lookups/domain-lookups.resource', async (importOriginal) => ({
   ...(await importOriginal<object>()),
@@ -14,10 +14,14 @@ vi.mock('../../domain-lookups/domain-lookups.resource', async (importOriginal) =
 
 vi.mock('../../packages/packages.resource', () => ({
   createPackage: vi.fn(),
+  editPackage: vi.fn(),
+  usePackage: vi.fn(),
 }));
 
 const mockUseDomains = useDomains as Mock;
 const mockCreatePackage = createPackage as Mock;
+const mockEditPackage = editPackage as Mock;
+const mockUsePackage = usePackage as Mock;
 const mockShowSnackbar = showSnackbar as Mock;
 const mockCloseWorkspace = vi.fn();
 const mockCloseWorkspaceWithSavedChanges = vi.fn();
@@ -35,9 +39,10 @@ const fetchError = (responseBody: unknown) =>
     new Error(),
   );
 
-function renderWorkspace() {
-  render(
-    <NewPackageWorkspace
+function renderWorkspace(uuid?: string) {
+  return render(
+    <MetadataPackageFormWorkspace
+      uuid={uuid}
       closeWorkspace={mockCloseWorkspace}
       closeWorkspaceWithSavedChanges={mockCloseWorkspaceWithSavedChanges}
       promptBeforeClosing={mockPromptBeforeClosing}
@@ -48,10 +53,12 @@ function renderWorkspace() {
   );
 }
 
-describe('NewPackageWorkspace', () => {
+describe('PackageFormWorkspace', () => {
   beforeEach(() => {
     mockUseDomains.mockReturnValue({ domains, isLoading: false, error: undefined });
+    mockUsePackage.mockReturnValue({ exportPackage: undefined, isLoading: false, error: undefined });
     mockCreatePackage.mockResolvedValue({ data: {} });
+    mockEditPackage.mockResolvedValue({ data: {} });
   });
 
   it('renders a checkbox for each domain with a human-readable label', () => {
@@ -203,4 +210,138 @@ describe('NewPackageWorkspace', () => {
 
     expect(mockCloseWorkspace).toHaveBeenCalled();
   });
+
+  describe('edit mode', () => {
+    const uuid = 'package-uuid';
+
+    it('shows a loading indicator while the package is being fetched', () => {
+      mockUsePackage.mockReturnValue({ exportPackage: undefined, isLoading: true, error: undefined });
+      renderWorkspace(uuid);
+
+      expect(screen.getByText('Loading package…')).toBeInTheDocument();
+      expect(screen.queryByRole('textbox', { name: 'Package name' })).not.toBeInTheDocument();
+    });
+
+    it('shows an error notification when the package request fails', () => {
+      mockUsePackage.mockReturnValue({ exportPackage: undefined, isLoading: false, error: new Error('Not found') });
+      renderWorkspace(uuid);
+
+      expect(screen.getByText('Error loading package')).toBeInTheDocument();
+      expect(screen.getByText('Not found')).toBeInTheDocument();
+    });
+
+    it('seeds the form from the fetched package', () => {
+      mockUsePackage.mockReturnValue({
+        exportPackage: {
+          name: 'Core reference data',
+          description: 'Some notes',
+          entries: [{ domain: 'CONCEPTS' }, { domain: 'ENCOUNTER_TYPES' }],
+        },
+        isLoading: false,
+        error: undefined,
+      });
+      renderWorkspace(uuid);
+
+      expect(screen.getByRole('textbox', { name: 'Package name' })).toHaveValue('Core reference data');
+      expect(screen.getByRole('textbox', { name: 'Description' })).toHaveValue('Some notes');
+      expect(screen.getByRole('checkbox', { name: 'Concepts' })).toBeChecked();
+      expect(screen.getByRole('checkbox', { name: 'Encounter types' })).toBeChecked();
+      expect(screen.getByRole('checkbox', { name: 'Attribute types' })).not.toBeChecked();
+    });
+
+    it('does not overwrite in-progress edits when the package or domains revalidate', async () => {
+      // A fresh object each call mimics SWR handing back a new reference on revalidation.
+      const serverPackage = () => ({
+        exportPackage: { name: 'Original name', description: 'Original notes', entries: [{ domain: 'CONCEPTS' }] },
+        isLoading: false,
+        error: undefined,
+      });
+      mockUsePackage.mockReturnValue(serverPackage());
+      const user = userEvent.setup();
+      const { rerender } = renderWorkspace(uuid);
+
+      const nameInput = screen.getByRole('textbox', { name: 'Package name' });
+      await user.clear(nameInput);
+      await user.type(nameInput, 'My edited name');
+
+      // Simulate a background revalidation returning the original server values again.
+      mockUsePackage.mockReturnValue(serverPackage());
+      rerender(
+        <MetadataPackageFormWorkspace
+          uuid={uuid}
+          closeWorkspace={mockCloseWorkspace}
+          closeWorkspaceWithSavedChanges={mockCloseWorkspaceWithSavedChanges}
+          promptBeforeClosing={mockPromptBeforeClosing}
+          setTitle={vi.fn()}
+          // @ts-expect-error - the workspace only uses closeWorkspace and promptBeforeClosing from the default props
+          additionalProps={{}}
+        />,
+      );
+
+      expect(screen.getByRole('textbox', { name: 'Package name' })).toHaveValue('My edited name');
+    });
+
+    it('selects every domain when the package has no entries', () => {
+      mockUsePackage.mockReturnValue({
+        exportPackage: { name: 'Everything', description: '', entries: [] },
+        isLoading: false,
+        error: undefined,
+      });
+      renderWorkspace(uuid);
+
+      for (const label of ['Attribute types', 'Concepts', 'Encounter types']) {
+        expect(screen.getByRole('checkbox', { name: label })).toBeChecked();
+      }
+    });
+
+    it('updates the package via editPackage, shows a snackbar, and closes the workspace', async () => {
+      mockUsePackage.mockReturnValue({
+        exportPackage: {
+          name: 'Core reference data',
+          description: 'Some notes',
+          entries: [{ domain: 'CONCEPTS' }],
+        },
+        isLoading: false,
+        error: undefined,
+      });
+      const user = userEvent.setup();
+      renderWorkspace(uuid);
+
+      await user.click(screen.getByRole('checkbox', { name: 'Encounter types' }));
+      await user.click(screen.getByRole('button', { name: 'Save changes' }));
+
+      expect(mockEditPackage).toHaveBeenCalledWith(uuid, {
+        name: 'Core reference data',
+        description: 'Some notes',
+        entries: [{ domain: 'CONCEPTS' }, { domain: 'ENCOUNTER_TYPES' }],
+      });
+      expect(mockCreatePackage).not.toHaveBeenCalled();
+      expect(mockShowSnackbar).toHaveBeenCalledWith(
+        expect.objectContaining({ title: 'Package updated', kind: 'success' }),
+      );
+      expect(mockCloseWorkspaceWithSavedChanges).toHaveBeenCalled();
+    });
+
+    it('shows an update-failure snackbar and keeps the workspace open on error', async () => {
+      mockUsePackage.mockReturnValue({
+        exportPackage: { name: 'Core reference data', description: '', entries: [{ domain: 'CONCEPTS' }] },
+        isLoading: false,
+        error: undefined,
+      });
+      mockEditPackage.mockRejectedValue(new Error('Server exploded'));
+      const user = userEvent.setup();
+      renderWorkspace(uuid);
+
+      await user.click(screen.getByRole('button', { name: 'Save changes' }));
+
+      expect(mockShowSnackbar).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: 'Failed to update package',
+          subtitle: 'An unexpected error occurred',
+          kind: 'error',
+        }),
+      );
+      expect(mockCloseWorkspaceWithSavedChanges).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/components/{new-package/new-package.workspace.tsx → metadata-package-form/metadata-package-form.workspace.tsx}

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import {
   Button,
@@ -21,13 +21,18 @@ import {
   OpenmrsFetchError,
 } from '@openmrs/esm-framework';
 import { formatDomainLabel, useDomains } from '../../domain-lookups/domain-lookups.resource';
-import { createPackage } from '../../packages/packages.resource';
-import styles from './new-package.workspace.scss';
+import { createPackage, editPackage, usePackage } from '../../packages/packages.resource';
+import styles from './metadata-package-form.workspace.scss';
 
 const packagesUrl = `${restBaseUrl}/metadataexport/packages`;
 const isPackagesCacheKey = (key: unknown) => typeof key === 'string' && key.startsWith(packagesUrl);
 
-const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
+interface PackageFormWorkspaceProps extends DefaultWorkspaceProps {
+  uuid?: string;
+}
+
+const MetadataPackageFormWorkspace: React.FC<PackageFormWorkspaceProps> = ({
+  uuid,
   closeWorkspace,
   closeWorkspaceWithSavedChanges,
   promptBeforeClosing,
@@ -35,6 +40,7 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
   const { t } = useTranslation();
   const { mutate } = useSWRConfig();
   const isTablet = useLayoutType() === 'tablet';
+  const isEditMode = Boolean(uuid);
   const { domains, isLoading, error } = useDomains();
 
   const [packageName, setPackageName] = useState('');
@@ -45,6 +51,8 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
   const allSelected = domains.length > 0 && selectedDomains.size === domains.length;
   const someSelected = selectedDomains.size > 0 && !allSelected;
 
+  const { exportPackage, isLoading: isLoadingPackage, error: packageError } = usePackage(uuid ?? '');
+
   const toggleSelectAll = useCallback(
     (checked: boolean) => {
       setSelectedDomains(checked ? new Set(domains) : new Set());
@@ -70,6 +78,28 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
     promptBeforeClosing(() => hasUnsavedChanges);
   }, [hasUnsavedChanges, promptBeforeClosing]);
 
+  // Seed the form from the fetched package exactly once, so a later SWR revalidation
+  // of the package or domain list doesn't clobber the user's in-progress edits.
+  // An empty entries list means the package includes every registered domain.
+  const hasPrefilledFromPackage = useRef(false);
+  useEffect(() => {
+    if (!isEditMode || hasPrefilledFromPackage.current || !exportPackage) {
+      return;
+    }
+    // Wait for the domain list before expanding an "all domains" package.
+    if (exportPackage.entries.length === 0 && domains.length === 0) {
+      return;
+    }
+    hasPrefilledFromPackage.current = true;
+    setPackageName(exportPackage.name);
+    setDescription(exportPackage.description ?? '');
+    setSelectedDomains(
+      exportPackage.entries.length === 0
+        ? new Set(domains)
+        : new Set(exportPackage.entries.map((entry) => entry.domain)),
+    );
+  }, [isEditMode, exportPackage, domains]);
+
   const handleSubmit = useCallback(
     async (event: React.FormEvent<HTMLFormElement>) => {
       event.preventDefault();
@@ -77,17 +107,32 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
 
       // An explicit empty array tells the server to include every registered domain.
       const entries = allSelected ? [] : Array.from(selectedDomains, (domain) => ({ domain }));
+      const payload = { name: packageName.trim(), description: description.trim(), entries };
 
       try {
-        await createPackage({ name: packageName.trim(), description: description.trim(), entries });
-        // Revalidate the packages list so the table shows the new package without a refresh.
-        await mutate(isPackagesCacheKey);
-        showSnackbar({
-          title: t('packageCreated', 'Package created'),
-          subtitle: t('packageCreatedSubtitle', '{{name}} was created successfully', { name: packageName.trim() }),
-          kind: 'success',
-          isLowContrast: true,
-        });
+        const name = packageName.trim();
+
+        if (isEditMode && uuid) {
+          await editPackage(uuid, payload);
+          // Revalidate the packages list so the table reflects the change without a refresh.
+          await mutate(isPackagesCacheKey);
+          showSnackbar({
+            title: t('packageUpdated', 'Package updated'),
+            subtitle: t('packageUpdatedSubtitle', '{{name}} was updated successfully', { name }),
+            kind: 'success',
+            isLowContrast: true,
+          });
+        } else {
+          await createPackage(payload);
+          // Revalidate the packages list so the table reflects the change without a refresh.
+          await mutate(isPackagesCacheKey);
+          showSnackbar({
+            title: t('packageCreated', 'Package created'),
+            subtitle: t('packageCreatedSubtitle', '{{name}} was created successfully', { name }),
+            kind: 'success',
+            isLowContrast: true,
+          });
+        }
         // Bypass the "unsaved changes" prompt now that the package is persisted.
         closeWorkspaceWithSavedChanges();
       } catch (submitError) {
@@ -96,21 +141,63 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
           typeof responseBody === 'object' && responseBody !== null
             ? Object.values(responseBody.fieldErrors ?? {})[0] ?? responseBody.error
             : null;
-        showSnackbar({
-          title: t('packageCreationFailed', 'Failed to create package'),
-          subtitle: reason ?? t('unexpectedError', 'An unexpected error occurred'),
-          kind: 'error',
-          isLowContrast: false,
-        });
+        const subtitle = reason ?? t('unexpectedError', 'An unexpected error occurred');
+
+        if (isEditMode) {
+          showSnackbar({
+            title: t('packageUpdateFailed', 'Failed to update package'),
+            subtitle,
+            kind: 'error',
+            isLowContrast: false,
+          });
+        } else {
+          showSnackbar({
+            title: t('packageCreationFailed', 'Failed to create package'),
+            subtitle,
+            kind: 'error',
+            isLowContrast: false,
+          });
+        }
       } finally {
         setIsSubmitting(false);
       }
     },
-    [allSelected, closeWorkspaceWithSavedChanges, description, mutate, packageName, selectedDomains, t],
+    [
+      allSelected,
+      closeWorkspaceWithSavedChanges,
+      description,
+      isEditMode,
+      mutate,
+      packageName,
+      selectedDomains,
+      t,
+      uuid,
+    ],
   );
 
   const isSubmitDisabled = packageName.trim().length === 0 || selectedDomains.size === 0 || isSubmitting;
 
+  if (isEditMode && isLoadingPackage) {
+    return (
+      <div className={styles.form}>
+        <InlineLoading description={t('loadingPackage', 'Loading package…')} />
+      </div>
+    );
+  }
+
+  if (packageError) {
+    return (
+      <div className={styles.form}>
+        <InlineNotification
+          kind="error"
+          lowContrast
+          title={t('errorLoadingPackage', 'Error loading package')}
+          subtitle={packageError.message}
+        />
+      </div>
+    );
+  }
+
   return (
     <Form className={styles.form} onSubmit={handleSubmit}>
       <div className={styles.grid}>
@@ -184,7 +271,9 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
         </Button>
         <Button className={styles.button} kind="primary" type="submit" disabled={isSubmitDisabled}>
           {isSubmitting ? (
-            <InlineLoading description={t('creating', 'Creating') + '…'} />
+            <InlineLoading description={(isEditMode ? t('saving', 'Saving') : t('creating', 'Creating')) + '…'} />
+          ) : isEditMode ? (
+            t('saveChanges', 'Save changes')
           ) : (
             t('createPackage', 'Create package')
           )}
@@ -194,4 +283,4 @@ const NewPackageWorkspace: React.FC<DefaultWorkspaceProps> = ({
   );
 };
 
-export default NewPackageWorkspace;
+export default MetadataPackageFormWorkspace;

package/src/components/packages-table/packages-table.component.tsx

@@ -22,8 +22,8 @@ import {
 } from '@openmrs/esm-framework';
 import { formatDomainLabel } from '../../domain-lookups/domain-lookups.resource';
 import { useAllPackages } from '../../packages/packages.resource';
-import { launchAddNewPackageWorkspace } from '../new-package/new-package-utils';
-import ViewPackageActionButton from '../view-package/view-package-action-button/view-package-action-button.component';
+import { launchPackageFormWorkspace } from '../metadata-package-form/metadata-package-form-utils';
+import ViewPackageActionButton from '../view-metadata-package/view-package-action-button/view-package-action-button.component';
 import styles from './packages-table.scss';
 
 /**
@@ -97,7 +97,7 @@ const PackagesTable: React.FC = () => {
         <EmptyCard
           displayText={t('packages__lower', 'packages')}
           headerTitle={headerTitle}
-          launchForm={canManage ? () => launchAddNewPackageWorkspace(t) : undefined}
+          launchForm={canManage ? () => launchPackageFormWorkspace(t) : undefined}
         />
       </div>
     );

package/src/components/packages-table/packages-table.test.tsx

@@ -5,8 +5,8 @@ import { type Session, useSession, userHasAccess } from '@openmrs/esm-framework'
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { type ExportPackage } from '../../types/index';
 import { useAllPackages } from '../../packages/packages.resource';
-import { launchAddNewPackageWorkspace } from '../new-package/new-package-utils';
-import { launchViewPackageWorkspace } from '../view-package/view-package-utils';
+import { launchPackageFormWorkspace } from '../metadata-package-form/metadata-package-form-utils';
+import { launchViewMetadataPackageWorkspace } from '../view-metadata-package/view-metadata-package-utils';
 import PackagesTable from './packages-table.component';
 
 vi.mock('../../packages/packages.resource', async (importOriginal) => ({
@@ -14,19 +14,19 @@ vi.mock('../../packages/packages.resource', async (importOriginal) => ({
   useAllPackages: vi.fn(),
 }));
 
-vi.mock('../new-package/new-package-utils', () => ({
-  launchAddNewPackageWorkspace: vi.fn(),
+vi.mock('../metadata-package-form/metadata-package-form-utils', () => ({
+  launchPackageFormWorkspace: vi.fn(),
 }));
 
-vi.mock('../view-package/view-package-utils', () => ({
-  launchViewPackageWorkspace: vi.fn(),
+vi.mock('../view-metadata-package/view-metadata-package-utils', () => ({
+  launchViewMetadataPackageWorkspace: vi.fn(),
 }));
 
 const mockUseAllPackages = vi.mocked(useAllPackages);
 const mockUseSession = vi.mocked(useSession);
 const mockUserHasAccess = vi.mocked(userHasAccess);
-const mockLaunchAddNewPackageWorkspace = vi.mocked(launchAddNewPackageWorkspace);
-const mockLaunchViewPackageWorkspace = vi.mocked(launchViewPackageWorkspace);
+const mockLaunchPackageFormWorkspace = vi.mocked(launchPackageFormWorkspace);
+const mockLaunchViewPackageWorkspace = vi.mocked(launchViewMetadataPackageWorkspace);
 
 const sessionWithUser = () => ({ user: { uuid: 'cc8507b8-7c9a-486b-85dc-b8f25ad1e4cc' } }) as unknown as Session;
 
@@ -81,7 +81,7 @@ describe('PackagesTable', () => {
     await user.click(screen.getByRole('button', { name: 'Record packages' }));
 
     expect(mockUserHasAccess).toHaveBeenCalledWith('Manage Metadata Export Packages', expect.anything());
-    expect(mockLaunchAddNewPackageWorkspace).toHaveBeenCalledTimes(1);
+    expect(mockLaunchPackageFormWorkspace).toHaveBeenCalledTimes(1);
   });
 
   it('does not offer the empty-state action to users without the manage privilege', () => {
@@ -89,7 +89,7 @@ describe('PackagesTable', () => {
     render(<PackagesTable />);
 
     expect(screen.queryByRole('button', { name: 'Record packages' })).not.toBeInTheDocument();
-    expect(mockLaunchAddNewPackageWorkspace).not.toHaveBeenCalled();
+    expect(mockLaunchPackageFormWorkspace).not.toHaveBeenCalled();
   });
 
   it('renders the build status per package and launches the view workspace with the package for the clicked row', async () => {

package/src/components/{view-package/delete-package.modal.test.tsx → view-metadata-package/delete-metadata-package.modal.test.tsx}

@@ -3,7 +3,7 @@ import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { describe, it, expect, vi, type Mock } from 'vitest';
 import * as esmFramework from '@openmrs/esm-framework';
-import DeletePackageModal from './delete-package.modal';
+import DeleteMetadataPackageModal from './delete-metadata-package.modal';
 import { deletePackage } from '../../packages/packages.resource';
 import type { ExportPackage } from '../../types';
 
@@ -28,7 +28,9 @@ const mockCloseModal = vi.fn();
 const mockOnDeleted = vi.fn();
 
 function renderModal() {
-  render(<DeletePackageModal closeModal={mockCloseModal} exportPackage={exportPackage} onDeleted={mockOnDeleted} />);
+  render(
+    <DeleteMetadataPackageModal closeModal={mockCloseModal} exportPackage={exportPackage} onDeleted={mockOnDeleted} />,
+  );
 }
 
 describe('DeletePackageModal', () => {

package/src/components/{view-package/delete-package.modal.tsx → view-metadata-package/delete-metadata-package.modal.tsx}

@@ -5,7 +5,7 @@ import { useSWRConfig } from 'swr';
 import { OpenmrsFetchError, restBaseUrl, showSnackbar } from '@openmrs/esm-framework';
 import { deletePackage } from '../../packages/packages.resource';
 import type { ExportPackage } from '../../types';
-import styles from './delete-package.modal.scss';
+import styles from './delete-metadata-package.modal.scss';
 
 const packagesUrl = `${restBaseUrl}/metadataexport/packages`;
 const isPackagesCacheKey = (key: unknown) => typeof key === 'string' && key.startsWith(packagesUrl);
@@ -16,7 +16,7 @@ interface DeletePackageModalProps {
   onDeleted: () => void;
 }
 
-const DeletePackageModal: React.FC<DeletePackageModalProps> = ({ closeModal, exportPackage, onDeleted }) => {
+const DeleteMetadataPackageModal: React.FC<DeletePackageModalProps> = ({ closeModal, exportPackage, onDeleted }) => {
   const { t } = useTranslation();
   const { mutate } = useSWRConfig();
   const [isDeleting, setIsDeleting] = useState(false);
@@ -79,4 +79,4 @@ const DeletePackageModal: React.FC<DeletePackageModalProps> = ({ closeModal, exp
   );
 };
 
-export default DeletePackageModal;
+export default DeleteMetadataPackageModal;

package/src/components/{view-package/view-package-utils.ts → view-metadata-package/view-metadata-package-utils.ts}

@@ -1,8 +1,8 @@
 import { launchWorkspace } from '@openmrs/esm-framework';
 import { type ExportPackage } from '../../types/index';
 
-export const launchViewPackageWorkspace = (exportPackage: ExportPackage) => {
-  launchWorkspace('view-package-workspace', {
+export const launchViewMetadataPackageWorkspace = (exportPackage: ExportPackage) => {
+  launchWorkspace('view-metadata-package-workspace', {
     workspaceTitle: exportPackage.name,
     exportPackage,
   });

package/src/components/{view-package/view-package.workspace.scss → view-metadata-package/view-metadata-package.workspace.scss}

@@ -25,12 +25,24 @@
 
 .actionRow {
   display: flex;
-  flex-direction: row;
+  flex-direction: column;
   gap: layout.$spacing-04;
 }
 
 .triggerButton {
-  flex: 1 1 auto;
+  width: 100%;
+  max-width: none;
+  justify-content: center;
+}
+
+.secondaryActions {
+  display: flex;
+  flex-direction: row;
+  gap: layout.$spacing-04;
+}
+
+.secondaryButton {
+  flex: 1 1 0;
   max-width: none;
   justify-content: center;
 }

package/src/components/{view-package/view-package.workspace.test.tsx → view-metadata-package/view-metadata-package.workspace.test.tsx}

@@ -3,7 +3,7 @@ import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
 import * as esmFramework from '@openmrs/esm-framework';
-import ViewPackageWorkspace from './view-package.workspace';
+import ViewMetadataPackageWorkspace from './view-metadata-package.workspace';
 import { usePackageBuilds, triggerBuild } from '../../packages/packages.resource';
 import type { ExportPackage, ExportPackageBuild } from '../../types';
 
@@ -75,7 +75,7 @@ function mockBuilds(overrides: Partial<ReturnType<typeof usePackageBuilds>> = {}
 
 function renderWorkspace(pkg: ExportPackage = exportPackage) {
   render(
-    <ViewPackageWorkspace
+    <ViewMetadataPackageWorkspace
       exportPackage={pkg}
       closeWorkspace={mockCloseWorkspace}
       closeWorkspaceWithSavedChanges={mockCloseWorkspaceWithSavedChanges}
@@ -224,4 +224,54 @@ describe('ViewPackageWorkspace', () => {
       }),
     );
   });
+
+  it('triggers a build and revalidates the builds list', async () => {
+    const user = userEvent.setup();
+    const mutate = vi.fn();
+    mockBuilds({ mutate });
+    mockTriggerBuild.mockResolvedValue({});
+    renderWorkspace();
+
+    await user.click(screen.getByRole('button', { name: 'Trigger new build' }));
+
+    expect(mockTriggerBuild).toHaveBeenCalledWith(exportPackage.uuid);
+    await waitFor(() => expect(mutate).toHaveBeenCalled());
+    expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' }));
+  });
+
+  it('shows an error snackbar when triggering a build fails', async () => {
+    const user = userEvent.setup();
+    const error = new esmFramework.OpenmrsFetchError(
+      '/url',
+      {} as Response,
+      { error: 'A build is already running for this package' },
+      new Error(),
+    );
+    mockTriggerBuild.mockRejectedValue(error);
+    renderWorkspace();
+
+    await user.click(screen.getByRole('button', { name: 'Trigger new build' }));
+
+    await waitFor(() =>
+      expect(mockShowSnackbar).toHaveBeenCalledWith(
+        expect.objectContaining({ kind: 'error', subtitle: 'A build is already running for this package' }),
+      ),
+    );
+  });
+
+  it('launches the delete confirmation modal wired to close the workspace on success', async () => {
+    const user = userEvent.setup();
+    renderWorkspace();
+
+    await user.click(screen.getByRole('button', { name: /delete/i }));
+
+    expect(mockShowModal).toHaveBeenCalledWith(
+      'delete-package-modal',
+      expect.objectContaining({
+        exportPackage,
+        onDeleted: mockCloseWorkspace,
+        closeModal: expect.any(Function),
+      }),
+    );
+  });
 });