The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
feat(studio): log date range domain + session logRange state (#48401)
Charisd5436ae82668
diff --git a/apps/studio/CLAUDE.md b/apps/studio/CLAUDE.mdindex 892cbf8e93d..53de52db891 100644--- a/apps/studio/CLAUDE.md+++ b/apps/studio/CLAUDE.md@@ -69,6 +69,7 @@ Older Studio code predates some of these conventions. For new or modified code,- **Memoization is not the default**: `useMemo`/`useCallback` only for measured expense or referential stability a memoized child depends on.- **TypeScript**: avoid `as` casts — where external data enters, parse it with zod (`schema.parse`/`safeParse`) instead. Model multi-state values as discriminated unions (`{ status: 'success'; data: T } | { status: 'error'; error: Error }`) rather than independent boolean flags.- **Naming**: prop callbacks are `onX`, internal handlers are `handleX`. Custom hooks return objects, not tuples.+- **Refactoring**: when you move or extract code into a new module, update every importer to point at the new location directly — do **not** leave a re-export shim in the old file "for backward compatibility." It's a one-line import change per consumer, and keeping shims around makes the codebase messy and the true source of a symbol ambiguous.## Defaults that differ herediff --git a/apps/studio/components/interfaces/SQLEditor/querySource.test.ts b/apps/studio/components/interfaces/SQLEditor/querySource.test.tsindex 16f1e6ae16d..9c63333f64e 100644--- a/apps/studio/components/interfaces/SQLEditor/querySource.test.ts+++ b/apps/studio/components/interfaces/SQLEditor/querySource.test.ts@@ -1,6 +1,39 @@-import { describe, expect, it } from 'vitest'+import dayjs from 'dayjs'+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'-import { getSnippetSource } from './querySource'+import {+ datePickerValueToLogDateRange,+ DEFAULT_LOG_DATE_RANGE,+ getSnippetSource,+ isoDateTimeString,+ logDateRangeToDatePickerValue,+ resolveLogRunRange,+ type LogDateRange,+} from './querySource'+import {+ EXPLORER_DATEPICKER_HELPERS,+ getDefaultHelper,+} from '@/components/interfaces/Settings/Logs/Logs.constants'+import { generateHelpersFromInput } from '@/components/interfaces/Settings/Logs/Logs.datePickerHelpers'+import type { DatePickerValue } from '@/components/interfaces/Settings/Logs/Logs.DatePickers'+import type { DatetimeHelper } from '@/components/interfaces/Settings/Logs/Logs.types'++/** Build the `DatePickerValue` the Logs picker submits when a helper is selected. */+const valueFromHelper = (helper: DatetimeHelper): DatePickerValue => ({+ from: helper.calcFrom(),+ to: helper.calcTo(),+ isHelper: true,+ text: helper.text,+})++/** The single dynamic helper produced from typed input like "2h" / "30m". */+const dynamicHelper = (input: string): DatetimeHelper => {+ const generated = generateHelpersFromInput(input)+ if (!generated || generated.length !== 1) {+ throw new Error(`Expected a single dynamic helper for "${input}"`)+ }+ return generated[0]+}describe('querySource.ts:getSnippetSource', () => {it('maps log_sql to the logs source', () => {@@ -15,3 +48,183 @@ describe('querySource.ts:getSnippetSource', () => {expect(getSnippetSource({ type: 'report' })).toBe('database')})})++describe('querySource.ts:isoDateTimeString', () => {+ it('accepts a valid ISO datetime', () => {+ const raw = '2025-01-01T12:00:00.000Z'+ expect(isoDateTimeString(raw)).toBe(raw)+ })++ it('rejects an empty string', () => {+ expect(isoDateTimeString('')).toBeNull()+ })++ it('rejects junk', () => {+ expect(isoDateTimeString('not-a-date')).toBeNull()+ expect(isoDateTimeString('2025-13-45T99:99:99Z')).toBeNull()+ })+})++describe('querySource.ts:datePickerValueToLogDateRange', () => {+ it('parses every static preset into a relative range', () => {+ const cases: Array<[string, { amount: number; unit: 'minute' | 'hour' | 'day' }]> = [+ ['Last hour', { amount: 1, unit: 'hour' }],+ ['Last 3 hours', { amount: 3, unit: 'hour' }],+ ['Last 24 hours', { amount: 24, unit: 'hour' }],+ ['Last 3 days', { amount: 3, unit: 'day' }],+ ['Last 7 days', { amount: 7, unit: 'day' }],+ ]++ for (const [text, last] of cases) {+ const helper = EXPLORER_DATEPICKER_HELPERS.find((h) => h.text === text)+ expect(helper, `preset "${text}" exists`).toBeDefined()+ expect(datePickerValueToLogDateRange(valueFromHelper(helper!))).toEqual({+ kind: 'relative',+ last,+ })+ }+ })++ it('parses dynamic helpers ("2h", "30m", "7d") into relative ranges', () => {+ expect(datePickerValueToLogDateRange(valueFromHelper(dynamicHelper('2h')))).toEqual({+ kind: 'relative',+ last: { amount: 2, unit: 'hour' },+ })+ expect(datePickerValueToLogDateRange(valueFromHelper(dynamicHelper('30m')))).toEqual({+ kind: 'relative',+ last: { amount: 30, unit: 'minute' },+ })+ expect(datePickerValueToLogDateRange(valueFromHelper(dynamicHelper('7d')))).toEqual({+ kind: 'relative',+ last: { amount: 7, unit: 'day' },+ })+ })++ it('treats a preset (calcTo() === "") as relative — the empty end means "now"', () => {+ const lastHour = getDefaultHelper(EXPLORER_DATEPICKER_HELPERS)+ const value = valueFromHelper(lastHour)+ expect(value.to).toBe('')+ expect(datePickerValueToLogDateRange(value)).toEqual({+ kind: 'relative',+ last: { amount: 1, unit: 'hour' },+ })+ })++ it('degrades an unparseable helper to an absolute range using from/now (never empty)', () => {+ vi.useFakeTimers()+ const now = new Date('2025-01-01T12:00:00.000Z')+ vi.setSystemTime(now)++ const from = '2024-12-31T00:00:00.000Z'+ const result = datePickerValueToLogDateRange({+ from,+ to: '',+ isHelper: true,+ text: 'Some custom label',+ })++ expect(result).toEqual({+ kind: 'absolute',+ from,+ to: dayjs(now).toISOString(),+ })+ })++ it('maps a custom (non-helper) pick to an absolute range with both endpoints', () => {+ const from = '2025-01-01T00:00:00.000Z'+ const to = '2025-01-02T00:00:00.000Z'+ expect(datePickerValueToLogDateRange({ from, to, isHelper: false })).toEqual({+ kind: 'absolute',+ from,+ to,+ })+ })++ it('falls back to the default range when the value has no usable from', () => {+ expect(datePickerValueToLogDateRange({ from: '', to: '', isHelper: false })).toEqual(+ DEFAULT_LOG_DATE_RANGE+ )+ })+})++describe('querySource.ts:logDateRangeToDatePickerValue', () => {+ beforeEach(() => {+ vi.useFakeTimers()+ vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'))+ })++ it('renders a relative range exactly as the picker would emit the helper', () => {+ const value = logDateRangeToDatePickerValue({+ kind: 'relative',+ last: { amount: 1, unit: 'hour' },+ })+ expect(value).toEqual({+ from: dayjs().subtract(1, 'hour').toISOString(),+ to: dayjs().toISOString(),+ isHelper: true,+ text: 'Last 1 hour',+ })+ })++ it('pluralizes the label for amounts greater than one', () => {+ expect(+ logDateRangeToDatePickerValue({ kind: 'relative', last: { amount: 3, unit: 'day' } }).text+ ).toBe('Last 3 days')+ })++ it('round-trips through datePickerValueToLogDateRange', () => {+ const range: LogDateRange = { kind: 'relative', last: { amount: 30, unit: 'minute' } }+ expect(datePickerValueToLogDateRange(logDateRangeToDatePickerValue(range))).toEqual(range)+ })++ it('passes an absolute range through as a non-helper value', () => {+ const range: LogDateRange = {+ kind: 'absolute',+ from: isoDateTimeString('2025-01-01T00:00:00.000Z')!,+ to: isoDateTimeString('2025-01-02T00:00:00.000Z')!,+ }+ expect(logDateRangeToDatePickerValue(range)).toEqual({+ from: '2025-01-01T00:00:00.000Z',+ to: '2025-01-02T00:00:00.000Z',+ isHelper: false,+ })+ })+})++describe('querySource.ts:resolveLogRunRange', () => {+ afterEach(() => {+ vi.useRealTimers()+ })++ it('re-resolves a relative range against the current time', () => {+ vi.useFakeTimers()+ const now = new Date('2025-06-15T08:30:00.000Z')+ vi.setSystemTime(now)++ expect(resolveLogRunRange({ kind: 'relative', last: { amount: 2, unit: 'hour' } })).toEqual({+ from: dayjs(now).subtract(2, 'hour').toISOString(),+ to: dayjs(now).toISOString(),+ })+ })++ it('re-resolves the same relative range differently as time advances', () => {+ vi.useFakeTimers()+ vi.setSystemTime(new Date('2025-06-15T08:00:00.000Z'))+ const first = resolveLogRunRange({ kind: 'relative', last: { amount: 1, unit: 'hour' } })++ vi.setSystemTime(new Date('2025-06-15T10:00:00.000Z'))+ const second = resolveLogRunRange({ kind: 'relative', last: { amount: 1, unit: 'hour' } })++ expect(first).not.toEqual(second)+ expect(second.to).toBe(dayjs('2025-06-15T10:00:00.000Z').toISOString())+ })++ it('passes an absolute range through unchanged', () => {+ const from = isoDateTimeString('2025-01-01T00:00:00.000Z')!+ const to = isoDateTimeString('2025-01-02T00:00:00.000Z')!+ expect(resolveLogRunRange({ kind: 'absolute', from, to })).toEqual({+ from: '2025-01-01T00:00:00.000Z',+ to: '2025-01-02T00:00:00.000Z',+ })+ })+})diff --git a/apps/studio/components/interfaces/SQLEditor/querySource.ts b/apps/studio/components/interfaces/SQLEditor/querySource.tsindex ed6bf4e6412..af6d1d169a2 100644--- a/apps/studio/components/interfaces/SQLEditor/querySource.ts+++ b/apps/studio/components/interfaces/SQLEditor/querySource.ts@@ -1,3 +1,9 @@+import dayjs from 'dayjs'++import { generateDynamicHelper } from '@/components/interfaces/Settings/Logs/Logs.datePickerHelpers'+import type { Unit } from '@/components/interfaces/Settings/Logs/Logs.datePickerHelpers'+import type { DatePickerValue } from '@/components/interfaces/Settings/Logs/Logs.DatePickers'+import type { ResolvedLogDateRange } from '@/components/interfaces/Settings/Logs/logsDateRange'import type { Snippet } from '@/data/content/sql-folders-query'/**@@ -18,3 +24,121 @@ export type SqlSnippetSource = 'database' | 'logs'export function getSnippetSource(snippet: Pick<Snippet, 'type'>): SqlSnippetSource {return snippet.type === 'log_sql' ? 'logs' : 'database'}++/**+ * An ISO-8601 datetime proven valid at construction via a dayjs parse. Absolute+ * log ranges carry these instead of raw strings so an unvalidated datetime can+ * never reach execution.+ */+export type IsoDateTimeString = string & { readonly __isoDateTimeBrand: unique symbol }++/**+ * Validate a raw string as an ISO datetime, returning the branded value or null.+ * The sole construction site for `IsoDateTimeString` outside `now`.+ */+export function isoDateTimeString(raw: string): IsoDateTimeString | null {+ if (!raw) return null+ return dayjs(raw).isValid() ? (raw as IsoDateTimeString) : null+}++/** `now` as a branded ISO datetime — `toISOString()` is always valid ISO-8601. */+function nowIsoDateTime(): IsoDateTimeString {+ return dayjs().toISOString() as IsoDateTimeString+}++/**+ * The units a relative log range is expressed in. Aliases the Logs date picker's+ * `Unit` so the two stay in lockstep rather than drifting as parallel unions.+ */+export type RelativeTimeUnit = Unit++/**+ * A log query's time range. Relative ranges are structural (amount + unit) and+ * re-resolve against `now` at every run — so a saved "last hour" always means the+ * hour before the run, not the hour before the snippet was opened. Absolute ranges+ * carry validated ISO datetimes and pass through unchanged.+ */+export type LogDateRange =+ | { kind: 'relative'; last: { amount: number; unit: RelativeTimeUnit } }+ | { kind: 'absolute'; from: IsoDateTimeString; to: IsoDateTimeString }++/** The range a freshly opened logs snippet starts with: the last hour. */+export const DEFAULT_LOG_DATE_RANGE: LogDateRange = {+ kind: 'relative',+ last: { amount: 1, unit: 'hour' },+}++/**+ * Parse a date-picker helper's label (e.g. "Last hour", "Last 3 hours", "Last 30+ * minutes") into a relative amount/unit. Covers both the static presets in+ * `EXPLORER_DATEPICKER_HELPERS` and the dynamic helpers `generateHelpersFromInput`+ * produces from typed input like "2h"/"30m". A label with no number means one unit+ * ("Last hour"). Returns null for any other label.+ */+function parseRelativeHelperLabel(+ text: string | undefined+): { amount: number; unit: RelativeTimeUnit } | null {+ if (!text) return null+ const match = text+ .trim()+ .toLowerCase()+ .match(/^last\s+(?:(\d+)\s+)?(minute|hour|day)s?$/)+ if (!match) return null+ const amount = match[1] ? parseInt(match[1], 10) : 1+ if (!Number.isFinite(amount) || amount <= 0) return null+ const unit = match[2]+ if (unit !== 'minute' && unit !== 'hour' && unit !== 'day') return null+ return { amount, unit }+}++/**+ * Convert a Logs date-picker value into a `LogDateRange`. Helper picks (presets and+ * dynamic "2h"/"30m" helpers) become relative ranges by parsing the helper label;+ * a preset's `calcTo()` resolves to `''` (meaning "now"), which the relative variant+ * models implicitly. Everything else — custom calendar picks, or a helper whose label+ * we can't parse — becomes an absolute range with validated ISO datetimes, degrading+ * via `from`/now rather than rejecting an empty string. A value with no usable `from`+ * falls back to the default range.+ */+export function datePickerValueToLogDateRange(value: DatePickerValue): LogDateRange {+ if (value.isHelper) {+ const relative = parseRelativeHelperLabel(value.text)+ if (relative) return { kind: 'relative', last: relative }+ }++ const from = isoDateTimeString(value.from)+ if (from === null) return DEFAULT_LOG_DATE_RANGE+ const to = isoDateTimeString(value.to) ?? nowIsoDateTime()+ return { kind: 'absolute', from, to }+}++/**+ * Render a `LogDateRange` back into a Logs date-picker value for display. Relative+ * ranges reuse the picker's own `generateDynamicHelper` to derive the resolved+ * `from`/`to` and matching "Last N unit(s)" label, so the value is byte-for-byte+ * what the picker itself would emit for that helper. Absolute ranges pass their+ * datetimes through.+ */+export function logDateRangeToDatePickerValue(range: LogDateRange): DatePickerValue {+ if (range.kind === 'relative') {+ const helper = generateDynamicHelper(range.last.amount, range.last.unit)+ return { from: helper.calcFrom(), to: helper.calcTo(), isHelper: true, text: helper.text }+ }+ return { from: range.from, to: range.to, isHelper: false }+}++/**+ * Resolve a `LogDateRange` to concrete ISO endpoints for a run. Relative ranges+ * re-resolve against `now` (so "last hour" is always the hour before the run);+ * absolute ranges pass through. Reuses the Logs `ResolvedLogDateRange` shape.+ */+export function resolveLogRunRange(range: LogDateRange): ResolvedLogDateRange {+ if (range.kind === 'relative') {+ const now = dayjs()+ return {+ from: now.subtract(range.last.amount, range.last.unit).toISOString(),+ to: now.toISOString(),+ }+ }+ return { from: range.from, to: range.to }+}diff --git a/apps/studio/components/interfaces/Settings/Logs/Logs.DatePickers.tsx b/apps/studio/components/interfaces/Settings/Logs/Logs.DatePickers.tsxindex 1c1c6975f52..811191d918a 100644--- a/apps/studio/components/interfaces/Settings/Logs/Logs.DatePickers.tsx+++ b/apps/studio/components/interfaces/Settings/Logs/Logs.DatePickers.tsx@@ -17,6 +17,7 @@ import {} from 'ui'import { LOGS_LARGE_DATE_RANGE_DAYS_THRESHOLD } from './Logs.constants'+import { generateHelpersFromInput } from './Logs.datePickerHelpers'import type { DatetimeHelper } from './Logs.types'import { ButtonTooltip } from '@/components/ui/ButtonTooltip'import { TimeSplitInput } from '@/components/ui/DatePicker/TimeSplitInput'@@ -24,65 +25,6 @@ import { ShortcutTooltip } from '@/components/ui/ShortcutTooltip'import { useCheckEntitlements } from '@/hooks/misc/useCheckEntitlements'import type { ShortcutId } from '@/state/shortcuts/registry'-type Unit = 'minute' | 'hour' | 'day'--export type ParsedCustomInput =- | { type: 'number'; value: number }- | { type: 'unit'; value: number; unit: Unit }- | { type: 'invalid' }--export const parseCustomInput = (input: string): ParsedCustomInput => {- const trimmed = input.trim().toLowerCase()- if (!trimmed) return { type: 'invalid' }-- // Try to match "number + optional space + unit prefix"- const match = trimmed.match(/^(\d+)\s*([a-z]*)$/)- if (!match) return { type: 'invalid' }-- const [, numStr, unitStr] = match- const value = parseInt(numStr, 10)-- if (isNaN(value) || value <= 0) return { type: 'invalid' }-- if (!unitStr) {- return { type: 'number', value }- }-- // Match if unitStr is a prefix of any unit name or its first letter- const units: Unit[] = ['minute', 'hour', 'day']- const matchedUnit = units.find((u) => u.startsWith(unitStr) || u[0] === unitStr)-- if (!matchedUnit) return { type: 'invalid' }-- return { type: 'unit', value, unit: matchedUnit }-}--export const generateDynamicHelper = (value: number, unit: Unit): DatetimeHelper => {- return {- text: `Last ${value} ${unit}${value === 1 ? '' : 's'}`,- calcFrom: () => dayjs().subtract(value, unit).toISOString(),- calcTo: () => dayjs().toISOString(),- }-}--export const generateDynamicHelpers = (value: number): DatetimeHelper[] => {- const units: Unit[] = ['minute', 'hour', 'day']- return units.map((unit) => generateDynamicHelper(value, unit))-}--export const generateHelpersFromInput = (input: string): DatetimeHelper[] | null => {- const parsed = parseCustomInput(input)-- switch (parsed.type) {- case 'number':- return generateDynamicHelpers(parsed.value)- case 'unit':- return [generateDynamicHelper(parsed.value, parsed.unit)]- case 'invalid':- return null- }-}-export type DatePickerValue = {to: stringfrom: stringdiff --git a/apps/studio/components/interfaces/Settings/Logs/Logs.datePickerHelpers.ts b/apps/studio/components/interfaces/Settings/Logs/Logs.datePickerHelpers.tsnew file mode 100644index 00000000000..422a2f04033--- /dev/null+++ b/apps/studio/components/interfaces/Settings/Logs/Logs.datePickerHelpers.ts@@ -0,0 +1,73 @@+import dayjs from 'dayjs'++import type { DatetimeHelper } from './Logs.types'++/**+ * Framework-free date-range helpers shared by the Logs date picker+ * (`Logs.DatePickers.tsx`) and the SQL editor's logs query-source domain+ * (`SQLEditor/querySource.ts`). Kept in a pure `.ts` module — depending only on+ * dayjs — so both a React component and a valtio-free domain module can import it+ * without pulling in the picker's UI.+ */++/** The relative-range units the picker and the logs domain both speak. */+export type Unit = 'minute' | 'hour' | 'day'++export type ParsedCustomInput =+ | { type: 'number'; value: number }+ | { type: 'unit'; value: number; unit: Unit }+ | { type: 'invalid' }++export const parseCustomInput = (input: string): ParsedCustomInput => {+ const trimmed = input.trim().toLowerCase()+ if (!trimmed) return { type: 'invalid' }++ // Try to match "number + optional space + unit prefix"+ const match = trimmed.match(/^(\d+)\s*([a-z]*)$/)+ if (!match) return { type: 'invalid' }++ const [, numStr, unitStr] = match+ const value = Number.parseInt(numStr, 10)++ // Only finite positive values may reach generateDynamicHelper(): Number.isFinite+ // rejects NaN and Infinity outright, and the <= 0 guard keeps out non-positive.+ if (!Number.isFinite(value) || value <= 0) return { type: 'invalid' }++ if (!unitStr) {+ return { type: 'number', value }+ }++ // Match if unitStr is a prefix of any unit name or its first letter+ const units: Unit[] = ['minute', 'hour', 'day']+ const matchedUnit = units.find((u) => u.startsWith(unitStr) || u[0] === unitStr)++ if (!matchedUnit) return { type: 'invalid' }++ return { type: 'unit', value, unit: matchedUnit }+}++export const generateDynamicHelper = (value: number, unit: Unit): DatetimeHelper => {+ return {+ text: `Last ${value} ${unit}${value === 1 ? '' : 's'}`,+ calcFrom: () => dayjs().subtract(value, unit).toISOString(),+ calcTo: () => dayjs().toISOString(),+ }+}++export const generateDynamicHelpers = (value: number): DatetimeHelper[] => {+ const units: Unit[] = ['minute', 'hour', 'day']+ return units.map((unit) => generateDynamicHelper(value, unit))+}++export const generateHelpersFromInput = (input: string): DatetimeHelper[] | null => {+ const parsed = parseCustomInput(input)++ switch (parsed.type) {+ case 'number':+ return generateDynamicHelpers(parsed.value)+ case 'unit':+ return [generateDynamicHelper(parsed.value, parsed.unit)]+ case 'invalid':+ return null+ }+}diff --git a/apps/studio/state/sql-editor/sql-editor-session-state.ts b/apps/studio/state/sql-editor/sql-editor-session-state.tsindex 338e7eb3651..38aeafc030c 100644--- a/apps/studio/state/sql-editor/sql-editor-session-state.ts+++ b/apps/studio/state/sql-editor/sql-editor-session-state.ts@@ -1,10 +1,12 @@import { proxy, ref, snapshot, useSnapshot } from 'valtio'+import type { LogDateRange } from '@/components/interfaces/SQLEditor/querySource'+/**- * Ephemeral, per-session SQL editor state that is NOT persisted: query results- * and the row limit. Kept separate from the snippet/folder store (which deals- * with persistence) because none of this is saved — it lives only for the- * current editing session.+ * Ephemeral, per-session SQL editor state that is NOT persisted: query results,+ * the row limit, and the per-snippet logs time range. Kept separate from the+ * snippet/folder store (which deals with persistence) because none of this is+ * saved — it lives only for the current editing session.*/export const sqlEditorSessionState = proxy({/**@@ -29,6 +31,18 @@ export const sqlEditorSessionState = proxy({setLimit: (value: number) => (sqlEditorSessionState.limit = value),+ /**+ * The logs time range for a logs snippet, keyed by snippet id. Session state —+ * never written to snippet content — so it works on read-only shared snippets+ * and resets on reload. An unset snippet has no entry; read sites fall back to+ * `DEFAULT_LOG_DATE_RANGE`.+ */+ logRange: {} as { [snippetId: string]: LogDateRange },++ setLogRange: (id: string, range: LogDateRange) => {+ sqlEditorSessionState.logRange[id] = range+ },+addResult: (id: string, results: any[], autoLimit?: number) => {// Use ref() to prevent Valtio from creating proxies for each row object.// This is critical for large result sets - without ref(), Valtio wraps every@@ -49,6 +63,7 @@ export const sqlEditorSessionState = proxy({/** Drop all session state for a snippet (called when the snippet is removed). */clearForSnippet: (id: string) => {delete sqlEditorSessionState.results[id]+ delete sqlEditorSessionState.logRange[id]},})diff --git a/apps/studio/tests/features/logs/Logs.Datepickers.test.tsx b/apps/studio/tests/features/logs/Logs.Datepickers.test.tsxindex 654a4d52a8c..09e328d5f4e 100644--- a/apps/studio/tests/features/logs/Logs.Datepickers.test.tsx+++ b/apps/studio/tests/features/logs/Logs.Datepickers.test.tsx@@ -11,9 +11,9 @@ import {generateDynamicHelper,generateDynamicHelpers,generateHelpersFromInput,- LogsDatePicker,parseCustomInput,-} from '@/components/interfaces/Settings/Logs/Logs.DatePickers'+} from '@/components/interfaces/Settings/Logs/Logs.datePickerHelpers'+import { LogsDatePicker } from '@/components/interfaces/Settings/Logs/Logs.DatePickers'import { DatetimeHelper } from '@/components/interfaces/Settings/Logs/Logs.types'dayjs.extend(timezone)