mirror of
https://github.com/SigNoz/signoz.git
synced 2026-04-26 22:00:23 +01:00
5b599babd5
* refactor(frontend): migrate deleteDowntimeSchedule to generated client
Replace useDeleteDowntimeSchedule with useDeleteDowntimeScheduleByID
from the generated API client. Update PlannedDowntime.tsx and
PlannedDowntimeutils.ts to use pathParams pattern.
* refactor(frontend): migrate all downtime schedule APIs to generated clients
Replace hand-written getAllDowntimeSchedules, createDowntimeSchedule,
updateDowntimeSchedule with generated useListDowntimeSchedules,
createDowntimeSchedule, updateDowntimeScheduleByID from Orval clients.
Update all type references from DowntimeSchedules/Recurrence to
RuletypesGettablePlannedMaintenanceDTO/RuletypesRecurrenceDTO.
Update tests to mock generated hooks.
* refactor(frontend): migrate testAlert API to generated testRule client
Replace direct testAlertApi call in FormAlertRules with generated
testRule function. Update useTestAlertRule hook to use generated client
while maintaining backward-compatible wrapper types for CreateAlertV2
context consumers.
* refactor(frontend): migrate createAlertRule API to generated createRule client
Update useCreateAlertRule hook to use generated createRule function.
Maintain backward-compatible SuccessResponse wrapper for CreateAlertV2
context consumers.
* refactor(frontend): migrate rules APIs to generated clients
Replace hand-written getAll, get, delete, patch imports with generated
listRules, getRuleByID, deleteRuleByID, patchRuleByID from Orval
clients. Use adapter wrappers in consumers that depend on the old
SuccessResponse envelope to minimize cascading type changes.
* refactor(frontend): extract getAll adapter to shared api/alerts/getAll.ts
Remove duplicated inline getAll adapter from ListAlertRules and
AlertRules components. Replace the old hand-written getAll.ts with a
thin adapter over the generated listRules client.
* refactor(frontend): switch to generated react-query hooks directly
Replace adapter wrappers with direct usage of generated hooks:
- useListRules() in ListAlertRules, AlertRules
- useGetRuleByID() in AlertDetails hooks, EditRules
- useCreateRule re-exported as useCreateAlertRule
- useTestRule re-exported as useTestAlertRule
- Update consumers to access data.data instead of data.payload
- Remove SuccessResponse envelope wrappers
* fix(frontend): fix accidental rename, cache fragmentation, and sort mutation
- Revert setRuletypesRecurrenceDTOType back to setRecurrenceType (find-replace artifact)
- Remove duplicate isError condition in AlertDetails guard
- Replace manual useQuery(listRules) with useListRules in PlannedDowntime and hooks
- Fix showErrorNotification import path in PlannedDowntimeutils
- Use spread before sort to avoid mutating react-query cache
* refactor(frontend): delete dead re-export wrappers for rules hooks
Remove api/alerts/getAll.ts, hooks/alerts/useCreateAlertRule.ts, and
hooks/alerts/useTestAlertRule.ts — all were single-line re-exports of
generated hooks with zero unique logic. Update the one consumer
(CreateAlertV2 context) and its test to import directly from the
generated services.
* refactor(frontend): delete dead API adapters, migrate save to generated hooks
Delete 14 unused hand-written API adapter files for alerts and planned
downtime. Migrate the 3 consumers of save.ts to call createRule and
updateRuleByID from generated services directly, removing the
create/update routing layer.
* refactor(frontend): migrate updateAlertRule to generated useUpdateRuleByID
Delete hooks/alerts/useUpdateAlertRule.ts and api/alerts/updateAlertRule.ts.
Migrate CreateAlertV2 context to use useUpdateRuleByID from generated
services. Expose ruleId on context so Footer can pass it to the mutation.
* refactor(frontend): integrate convertToApiError and error modal across rules/downtime
Replace all raw (error as any)?.message casts and generic "Something
went wrong" strings with proper error handling using convertToApiError
and showErrorModal. Query errors use convertToApiError for message
extraction, mutation errors show the rich error modal.
* fix(frontend): remove downtime ID number coercion, delete routing adapter
Delete DowntimeScheduleUpdatePayload and createEditDowntimeSchedule —
the form now calls createDowntimeSchedule/updateDowntimeScheduleByID
directly, keeping the string ID from the generated schema end-to-end
instead of coercing to number.
* fix(frontend): handle null rules from API to prevent infinite spinner
The generated schema allows rules?: ...[] | null. When the API returns
null, the component treated it as still-loading. Normalize null to []
via nullish coalescing and gate loading on data presence, not rules
truthiness.
* fix(frontend): update PlannedDowntime test mock to use generated rules hook
Replace deleted api/alerts/getAll mock with api/generated/services/rules
mock returning useListRules shape.
* fix(frontend): mock useErrorModal in Footer test to fix provider error
Footer now calls useErrorModal which requires ErrorModalProvider. Add
mock to the test since it imports render from @testing-library/react
directly instead of the custom test-utils wrapper.
* refactor(frontend): adopt IngestionSettings date pattern in PlannedDowntime
Replace all (x as unknown) as Date/string double casts with the
established codebase pattern: new Date() for writes to API, dayjs()
for reads. Removes String() wraps in PlannedDowntimeList in favor of
dayjs().toISOString(). Tests use new Date() instead of double casts.
* refactor(frontend): adopt generated rule types, drop as any casts
Switch reader components (ListAlertRules, Home/AlertRules, AlertDetails,
EditRules) to use RuletypesGettableRuleDTO directly from the generated
OpenAPI client. Writer callers cast once via `as unknown as
RuletypesPostableRuleDTO` at the API boundary. Also fixes a poll bug in
ListAlert.tsx that read the old refetchData.payload shape.
* test(frontend): satisfy newly-required condition/ruleType in filterAlerts mocks
After merging the backend schema tightening, RuletypesGettableRuleDTO
requires `condition` and `ruleType`. Update the test fixtures to
include placeholder values so they type-check against the stricter
shape.
* refactor(frontend): retire GettableAlert in favor of generated type
Status and AlertHeader consume RuletypesGettableRuleDTO directly from
the generated OpenAPI client. Delete types/api/alerts/{get,getAll,patch}.ts
now that nothing imports from them.
* fix(frontend): satisfy newly-required condition and timezone fields
After merging the ruler schema tightening, RuletypesRuleConditionDTO
now requires compositeQuery/op/matchType, AlertCompositeQuery requires
queries/panelType/queryType, and Schedule requires timezone. Update
the filterAlerts test fixtures to populate the nested condition, and
default timezone to an empty string in the downtime form payload so
the generated type is satisfied (backend still validates timezone is
non-empty).
* refactor(frontend): cast timezone to string instead of empty-string default
Antd's required validation on the timezone field blocks submission when
empty, so values.timezone is guaranteed non-undefined by the time
saveHanlder runs. `?? ''` silently substituted a value the backend
rejects; `as string` matches the existing pattern used for the same
field at initialization (line 299) and surfaces drift as a type error
instead of a 400.
* refactor(frontend): key the alert-not-found message on HTTP 404
Drop the brittle comparison against the raw Go "sql: no rows in result
set" string. With the backend now wrapping sql.ErrNoRows as
TypeNotFound, GET /api/v1/rules/{id} returns HTTP 404 on a missing ID
(matching the existing OpenAPI contract). Use APIError.getHttpStatusCode
instead, and delete errorMessageReceivedFromBackend.
* refactor(frontend): show backend error message directly on rule-fetch failure
Drop the improvedErrorMessage override that hid the backend's message
behind a generic "does not exist" string. With the backend now
returning a descriptive "rule with ID: <id> does not exist" on 404, the
APIError message is the right thing to render. Inline the remaining
button label and delete the now-empty constants module.
* refactor(frontend): drop duplicative AlertDetailsStatusRenderer
The inner component re-derived alertRuleDetails from the same response
as the parent, but via the stale .payload.data path that didn't exist
on the generated GetRuleByID200 shape — so it was silently feeding
undefined to AlertHeader. The any-typed data prop hid the error from
TypeScript during the migration to generated hooks.
The parent already derives alertRuleDetails correctly and gates on
isError/isLoading before the main render, so the inner component's
loading/error branches were unreachable. Inline AlertHeader directly.
* refactor(frontend): drop optional chains on fields now required by generated types
* refactor(frontend): drop Record cast in PlannedDowntime recurrence spread
* refactor(frontend): type formData seed as Partial in PlannedDowntimeForm
* refactor(frontend): type defautlInitialValues as Partial directly
* refactor(frontend): drop as unknown from copyAlert cast in clone flow
* refactor(frontend): add dataSourceForAlertType helper keyed on generated enum
* refactor(frontend): align defautlInitialValues createdBy with createdAt as undefined
* refactor(frontend): surface BE error via convertToApiError on save alert paths
* refactor(frontend): adopt renamed RuletypesRuleDTO and created/updated field names
* fix(frontend): re-hydrate downtime edit drawer when alerts list arrives async
The formatedInitialValues memo depended only on initialValues, so when the
edit drawer opened before useListRules resolved, getAlertOptionsFromIds
returned an empty array and the form's alertRules state stayed empty —
even though the sidecar AlertRuleTags rendered a tag via selectedTags.
Submitting then sent alertIds: [] or stale values, which is why the
"edit downtime → remove silenced alert → save → delete" cleanup flow
never actually cleared the server-side association.
Adds alertOptions to the deps so the memo recomputes once the rules
list arrives, letting the useEffect below re-hydrate both selectedTags
and the form state with the correct tags.
* chore(frontend): stop logging validateFields rejection from downtime form
Form.validateFields() rejects with {values, errorFields, outOfDate}
whenever a required field is empty (e.g. Ends on). antd already renders
the field-level error inline, so console.error adds no user-facing
value and pollutes Sentry / devtools with routine typos.
Replaces the try/catch+log with a noop .catch().
* refactor(frontend): add typed converters between local alert types and generated DTOs
* refactor(frontend): add patchRulePartial wrapper for Partial rule patches
* refactor(frontend): replace inline alert DTO casts with typed converters
* refactor(frontend): inline single-use handleMutationError in alert hooks
Replaces four call sites in AlertDetails/hooks.tsx with the same
showErrorModal(convertToApiError(...)) expression directly; the helper
added no semantics beyond the type cast it wrapped. The two pure
onError arrows end up byte-identical, so the delete hook carries an
eslint-disable for sonarjs/no-identical-functions (same pattern already
used in providers/QueryBuilder.tsx).
* chore: parity with expected enum values of match type and compare operator
* chore: remove unused Typography import
---------
Co-authored-by: Srikanth Chekuri <srikanth.chekuri92@gmail.com>
13 lines
645 B
TypeScript
13 lines
645 B
TypeScript
import { patchRuleByID } from 'api/generated/services/rules';
|
|
import type { RuletypesPostableRuleDTO } from 'api/generated/services/sigNoz.schemas';
|
|
|
|
// why: patchRuleByID's generated body type is the full RuletypesPostableRuleDTO
|
|
// because the backend OpenAPI spec currently advertises PostableRule. The
|
|
// endpoint itself accepts any subset of fields. Until the backend introduces
|
|
// PatchableRule, this wrapper localizes the cast so callers stay typed.
|
|
export const patchRulePartial = (
|
|
id: string,
|
|
patch: Partial<RuletypesPostableRuleDTO>,
|
|
): ReturnType<typeof patchRuleByID> =>
|
|
patchRuleByID({ id }, patch as RuletypesPostableRuleDTO);
|