create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/blank/src/actions/locator-groups/locator-group-actions.ts

@@ -0,0 +1,115 @@
+'use server'
+
+import { locatorGroupSchema } from '@/constants/form-opts/locator-group-form-opts'
+import {
+  checkLocatorGroupNameUnique,
+  createLocatorGroup,
+  deleteLocatorGroups,
+  getLocatorGroupByIdOrThrow,
+  listLocatorGroups,
+  updateLocatorGroup,
+} from '@/services/locator-group/locator-group-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+export async function getAllLocatorGroupsAction(): Promise<ActionResponse> {
+  try {
+    const locatorGroups = await listLocatorGroups()
+    return {
+      status: 200,
+      success: true,
+      data: locatorGroups,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getLocatorGroupByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const locatorGroup = await getLocatorGroupByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: locatorGroup,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createLocatorGroupAction(
+  _prev: unknown,
+  value: z.infer<typeof locatorGroupSchema>,
+): Promise<ActionResponse> {
+  try {
+    const locatorGroup = await createLocatorGroup(value)
+    revalidatePath('/locator-groups')
+    return {
+      status: 200,
+      success: true,
+      data: locatorGroup,
+      message: 'Locator group created successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateLocatorGroupAction(
+  _prev: unknown,
+  value: z.infer<typeof locatorGroupSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    const updatedLocatorGroup = await updateLocatorGroup(id, value)
+    revalidatePath('/locator-groups')
+    return {
+      status: 200,
+      success: true,
+      data: updatedLocatorGroup,
+      message: 'Locator group updated successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteLocatorGroupAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteLocatorGroups(ids)
+    revalidatePath('/locator-groups')
+    return {
+      status: 200,
+      success: true,
+      data: ids,
+      message: `${ids.length} locator group(s) deleted successfully`,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function checkLocatorGroupNameUniqueAction(name: string, excludeId?: string): Promise<ActionResponse> {
+  try {
+    const isUnique = await checkLocatorGroupNameUnique(name, excludeId)
+    return {
+      status: 200,
+      success: true,
+      data: { isUnique },
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}

package/templates/blank/src/actions/locator-picker/locator-picker-actions.test.ts

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('next/cache', () => ({
+  revalidatePath: vi.fn(),
+}))
+
+vi.mock('@/lib/locator-picker/session-manager', () => ({
+  locatorPickerSessionManager: {
+    startSession: vi.fn(),
+    getSession: vi.fn(),
+    closeSession: vi.fn(),
+    markReadyAfterSave: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+vi.mock('@/services/locator/locator-service', () => ({
+  savePickedLocatorFromRequest: vi.fn(),
+}))
+
+import { revalidatePath } from 'next/cache'
+import { locatorPickerSessionManager } from '@/lib/locator-picker/session-manager'
+import { savePickedLocatorFromRequest } from '@/services/locator/locator-service'
+import { savePickedLocatorAction } from './locator-picker-actions'
+
+describe('savePickedLocatorAction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('revalidates locator pages after a successful update', async () => {
+    vi.mocked(savePickedLocatorFromRequest).mockResolvedValue({
+      kind: 'success',
+      locatorId: 'loc-1',
+      locatorGroupId: 'group-1',
+      message: 'Locator updated successfully.',
+      wasUpdate: true,
+    })
+
+    const result = await savePickedLocatorAction({
+      sessionId: 'session-1',
+      locatorId: 'loc-1',
+      locatorName: 'submit',
+      selector: '[data-testid="submit"]',
+      resolutionMode: 'existing',
+      existingLocatorGroupId: 'group-1',
+    })
+
+    expect(result).toEqual({
+      status: 200,
+      success: true,
+      data: {
+        locatorId: 'loc-1',
+        locatorGroupId: 'group-1',
+      },
+      message: 'Locator updated successfully.',
+    })
+    expect(revalidatePath).toHaveBeenCalledWith('/locators')
+    expect(revalidatePath).toHaveBeenCalledWith('/locator-groups')
+    expect(revalidatePath).toHaveBeenCalledWith('/locators/create')
+    expect(revalidatePath).toHaveBeenCalledWith('/locators/modify/loc-1')
+  })
+
+  it('marks the session ready again when saving throws', async () => {
+    vi.mocked(savePickedLocatorFromRequest).mockRejectedValue(new Error('disk full'))
+
+    const result = await savePickedLocatorAction({
+      sessionId: 'session-9',
+      locatorName: 'submit',
+      selector: '[data-testid="submit"]',
+      resolutionMode: 'existing',
+      existingLocatorGroupId: 'group-1',
+    })
+
+    expect(locatorPickerSessionManager.markReadyAfterSave).toHaveBeenCalledWith('session-9')
+    expect(result).toEqual({
+      status: 500,
+      success: false,
+      error: 'disk full',
+    })
+  })
+})

package/templates/blank/src/actions/locator-picker/locator-picker-actions.ts

@@ -0,0 +1,102 @@
+'use server'
+
+import type { ActionResponse } from '@/types/form/actionHandler'
+import type { SavePickedLocatorRequest, StartLocatorPickerSessionRequest } from '@/types/locator-picker'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import { locatorPickerSessionManager } from '@/lib/locator-picker/session-manager'
+import { savePickedLocatorFromRequest } from '@/services/locator/locator-service'
+
+const startLocatorPickerSessionSchema = z
+  .object({
+    environmentId: z.string().optional(),
+    url: z.string().optional(),
+  })
+  .refine(value => Boolean(value.environmentId || value.url), {
+    message: 'Choose an environment or provide a URL.',
+  })
+
+export async function startLocatorPickerSessionAction(
+  request: StartLocatorPickerSessionRequest,
+): Promise<ActionResponse> {
+  try {
+    const parsedRequest = startLocatorPickerSessionSchema.parse(request)
+    const session = await locatorPickerSessionManager.startSession(parsedRequest)
+
+    return {
+      status: session.status === 'error' ? 500 : 200,
+      success: session.status !== 'error',
+      data: session,
+      error: session.error,
+    }
+  } catch (error) {
+    return {
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to start the locator picker session.',
+    }
+  }
+}
+
+export async function getLocatorPickerSessionAction(sessionId: string): Promise<ActionResponse> {
+  try {
+    const session = await locatorPickerSessionManager.getSession(sessionId)
+    if (!session) {
+      return {
+        status: 404,
+        success: false,
+        error: 'Locator picker session not found.',
+      }
+    }
+
+    return {
+      status: 200,
+      success: true,
+      data: session,
+    }
+  } catch (error) {
+    return {
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to load the locator picker session.',
+    }
+  }
+}
+
+export async function savePickedLocatorAction(request: SavePickedLocatorRequest): Promise<ActionResponse> {
+  try {
+    const outcome = await savePickedLocatorFromRequest(request)
+
+    if (outcome.kind === 'error') {
+      return {
+        status: outcome.status,
+        success: false,
+        error: outcome.message,
+      }
+    }
+
+    revalidatePath('/locators')
+    revalidatePath('/locator-groups')
+    revalidatePath('/locators/create')
+    if (outcome.wasUpdate) {
+      revalidatePath(`/locators/modify/${outcome.locatorId}`)
+    }
+
+    return {
+      status: 200,
+      success: true,
+      data: {
+        locatorId: outcome.locatorId,
+        locatorGroupId: outcome.locatorGroupId,
+      },
+      message: outcome.message,
+    }
+  } catch (error) {
+    await locatorPickerSessionManager.markReadyAfterSave(request.sessionId).catch(() => undefined)
+    return {
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to save the picked locator.',
+    }
+  }
+}

package/templates/blank/src/actions/modules/module-actions.ts

@@ -0,0 +1,99 @@
+'use server'
+
+import { moduleSchema } from '@/constants/form-opts/module-form-opts'
+import {
+  createModule,
+  deleteModules,
+  getModuleByIdOrThrow,
+  listModules,
+  updateModule,
+} from '@/services/module/module-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+export async function getAllModulesAction(): Promise<ActionResponse> {
+  try {
+    const modules = await listModules()
+    return {
+      status: 200,
+      success: true,
+      data: modules,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteModuleAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteModules(ids)
+    revalidatePath('/modules')
+    return {
+      status: 200,
+      success: true,
+      message: 'Modules deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createModuleAction(_prev: unknown, value: z.infer<typeof moduleSchema>): Promise<ActionResponse> {
+  try {
+    moduleSchema.parse(value)
+    const newModule = await createModule(value)
+    revalidatePath('/modules')
+    return {
+      status: 200,
+      success: true,
+      data: newModule,
+      message: 'Module created successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getModuleByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const moduleData = await getModuleByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: moduleData,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateModuleAction(
+  _prev: unknown,
+  value: z.infer<typeof moduleSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    moduleSchema.parse(value)
+    const updatedModule = await updateModule(id, value)
+    revalidatePath('/modules')
+    return {
+      status: 200,
+      success: true,
+      data: updatedModule,
+      message: 'Module updated successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}

package/templates/blank/src/actions/reports/report-actions.ts

@@ -0,0 +1,79 @@
+'use server'
+
+import { ActionResponse } from '@/types/form/actionHandler'
+import {
+  getAllTestCaseMetricsForFilter,
+  getAllTestSuiteMetricsForFilter,
+  getReportByIdOrThrow,
+  listReports,
+} from '@/services/report/report-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+
+export async function getAllReportsAction(): Promise<ActionResponse> {
+  try {
+    const reports = await listReports()
+
+    return {
+      status: 200,
+      success: true,
+      data: reports,
+    }
+  } catch (error) {
+    console.error('[ReportActions] Error fetching all reports:', error)
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getReportByIdAction(reportId: string): Promise<ActionResponse> {
+  try {
+    const report = await getReportByIdOrThrow(reportId)
+
+    return {
+      status: 200,
+      success: true,
+      data: report,
+    }
+  } catch (error) {
+    console.error(`[ReportActions] Error fetching report ${reportId}:`, error)
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getAllTestCaseMetricsAction(filter: string): Promise<ActionResponse> {
+  try {
+    const testCaseMetrics = await getAllTestCaseMetricsForFilter(filter)
+    return {
+      status: 200,
+      success: true,
+      data: testCaseMetrics,
+    }
+  } catch (error) {
+    console.error(`[ReportActions] Error fetching all test case metrics:`, error)
+    return {
+      status: 500,
+      success: false,
+      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    }
+  }
+}
+
+export async function getAllTestSuiteMetricsAction(filter: string): Promise<ActionResponse> {
+  try {
+    const testSuiteMetrics = await getAllTestSuiteMetricsForFilter(filter)
+    return {
+      status: 200,
+      success: true,
+      data: testSuiteMetrics,
+    }
+  } catch (error) {
+    console.error(`[ReportActions] Error fetching all test suite metrics:`, error)
+    return {
+      status: 500,
+      success: false,
+      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    }
+  }
+}

package/templates/blank/src/actions/settings/sync-actions.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('next/cache', () => ({
+  revalidatePath: vi.fn(),
+}))
+
+vi.mock('@/lib/sync/sync-executor', () => ({
+  runRequestedSync: vi.fn(),
+}))
+
+vi.mock('@/lib/sync/sync-pending-counts', () => ({
+  getSyncPendingCounts: vi.fn(),
+}))
+
+import { revalidatePath } from 'next/cache'
+import { runRequestedSync } from '@/lib/sync/sync-executor'
+import { runSyncAction } from './sync-actions'
+
+describe('runSyncAction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('rejects an invalid sync request id without executing anything', async () => {
+    const result = await runSyncAction('not-a-sync-target')
+
+    expect(result).toEqual({
+      requestedScriptId: 'not-a-sync-target',
+      executedScriptIds: [],
+      success: false,
+      exitCode: 400,
+      durationMs: 0,
+      cause: 'Invalid sync target requested.',
+    })
+    expect(runRequestedSync).not.toHaveBeenCalled()
+    expect(revalidatePath).not.toHaveBeenCalled()
+  })
+
+  it('revalidates settings after a successful sync request', async () => {
+    vi.mocked(runRequestedSync).mockResolvedValue({
+      requestedScriptId: 'sync-tags',
+      executedScriptIds: ['sync-tags'],
+      success: true,
+      durationMs: 12,
+    })
+
+    const result = await runSyncAction('sync-tags')
+
+    expect(result).toEqual({
+      requestedScriptId: 'sync-tags',
+      executedScriptIds: ['sync-tags'],
+      success: true,
+      durationMs: 12,
+    })
+    expect(runRequestedSync).toHaveBeenCalledWith('sync-tags')
+    expect(revalidatePath).toHaveBeenCalledWith('/settings')
+  })
+})

package/templates/blank/src/actions/tags/tag-actions.ts

@@ -0,0 +1,99 @@
+'use server'
+
+import { tagSchema } from '@/constants/form-opts/tag-form-opts'
+import {
+  createTag,
+  deleteTags,
+  getTagByIdOrThrow,
+  listFilterTags,
+  updateTag,
+} from '@/services/tag/tag-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+import { ActionResponse } from '@/types/form/actionHandler'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+export async function getAllTagsAction(): Promise<ActionResponse> {
+  try {
+    const tags = await listFilterTags()
+    return {
+      status: 200,
+      success: true,
+      data: tags,
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function deleteTagAction(ids: string[]): Promise<ActionResponse> {
+  try {
+    await deleteTags(ids)
+    revalidatePath('/tags')
+    return {
+      status: 200,
+      success: true,
+      message: 'Tag deleted successfully',
+    }
+  } catch (error) {
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function createTagAction(_prev: unknown, value: z.infer<typeof tagSchema>): Promise<ActionResponse> {
+  try {
+    tagSchema.parse(value)
+    const newTag = await createTag(value)
+    revalidatePath('/tags')
+    return {
+      status: 200,
+      success: true,
+      data: newTag,
+      message: 'Tag created successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function getTagByIdAction(id: string): Promise<ActionResponse> {
+  try {
+    const tag = await getTagByIdOrThrow(id)
+    return {
+      status: 200,
+      success: true,
+      data: tag,
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}
+
+export async function updateTagAction(
+  _prev: unknown,
+  value: z.infer<typeof tagSchema>,
+  id?: string,
+): Promise<ActionResponse> {
+  try {
+    tagSchema.parse(value)
+    const updatedTag = await updateTag(id, value)
+    revalidatePath('/tags')
+    return {
+      status: 200,
+      success: true,
+      data: updatedTag,
+      message: 'Tag updated successfully',
+    }
+  } catch (error) {
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
+    }
+    return unknownErrorToActionResponse(error)
+  }
+}