@postgres.ai/shared 4.0.4 → 4.1.0

package/types/api/entities/createBranch.ts

@@ -0,0 +1,7 @@
+export type CreateBranchDTO = {
+  name: string
+}
+
+export const formatCreateBranchDto = (dto: CreateBranchDTO) => dto
+
+export type CreateBranchResponse = ReturnType<typeof formatCreateBranchDto>

package/types/api/entities/createSnapshot.ts

@@ -0,0 +1,7 @@
+export type CreateSnapshotDTO = {
+  snapshotID: string
+}
+
+export const formatCreateSnapshotDto = (dto: CreateSnapshotDTO) => dto
+
+export type CreateSnapshotResponse = ReturnType<typeof formatCreateSnapshotDto>

package/types/api/entities/dbSource.ts

@@ -0,0 +1,14 @@
+export type dbSource = {
+  host: string
+  port: string
+  dbname: string
+  username: string
+  password: string
+  instanceId: string
+  db_list?: string[]
+}
+
+export type TestSourceDTO = {
+  message: string
+  status: string
+}

package/types/api/entities/instance.ts

@@ -0,0 +1,67 @@
+import {
+  InstanceStateDto,
+  formatInstanceStateDto,
+} from '@postgres.ai/shared/types/api/entities/instanceState'
+
+type CoreInstanceDto = {
+  id: number
+  state: InstanceStateDto
+  plan: string
+  selfassigned_instance_id: string
+}
+
+type CeInstanceDto = CoreInstanceDto & {}
+
+type PlatformInstanceDto = CoreInstanceDto & {
+  created_at: string
+  telemetry_last_reported_at?: string
+  created_formatted: string
+  iid: number | null
+  is_active: true
+  org_id: number
+  project_alias: string
+  project_id: number
+  project_name: string
+  ssh_server_url: string | null
+  url: string
+  use_tunnel: boolean
+  verify_token: string
+}
+
+export type InstanceDto = CeInstanceDto | PlatformInstanceDto
+
+export const formatInstanceDto = (dto: InstanceDto) => {
+  const coreMapped = {
+    id: dto.id.toString(),
+    state: formatInstanceStateDto(dto.state),
+    dto,
+  }
+
+  const platformMapped =
+    'created_at' in dto
+      ? {
+          createdAt: new Date(dto.created_at),
+          ...(dto.telemetry_last_reported_at && {
+            telemetryLastReportedAt: new Date(dto.telemetry_last_reported_at),
+          }),
+          createdFormatted: `${dto.created_formatted} UTC`,
+          iid: dto.iid,
+          isActive: dto.is_active,
+          orgId: dto.org_id.toString(),
+          projectAlias: dto.project_alias,
+          projectId: dto.project_id.toString(),
+          projectName: dto.project_name,
+          sshServerUrl: dto.ssh_server_url,
+          useTunnel: dto.use_tunnel,
+          verifyToken: dto.verify_token,
+          url: dto.url,
+        }
+      : null
+
+  return {
+    ...coreMapped,
+    ...platformMapped,
+  }
+}
+
+export type Instance = ReturnType<typeof formatInstanceDto>

package/types/api/entities/instanceRetrieval.ts

