@postgres.ai/shared 4.1.3 → 4.2.0-pr-1200

package/types/api/entities/config.ts

@@ -1,126 +0,0 @@
-import {
-  formatDatabases,
-  formatDumpCustomOptions,
-  getImageMajorVersion,
-  getImageType,
-  isSeDockerImage,
-} from '@postgres.ai/shared/pages/Instance/Configuration/utils'
-import { formatTuningParams } from '../endpoints/testDbSource'
-
-export interface DatabaseType {
-  [name: string]: string | Object
-}
-
-export type configTypes = {
-  global?: {
-    debug?: boolean
-  }
-  databaseContainer?: {
-    dockerImage?: string
-    dockerPath?: string
-  }
-  databaseConfigs?: {
-    configs?: {
-      [key: string]: string
-    }
-  }
-  retrieval?: {
-    refresh?: {
-      timetable?: string
-    }
-    spec?: {
-      logicalDump?: {
-        options?: {
-          customOptions?: string[]
-          databases?: DatabaseType | null
-          parallelJobs?: string | number
-          ignoreErrors?: boolean
-          source?: {
-            connection?: {
-              dbname?: string
-              host?: string
-              port?: string | number
-              username?: string
-              password?: string
-            }
-          }
-        }
-      }
-      logicalRestore?: {
-        options?: {
-          customOptions?: string[]
-          parallelJobs?: string | number
-          ignoreErrors?: boolean
-          configs?: { [key: string]: string }
-        }
-      }
-    }
-  }
-}
-
-export const formatConfig = (config: configTypes) => {
-  const dockerImage = config.databaseContainer?.dockerImage
-  return {
-    debug: config.global?.debug,
-    dockerImage: isSeDockerImage(dockerImage)
-      ? getImageMajorVersion(dockerImage)
-      : dockerImage && getImageType(dockerImage) === 'Generic Postgres'
-      ? getImageMajorVersion(dockerImage) || dockerImage
-      : dockerImage,
-    ...(dockerImage && {
-      dockerImageType: getImageType(dockerImage),
-    }),
-    // Extract dockerTag for both SE images and Generic Postgres images
-    ...(dockerImage && dockerImage.includes(':') && {
-      dockerTag: dockerImage.split(':')[1],
-    }),
-    dockerPath: dockerImage,
-    tuningParams: formatTuningParams(config.databaseConfigs?.configs),
-    sharedBuffers: config.databaseConfigs?.configs?.shared_buffers,
-    sharedPreloadLibraries:
-      config.databaseConfigs?.configs?.shared_preload_libraries,
-    timetable: config.retrieval?.refresh?.timetable,
-    dbname:
-      config.retrieval?.spec?.logicalDump?.options?.source?.connection?.dbname,
-    host: config.retrieval?.spec?.logicalDump?.options?.source?.connection
-      ?.host,
-    port: config.retrieval?.spec?.logicalDump?.options?.source?.connection
-      ?.port,
-    username:
-      config.retrieval?.spec?.logicalDump?.options?.source?.connection
-        ?.username,
-    password:
-      config.retrieval?.spec?.logicalDump?.options?.source?.connection
-        ?.password,
-    databases: formatDatabases(
-      (config.retrieval?.spec?.logicalDump?.options
-        ?.databases as DatabaseType | undefined) ?? null,
-    ),
-    dumpParallelJobs:
-      config.retrieval?.spec?.logicalDump?.options?.parallelJobs,
-    dumpIgnoreErrors:
-      config.retrieval?.spec?.logicalDump?.options?.ignoreErrors,
-    restoreParallelJobs:
-      config.retrieval?.spec?.logicalRestore?.options?.parallelJobs,
-    restoreIgnoreErrors:
-      config.retrieval?.spec?.logicalRestore?.options?.ignoreErrors,
-    restoreConfigs: (() => {
-      const configs =
-        config.retrieval?.spec?.logicalRestore?.options?.configs
-      if (!configs || Object.keys(configs).length === 0) return ''
-      return Object.entries(configs)
-        .map(([k, v]) => `${k}=${v}`)
-        .join('\n')
-    })(),
-    pgDumpCustomOptions: formatDumpCustomOptions(
-      (config.retrieval?.spec?.logicalDump?.options
-        ?.customOptions as string[] | undefined) ?? null,
-    ),
-    pgRestoreCustomOptions: formatDumpCustomOptions(
-      (config.retrieval?.spec?.logicalRestore?.options
-        ?.customOptions as string[] | undefined) ?? null,
-    ),
-  }
-}
-
-export type Config = ReturnType<typeof formatConfig>

package/types/api/entities/createBranch.ts

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

package/types/api/entities/createSnapshot.ts

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

package/types/api/entities/dbSource.ts

@@ -1,14 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/*--------------------------------------------------------------------------
- * 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

@@ -1,22 +0,0 @@
-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

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

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

@@ -1,22 +0,0 @@
-/*--------------------------------------------------------------------------
- * 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

@@ -1,30 +0,0 @@
-/*--------------------------------------------------------------------------
- * 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

@@ -1,31 +0,0 @@
-/*--------------------------------------------------------------------------
- * 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

@@ -1,38 +0,0 @@
-/*--------------------------------------------------------------------------
- * 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`
-}