{{$name}}{{end}}
7 | {{if $message}}
8 | {{truncateText $message 64}}
9 | {{else if $value}}
10 | {{truncateText $value 64}}
11 | {{else}}
12 | Error event
13 | {{end}}
14 | {{- end}}
15 |
16 | {{- define "error-event-details" -}}
17 |
18 |
22 | {{- end}}
23 |
24 | {{- define "error-event" -}}
25 | {{template "error-event-details" .}}
26 | {{- end}}
27 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/template_allowlist_test.go:
--------------------------------------------------------------------------------
1 | package httpx
2 |
3 | import (
4 | "bytes"
5 | "testing"
6 | )
7 |
8 | // Verifies allowlist pages map to the expected content partials via sectionTmpl.
9 | func TestTemplateHelpers_Allowlist_Mapping(t *testing.T) {
10 | tr := RequireTemplateRenderer(t)
11 | if tr == nil {
12 | return
13 | }
14 | cloned, err := tr.t.Clone()
15 | if err != nil {
16 | t.Fatalf("clone: %v", err)
17 | }
18 | cloned, err = cloned.Parse(`{{define "probe"}}{{ sectionTmpl . }}{{end}}`)
19 | if err != nil {
20 | t.Fatalf("parse probe: %v", err)
21 | }
22 |
23 | cases := map[string]string{
24 | PageAllowlist: "allowlist-content",
25 | PageAllowlistForm: "allowlist-form-content",
26 | }
27 | for page, want := range cases {
28 | var buf bytes.Buffer
29 | if err := cloned.ExecuteTemplate(&buf, "probe", page); err != nil {
30 | t.Fatalf("execute probe(%s): %v", page, err)
31 | }
32 | got := buf.String()
33 | if got != want {
34 | t.Fatalf("sectionTmpl(%s) => %q, want %q", page, got, want)
35 | }
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/partials/events/console_event.tmpl:
--------------------------------------------------------------------------------
1 | {{- define "console-event-summary" -}}
2 | {{$data := .EventData | parseEventData}}
3 | {{$level := index $data "type"}}
4 | {{$text := index $data "text"}}
5 | {{if $level}}
19 |
21 | {{.EventData | formatEventData}}
20 | {{$level}}{{end}}
6 | {{if $text}}
7 | {{truncateText $text 64}}
8 | {{else}}
9 | Console output
10 | {{end}}
11 | {{- end}}
12 |
13 | {{- define "console-event-details" -}}
14 | {{$data := .EventData | parseEventData}}
15 | {{$text := index $data "text"}}
16 |
17 | {{if $text}}
18 |
24 | {{- end}}
25 |
26 | {{- define "console-event" -}}
27 | {{template "console-event-details" .}}
28 | {{- end}}
29 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/styles/utilities/text.css:
--------------------------------------------------------------------------------
1 | /* Utilities: Text & Typography */
2 |
3 | .text-secondary {
4 | color: var(--color-text-secondary);
5 | }
6 | .text-muted {
7 | color: var(--color-text-muted);
8 | }
9 | .text-success {
10 | color: var(--color-success);
11 | }
12 | .text-danger {
13 | color: var(--color-danger);
14 | }
15 | .text-warning {
16 | color: var(--color-warning);
17 | }
18 |
19 | .small {
20 | font-size: var(--font-size-sm);
21 | }
22 | .mono {
23 | font-family:
24 | ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New",
25 | monospace;
26 | }
27 | .nowrap {
28 | white-space: nowrap;
29 | }
30 |
31 | /* Backwards compatibility aliases */
32 | .text-sm {
33 | font-size: var(--font-size-sm);
34 | }
35 | .fw-medium {
36 | font-weight: var(--font-weight-medium);
37 | }
38 |
39 | .text-center {
40 | text-align: center;
41 | }
42 |
43 | .fw-semibold {
44 | font-weight: var(--font-weight-semibold);
45 | }
46 |
47 | .text-xs {
48 | font-size: var(--font-size-xs);
49 | }
50 |
51 | .text-danger-conditional {
52 | color: var(--color-danger);
53 | }
54 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/adapters/devauth/provider_test.go:
--------------------------------------------------------------------------------
1 | package devauth
2 |
3 | import (
4 | "context"
5 | "strings"
6 | "testing"
7 |
8 | "github.com/target/mmk-ui-api/internal/ports"
9 | )
10 |
11 | func TestProvider_BeginAndExchange(t *testing.T) {
12 | prov, err := NewProvider(Config{UserID: "dev-user", Email: "dev@example.com", Groups: []string{"users"}})
13 | if err != nil {
14 | t.Fatalf("NewProvider error: %v", err)
15 | }
16 | url, state, nonce, err := prov.Begin(context.Background(), ports.BeginInput{RedirectURL: "/"})
17 | if err != nil {
18 | t.Fatalf("Begin error: %v", err)
19 | }
20 | if !strings.HasPrefix(url, "/auth/callback?") {
21 | t.Fatalf("unexpected authURL: %s", url)
22 | }
23 | if state == "" || nonce == "" {
24 | t.Fatal("state and nonce should be generated")
25 | }
26 | id, err := prov.Exchange(context.Background(), ports.ExchangeInput{Code: "dev", State: state, Nonce: nonce})
27 | if err != nil {
28 | t.Fatalf("Exchange error: %v", err)
29 | }
30 | if id.UserID != "dev-user" || id.Email != "dev@example.com" {
31 | t.Fatalf("unexpected identity: %+v", id)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/features/icons.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Lucide icon feature module
3 | *
4 | * Initializes Lucide icons on initial load and after HTMX swaps to ensure newly
5 | * injected fragments receive icon treatment.
6 | */
7 | import { on } from "../core/htmx-bridge.js";
8 |
9 | let initialized = false;
10 |
11 | function createIcons() {
12 | try {
13 | if (!window.lucide || typeof window.lucide.createIcons !== "function") return;
14 |
15 | window.lucide.createIcons(
16 | { icons: window.lucide.icons },
17 | { attrs: {}, nameAttr: "data-lucide" },
18 | );
19 | } catch (_) {
20 | /* noop */
21 | }
22 | }
23 |
24 | function registerEventHandlers() {
25 | const refresh = () => {
26 | createIcons();
27 | };
28 |
29 | if (document.readyState === "loading") {
30 | document.addEventListener("DOMContentLoaded", refresh, { once: true });
31 | } else {
32 | refresh();
33 | }
34 |
35 | on("htmx:afterSwap", refresh);
36 | on("htmx:historyRestore", refresh);
37 | }
38 |
39 | export function initIcons() {
40 | if (initialized) return;
41 | initialized = true;
42 | registerEventHandlers();
43 | }
44 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/styles/components/job-status.css:
--------------------------------------------------------------------------------
1 | /* Component: Job Status Pills */
2 |
3 | .job-status {
4 | font-size: var(--font-size-sm);
5 | font-weight: var(--font-weight-medium);
6 | text-decoration: none;
7 | padding: var(--space-1) var(--space-2);
8 | border-radius: var(--border-radius-sm);
9 | display: inline-flex;
10 | align-items: center;
11 | gap: var(--space-1);
12 | }
13 | .job-status.completed {
14 | color: var(--color-success);
15 | background-color: var(--color-success-subtle, hsl(150, 60%, 95%));
16 | }
17 | .job-status.failed {
18 | color: var(--color-danger);
19 | background-color: var(--color-danger-subtle, hsl(0, 70%, 95%));
20 | }
21 | .job-status.running {
22 | color: var(--color-warning);
23 | background-color: var(--color-warning-subtle, hsl(38, 92%, 95%));
24 | }
25 | .job-status.pending {
26 | color: var(--color-text-secondary);
27 | background-color: var(--color-background);
28 | }
29 | .job-status.timeout,
30 | .job-status.error {
31 | color: var(--color-text-muted);
32 | background-color: var(--color-background);
33 | }
34 | .job-status:hover {
35 | text-decoration: underline;
36 | }
37 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/domain/scheduler_test.go:
--------------------------------------------------------------------------------
1 | package domain_test
2 |
3 | import (
4 | "testing"
5 |
6 | "github.com/stretchr/testify/require"
7 | "github.com/target/mmk-ui-api/internal/domain"
8 | )
9 |
10 | func TestParseOverrunStateMask(t *testing.T) {
11 | mask, err := domain.ParseOverrunStateMask("running, pending")
12 | require.NoError(t, err)
13 | require.True(t, mask.Has(domain.OverrunStateRunning))
14 | require.True(t, mask.Has(domain.OverrunStatePending))
15 | require.False(t, mask.Has(domain.OverrunStateRetrying))
16 | require.Equal(t, "running,pending", mask.String())
17 | }
18 |
19 | func TestParseOverrunStateMaskInvalid(t *testing.T) {
20 | _, err := domain.ParseOverrunStateMask("unknown")
21 | require.Error(t, err)
22 | }
23 |
24 | func TestOverrunStateMaskMarshal(t *testing.T) {
25 | mask := domain.OverrunStatePending | domain.OverrunStateRetrying
26 | text, err := mask.MarshalText()
27 | require.NoError(t, err)
28 | require.Equal(t, "pending,retrying", string(text))
29 |
30 | var roundTrip domain.OverrunStateMask
31 | require.NoError(t, roundTrip.UnmarshalText(text))
32 | require.Equal(t, mask, roundTrip)
33 | }
34 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/observability/notify/event.go:
--------------------------------------------------------------------------------
1 | package notify
2 |
3 | import (
4 | "context"
5 | "time"
6 | )
7 |
8 | // Severity constants recognised by downstream sinks.
9 | const (
10 | SeverityCritical = "critical"
11 | )
12 |
13 | // JobFailurePayload captures the canonical data we emit for job failure notifications.
14 | type JobFailurePayload struct {
15 | JobID string
16 | JobType string
17 | SiteID string
18 | Scope string
19 | IsTest bool
20 | Error string
21 | ErrorClass string
22 | Severity string
23 | OccurredAt time.Time
24 | Metadata map[string]string
25 | }
26 |
27 | // Sink describes a destination capable of consuming job failure notifications.
28 | type Sink interface {
29 | SendJobFailure(ctx context.Context, payload JobFailurePayload) error
30 | }
31 |
32 | // SinkFunc adapts a function to the Sink interface (useful for tests).
33 | type SinkFunc func(ctx context.Context, payload JobFailurePayload) error
34 |
35 | // SendJobFailure implements the Sink interface.
36 | func (f SinkFunc) SendJobFailure(ctx context.Context, payload JobFailurePayload) error {
37 | if f == nil {
38 | return nil
39 | }
40 | return f(ctx, payload)
41 | }
42 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/partials/events/page_event.tmpl:
--------------------------------------------------------------------------------
1 | {{- define "page-event-summary" -}}
2 | {{$data := .EventData | parseEventData}}
3 | {{$url := index $data "url"}}
4 | {{$selector := index $data "selector"}}
5 | {{$value := index $data "value"}}
6 | {{$text := index $data "text"}}
7 | {{if $url}}
8 | {{truncateURL120 $url}}
9 | {{else if $selector}}
10 | {{$text}}
19 | {{end}}
20 |
21 |
23 | {{.EventData | formatEventData}}
22 | {{$selector}}
11 | {{else if $text}}
12 | {{truncateText $text 60}}
13 | {{else if $value}}
14 | {{truncateText $value 60}}
15 | {{else}}
16 | Event details
17 | {{end}}
18 | {{- end}}
19 |
20 | {{- define "page-event-details" -}}
21 |
22 |
26 | {{- end}}
27 |
28 | {{- define "page-event" -}}
29 | {{template "page-event-details" .}}
30 | {{- end}}
31 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/styles/base/reset.css:
--------------------------------------------------------------------------------
1 | /**
2 | * CSS RESET AND BASE STYLES
3 | *
4 | * This file contains the CSS reset and base element styles.
5 | * It provides a consistent foundation across all browsers.
6 | */
7 |
8 | *,
9 | *::before,
10 | *::after {
11 | box-sizing: border-box;
12 | margin: 0;
13 | padding: 0;
14 | }
15 |
16 | /* Fallback focus styles for accessibility - ensures all inputs have focus indicators */
17 | input:focus-visible:not(.input):not(.filter-input),
18 | select:focus-visible:not(.filter-select),
19 | textarea:focus-visible:not(.input) {
20 | outline: 2px solid var(--color-brand-primary);
21 | outline-offset: 2px;
22 | }
23 |
24 | html {
25 | -webkit-font-smoothing: antialiased;
26 | -moz-osx-font-smoothing: grayscale;
27 | }
28 |
29 | body {
30 | font-family: var(--font-family-sans);
31 | font-size: var(--font-size-base);
32 | color: var(--color-text-primary);
33 | background-color: var(--color-background);
34 | line-height: 1.6;
35 | }
36 |
37 | /* Help text styling */
38 | small {
39 | display: block;
40 | margin-top: var(--space-2);
41 | font-size: var(--font-size-sm);
42 | color: var(--color-text-muted);
43 | line-height: 1.4;
44 | }
45 |
46 | /* Simple unstyled, divided list */
47 | .list {
48 | list-style: none;
49 | padding-left: 0;
50 | }
51 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/context_helpers_test.go:
--------------------------------------------------------------------------------
1 | package httpx
2 |
3 | import (
4 | "context"
5 | "testing"
6 |
7 | "github.com/stretchr/testify/assert"
8 | domainauth "github.com/target/mmk-ui-api/internal/domain/auth"
9 | )
10 |
11 | func TestGetUserSessionFromContext(t *testing.T) {
12 | // No session
13 | if s, ok := GetUserSessionFromContext(context.Background()); assert.False(t, ok) {
14 | assert.Nil(t, s)
15 | }
16 |
17 | // With session
18 | sess := &domainauth.Session{ID: "abc", Role: domainauth.RoleUser}
19 | ctx := SetSessionInContext(context.Background(), sess)
20 | s, ok := GetUserSessionFromContext(ctx)
21 | assert.True(t, ok)
22 | assert.Equal(t, sess, s)
23 | }
24 |
25 | func TestIsGuestUser(t *testing.T) {
26 | // No session => guest
27 | assert.True(t, IsGuestUser(context.Background()))
28 |
29 | // Guest role => guest
30 | guest := &domainauth.Session{ID: "g", Role: domainauth.RoleGuest}
31 | assert.True(t, IsGuestUser(SetSessionInContext(context.Background(), guest)))
32 |
33 | // User/Admin => not guest
34 | user := &domainauth.Session{ID: "u", Role: domainauth.RoleUser}
35 | admin := &domainauth.Session{ID: "a", Role: domainauth.RoleAdmin}
36 | assert.False(t, IsGuestUser(SetSessionInContext(context.Background(), user)))
37 | assert.False(t, IsGuestUser(SetSessionInContext(context.Background(), admin)))
38 | }
39 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/pages/alert_sink_view.tmpl:
--------------------------------------------------------------------------------
1 | {{define "alert-sink-view-content"}}
2 |
23 |
25 | {{.EventData | formatEventData}}
24 |
3 | {{with .AlertSink}}
4 |
35 | {{end}}
36 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/app.js:
--------------------------------------------------------------------------------
1 | /**
2 | * App initialization for the browser UI
3 | * - Boots feature modules registered with the app shell
4 | * - Boots component lifecycle integrations
5 | */
6 | import { Lifecycle } from "./core/lifecycle.js";
7 | import "./alert_sink_form.js";
8 | import "./components/filter-pills.js";
9 | import "./components/toast.js";
10 | import "./components/row-delete.js";
11 | import "./components/ioc-form.js";
12 | import "./job_status.js";
13 | import "./source_form.js";
14 | import { bootFeatures } from "./features/index.js";
15 | import { closeSidebar } from "./features/sidebar.js";
16 | import { closeAllUserMenus } from "./features/user-menu.js";
17 |
18 | function setupLifecycle() {
19 | const boot = () => {
20 | Lifecycle.init();
21 | };
22 |
23 | if (document.readyState === "loading") {
24 | document.addEventListener("DOMContentLoaded", boot, { once: true });
25 | } else {
26 | boot();
27 | }
28 | }
29 |
30 | function setupEscapeKeyListeners() {
31 | document.addEventListener("keydown", (event) => {
32 | if (event.key !== "Escape") return;
33 |
34 | closeSidebar();
35 |
36 | const toggles = closeAllUserMenus();
37 | const lastToggle = toggles[toggles.length - 1];
38 | if (lastToggle) lastToggle.focus();
39 | });
40 | }
41 |
42 | bootFeatures();
43 | setupLifecycle();
44 | setupEscapeKeyListeners();
45 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/features/network.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Network event helpers feature module
3 | *
4 | * Provides toggle support for expanding and collapsing long network URLs in
5 | * event detail views.
6 | */
7 | import { Events } from "../core/events.js";
8 |
9 | let initialized = false;
10 |
11 | function registerEventHandlers() {
12 | Events.on('[data-action="toggle-url"]', "click", (_event, button) => {
13 | const span = button.previousElementSibling;
14 | if (!span?.dataset.fullUrl) return;
15 |
16 | const isExpanded = button.dataset.expanded === "true";
17 | const nextExpanded = !isExpanded;
18 | const nextUrl = nextExpanded
19 | ? span.dataset.fullUrl
20 | : (span.dataset.truncatedUrl ?? span.dataset.fullUrl ?? "");
21 | const nextLabel = nextExpanded ? "Show less" : "Show full";
22 |
23 | const schedule = window.requestAnimationFrame?.bind(window) ?? ((fn) => setTimeout(fn, 16));
24 | schedule(() => {
25 | if (!(span.isConnected && button.isConnected)) return;
26 |
27 | span.textContent = nextUrl;
28 | button.dataset.expanded = String(nextExpanded);
29 | button.setAttribute("aria-pressed", String(nextExpanded));
30 | button.textContent = nextLabel;
31 | });
32 | });
33 | }
34 |
35 | export function initNetworkDetails() {
36 | if (initialized) return;
37 | initialized = true;
38 | registerEventHandlers();
39 | }
40 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/domain/model/event_query.go:
--------------------------------------------------------------------------------
1 | //revive:disable-next-line:var-naming // legacy package name widely used across the project
2 | package model
3 |
4 | // EventListByJobOptions groups parameters for listing/counting events by job with optional filters.
5 | type EventListByJobOptions struct {
6 | JobID string
7 | Limit int
8 | Offset int
9 | // CursorAfter and CursorBefore enable keyset pagination. When provided, they take precedence over Offset.
10 | CursorAfter *string
11 | CursorBefore *string
12 | // Optional filters (when nil/empty, no filter is applied)
13 | EventType *string // Optional filter by exact event_type (e.g., "Network.requestWillBeSent")
14 | Category *string // Optional filter by event category (network, console, security, page, action, error, other)
15 | SearchQuery *string // Optional text search in event_data JSON
16 | SortBy *string // Optional sort field (timestamp, event_type)
17 | SortDir *string // Optional sort direction (asc, desc)
18 | }
19 |
20 | // EventListPage contains a page of events with pagination cursors.
21 | type EventListPage struct {
22 | Events []*Event
23 | NextCursor *string
24 | PrevCursor *string
25 | }
26 |
27 | // EventListOptions is an alias for EventListByJobOptions for backward compatibility.
28 | //
29 | // Deprecated: Use EventListByJobOptions instead.
30 | type EventListOptions = EventListByJobOptions
31 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/migrate/migrations/003_job_results_retention.sql:
--------------------------------------------------------------------------------
1 | -- Reshape job_results so we can keep delivery history after reaping jobs.
2 | ALTER TABLE job_results
3 | DROP CONSTRAINT IF EXISTS job_results_job_id_fkey;
4 |
5 | ALTER TABLE job_results
6 | DROP CONSTRAINT IF EXISTS job_results_pkey;
7 |
8 | ALTER TABLE job_results
9 | ADD COLUMN IF NOT EXISTS id UUID;
10 |
11 | UPDATE job_results
12 | SET id = gen_random_uuid()
13 | WHERE id IS NULL;
14 |
15 | ALTER TABLE job_results
16 | ALTER COLUMN id SET DEFAULT gen_random_uuid();
17 |
18 | ALTER TABLE job_results
19 | ALTER COLUMN id SET NOT NULL;
20 |
21 | ALTER TABLE job_results
22 | ALTER COLUMN job_id DROP NOT NULL;
23 |
24 | ALTER TABLE job_results
25 | ADD CONSTRAINT job_results_pkey PRIMARY KEY (id);
26 |
27 | ALTER TABLE job_results
28 | ADD CONSTRAINT job_results_job_id_fkey
29 | FOREIGN KEY (job_id) REFERENCES jobs(id) ON DELETE SET NULL;
30 |
31 | CREATE UNIQUE INDEX IF NOT EXISTS job_results_job_id_key
32 | ON job_results (job_id);
33 |
34 | -- Improve lookup performance when listing results by alert id.
35 | CREATE INDEX IF NOT EXISTS job_results_alert_id_idx
36 | ON job_results ((result ->> 'alert_id'));
37 |
38 | -- Support batched retention cleanup queries.
39 | CREATE INDEX IF NOT EXISTS job_results_job_type_updated_at_idx
40 | ON job_results (job_type, updated_at, job_id);
41 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/styles/components/ioc-mode-toggle.css:
--------------------------------------------------------------------------------
1 | /* Component: IOC Mode Toggle */
2 |
3 | .ioc-mode-toggle {
4 | display: inline-flex;
5 | background-color: var(--color-background);
6 | border: var(--border-width) solid var(--color-border);
7 | border-radius: var(--border-radius-md);
8 | padding: var(--space-1);
9 | gap: var(--space-1);
10 | }
11 |
12 | .ioc-mode-btn {
13 | display: inline-flex;
14 | align-items: center;
15 | justify-content: center;
16 | padding: var(--space-2) var(--space-4);
17 | border: var(--border-width) solid transparent;
18 | background-color: transparent;
19 | color: var(--color-text-secondary);
20 | border-radius: calc(var(--border-radius-md) - var(--space-1));
21 | font-size: var(--font-size-sm);
22 | font-weight: var(--font-weight-medium);
23 | cursor: pointer;
24 | transition:
25 | background-color 0.2s ease,
26 | color 0.2s ease,
27 | border-color 0.2s ease;
28 | white-space: nowrap;
29 | }
30 |
31 | .ioc-mode-btn:hover {
32 | color: var(--color-text-primary);
33 | background-color: var(--color-surface);
34 | }
35 |
36 | .ioc-mode-btn.active {
37 | background-color: var(--color-surface);
38 | color: var(--color-text-primary);
39 | border-color: var(--color-border);
40 | box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
41 | }
42 |
43 | .ioc-mode-btn:focus-visible {
44 | outline: 2px solid var(--color-brand-primary);
45 | outline-offset: 2px;
46 | }
47 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/partials/events/worker_log_event.tmpl:
--------------------------------------------------------------------------------
1 | {{- define "worker-log-event-summary" -}}
2 | {{$data := .EventData | parseEventData}}
3 | {{$message := index $data "message"}}
4 | {{if not $message}}
5 | {{$message = index $data "text"}}
6 | {{end}}
7 | {{if not $message}}
8 | {{$message = index $data "msg"}}
9 | {{end}}
10 | {{if $message}}
11 | {{truncateText $message 64}}
12 | {{else}}
13 | Worker log entry
14 | {{end}}
15 | {{- end}}
16 |
17 | {{- define "worker-log-event-details" -}}
18 | {{$data := .EventData | parseEventData}}
19 | {{$message := index $data "message"}}
20 | {{if not $message}}
21 | {{$message = index $data "text"}}
22 | {{end}}
23 | {{if not $message}}
24 | {{$message = index $data "msg"}}
25 | {{end}}
26 | {{.Name}}
5 |
6 |
31 | {{else}}
32 |
7 |
30 | -
8 |
- Method 10 |
- {{ .Method }} 11 |
- URI 14 |
{{ .URI }}
15 | - OK Status 18 |
- {{ .OkStatus }} 19 |
- Retry 22 |
- {{ .Retry }} 23 |
- Secrets 26 |
- {{ if .Secrets }}{{ range $i, $s := .Secrets }}{{ if $i }}, {{ end }}{{ $s }}{{ end }}{{ else }}None{{ end }} 27 |
9 |
12 |
13 |
16 |
17 |
20 |
21 |
24 |
25 |
28 | Alert sink not found.
33 | {{end}} 34 |
27 |
34 | {{- end}}
35 |
36 | {{- define "worker-log-event" -}}
37 | {{template "worker-log-event-details" .}}
38 | {{- end}}
39 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/handlers_sources.go:
--------------------------------------------------------------------------------
1 | // Package httpx provides HTTP handlers and utilities for the merrymaker job system API.
2 | package httpx
3 |
4 | import (
5 | "errors"
6 | "net/http"
7 |
8 | "github.com/target/mmk-ui-api/internal/data"
9 | "github.com/target/mmk-ui-api/internal/domain/model"
10 | "github.com/target/mmk-ui-api/internal/service"
11 | )
12 |
13 | // SourceHandlers provides HTTP handlers for source-related operations using the orchestration service layer.
14 | type SourceHandlers struct {
15 | Svc *service.SourceService
16 | }
17 |
18 | // Create handles HTTP requests to create a new source. If Test=true, a job is auto-enqueued.
19 | func (h *SourceHandlers) Create(w http.ResponseWriter, r *http.Request) {
20 | var req *model.CreateSourceRequest
21 | if !DecodeJSON(w, r, &req) {
22 | return
23 | }
24 |
25 | src, err := h.Svc.Create(r.Context(), req)
26 | if err != nil {
27 | switch {
28 | case errors.Is(err, data.ErrSourceNameExists):
29 | WriteError(w, ErrorParams{Code: http.StatusConflict, ErrCode: "name_conflict", Err: err})
30 | case isValidationError(err):
31 | WriteError(w, ErrorParams{Code: http.StatusBadRequest, ErrCode: "validation_failed", Err: err})
32 | default:
33 | WriteError(w, ErrorParams{Code: http.StatusInternalServerError, ErrCode: "create_failed", Err: err})
34 | }
35 | return
36 | }
37 |
38 | WriteJSON(w, http.StatusCreated, src)
39 | }
40 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/layout.tmpl:
--------------------------------------------------------------------------------
1 | {{ define "layout" }}
2 |
3 |
4 |
5 |
6 |
7 |
8 | {{if $message}}{{$message}}{{else}}(empty log message){{end}}
33 |
7 |
33 | {{end}}
34 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/handlers_health_test.go:
--------------------------------------------------------------------------------
1 | package httpx
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 | )
8 |
9 | func TestHealthHandlerGET(t *testing.T) {
10 | req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
11 | rec := httptest.NewRecorder()
12 |
13 | healthHandler(rec, req)
14 |
15 | resp := rec.Result()
16 | t.Cleanup(func() { _ = resp.Body.Close() })
17 |
18 | if resp.StatusCode != http.StatusOK {
19 | t.Fatalf("expected status %d, got %d", http.StatusOK, resp.StatusCode)
20 | }
21 |
22 | if ct := resp.Header.Get("Content-Type"); ct != "application/json" {
23 | t.Fatalf("expected content-type application/json, got %q", ct)
24 | }
25 |
26 | body := rec.Body.String()
27 | if body != `{"status":"ok"}` {
28 | t.Fatalf("unexpected body: %q", body)
29 | }
30 | }
31 |
32 | func TestHealthHandlerHEAD(t *testing.T) {
33 | req := httptest.NewRequest(http.MethodHead, "/healthz", nil)
34 | rec := httptest.NewRecorder()
35 |
36 | healthHandler(rec, req)
37 |
38 | resp := rec.Result()
39 | t.Cleanup(func() { _ = resp.Body.Close() })
40 |
41 | if resp.StatusCode != http.StatusOK {
42 | t.Fatalf("expected status %d, got %d", http.StatusOK, resp.StatusCode)
43 | }
44 |
45 | if ct := resp.Header.Get("Content-Type"); ct != "application/json" {
46 | t.Fatalf("expected content-type application/json, got %q", ct)
47 | }
48 |
49 | if bodyLen := rec.Body.Len(); bodyLen != 0 {
50 | t.Fatalf("expected empty body for HEAD request, got %d bytes", bodyLen)
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/template_test.go:
--------------------------------------------------------------------------------
1 | package httpx
2 |
3 | import (
4 | "testing"
5 |
6 | "github.com/stretchr/testify/assert"
7 | "github.com/stretchr/testify/require"
8 | )
9 |
10 | func TestTemplateRenderer_LoadTemplates(t *testing.T) {
11 | // Test loading templates from the correct path
12 | tr := RequireTemplateRenderer(t)
13 | require.NotNil(t, tr, "Template renderer should not be nil")
14 |
15 | // Test that the templates are loaded correctly
16 | assert.NotNil(t, tr.t, "Template should be loaded")
17 |
18 | // Test that we can find the expected templates
19 | templates := tr.t.Templates()
20 | templateNames := make([]string, len(templates))
21 | for i, tmpl := range templates {
22 | templateNames[i] = tmpl.Name()
23 | }
24 |
25 | // Check for expected template names
26 | expectedTemplates := []string{"layout", "content", "error-layout", "dashboard-content"}
27 | for _, expected := range expectedTemplates {
28 | found := false
29 | for _, name := range templateNames {
30 | if name == expected {
31 | found = true
32 | break
33 | }
34 | }
35 | assert.True(t, found, "Template %s should be loaded", expected)
36 | }
37 | }
38 |
39 | func TestTemplateRenderer_FromCurrentDir(t *testing.T) {
40 | // Test loading templates from the current directory (as the router does)
41 | tr := RequireTemplateRendererFromRoot(t)
42 | if tr == nil {
43 | return
44 | }
45 |
46 | assert.NotNil(t, tr, "Template renderer should not be nil")
47 | assert.NotNil(t, tr.t, "Template should be loaded")
48 | }
49 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/domain/auth/types.go:
--------------------------------------------------------------------------------
1 | package auth
2 |
3 | // Package auth contains domain-level types for authentication and sessions.
4 | // It is pure and free of framework/adapter concerns.
5 |
6 | import "time"
7 |
8 | // Role represents an application's authorization role.
9 | // Keep string form for easy persistence and cookies.
10 | // Valid values are defined as constants below.
11 | type Role string
12 |
13 | const (
14 | RoleAdmin Role = "admin"
15 | RoleUser Role = "user"
16 | RoleGuest Role = "guest"
17 | )
18 |
19 | // Identity represents the authenticated principal returned by an IdP.
20 | // Adapters map provider-specific claims into this shape.
21 | type Identity struct {
22 | UserID string // stable user identifier (e.g., samAccountName or sub)
23 | FirstName string
24 | LastName string
25 | Email string
26 | Groups []string
27 | ExpiresAt time.Time // absolute expiry from IdP token
28 | }
29 |
30 | // Session is the server-side record we persist for an authenticated user.
31 | // ID is an opaque session identifier (e.g., random URL-safe string).
32 | type Session struct {
33 | ID string `json:"id"`
34 | UserID string `json:"user_id"`
35 | FirstName string `json:"first_name"`
36 | LastName string `json:"last_name"`
37 | Email string `json:"email"`
38 | Role Role `json:"role"`
39 | ExpiresAt time.Time `json:"expires_at"`
40 | }
41 |
42 | // IsGuest returns true if the session role is guest.
43 | func (s Session) IsGuest() bool { return s.Role == RoleGuest }
44 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/bootstrap/auth_test.go:
--------------------------------------------------------------------------------
1 | package bootstrap
2 |
3 | import (
4 | "io"
5 | "log/slog"
6 | "testing"
7 |
8 | "github.com/target/mmk-ui-api/config"
9 | )
10 |
11 | func TestBuildAuthServiceReturnsNilWithoutRedis(t *testing.T) {
12 | logger := slog.New(slog.NewTextHandler(io.Discard, nil))
13 |
14 | tests := []struct {
15 | name string
16 | auth config.AuthConfig
17 | }{
18 | {
19 | name: "dev auth mode",
20 | auth: config.AuthConfig{
21 | Mode: config.AuthModeMock,
22 | AdminGroup: "admins",
23 | UserGroup: "users",
24 | DevAuth: config.DevAuthConfig{
25 | UserID: "dev",
26 | Email: "dev@example.com",
27 | Groups: []string{"admins"},
28 | },
29 | },
30 | },
31 | {
32 | name: "oauth mode",
33 | auth: config.AuthConfig{
34 | Mode: config.AuthModeOAuth,
35 | AdminGroup: "admins",
36 | UserGroup: "users",
37 | OAuth: config.OAuthConfig{
38 | ClientID: "client-id",
39 | ClientSecret: "client-secret",
40 | DiscoveryURL: "https://issuer.example.com",
41 | RedirectURL: "https://app.example.com/auth/callback",
42 | Scope: "openid",
43 | },
44 | },
45 | },
46 | }
47 |
48 | for _, tt := range tests {
49 | t.Run(tt.name, func(t *testing.T) {
50 | cfg := AuthConfig{
51 | Auth: tt.auth,
52 | RedisClient: nil,
53 | Logger: logger,
54 | }
55 |
56 | if svc := BuildAuthService(cfg); svc != nil {
57 | t.Fatalf("BuildAuthService() = %v, want nil", svc)
58 | }
59 | })
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/ports/auth.go:
--------------------------------------------------------------------------------
1 | package ports
2 |
3 | // Package ports defines interfaces (hexagonal ports) for auth-related behavior.
4 | // Implementations live in internal/adapters; orchestration in internal/service.
5 |
6 | import (
7 | "context"
8 |
9 | domainauth "github.com/target/mmk-ui-api/internal/domain/auth"
10 | )
11 |
12 | // BeginInput carries inputs for initiating an auth flow.
13 | type BeginInput struct {
14 | RedirectURL string
15 | }
16 |
17 | // AuthProvider initiates and completes an authentication flow against an IdP.
18 | type AuthProvider interface {
19 | // Begin starts the login flow and returns the provider auth URL, an opaque state, and a nonce.
20 | Begin(ctx context.Context, in BeginInput) (authURL, state, nonce string, err error)
21 |
22 | // Exchange completes the login flow, verifying state and nonce, and returns the authenticated identity.
23 | Exchange(ctx context.Context, in ExchangeInput) (domainauth.Identity, error)
24 | }
25 |
26 | // ExchangeInput groups parameters for the code/token exchange.
27 | type ExchangeInput struct {
28 | Code string
29 | State string
30 | Nonce string
31 | }
32 |
33 | // SessionStore persists and retrieves user sessions.
34 | type SessionStore interface {
35 | Save(ctx context.Context, sess domainauth.Session) error
36 | Get(ctx context.Context, id string) (domainauth.Session, error)
37 | Delete(ctx context.Context, id string) error
38 | }
39 |
40 | // RoleMapper maps provider groups to application roles.
41 | type RoleMapper interface {
42 | Map(groups []string) domainauth.Role
43 | }
44 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/testutil/workflowtest/workflow_test.go:
--------------------------------------------------------------------------------
1 | package workflowtest
2 |
3 | import (
4 | "testing"
5 | "time"
6 |
7 | "github.com/stretchr/testify/assert"
8 | )
9 |
10 | // TestCreateSimpleEventBatch tests the event batch creation utility.
11 | func TestCreateSimpleEventBatch(t *testing.T) {
12 | batchID := "test-batch-1"
13 | sessionID := ""
14 | jobID := "job-123"
15 |
16 | batch := CreateSimpleEventBatch(batchID, sessionID, jobID)
17 |
18 | assert.Equal(t, batchID, batch.BatchID)
19 | assert.NotEmpty(t, batch.SessionID) // Should generate a UUID
20 | assert.Len(t, batch.Events, 1)
21 | assert.Equal(t, "event-1", batch.Events[0].ID)
22 | assert.Equal(t, "Network.requestWillBeSent", batch.Events[0].Method)
23 | assert.Equal(t, jobID, batch.BatchMetadata.JobID)
24 |
25 | // Test with provided sessionID
26 | providedSessionID := "550e8400-e29b-41d4-a716-446655440000"
27 | batch2 := CreateSimpleEventBatch("batch-2", providedSessionID, jobID)
28 | assert.Equal(t, providedSessionID, batch2.SessionID)
29 | }
30 |
31 | // TestWorkflowTestOptions tests the option builders.
32 | func TestWorkflowTestOptions(t *testing.T) {
33 | // Test default options
34 | opts := DefaultWorkflowOptions()
35 | assert.False(t, opts.EnableRedis)
36 | assert.Equal(t, 30*time.Second, opts.JobLease)
37 | assert.Equal(t, 1000, opts.EventMaxBatch)
38 |
39 | // Test Redis options
40 | redisOpts := RedisWorkflowOptions()
41 | assert.True(t, redisOpts.EnableRedis)
42 | assert.Equal(t, 30*time.Second, redisOpts.JobLease)
43 | assert.Equal(t, 1000, redisOpts.EventMaxBatch)
44 | }
45 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/observability/metrics/jobs.go:
--------------------------------------------------------------------------------
1 | package metrics
2 |
3 | import (
4 | "time"
5 |
6 | obserrors "github.com/target/mmk-ui-api/internal/observability/errors"
7 | "github.com/target/mmk-ui-api/internal/observability/statsd"
8 | )
9 |
10 | // Result constants for metric tagging.
11 | const (
12 | ResultSuccess = "success"
13 | ResultError = "error"
14 | ResultNoop = "noop"
15 | )
16 |
17 | // JobMetric captures details about a job lifecycle event for metric emission.
18 | type JobMetric struct {
19 | JobType string
20 | Transition string
21 | Result string
22 | Duration time.Duration
23 | Err error
24 | }
25 |
26 | // EmitJobLifecycle emits standardised job lifecycle metrics.
27 | func EmitJobLifecycle(sink statsd.Sink, in JobMetric) {
28 | if sink == nil {
29 | return
30 | }
31 |
32 | tags := map[string]string{
33 | "job_type": in.JobType,
34 | "transition": in.Transition,
35 | "result": in.Result,
36 | }
37 |
38 | if in.Err != nil && in.Result == ResultError {
39 | if class := obserrors.Classify(in.Err); class != "" {
40 | tags["error_class"] = class
41 | }
42 | }
43 |
44 | sink.Count("job.transition", 1, tags)
45 |
46 | if in.Duration > 0 {
47 | sink.Timing("job.duration", in.Duration, CloneTags(tags))
48 | }
49 | }
50 |
51 | // CloneTags creates a shallow copy of a tag map, filtering out empty keys.
52 | func CloneTags(src map[string]string) map[string]string {
53 | if len(src) == 0 {
54 | return nil
55 | }
56 | out := make(map[string]string, len(src))
57 | for k, v := range src {
58 | out[k] = v
59 | }
60 | return out
61 | }
62 |
--------------------------------------------------------------------------------
/services/puppeteer-worker/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "puppeteer-worker",
3 | "version": "1.0.0",
4 | "description": "merrymaker puppeteer worker",
5 | "main": "dist/index.js",
6 | "scripts": {
7 | "test": "npm run build && node --test src/*.test.js",
8 | "test:watch": "npm run build:watch & node --test --watch src/*.test.js src/*-test.js",
9 | "lint": "biome lint",
10 | "lint:fix": "biome lint --write",
11 | "format": "biome format --write",
12 | "build": "tsc --emitDeclarationOnly && node scripts/esbuild.mjs",
13 | "build:watch": "node scripts/esbuild.mjs --watch",
14 | "start": "tsx src/index.ts",
15 | "start:dist": "node dist/index.js",
16 | "start:env": "node --env-file=.env dist/index.js",
17 | "worker": "tsx src/worker-main.ts",
18 | "worker:dist": "node dist/worker-main.js",
19 | "worker:env": "node --env-file=.env dist/worker-main.js",
20 | "dev": "tsx --watch src/index.ts",
21 | "examples": "node dist/examples.js",
22 | "demo": "tsx src/index.ts"
23 | },
24 | "keywords": [],
25 | "author": "",
26 | "license": "ISC",
27 | "type": "module",
28 | "engines": {
29 | "node": ">=24.0.0"
30 | },
31 | "devDependencies": {
32 | "@biomejs/biome": "2.3.8",
33 | "esbuild": "^0.27.0",
34 | "tsx": "^4.20.4",
35 | "typescript": "^5.9.2"
36 | },
37 | "dependencies": {
38 | "@aws-sdk/client-s3": "^3.873.0",
39 | "@aws-sdk/s3-request-presigner": "^3.873.0",
40 | "@azure/storage-blob": "^12.28.0",
41 | "@google-cloud/storage": "^7.17.0",
42 | "ioredis": "^5.7.0",
43 | "minio": "^8.0.5",
44 | "puppeteer": "^24.17.0",
45 | "undici": "^7.14.0",
46 | "yaml": "^2.8.1"
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/services/puppeteer-worker/src/file-capture.unit.test.js:
--------------------------------------------------------------------------------
1 | import assert from "node:assert/strict";
2 | import { describe, test } from "node:test";
3 |
4 | // NOTE: Tests import the built artifact. Run `npm run build` before these tests.
5 | import { FileCapture } from "../dist/file-capture.js";
6 |
7 | function makeMemoryConfig(overrides = {}) {
8 | return {
9 | enabled: true,
10 | types: ["script", "document", "stylesheet"],
11 | maxFileSize: 1024 * 1024,
12 | storage: "memory",
13 | storageConfig: { ...overrides },
14 | };
15 | }
16 |
17 | describe("FileCapture in-run dedupe (memory storage)", () => {
18 | test("same-session duplicate uses same fileId and is retrievable", async () => {
19 | const sessionId = `sess-${Math.random().toString(36).slice(2)}`;
20 | const fc = new FileCapture(makeMemoryConfig(), sessionId);
21 |
22 | const content = Buffer.from("same content");
23 |
24 | const first = await fc.captureFile({
25 | url: "https://example.com/a.js",
26 | content,
27 | contentType: "application/javascript; charset=utf-8",
28 | sessionId,
29 | });
30 |
31 | assert.ok(first);
32 |
33 | const second = await fc.captureFile({
34 | url: "https://example.com/a.js",
35 | content,
36 | contentType: "application/javascript; charset=utf-8",
37 | sessionId,
38 | });
39 |
40 | assert.ok(second);
41 | assert.equal(second.fileId, first.fileId);
42 | assert.equal(second.metadata.captureReason, "duplicate");
43 |
44 | const roundTrip = await fc.retrieveFile(first.fileId);
45 | assert.ok(roundTrip);
46 | assert.equal(roundTrip.toString("utf8"), "same content");
47 |
48 | await fc.cleanup();
49 | });
50 | });
51 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/bootstrap/encryption.go:
--------------------------------------------------------------------------------
1 | package bootstrap
2 |
3 | import (
4 | "crypto/sha256"
5 | "encoding/hex"
6 | "errors"
7 | "log/slog"
8 |
9 | "github.com/target/mmk-ui-api/internal/data/cryptoutil"
10 | )
11 |
12 | // CreateEncryptor creates an AES-GCM encryptor from the provided key.
13 | // If the key is a hex string, it decodes it. Otherwise, it hashes the key to get a 32-byte key.
14 | // Returns a noop encryptor if the key is empty or invalid (with warning log).
15 | //
16 | //nolint:ireturn // Returning interface is intentional for encryptor abstraction
17 | func CreateEncryptor(key string, logger *slog.Logger) cryptoutil.Encryptor {
18 | if key == "" {
19 | if logger != nil {
20 | logger.Warn("encryption key is empty, using noop encryptor")
21 | }
22 | return &cryptoutil.NoopEncryptor{}
23 | }
24 |
25 | enc, err := createAESGCMEncryptor(key)
26 | if err != nil {
27 | if logger != nil {
28 | logger.Warn("failed to create encryptor, using noop encryptor", "error", err)
29 | }
30 | return &cryptoutil.NoopEncryptor{}
31 | }
32 |
33 | return enc
34 | }
35 |
36 | func createAESGCMEncryptor(key string) (*cryptoutil.AESGCMEncryptor, error) {
37 | if key == "" {
38 | return nil, errors.New("encryption key is required")
39 | }
40 |
41 | // If the key is a hex string, decode it
42 | var keyBytes []byte
43 | if decoded, err := hex.DecodeString(key); err == nil && len(decoded) == 32 {
44 | keyBytes = decoded
45 | } else {
46 | // Otherwise, hash the key to get a 32-byte key
47 | hash := sha256.Sum256([]byte(key))
48 | keyBytes = hash[:]
49 | }
50 |
51 | return cryptoutil.NewAESGCMEncryptor(keyBytes)
52 | }
53 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/htmx_response.go:
--------------------------------------------------------------------------------
1 | package httpx
2 |
3 | import (
4 | "net/http"
5 | )
6 |
7 | // HTMXResponse provides a fluent API for building HTMX responses.
8 | type HTMXResponse struct {
9 | w http.ResponseWriter
10 | }
11 |
12 | // HTMX creates a new HTMXResponse for fluent response building.
13 | func HTMX(w http.ResponseWriter) *HTMXResponse {
14 | return &HTMXResponse{w: w}
15 | }
16 |
17 | // Redirect instructs htmx to redirect the browser to the given URL.
18 | // It sets the HX-Redirect header and returns a 204 No Content status.
19 | // The handler should return immediately after calling this method to avoid
20 | // accidental writes that would be ignored.
21 | func (h *HTMXResponse) Redirect(url string) {
22 | SetHXRedirect(h.w, url)
23 | h.w.WriteHeader(http.StatusNoContent)
24 | }
25 |
26 | // Trigger triggers a client-side event after swap with optional payload.
27 | // This method is chainable.
28 | func (h *HTMXResponse) Trigger(event string, payload any) *HTMXResponse {
29 | SetHXTrigger(h.w, event, payload)
30 | return h
31 | }
32 |
33 | // PushURL pushes the given URL into the browser history for the new content.
34 | // This method is chainable.
35 | func (h *HTMXResponse) PushURL(url string) *HTMXResponse {
36 | SetHXPushURL(h.w, url)
37 | return h
38 | }
39 |
40 | // Refresh forces a full page refresh.
41 | // It sets the HX-Refresh header and returns a 204 No Content status.
42 | // The handler should return immediately after calling this method to avoid
43 | // accidental writes that would be ignored.
44 | func (h *HTMXResponse) Refresh() {
45 | SetHXRefresh(h.w, true)
46 | h.w.WriteHeader(http.StatusNoContent)
47 | }
48 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/domain/rules/engine_test.go:
--------------------------------------------------------------------------------
1 | package rules
2 |
3 | import (
4 | "context"
5 | "testing"
6 |
7 | "github.com/stretchr/testify/assert"
8 | "github.com/stretchr/testify/require"
9 | )
10 |
11 | type stubRule struct {
12 | id string
13 | apply func(*ProcessingResults)
14 | err error
15 | }
16 |
17 | func (s stubRule) ID() string {
18 | return s.id
19 | }
20 |
21 | func (s stubRule) Evaluate(_ context.Context, _ RuleWorkItem) RuleEvaluation {
22 | eval := RuleEvaluation{RuleID: s.id}
23 | if s.apply != nil {
24 | eval.ApplyFn = s.apply
25 | }
26 | eval.Err = s.err
27 | return eval
28 | }
29 |
30 | func TestDefaultRuleEngineEvaluate(t *testing.T) {
31 | engine := NewRuleEngine([]Rule{
32 | stubRule{
33 | id: "ok",
34 | apply: func(results *ProcessingResults) {
35 | results.AlertsCreated += 2
36 | },
37 | },
38 | stubRule{
39 | id: "err",
40 | err: assert.AnError,
41 | },
42 | nil,
43 | })
44 |
45 | item := RuleWorkItem{SiteID: "site-1", Scope: "default"}
46 |
47 | evals := engine.Evaluate(context.Background(), item)
48 | require.Len(t, evals, 2)
49 |
50 | require.Equal(t, "ok", evals[0].RuleID)
51 | require.NoError(t, evals[0].Err)
52 | require.NotNil(t, evals[0].ApplyFn)
53 |
54 | require.Equal(t, "err", evals[1].RuleID)
55 | require.Error(t, evals[1].Err)
56 | require.Nil(t, evals[1].ApplyFn)
57 |
58 | results := &ProcessingResults{}
59 | for _, eval := range evals {
60 | if eval.Err != nil {
61 | results.ErrorsEncountered++
62 | continue
63 | }
64 | eval.Apply(results)
65 | }
66 |
67 | assert.Equal(t, 2, results.AlertsCreated)
68 | assert.Equal(t, 1, results.ErrorsEncountered)
69 | }
70 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/http/json.go:
--------------------------------------------------------------------------------
1 | package httpx
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "net/http"
7 | )
8 |
9 | // DecodeJSON decodes JSON from the request body into the destination and handles errors.
10 | // Returns true if successful, false if there was an error (error response already written).
11 | func DecodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
12 | dec := json.NewDecoder(r.Body)
13 | dec.DisallowUnknownFields()
14 |
15 | if err := dec.Decode(dst); err != nil {
16 | WriteError(w, ErrorParams{Code: http.StatusBadRequest, ErrCode: "invalid_json", Err: err})
17 | return false
18 | }
19 |
20 | return true
21 | }
22 |
23 | // WriteJSON writes a JSON response with the given status code and data.
24 | func WriteJSON(w http.ResponseWriter, code int, v any) {
25 | var buf bytes.Buffer
26 | if err := json.NewEncoder(&buf).Encode(v); err != nil {
27 | http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
28 | return
29 | }
30 |
31 | w.Header().Set("Content-Type", "application/json")
32 | w.WriteHeader(code)
33 | if _, err := buf.WriteTo(w); err != nil {
34 | // Response writer errors (e.g., client disconnect) can't be recovered from here.
35 | return
36 | }
37 | }
38 |
39 | // ErrorParams groups parameters for WriteError to adhere to the ≤3 params guideline.
40 | type ErrorParams struct {
41 | Code int
42 | ErrCode string
43 | Err error
44 | }
45 |
46 | // WriteError writes a JSON error response using ErrorParams.
47 | func WriteError(w http.ResponseWriter, p ErrorParams) {
48 | WriteJSON(w, p.Code, map[string]string{"error": p.ErrCode, "message": p.Err.Error()})
49 | }
50 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/service/rules/metrics.go:
--------------------------------------------------------------------------------
1 | package rules
2 |
3 | // Minimal cache metrics hooks for rules caches.
4 | // Keep interface compact and avoid external deps; callers can adapt to Prometheus or other systems.
5 | // Functions must have ≤3 parameters; use a struct for event details.
6 |
7 | type CacheName string
8 |
9 | type CacheTier string
10 |
11 | type CacheOp string
12 |
13 | const (
14 | CacheSeen CacheName = "seen"
15 | CacheIOC CacheName = "ioc"
16 | CacheFiles CacheName = "files"
17 | )
18 |
19 | const (
20 | TierLocal CacheTier = "local"
21 | TierRedis CacheTier = "redis"
22 | TierRepo CacheTier = "repo"
23 | )
24 |
25 | const (
26 | OpHit CacheOp = "hit"
27 | OpMiss CacheOp = "miss"
28 | OpWrite CacheOp = "write"
29 | )
30 |
31 | // CacheEvent is a compact event describing a cache metric occurrence.
32 | // Add fields cautiously to keep it small and general.
33 | // Name: which typed cache (seen/ioc/files)
34 | // Tier: which tier (local/redis/repo)
35 | // Op: hit/miss/write
36 | // Ok: whether operation succeeded (for writes/lookups)
37 | // Note: Not every combination is used by all caches; unused are fine.
38 |
39 | type CacheEvent struct {
40 | Name CacheName
41 | Tier CacheTier
42 | Op CacheOp
43 | Ok bool
44 | }
45 |
46 | // CacheMetrics is an optional hook; implementations may aggregate counters.
47 | // A Noop implementation is provided for convenience.
48 |
49 | type CacheMetrics interface {
50 | RecordCacheEvent(e CacheEvent)
51 | }
52 |
53 | // NoopCacheMetrics is the default when no metrics are provided.
54 |
55 | type NoopCacheMetrics struct{}
56 |
57 | func (NoopCacheMetrics) RecordCacheEvent(_ CacheEvent) {}
58 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/auth.tmpl:
--------------------------------------------------------------------------------
1 | {{ define "signed-out-page" }}
2 |
3 |
4 |
5 |
6 |
7 |
8 | 8 | 11 | 12 | {{renderEventPartial $typeTpl .}} 13 | 14 | 15 | {{renderEventPartial $summaryTpl .}} 16 | 17 | 18 | 19 | 20 |
21 |
26 | {{if .DataTrimmed}}
27 |
32 | Loading full details on demand…
28 | {{else}}
29 | Loading event details…
30 | {{end}}
31 |
3 |
47 | {{end}}
48 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/partials/events/screenshot_event.tmpl:
--------------------------------------------------------------------------------
1 | {{- define "screenshot-event-summary" -}}
2 | {{$data := .EventData | parseEventData}}
3 | {{$caption := index $data "caption"}}
4 | {{if $caption}}
5 | {{truncateText $caption 48}}
6 | {{else}}
7 | Screenshot captured
8 | {{end}}
9 | {{- end}}
10 |
11 | {{- define "screenshot-event-details" -}}
12 | {{$data := .EventData | parseEventData}}
13 | {{$image := index $data "image"}}
14 | {{$mime := index $data "mime"}}
15 | {{$caption := index $data "caption"}}
16 |
4 | {{if and .StartIndex .EndIndex}}
5 | Showing {{formatNumber .StartIndex}}–{{formatNumber .EndIndex}}{{if .TotalCount}} of {{formatNumber .TotalCount}}{{end}}
6 | {{else}}
7 |
8 | {{end}}
9 |
10 |
11 | {{if .HasPrev}}
12 |
19 |
20 | Prev
21 |
22 | {{else}}
23 |
24 |
25 | Prev
26 |
27 | {{end}}
28 | {{if .HasNext}}
29 |
36 | Next
37 |
38 |
39 | {{else}}
40 |
41 | Next
42 |
43 |
44 | {{end}}
45 |
46 |
17 | {{if $image}}
18 | {{/* Render screenshot thumbnail with modal functionality */}}
19 |
41 | {{- end}}
42 |
43 | {{- define "screenshot-event" -}}
44 | {{template "screenshot-event-details" .}}
45 | {{- end}}
46 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/domain/rules/helpers.go:
--------------------------------------------------------------------------------
1 | package rules
2 |
3 | import "strings"
4 |
5 | func appendSample(samples *[]string, domain string) {
6 | if samples == nil {
7 | return
8 | }
9 | domain = strings.TrimSpace(domain)
10 | if domain == "" {
11 | return
12 | }
13 | for _, existing := range *samples {
14 | if strings.EqualFold(existing, domain) {
15 | return
16 | }
17 | }
18 | if len(*samples) < MetricsSampleLimit {
19 | *samples = append(*samples, domain)
20 | }
21 | }
22 |
23 | // MergeUnknownDomainMetrics merges src into dst, preserving sample limits.
24 | func MergeUnknownDomainMetrics(dst *UnknownDomainMetrics, src UnknownDomainMetrics) {
25 | if dst == nil {
26 | return
27 | }
28 | dst.Alerted.Merge(src.Alerted)
29 | dst.AlertedDryRun.Merge(src.AlertedDryRun)
30 | dst.AlertedMuted.Merge(src.AlertedMuted)
31 | dst.SuppressedAllowlist.Merge(src.SuppressedAllowlist)
32 | dst.SuppressedSeen.Merge(src.SuppressedSeen)
33 | dst.SuppressedDedupe.Merge(src.SuppressedDedupe)
34 | dst.NormalizationFailed.Merge(src.NormalizationFailed)
35 | dst.Errors.Merge(src.Errors)
36 | }
37 |
38 | // MergeIOCMetrics merges src into dst, preserving sample limits.
39 | func MergeIOCMetrics(dst *IOCMetrics, src IOCMetrics) {
40 | if dst == nil {
41 | return
42 | }
43 | dst.Matches.Merge(src.Matches)
44 | dst.MatchesDryRun.Merge(src.MatchesDryRun)
45 | dst.Alerts.Merge(src.Alerts)
46 | dst.AlertsMuted.Merge(src.AlertsMuted)
47 | }
48 |
49 | // AppendUniqueLower appends a lower-cased value when not already present.
50 | func AppendUniqueLower(list *[]string, value string) {
51 | if list == nil {
52 | return
53 | }
54 | v := strings.ToLower(strings.TrimSpace(value))
55 | if v == "" {
56 | return
57 | }
58 | for _, existing := range *list {
59 | if existing == v {
60 | return
61 | }
62 | }
63 | *list = append(*list, v)
64 | }
65 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/core/secret_repository_stub_test.go:
--------------------------------------------------------------------------------
1 | package core
2 |
3 | import (
4 | "context"
5 | "errors"
6 |
7 | "github.com/target/mmk-ui-api/internal/domain/model"
8 | )
9 |
10 | // stubSecretRepo provides a minimal SecretRepository implementation for tests.
11 | type stubSecretRepo struct {
12 | values map[string]*model.Secret
13 | err error
14 | }
15 |
16 | func newStubSecretRepo(values map[string]*model.Secret, err error) *stubSecretRepo {
17 | return &stubSecretRepo{values: values, err: err}
18 | }
19 |
20 | func (s *stubSecretRepo) Create(context.Context, model.CreateSecretRequest) (*model.Secret, error) {
21 | return nil, errors.New("not implemented")
22 | }
23 |
24 | func (s *stubSecretRepo) GetByID(context.Context, string) (*model.Secret, error) {
25 | return nil, errors.New("not implemented")
26 | }
27 |
28 | func (s *stubSecretRepo) GetByName(_ context.Context, name string) (*model.Secret, error) {
29 | if s.err != nil {
30 | return nil, s.err
31 | }
32 | if secret, ok := s.values[name]; ok {
33 | return secret, nil
34 | }
35 | return nil, errors.New("secret not found")
36 | }
37 |
38 | func (s *stubSecretRepo) List(context.Context, int, int) ([]*model.Secret, error) {
39 | return nil, errors.New("not implemented")
40 | }
41 |
42 | func (s *stubSecretRepo) Update(context.Context, string, model.UpdateSecretRequest) (*model.Secret, error) {
43 | return nil, errors.New("not implemented")
44 | }
45 |
46 | func (s *stubSecretRepo) Delete(context.Context, string) (bool, error) {
47 | return false, errors.New("not implemented")
48 | }
49 |
50 | func (s *stubSecretRepo) FindDueForRefresh(context.Context, int) ([]*model.Secret, error) {
51 | return nil, errors.New("not implemented")
52 | }
53 |
54 | func (s *stubSecretRepo) UpdateRefreshStatus(context.Context, UpdateSecretRefreshStatusParams) error {
55 | return errors.New("not implemented")
56 | }
57 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/domain/job/lease_policy_test.go:
--------------------------------------------------------------------------------
1 | package job
2 |
3 | import (
4 | "testing"
5 | "time"
6 |
7 | "github.com/stretchr/testify/assert"
8 | "github.com/stretchr/testify/require"
9 | )
10 |
11 | func TestNewLeasePolicy(t *testing.T) {
12 | t.Run("success", func(t *testing.T) {
13 | policy, err := NewLeasePolicy(30 * time.Second)
14 | require.NoError(t, err)
15 | assert.Equal(t, 30*time.Second, policy.Default())
16 | })
17 |
18 | t.Run("invalid default lease", func(t *testing.T) {
19 | policy, err := NewLeasePolicy(0)
20 | require.ErrorIs(t, err, ErrInvalidDefaultLease)
21 | assert.Nil(t, policy)
22 | })
23 | }
24 |
25 | func TestLeasePolicy_Resolve(t *testing.T) {
26 | policy, err := NewLeasePolicy(30 * time.Second)
27 | require.NoError(t, err)
28 |
29 | t.Run("explicit duration uses whole seconds", func(t *testing.T) {
30 | decision := policy.Resolve(45 * time.Second)
31 | assert.Equal(t, 45, decision.Seconds)
32 | assert.Equal(t, LeaseSourceExplicit, decision.Source)
33 | assert.False(t, decision.Clamped())
34 | })
35 |
36 | t.Run("default duration when request is zero", func(t *testing.T) {
37 | decision := policy.Resolve(0)
38 | assert.Equal(t, 30, decision.Seconds)
39 | assert.Equal(t, LeaseSourceDefault, decision.Source)
40 | assert.True(t, decision.UsedDefault())
41 | })
42 |
43 | t.Run("sub-second duration clamps to minimum", func(t *testing.T) {
44 | decision := policy.Resolve(500 * time.Millisecond)
45 | assert.Equal(t, 1, decision.Seconds)
46 | assert.Equal(t, LeaseSourceClamped, decision.Source)
47 | assert.True(t, decision.Clamped())
48 | })
49 |
50 | t.Run("negative duration clamps to minimum", func(t *testing.T) {
51 | decision := policy.Resolve(-5 * time.Second)
52 | assert.Equal(t, 1, decision.Seconds)
53 | assert.Equal(t, LeaseSourceClamped, decision.Source)
54 | assert.True(t, decision.Clamped())
55 | })
56 | }
57 |
--------------------------------------------------------------------------------
/services/puppeteer-worker/src/file-capture.content-type.test.js:
--------------------------------------------------------------------------------
1 | import assert from "node:assert/strict";
2 | import { describe, test } from "node:test";
3 |
4 | // NOTE: Tests import the built artifact. Run `npm run build` before these tests.
5 | import { FileCapture } from "../dist/file-capture.js";
6 |
7 | function makeMemoryConfig(types = ["document"]) {
8 | return {
9 | enabled: true,
10 | types,
11 | maxFileSize: 1024 * 1024,
12 | storage: "memory",
13 | storageConfig: {},
14 | };
15 | }
16 |
17 | describe("FileCapture content-type coverage", () => {
18 | test("captures JSON as document", async () => {
19 | const sessionId = `sess-json-${Math.random().toString(36).slice(2)}`;
20 | const fc = new FileCapture(makeMemoryConfig(["document"]), sessionId);
21 |
22 | const content = Buffer.from('{"ok":true}');
23 |
24 | const ctx = await fc.captureFile({
25 | url: "https://example.com/data.json",
26 | content,
27 | contentType: "application/json; charset=utf-8",
28 | sessionId,
29 | });
30 |
31 | assert.ok(ctx, "expected JSON to be captured");
32 | assert.equal(ctx.contentType.includes("application/json"), true);
33 |
34 | await fc.cleanup();
35 | });
36 |
37 | test("captures XML (+xml) as document", async () => {
38 | const sessionId = `sess-xml-${Math.random().toString(36).slice(2)}`;
39 | const fc = new FileCapture(makeMemoryConfig(["document"]), sessionId);
40 |
41 | const content = Buffer.from('
20 | {{if $caption}}
21 | 
35 |
37 | {{else}}
38 | {{$caption}}
22 | {{end}}
23 | Failed to load screenshot
36 | Screenshot (no image data)
39 | {{end}}
40 |
3 |
47 | {{end}}
48 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/features/row-nav.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Row navigation feature module
3 | *
4 | * Provides delegated handling for clickable table/list rows. Elements marked
5 | * with `.row-link` will trigger navigation when activated via click or keyboard,
6 | * unless an ancestor has `data-stop-row-nav` set.
7 | *
8 | * Supported attributes:
9 | * - data-row-nav-target: optional selector defining the element to activate.
10 | * Defaults to the row element itself.
11 | */
12 | import { Events } from "../core/events.js";
13 |
14 | let initialized = false;
15 |
16 | function getNavTarget(row) {
17 | const selector = row.getAttribute("data-row-nav-target");
18 | if (!selector) return row;
19 | return row.querySelector(selector) || row;
20 | }
21 |
22 | function triggerNavigation(target) {
23 | if (!target) return;
24 | if (window.htmx && typeof window.htmx.trigger === "function") {
25 | window.htmx.trigger(target, "row-nav");
26 | return;
27 | }
28 |
29 | if (typeof target.click === "function") {
30 | target.click();
31 | }
32 | }
33 |
34 | function isInteractiveControl(event) {
35 | const control = event.target?.closest("[data-stop-row-nav], button, a, input, select, textarea");
36 | return Boolean(control);
37 | }
38 |
39 | function registerHandlers() {
40 | Events.on(".row-link", "click", (event, row) => {
41 | // Ignore clicks on interactive controls inside the row
42 | if (isInteractiveControl(event)) return;
43 |
44 | triggerNavigation(getNavTarget(row));
45 | });
46 |
47 | Events.on(".row-link", "keydown", (event, row) => {
48 | if (event.key !== "Enter" && event.key !== " ") return;
49 |
50 | // Allow space/enter to activate interactive children normally
51 | if (isInteractiveControl(event)) return;
52 |
53 | event.preventDefault();
54 | triggerNavigation(getNavTarget(row));
55 | });
56 | }
57 |
58 | export function initRowNav() {
59 | if (initialized) return;
60 | initialized = true;
61 | registerHandlers();
62 | }
63 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/styles/index-modular.css:
--------------------------------------------------------------------------------
1 | /**
2 | * MERRYMAKER FRONTEND STYLES - MODULAR ARCHITECTURE
3 | *
4 | * This is the main entry point for all CSS styles.
5 | * It imports all modular CSS files in the correct order.
6 | *
7 | * Order matters:
8 | * 1. Fonts (self-hosted with font-display: swap)
9 | * 2. Base styles (variables, reset, typography)
10 | * 3. Layout styles (grid, header, responsive)
11 | * 4. Components (buttons, forms, tables, etc.)
12 | * 5. Pages (specific page styles)
13 | * 6. Utilities (helper classes)
14 | */
15 |
16 | /* === FONTS === */
17 | @import "./base/fonts.css";
18 |
19 | /* === BASE STYLES === */
20 | @import "./base/variables.css";
21 | @import "./base/reset.css";
22 |
23 | /* === LAYOUT === */
24 | /* Dashboard layout will be created separately */
25 |
26 | /* === COMPONENTS === */
27 | @import "./components/buttons.css";
28 | @import "./components/forms.css";
29 | @import "./components/filters.css";
30 |
31 | /* === MODULAR EXTENSIONS (override legacy block) === */
32 | @import "./layout/dashboard.css";
33 | @import "./components/cards.css";
34 | @import "./components/dashboard-stats.css";
35 | @import "./components/tables.css";
36 | @import "./components/pagination.css";
37 | @import "./components/alerts.css";
38 | @import "./components/badges.css";
39 | @import "./components/job-status.css";
40 | @import "./components/job-detail.css";
41 | @import "./components/spinner.css";
42 | @import "./components/lists.css";
43 | @import "./components/toolbar.css";
44 | @import "./components/events.css";
45 | @import "./components/failure-event.css";
46 | @import "./components/user-toggle.css";
47 | @import "./components/toast.css";
48 | @import "./components/ioc-mode-toggle.css";
49 | @import "./pages/auth.css";
50 | @import "./pages/sites.css";
51 | @import "./utilities/width.css";
52 | @import "./utilities/text.css";
53 | @import "./utilities/spacing.css";
54 | @import "./utilities/flex.css";
55 | @import "./utilities/layout.css";
56 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/data/export_contract_test.go:
--------------------------------------------------------------------------------
1 | package data
2 |
3 | import (
4 | "reflect"
5 | "testing"
6 |
7 | "github.com/target/mmk-ui-api/internal/core"
8 | )
9 |
10 | var (
11 | _ core.JobRepository = (*JobRepo)(nil)
12 | _ core.JobRepositoryTx = (*JobRepo)(nil)
13 | )
14 |
15 | func TestJobRepoExportedMethodsMatchAllowlist(t *testing.T) {
16 | allowed := map[string]struct{}{
17 | "Complete": {},
18 | "CountAggregatesBySources": {},
19 | "CountBrowserBySource": {},
20 | "CountBySource": {},
21 | "Create": {},
22 | "CreateInTx": {},
23 | "Delete": {},
24 | "DeleteByPayloadField": {},
25 | "DeleteOldJobResults": {},
26 | "DeleteOldJobs": {},
27 | "Fail": {},
28 | "FailStalePendingJobs": {},
29 | "GetByID": {},
30 | "Heartbeat": {},
31 | "JobStatesByTaskName": {},
32 | "List": {},
33 | "ListBySiteWithFilters": {},
34 | "ListBySource": {},
35 | "ListRecentByType": {},
36 | "ListRecentByTypeWithSiteNames": {},
37 | "ReserveNext": {},
38 | "RunningJobExistsByTaskName": {},
39 | "Stats": {},
40 | "WaitForNotification": {},
41 | }
42 |
43 | methods := reflect.TypeOf(&JobRepo{})
44 | seen := make(map[string]struct{})
45 |
46 | for i := range methods.NumMethod() {
47 | m := methods.Method(i)
48 | if !m.IsExported() {
49 | continue
50 | }
51 | name := m.Name
52 | if _, ok := allowed[name]; !ok {
53 | t.Fatalf("unexpected exported method on JobRepo: %s", name)
54 | }
55 | seen[name] = struct{}{}
56 | }
57 |
58 | for name := range allowed {
59 | if _, ok := seen[name]; !ok {
60 | t.Fatalf("expected JobRepo to export method %s", name)
61 | }
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/observability/notify/pagerduty/pagerduty_test.go:
--------------------------------------------------------------------------------
1 | package pagerduty
2 |
3 | import (
4 | "strings"
5 | "testing"
6 | "time"
7 |
8 | "github.com/target/mmk-ui-api/internal/observability/notify"
9 | )
10 |
11 | func TestNewClientValidation(t *testing.T) {
12 | if _, err := NewClient(Config{}); err == nil {
13 | t.Fatal("expected error when routing key missing")
14 | }
15 | }
16 |
17 | func TestBuildEventDefaults(t *testing.T) {
18 | client, err := NewClient(Config{
19 | RoutingKey: "key",
20 | Source: "",
21 | Component: "",
22 | Timeout: time.Second,
23 | })
24 | if err != nil {
25 | t.Fatalf("unexpected error: %v", err)
26 | }
27 |
28 | payload := notify.JobFailurePayload{
29 | JobID: "123",
30 | JobType: "rules",
31 | Error: "boom",
32 | ErrorClass: "err_class",
33 | }
34 | event := client.buildEvent(payload)
35 |
36 | payloadSection, ok := event["payload"].(map[string]any)
37 | if !ok {
38 | t.Fatalf("expected payload section")
39 | }
40 | if payloadSection["severity"] != notify.SeverityCritical {
41 | t.Fatalf("expected default severity, got %v", payloadSection["severity"])
42 | }
43 | if payloadSection["source"] != "merrymaker" {
44 | t.Fatalf("expected default source, got %v", payloadSection["source"])
45 | }
46 | if payloadSection["component"] != "merrymaker" {
47 | t.Fatalf("expected default component, got %v", payloadSection["component"])
48 | }
49 |
50 | custom, ok := payloadSection["custom_details"].(map[string]any)
51 | if !ok {
52 | t.Fatalf("expected custom details")
53 | }
54 |
55 | required := []string{"job_id", "job_type", "error", "error_class"}
56 | for _, key := range required {
57 | if _, exists := custom[key]; !exists {
58 | t.Fatalf("expected key %s in custom details", key)
59 | }
60 | }
61 |
62 | dedup, _ := event["dedup_key"].(string)
63 | if !strings.Contains(dedup, "123") {
64 | t.Fatalf("expected dedup key to reference job id, got %s", dedup)
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/services/merrymaker-go/internal/data/event_repo_bench_test.go:
--------------------------------------------------------------------------------
1 | package data
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "encoding/json"
7 | "fmt"
8 | "testing"
9 |
10 | "github.com/target/mmk-ui-api/internal/domain/model"
11 | "github.com/target/mmk-ui-api/internal/testutil"
12 | )
13 |
14 | func BenchmarkEventRepo_BulkInsert(b *testing.B) {
15 | testutil.SkipIfNoTestDB(b)
16 |
17 | testutil.WithAutoDB(b, func(db *sql.DB) {
18 | ctx := context.Background()
19 | eventRepo := &EventRepo{DB: db}
20 |
21 | // Create test events
22 | events := make([]model.RawEvent, 100)
23 | for i := range events {
24 | data := fmt.Sprintf(`{"index":%d}`, i)
25 | events[i] = model.RawEvent{
26 | Type: "benchmark_event",
27 | Data: json.RawMessage(data),
28 | Priority: intPtr(1),
29 | }
30 | }
31 |
32 | req := model.BulkEventRequest{
33 | SessionID: "550e8400-e29b-41d4-a716-446655440005",
34 | Events: events,
35 | }
36 |
37 | b.ResetTimer()
38 | for b.Loop() {
39 | _, err := eventRepo.BulkInsert(ctx, req, false)
40 | if err != nil {
41 | b.Fatal(err)
42 | }
43 | }
44 | })
45 | }
46 |
47 | func BenchmarkEventRepo_BulkInsertCopy(b *testing.B) {
48 | testutil.SkipIfNoTestDB(b)
49 |
50 | testutil.WithAutoDB(b, func(db *sql.DB) {
51 | ctx := context.Background()
52 | eventRepo := &EventRepo{DB: db}
53 |
54 | // Create test events
55 | events := make([]model.RawEvent, 100)
56 | for i := range 100 {
57 | data := fmt.Sprintf(`{"index":%d}`, i)
58 | events[i] = model.RawEvent{
59 | Type: "benchmark_event_copy",
60 | Data: json.RawMessage(data),
61 | Priority: intPtr(1),
62 | }
63 | }
64 |
65 | req := model.BulkEventRequest{
66 | SessionID: "550e8400-e29b-41d4-a716-446655440006",
67 | Events: events,
68 | }
69 |
70 | b.ResetTimer()
71 | for b.Loop() {
72 | _, err := eventRepo.BulkInsertCopy(ctx, req, false)
73 | if err != nil {
74 | b.Fatal(err)
75 | }
76 | }
77 | })
78 | }
79 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/features/htmx-history.js:
--------------------------------------------------------------------------------
1 | /**
2 | * HTMX history helpers
3 | *
4 | * Ensures forms can opt into pushState updates on submit-driven HTMX requests
5 | * without embedding inline `hx-on` handlers in templates.
6 | */
7 | import { on } from "../core/htmx-bridge.js";
8 |
9 | const PUSH_ON_SUBMIT_ATTR = "data-hx-push-url-on-submit";
10 | let initialized = false;
11 |
12 | function isSubmitRequest(detail) {
13 | return detail?.requestConfig?.triggeringEvent?.type === "submit";
14 | }
15 |
16 | function elementWithOptIn(detail, fallbackTarget) {
17 | const elt = detail?.elt ?? detail?.target ?? fallbackTarget;
18 | if (!(elt instanceof Element)) {
19 | return null;
20 | }
21 | return elt.closest(`[${PUSH_ON_SUBMIT_ATTR}]`);
22 | }
23 |
24 | function getFinalPath(detail) {
25 | const pathInfo = detail?.pathInfo;
26 | if (pathInfo?.finalPath) {
27 | return pathInfo.finalPath;
28 | }
29 | if (pathInfo?.requestPath) {
30 | return pathInfo.requestPath;
31 | }
32 | return detail?.requestConfig?.path ?? null;
33 | }
34 |
35 | function pushStateIfPossible(path) {
36 | if (!path) return;
37 | if (typeof window === "undefined") return;
38 | if (!window.history || typeof window.history.pushState !== "function") {
39 | return;
40 | }
41 |
42 | try {
43 | window.history.pushState({}, "", path);
44 | } catch (error) {
45 | console.warn("htmx-history: failed to push state", error);
46 | }
47 | }
48 |
49 | function handleAfterRequest(event) {
50 | const { detail } = event;
51 | if (!detail) return;
52 | if (!isSubmitRequest(detail)) return;
53 |
54 | const target = elementWithOptIn(detail, event.target);
55 | if (!target) return;
56 |
57 | const finalPath = getFinalPath(detail);
58 | pushStateIfPossible(finalPath);
59 | }
60 |
61 | function registerHandlers() {
62 | on("htmx:afterRequest", handleAfterRequest);
63 | }
64 |
65 | export function initHtmxHistory() {
66 | if (initialized) return;
67 | initialized = true;
68 | registerHandlers();
69 | }
70 |
--------------------------------------------------------------------------------
/services/merrymaker-go/Dockerfile:
--------------------------------------------------------------------------------
1 | # ---------- Builder ----------
2 | FROM golang:1.25.4-bookworm AS builder
3 |
4 |
5 | ENV CGO_ENABLED=0 \
6 | GOFLAGS=-trimpath
7 |
8 | WORKDIR /src
9 |
10 | # Leverage Docker layer cache: copy go.mod/go.sum first and download deps
11 | COPY go.mod go.sum ./
12 | RUN --mount=type=cache,target=/go/pkg/mod \
13 | go mod download
14 |
15 | # Copy the rest of the source
16 | COPY . ./
17 |
18 | # Build the binaries (embed assets via go:embed)
19 | RUN --mount=type=cache,target=/go/pkg/mod \
20 | --mount=type=cache,target=/root/.cache/go-build \
21 | go build -buildvcs=false -ldflags "-s -w" -o /out/merrymaker ./cmd/merrymaker
22 |
23 | # ---------- Runtime ----------
24 | FROM debian:bookworm-slim AS runtime
25 |
26 | # Install minimal runtime deps and wget for HEALTHCHECK
27 | RUN apt-get update && apt-get install -y --no-install-recommends \
28 | ca-certificates wget \
29 | && rm -rf /var/lib/apt/lists/*
30 |
31 | # Create non-root user
32 | RUN groupadd -r app && useradd -r -g app app
33 |
34 | WORKDIR /app
35 | COPY --chown=app:app --from=builder /out/merrymaker /app/merrymaker
36 | COPY --chown=app:app env_secrets_expand.sh /app/env_secrets_expand.sh
37 |
38 | RUN chmod +x /app/env_secrets_expand.sh
39 |
40 | USER app
41 | EXPOSE 8080
42 |
43 | # OCI labels (optionally overridden via build args)
44 | ARG VERSION="dev"
45 | ARG VCS_REF="unknown"
46 | LABEL org.opencontainers.image.title="merrymaker-go" \
47 | org.opencontainers.image.description="Merrymaker Go service" \
48 | org.opencontainers.image.version=$VERSION \
49 | org.opencontainers.image.revision=$VCS_REF \
50 | org.opencontainers.image.source="https://github.com/target/mmk-ui-api"
51 |
52 | # Healthcheck: HTTP reachability of dedicated health endpoint
53 | HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
54 | CMD wget -q --spider http://localhost:8080/healthz || exit 1
55 |
56 | ENTRYPOINT ["/bin/bash", "/app/env_secrets_expand.sh"]
57 | CMD ["/app/merrymaker"]
58 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/features/htmx-fragments.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Utility helpers for HTMX-driven fragments.
3 | * Provides a declarative pattern for showing/hiding error states
4 | * without relying on verbose inline hx-on attributes.
5 | */
6 | import { on } from "../core/htmx-bridge.js";
7 |
8 | const PANEL_SELECTOR = "[data-fragment-panel]";
9 | const ERROR_SELECTOR = "[data-fragment-error]";
10 |
11 | /**
12 | * Hide all error elements within a fragment panel.
13 | * @param {Element} panel
14 | */
15 | function hideErrors(panel) {
16 | panel.querySelectorAll(ERROR_SELECTOR).forEach((el) => {
17 | el.setAttribute("hidden", "");
18 | });
19 | }
20 |
21 | /**
22 | * Show all error elements within a fragment panel.
23 | * @param {Element} panel
24 | */
25 | function showErrors(panel) {
26 | panel.querySelectorAll(ERROR_SELECTOR).forEach((el) => {
27 | el.removeAttribute("hidden");
28 | });
29 | }
30 |
31 | /**
32 | * Extract the fragment panel associated with an HTMX event.
33 | * @param {CustomEvent} event
34 | * @returns {Element|null}
35 | */
36 | function panelFromEvent(event) {
37 | const elt = event.detail?.elt ?? event.detail?.target ?? event.target;
38 | if (!(elt instanceof Element)) {
39 | return null;
40 | }
41 | return elt.closest(PANEL_SELECTOR);
42 | }
43 |
44 | /**
45 | * Initialize fragment helpers.
46 | * Wires HTMX lifecycle events to toggle error states on panels.
47 | */
48 | let helpersInitialized = false;
49 |
50 | export function initFragmentHelpers() {
51 | if (helpersInitialized || typeof document === "undefined") {
52 | return;
53 | }
54 | helpersInitialized = true;
55 |
56 | on("htmx:beforeRequest", (event) => {
57 | const panel = panelFromEvent(event);
58 | if (!panel) return;
59 | hideErrors(panel);
60 | });
61 |
62 | const showErrorHandler = (event) => {
63 | const panel = panelFromEvent(event);
64 | if (!panel) return;
65 | showErrors(panel);
66 | };
67 |
68 | on("htmx:responseError", showErrorHandler);
69 | on("htmx:sendError", showErrorHandler);
70 | on("htmx:timeout", showErrorHandler);
71 | }
72 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/public/js/features/user-menu.js:
--------------------------------------------------------------------------------
1 | /**
2 | * User menu feature module
3 | *
4 | * Manages dropdown menu toggling, closing on outside clicks, and accessibility
5 | * attributes for user navigation controls.
6 | */
7 | import { qsa } from "../core/dom.js";
8 | import { Events } from "../core/events.js";
9 |
10 | let initialized = false;
11 |
12 | function closeAllUserMenus() {
13 | const toggles = [];
14 |
15 | qsa(".user-toggle-menu.is-open").forEach((menu) => {
16 | menu.classList.remove("is-open");
17 | const btn = menu.parentElement?.querySelector("[data-user-toggle]");
18 | if (btn) {
19 | btn.setAttribute("aria-expanded", "false");
20 | toggles.push(btn);
21 | }
22 | });
23 |
24 | return toggles;
25 | }
26 |
27 | function toggleUserMenu(toggle, menu) {
28 | const isOpen = menu.classList.contains("is-open");
29 |
30 | qsa(".user-toggle-menu.is-open").forEach((otherMenu) => {
31 | if (otherMenu === menu) return;
32 |
33 | otherMenu.classList.remove("is-open");
34 | const otherBtn = otherMenu.parentElement?.querySelector("[data-user-toggle]");
35 | if (otherBtn) otherBtn.setAttribute("aria-expanded", "false");
36 | });
37 |
38 | menu.classList.toggle("is-open", !isOpen);
39 | toggle.setAttribute("aria-expanded", !isOpen ? "true" : "false");
40 | }
41 |
42 | function registerEventHandlers() {
43 | Events.on("[data-user-toggle]", "click", (event, toggle) => {
44 | event.preventDefault();
45 | event.stopPropagation();
46 |
47 | const menu = toggle.parentElement?.querySelector("[data-user-menu]");
48 | if (!menu) return;
49 |
50 | toggleUserMenu(toggle, menu);
51 | });
52 |
53 | document.addEventListener("click", (event) => {
54 | const toggle = event.target?.closest("[data-user-toggle]");
55 | const inMenu = event.target?.closest("[data-user-menu]");
56 |
57 | if (!(toggle || inMenu)) {
58 | closeAllUserMenus();
59 | }
60 | });
61 | }
62 |
63 | export function initUserMenu() {
64 | if (initialized) return;
65 | initialized = true;
66 | registerEventHandlers();
67 | }
68 |
69 | export { closeAllUserMenus };
70 |
--------------------------------------------------------------------------------
/services/merrymaker-go/frontend/templates/partials/user_toggle.tmpl:
--------------------------------------------------------------------------------
1 | {{ define "user-toggle" }}
2 | {{ if .IsAuthenticated }}
3 |
4 | {{if and .StartIndex .EndIndex}}
5 | Showing {{formatNumber .StartIndex}}–{{formatNumber .EndIndex}}{{if .TotalCount}} of {{formatNumber .TotalCount}}{{end}}
6 | {{else}}
7 |
8 | {{end}}
9 |
10 |
11 | {{if .HasPrev}}
12 |
19 |
20 | Prev
21 |
22 | {{else}}
23 |
24 |
25 | Prev
26 |
27 | {{end}}
28 | {{if .HasNext}}
29 |
36 | Next
37 |
38 |
39 | {{else}}
40 |
41 | Next
42 |
43 |
44 | {{end}}
45 |
46 |
4 |
12 |
42 |
43 | {{ else }}
44 |
45 |
46 |
47 | Sign In
48 |
49 |
50 | {{ end }}
51 | {{ end }}
52 |
--------------------------------------------------------------------------------
/services/puppeteer-worker/src/index.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Puppeteer Worker - Main Library Entry Point
3 | *
4 | * Exports core functionality for browser automation and event monitoring.
5 | * When run directly, executes a simple demo script.
6 | */
7 |
8 | import { loadConfig } from "./config-loader.js";
9 | import { logger } from "./logger.js";
10 | import { PuppeteerRunner } from "./puppeteer-runner.js";
11 |
12 | /**
13 | * Simple demo for development/testing
14 | * Run with: npm run start, npm run dev, or npm run demo
15 | */
16 | async function runDemo(): Promise