@@ -0,0 +1,46 @@
+export interface ActivityType {
+  user?: string
+  query?: string
+  duration?: number | string
+  waitEventType?: string
+  waitEvent?: string
+}
+
+export type InstanceRetrieval = {
+  mode: string
+  alerts: Object | null
+  lastRefresh: string | null
+  nextRefresh: string | null
+  status: string
+  currentJob?: string
+  activity: {
+    source: ActivityType[]
+    target: ActivityType[]
+  }
+}
+
+const replaceSinglequote = (string?: string) => string?.replace(/'/g, '')
+
+const formatActivity = (activity: ActivityType[]) =>
+  activity?.map((item) => {
+    return {
+      user: replaceSinglequote(item.user),
+      query: replaceSinglequote(item.query),
+      duration: replaceSinglequote(`${item.duration}ms`),
+      'wait type/event': replaceSinglequote(
+        `${item.waitEventType}/${item.waitEvent}`,
+      ),
+    }
+  })
+
+export const formatInstanceRetrieval = (retrieval: InstanceRetrieval) => {
+  return {
+    ...retrieval,
+    activity: {
+      source: formatActivity(retrieval.activity?.source),
+      target: formatActivity(retrieval.activity?.target),
+    },
+  }
+}
+
+export type InstanceRetrievalType = ReturnType<typeof formatInstanceRetrieval>

package/types/api/entities/instanceState.ts

@@ -0,0 +1,106 @@
+import {
+  CloneDto,
+  formatCloneDto,
+} from '@postgres.ai/shared/types/api/entities/clone'
+import {
+  formatPoolDto,
+  PoolDto,
+} from '@postgres.ai/shared/types/api/entities/pool'
+
+export type InstanceStateDto = {
+  cloning: {
+    clones: CloneDto[]
+    expectedCloningTime: number
+    numClones?: number
+    protectionLeaseDurationMinutes?: number
+    protectionMaxDurationMinutes?: number
+  }
+  status: {
+    code: 'OK' | 'WARNING' | 'NO_RESPONSE'
+    message: string
+  }
+  // Fallback for capability with old API.
+  clones?: CloneDto[]
+  // Fallback for capability with old API.
+  expectedCloningTime?: number
+  // Fallback for capability with old API.
+  pools?: PoolDto[]
+  // Fallback for capability with old API.
+  retrieving?: {
+    lastRefresh: string | null
+    nextRefresh: string | null
+    mode: string
+    status: 'finished' | 'failed' | 'refreshing' | 'pending'
+    alerts?: {
+      refresh_failed?: {
+        level: 'error'
+        message: string
+        lastSeen: string
+        count: number
+      }
+    }
+  }
+  // Fallback for capability with old API.
+  fileSystem?: {
+    free: number
+    size: number
+    used: number
+  }
+  engine?: {
+    version: string
+    startedAt: string
+    edition?: string
+    disableConfigModification?: boolean
+  }
+  dataSize?: number
+}
+
+export const formatInstanceStateDto = (dto: InstanceStateDto) => {
+  if (!dto) return null
+
+  const pools = dto.pools?.map(formatPoolDto) ?? null
+  const clones =
+    dto?.clones?.map(formatCloneDto) ?? dto.cloning?.clones?.map(formatCloneDto)
+  const expectedCloningTime =
+    dto?.expectedCloningTime ?? dto.cloning?.expectedCloningTime
+
+  return {
+    ...dto,
+    engine: {
+      version: dto.engine?.version ?? null,
+      startedAt: dto.engine?.startedAt && new Date(dto.engine?.startedAt),
+      disableConfigModification: false,
+    },
+    retrieving: dto.retrieving && {
+      lastRefresh: dto.retrieving.lastRefresh
+        ? new Date(dto.retrieving.lastRefresh)
+        : null,
+      nextRefresh: dto.retrieving.nextRefresh
+        ? new Date(dto.retrieving.nextRefresh)
+        : null,
+      mode: dto.retrieving.mode,
+      status: dto.retrieving.status,
+      alerts: dto.retrieving.alerts && {
+        refreshFailed: dto.retrieving.alerts.refresh_failed && {
+          level: dto.retrieving.alerts.refresh_failed.level,
+          message: dto.retrieving.alerts.refresh_failed.message,
+          lastSeen: new Date(dto.retrieving.alerts.refresh_failed.lastSeen),
+          count: dto.retrieving.alerts.refresh_failed.count,
+        },
+      },
+    },
+    cloning: {
+      clones: clones,
+      expectedCloningTime: expectedCloningTime,
+      protectionLeaseDurationMinutes: dto.cloning?.protectionLeaseDurationMinutes,
+      protectionMaxDurationMinutes: dto.cloning?.protectionMaxDurationMinutes,
+    },
+    pools,
+    dataSize:
+      dto.dataSize ??
+      pools?.reduce((sum, pool) => pool.fileSystem.dataSize + sum, 0) ??
+      null,
+  }
+}
+
+export type InstanceState = ReturnType<typeof formatInstanceStateDto>

package/types/api/entities/pool.ts

@@ -0,0 +1,27 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+ export type PoolDto = {
+  cloneList: string[]
+  fileSystem: {
+    compressRatio: number
+    dataSize: number
+    free: number
+    mode: string
+    size: number
+    used: number
+    usedByClones: number
+    usedBySnapshots: number
+  }
+  mode: string
+  name: string
+  status: 'active' | 'empty' | 'refreshing'
+}
+
+export const formatPoolDto = (dto: PoolDto) => dto
+
+export type Pool = ReturnType<typeof formatPoolDto>

package/types/api/entities/snapshot.ts

@@ -0,0 +1,22 @@
+import { parseDate } from '@postgres.ai/shared/utils/date'
+
+export type SnapshotDto = {
+  numClones: string | number
+  clones: string[]
+  createdAt: string
+  dataStateAt: string
+  id: string
+  pool: string
+  physicalSize: number
+  logicalSize: number
+  message: string
+  branch: string
+}
+
+export const formatSnapshotDto = (dto: SnapshotDto) => ({
+  ...dto,
+  createdAtDate: parseDate(dto.createdAt),
+  dataStateAtDate: parseDate(dto.dataStateAt),
+})
+
+export type Snapshot = ReturnType<typeof formatSnapshotDto>

package/types/api/entities/wsToken.ts

@@ -0,0 +1,7 @@
+export type WSTokenDTO = {
+  token: string
+}
+
+export const formatWSTokenDto = (dto: WSTokenDTO) => dto
+
+export type WSToken = ReturnType<typeof formatWSTokenDto>

package/types/byte-size/index.d.ts

@@ -0,0 +1,22 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+type Options = {
+  precision: number
+  units: 'metric' | 'iec' | 'metric_octet' | 'iec_octet'
+}
+
+type Result = {
+  value: string
+  unit: string
+  long: string
+}
+
+declare module 'byte-size' {
+  declare const byteSize: (bytes: number, options?: Options) => Result
+  export default byteSize
+}

package/utils/api.ts

@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+export const getTextFromUnknownApiError = async (error: Response) => {
+  const log = (text: string) => console.error('Unknown API error', text)
+
+  try {
+    const result = await error.json()
+    log(result)
+    return JSON.stringify(result)
+  } catch (e) {
+    // not a json
+  }
+
+  try {
+    const result = await error.text()
+    log(result)
+    return result
+  } catch (e) {
+    // not a text
+  }
+
+  const result = `${error.status} ${error.statusText}`
+  log(result)
+  return result
+}

package/utils/clone.ts

@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+import { Clone } from '@postgres.ai/shared/types/api/entities/clone'
+import { capitalize } from '@postgres.ai/shared/utils/strings'
+
+const STATUS_CODE_TO_TYPE = {
+  OK: 'ok' as const,
+  CREATING: 'waiting' as const,
+  DELETING: 'waiting' as const,
+  RESETTING: 'waiting' as const,
+  FATAL: 'error' as const,
+}
+
+type StatusCode = keyof typeof STATUS_CODE_TO_TYPE
+
+export const getCloneStatusType = (statusCode: StatusCode) =>
+  STATUS_CODE_TO_TYPE[statusCode] ?? 'unknown'
+
+export const getCloneStatusText = (statusCode: StatusCode) => {
+  if (statusCode === 'OK') return statusCode
+
+  return capitalize(statusCode)
+}
+
+export const checkIsCloneStable = (clone: Clone) =>
+  clone.status.code === 'OK' || clone.status.code === 'FATAL'

package/utils/connection.ts

@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+import { Instance } from '@postgres.ai/shared/types/api/entities/instance'
+import { Clone } from '@postgres.ai/shared/types/api/entities/clone'
+
+const isEmptyDbData = (clone: Clone) => {
+  const { host, port, username } = clone.db
+
+  // 'host', 'port' or 'username' can be empty string.
+  return !host || !port || !username
+}
+
+export const getSshPortForwardingCommand = (
+  instance: Instance,
+  clone: Clone,
+) => {
+  if (!instance.sshServerUrl) return null
+  if (isEmptyDbData(clone)) return null
+
+  return `ssh -NTML ${clone.db.port}:localhost:${clone.db.port} ${instance.sshServerUrl} -i ~/.ssh/id_rsa`
+}
+
+export const getPsqlConnectionStr = (clone: Clone) => {
+  if (isEmptyDbData(clone)) return null
+
+  return `"host=${clone.db.host} port=${clone.db.port} user=${clone.db.username} dbname=DBNAME"`
+}
+
+export const getJdbcConnectionStr = (clone: Clone) => {
+  if (isEmptyDbData(clone)) return null
+
+  return `jdbc:postgresql://${clone.db.host}:${clone.db.port}/DBNAME?user=${clone.db.username}&password=DBPASSWORD`
+}

package/utils/date.ts

@@ -0,0 +1,136 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+import {
+  parse,
+  startOfDay,
+  isSameDay,
+  startOfMonth,
+  startOfWeek,
+  endOfMonth,
+  endOfWeek,
+  differenceInDays,
+  addDays,
+  addMonths,
+  isSameMonth,
+  format,
+  formatDistanceToNowStrict,
+} from 'date-fns'
+
+export const formatDateToISO = (dateString: string) => {
+  // Handle empty or invalid date strings
+  if (!dateString || dateString.trim() === '') {
+    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
+    return ''
+  }
+}
+
+// parseDate parses date of both format: '2006-01-02 15:04:05 UTC' and `2006-01-02T15:04:05Z` (RFC3339).
+export const parseDate = (dateStr: string) =>
+  parse(
+    dateStr.replace(' UTC', 'Z').replace('T', ' '),
+    'yyyy-MM-dd HH:mm:ssX',
+    new Date(),
+  )
+
+// UTCf - UTC formatted, but not actually UTC.
+// date-fns using this approach because browser don't have an opportunity to switch single date
+// object in different timezones.
+// Example: 15:00:00 <some date> Moscow Standard Time -> 12:00:00 <same date> Moscow Standard Time.
+// In example above just ignore real timezone "Moscow Standard Time" and imagine that it is UTC.
+const toUTCf = (date: Date) =>
+  new Date(date.getTime() + date.getTimezoneOffset() * 60 * 1000)
+
+const toLocal = (date: Date) =>
+  new Date(date.getTime() - date.getTimezoneOffset() * 60 * 1000)
+
+const inUTC =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+    <T extends (date: Date, ...otherArgs: any[]) => Date>(func: T) =>
+    (date: Date, ...otherArgs: unknown[]) =>
+      toLocal(func(toUTCf(date), ...otherArgs))
+
+export const startOfMonthUTC = inUTC(startOfMonth)
+
+export const startOfWeekUTC = inUTC(startOfWeek)
+
+export const endOfMonthUTC = inUTC(endOfMonth)
+
+export const endOfWeekUTC = inUTC(endOfWeek)
+
+export const startOfDayUTC = inUTC(startOfDay)
+
+export const addDaysUTC = inUTC(addDays)
+
+export const addMonthsUTC = inUTC(addMonths)
+
+export const differenceInDaysUTC = (date1: Date, date2: Date) =>
+  differenceInDays(toUTCf(date1), toUTCf(date2))
+
+export const isSameMonthUTC = (date1: Date, date2: Date) =>
+  isSameMonth(toUTCf(date1), toUTCf(date2))
+
+export const formatUTC = (date: Date, formatStr: string) =>
+  format(toUTCf(date), formatStr)
+
+export const isSameDayUTC = (date1: Date, date2: Date) =>
+  isSameDay(toUTCf(date1), toUTCf(date2))
+
+// Std date utils.
+export const formatDistanceStd = (date: Date) =>
+  formatDistanceToNowStrict(date, { addSuffix: true })
+
+export const formatDateStd = (
+  date: Date,
+  options?: { withDistance?: boolean },
+) =>
+  `${formatUTC(date, 'yyyy-MM-dd HH:mm:ss')} UTC ${
+    options?.withDistance ? `(${formatDistanceStd(date)})` : ''
+  }`
+
+export const isValidDate = (dateObject: Date) => {
+  return new Date(dateObject).toString() !== 'Invalid Date'
+}
+
+// Safe date formatting with distance
+export const formatDateWithDistance = (dateString: string, dateObject: Date) => {
+  if (!dateString || !isValidDate(dateObject)) return '-'
+  
+  try {
+    return `${dateString} (${formatDistanceToNowStrict(dateObject, { addSuffix: true })})`
+  } catch (error) {
+    console.warn('Error formatting date distance:', error, 'date:', dateObject)
+    return '-'
+  }
+}
+
+// Safe distance formatting only
+export const formatDistanceSafe = (dateObject: Date) => {
+  if (!isValidDate(dateObject)) return '-'
+  
+  try {
+    return formatDistanceToNowStrict(dateObject, { addSuffix: true })
+  } catch (error) {
+    console.warn('Error formatting distance:', error, 'date:', dateObject)
+    return '-'
+  }
+}

package/utils/instance.ts

@@ -0,0 +1,10 @@
+export const parseEngineVersion = (str: string) => {
+  const [versionStr] = str.split('-')
+  const [major, minor, patch] = versionStr.split('.')
+  if (!major || !minor || !patch) return null
+  return {
+    major: Number(major),
+    minor: Number(minor),
+    patch: Number(patch),
+  }
+}

package/utils/numbers.ts

@@ -0,0 +1,11 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+export const round = (value: number, precision = 0) => {
+  const multiplier = 10 ** precision
+  return Math.round(value * multiplier) / multiplier
+}

package/utils/react.ts

@@ -0,0 +1,10 @@
+import { useContext, createContext } from 'react'
+
+export const createStrictContext = <Value>() => {
+  const Context = createContext<Value>(undefined as unknown as Value)
+
+  return {
+    useStrictContext: () => useContext(Context),
+    Provider: Context.Provider,
+  }
+}

package/utils/snapshot.ts

@@ -0,0 +1,8 @@
+export const compareSnapshotsDesc = (
+  a: { dataStateAtDate: Date },
+  b: { dataStateAtDate: Date },
+): number => {
+  const dataStateAtDateA = a.dataStateAtDate?.getTime() ?? 0
+  const dataStateAtDateB = b.dataStateAtDate?.getTime() ?? 0
+  return dataStateAtDateB - dataStateAtDateA
+}

package/utils/strings.ts

@@ -0,0 +1,11 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+export const capitalize = (value: string) => {
+  const [firstChar, ...otherChars] = value.split('')
+  return `${firstChar.toUpperCase()}${otherChars.join('').toLowerCase()}`
+}

package/utils/units.ts

@@ -0,0 +1,23 @@
+/*--------------------------------------------------------------------------
+ * 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
+ *--------------------------------------------------------------------------
+ */
+
+import byteSize from 'byte-size'
+
+type Options = {
+  precision?: number
+}
+
+export const formatBytesIEC = (bytes: number, options?: Options) => {
+  const { precision = 3 } = options ?? {}
+
+  const result = byteSize(bytes, {
+    precision,
+    units: 'iec',
+  })
+
+  return `${result.value} ${result.unit}`
+}

package/pages/Instance/Info/Disks/Disk/Marker/index.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" />
-declare type Props = {
-    className: string;
-};
-export declare const Marker: (props: Props) => JSX.Element;
-export {};

package/pages/Instance/Info/Disks/Disk/Marker/index.js

@@ -1,15 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { makeStyles } from '@material-ui/core';
-import clsx from 'clsx';
-import { CircleIcon } from '@postgres.ai/shared/icons/Circle';
-const useStyles = makeStyles({
-    root: {
-        display: 'inline',
-        verticalAlign: 'middle',
-        width: '10px',
-    },
-}, { index: 1 });
-export const Marker = (props) => {
-    const classes = useStyles();
-    return _jsx(CircleIcon, { className: clsx(classes.root, props.className) });
-};