@postgres.ai/shared 4.1.2 → 4.2.0

package/utils/clonePoller.ts

@@ -0,0 +1,47 @@
+/*--------------------------------------------------------------------------
+ * Copyright (c) 2019-2021, Postgres.ai, Nikolay Samokhvalov nik@postgres.ai
+ * All Rights Reserved. Proprietary and confidential.
+ * Unauthorized copying of this file, via any medium is strictly prohibited
+ *--------------------------------------------------------------------------
+ */
+
+// interval between clone status polls while a clone is still unstable.
+export const UNSTABLE_CLONE_UPDATE_TIMEOUT = 1000
+
+// ClonePoller owns a single self-rescheduling timeout used to poll clone status
+// until it becomes stable. It is reusable: start() re-arms a poller that was
+// previously stopped, and stop() cancels any pending tick and blocks further
+// scheduling — including a tick that an in-flight request is about to queue.
+export class ClonePoller {
+  private timeout?: ReturnType<typeof setTimeout>
+  private stopped = false
+
+  constructor(private readonly intervalMs: number = UNSTABLE_CLONE_UPDATE_TIMEOUT) {}
+
+  get isStopped() {
+    return this.stopped
+  }
+
+  // start re-arms the poller so a reused store polls again.
+  start = () => {
+    this.stopped = false
+  }
+
+  // stop halts polling and cancels any pending tick.
+  stop = () => {
+    this.stopped = true
+    clearTimeout(this.timeout)
+  }
+
+  // cancel drops a pending tick without blocking future scheduling.
+  cancel = () => {
+    clearTimeout(this.timeout)
+  }
+
+  // scheduleNext queues the next tick, unless the poller has been stopped.
+  scheduleNext = (tick: () => void) => {
+    clearTimeout(this.timeout)
+    if (this.stopped) return
+    this.timeout = setTimeout(tick, this.intervalMs)
+  }
+}

package/utils/date.ts

@@ -21,25 +21,30 @@ import {
   formatDistanceToNowStrict,
 } from 'date-fns'
 
+const compactDatePattern = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/
+
+// formatDateToISO converts a compact UTC timestamp ('20060102150405') to RFC3339 ('2006-01-02T15:04:05Z').
+// The value is a UTC wall-clock, so it must never be interpreted in the browser timezone.
 export const formatDateToISO = (dateString: string) => {
-  // Handle empty or invalid date strings
-  if (!dateString || dateString.trim() === '') {
+  const parts = compactDatePattern.exec(dateString?.trim() ?? '')
+
+  if (!parts) {
     return ''
   }
-  
-  try {
-    const parsedDate = parse(dateString, 'yyyyMMddHHmmss', new Date())
-    
-    // Additional validation of parsed date
-    if (!isValidDate(parsedDate) || isNaN(parsedDate.getTime())) {
-      return ''
-    }
-    
-    return format(parsedDate, "yyyy-MM-dd'T'HH:mm:ssXXX")
-  } catch (error) {
-    // Return empty string for invalid date formats
+
+  const [compact, year, month, day, hours, minutes, seconds] = parts
+  const parsedDate = new Date(
+    Date.UTC(+year, +month - 1, +day, +hours, +minutes, +seconds),
+  )
+
+  if (!isValidDate(parsedDate)) {
     return ''
   }
+
+  const isoDate = parsedDate.toISOString().replace(/\.\d+Z$/, 'Z')
+
+  // reject values rolled over by Date.UTC, e.g. month 13 or hour 25.
+  return isoDate.replace(/[-:TZ]/g, '') === compact ? isoDate : ''
 }
 
 // parseDate parses date of both format: '2006-01-02 15:04:05 UTC' and `2006-01-02T15:04:05Z` (RFC3339).

package/utils/protection.ts

@@ -0,0 +1,25 @@
+// protectionOptions lists the deletion-protection choices shared by the branch and snapshot
+// detail pages: no protection, a set of bounded durations, and forever. The values are the
+// protectionDurationMinutes passed to the update endpoints ('0' means forever, 'none' clears
+// protection).
+export const protectionOptions = [
+  { value: 'none', children: 'No protection' },
+  { value: '60', children: '1 hour' },
+  { value: '720', children: '12 hours' },
+  { value: '1440', children: '1 day' },
+  { value: '4320', children: '3 days' },
+  { value: '10080', children: '7 days' },
+  { value: '43200', children: '30 days' },
+  { value: '0', children: 'Forever' },
+]
+
+// getProtectionSelectValue maps an entity's protection state to the Select value: 'none' when
+// unprotected, 'current' when protected until a specific time, '0' when protected forever.
+export const getProtectionSelectValue = (
+  isProtected: boolean,
+  protectedTillDate: Date | null,
+): string => {
+  if (!isProtected) return 'none'
+  if (!protectedTillDate) return '0'
+  return 'current'
+}