@env-hopper/frontend-core 2.0.1-alpha

package/src/modules/resourceJump/ResourceJumpContext.tsx

@@ -0,0 +1,142 @@
+import { useNavigate } from '@tanstack/react-router'
+import {
+  createContext,
+  use,
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+} from 'react'
+import { useEnvironmentContext } from '../environment/EnvironmentContext'
+import { usePluginManager } from '../pluginCore/PluginManagerContext'
+import { buildJumpUrl } from './buildJumpUrl'
+import type { EhUrlParams } from '~/types/ehTypes'
+import type { ReactNode } from 'react'
+import type { EnvSlug, JumpResouceSlug } from '@env-hopper/backend-core'
+import type { ResourceJumpItem, ResourceJumpLoaderReturn } from './types'
+import { getEhToOptions } from '~/util/route-utils'
+import { useBootstrapConfig } from '~/modules/config/BootstrapConfigContext'
+
+export interface ResourceJumpContextIface {
+  setCurrentResourceJumpSlug: (slug: JumpResouceSlug | undefined) => void
+  currentResourceJump: ResourceJumpItem | undefined
+  jumpResources: Array<ResourceJumpItem>
+  getJumpUrl: (
+    jumpResourceSlug: JumpResouceSlug | undefined,
+    envSlug: EnvSlug | undefined,
+  ) => string
+}
+
+const ResourceJumpContext = createContext<ResourceJumpContextIface | undefined>(
+  undefined,
+)
+
+interface ResouceJumpProviderProps {
+  children: ReactNode
+  initialJumpLinkSlug?: string
+  resourceJumpLoader: ResourceJumpLoaderReturn
+}
+
+export function ResourceJumpProvider({
+  children,
+  resourceJumpLoader,
+}: ResouceJumpProviderProps) {
+  const { autocompleteFactoryItems } = usePluginManager()
+  const indexData = useBootstrapConfig()
+  const { currentEnv } = useEnvironmentContext()
+  const navigate = useNavigate()
+  const [currentResourceJumpSlug, setCurrentResourceJumpSlug] = useState<
+    string | undefined
+  >(resourceJumpLoader.resourceSlug)
+
+  const [jumpResources, setJumpResources] = useState<Array<ResourceJumpItem>>(
+    () =>
+      autocompleteFactoryItems({
+        bootstrapConfig: indexData,
+      }),
+  )
+
+  // const [initialEnvAppSubBased] = useState(() => {
+  //   return parseUrlParams({
+  //     rawUrlParams: urlParams,
+  //     config: {
+  //       envs: indexData.envs,
+  //       apps: indexData.apps,
+  //     },
+  //     lastUsedAppSlug: undefined,
+  //     lastUsedEnvSlug: undefined,
+  //   })
+  // })
+
+  const fixUrlBasedOnSelection = useCallback(
+    async (state: EhUrlParams, replace = false) => {
+      await navigate({
+        ...getEhToOptions(state),
+        replace,
+      })
+    },
+    [navigate],
+  )
+
+  useEffect(() => {
+    // eslint-disable-next-line @eslint-react/hooks-extra/no-direct-set-state-in-use-effect
+    setJumpResources(autocompleteFactoryItems({ bootstrapConfig: indexData }))
+  }, [indexData, autocompleteFactoryItems])
+
+  const currentResourceJump = useMemo(() => {
+    return jumpResources.find((item) => item.slug === currentResourceJumpSlug)
+  }, [currentResourceJumpSlug, jumpResources])
+
+  useEffect(() => {
+    if (
+      resourceJumpLoader.envSlug !== currentEnv?.slug ||
+      resourceJumpLoader.resourceSlug !== currentResourceJump?.slug
+    ) {
+      void fixUrlBasedOnSelection(
+        { envId: currentEnv?.slug, appId: currentResourceJump?.slug },
+        true,
+      )
+    }
+  }, [
+    currentResourceJump,
+    currentEnv,
+    resourceJumpLoader,
+    fixUrlBasedOnSelection,
+  ])
+
+  const getJumpUrl = useCallback(
+    (
+      jumpResourceSlug: JumpResouceSlug | undefined,
+      envSlug: EnvSlug | undefined,
+    ) => {
+      return buildJumpUrl(
+        jumpResourceSlug,
+        envSlug,
+        resourceJumpLoader.resourceJumps,
+      )
+    },
+    [resourceJumpLoader],
+  )
+
+  const value: ResourceJumpContextIface = useMemo(
+    () => ({
+      currentResourceJump,
+      setCurrentResourceJumpSlug,
+      jumpResources,
+      getJumpUrl,
+    }),
+    [currentResourceJump, jumpResources, getJumpUrl],
+  )
+
+  return <ResourceJumpContext value={value}>{children}</ResourceJumpContext>
+}
+
+export function useResourceJumpContext(): ResourceJumpContextIface {
+  const context = use(ResourceJumpContext)
+  if (context === undefined) {
+    throw new Error(
+      'useResourceJumpContext must be used within an ResourceJumpContext',
+    )
+  }
+  return context
+}

package/src/modules/resourceJump/buildJumpUrl.ts

@@ -0,0 +1,40 @@
+import type {
+  EnvSlug,
+  JumpResouceSlug,
+  ResourceJumpsData,
+} from '@env-hopper/backend-core'
+
+export function buildJumpUrl(
+  jumpResourceSlug: JumpResouceSlug | undefined,
+  envSlug: EnvSlug | undefined,
+  resourceJumps: ResourceJumpsData,
+): string {
+  const { baseResouceJumpUrls, resourceJumpsData, envData } = resourceJumps
+
+  const baseUrl = baseResouceJumpUrls[jumpResourceSlug || ''] || ''
+  let finalUrl = baseUrl
+  let prevUrl = ''
+
+  while (finalUrl !== prevUrl) {
+    prevUrl = finalUrl
+    finalUrl = finalUrl.replace(/{{(.+?)}}/g, function (match, contents) {
+      if (contents.startsWith('app.meta.')) {
+        const varName = contents.replace('app.meta.', '')
+        const r = resourceJumpsData[jumpResourceSlug || '']?.[varName]
+        if (r !== undefined) {
+          return r
+        }
+      }
+      if (contents.startsWith('env.meta.')) {
+        const varName = contents.replace('env.meta.', '')
+        const r = envData[envSlug || '']?.[varName]
+        if (r !== undefined) {
+          return r
+        }
+      }
+      return match
+    })
+  }
+
+  return finalUrl || `not found ${jumpResourceSlug}`
+}

package/src/modules/resourceJump/findBestMatchByUrl.ts

@@ -0,0 +1,121 @@
+import { sort } from 'radashi'
+import type {
+  AvailiabilityMatrixData,
+  EhEnvIndexed,
+  RenameRule,
+  RenameRuleParams,
+} from '@env-hopper/backend-core'
+import type { EnvironmentHistoryItem } from '../environment/types'
+import type { ResourceJumpItem } from './types'
+import type { AvailabilitySlugPair } from '~/util/availabilityMatrixUtils'
+import { findAvailableResources } from '~/util/availabilityMatrixUtils'
+
+export interface FindBestMatchingResourceJumpParams {
+  urlEnvSlug: string | undefined
+  urlAppSlug: string | undefined
+  envs: Record<string, EhEnvIndexed>
+  resourceJumps: Record<string, ResourceJumpItem>
+  getEnvHistory: () => Promise<Array<EnvironmentHistoryItem>>
+  getAvailabilityMatrix: () => Promise<AvailiabilityMatrixData>
+  getNameMigrations: (params: RenameRuleParams) => Promise<RenameRule | false>
+}
+
+export interface BestMatchByUrlReturn {
+  env: EhEnvIndexed | undefined
+  resourceJump: ResourceJumpItem | undefined
+}
+
+export async function findBestMatchByUrl({
+  urlAppSlug,
+  urlEnvSlug,
+  envs,
+  resourceJumps,
+  getEnvHistory,
+  getAvailabilityMatrix,
+  getNameMigrations,
+}: FindBestMatchingResourceJumpParams): Promise<BestMatchByUrlReturn> {
+  let envFound: EhEnvIndexed | undefined = undefined
+  let resourceJumpFound: ResourceJumpItem | undefined = undefined
+
+  if (urlAppSlug !== undefined) {
+    resourceJumpFound = resourceJumps[urlAppSlug]
+    if (!resourceJumpFound) {
+      const migrationRule = await getNameMigrations({
+        envSlug: undefined,
+        resourceSlug: urlAppSlug,
+      })
+      if (migrationRule !== false && migrationRule.type === 'resourceRename') {
+        resourceJumpFound = resourceJumps[migrationRule.targetSlug]
+      }
+    }
+  }
+
+  if (urlEnvSlug !== undefined) {
+    envFound = envs[urlEnvSlug]
+  }
+  if (!envFound) {
+    const migrationRule = await getNameMigrations({
+      envSlug: urlEnvSlug,
+      resourceSlug: undefined,
+    })
+    if (migrationRule !== false && migrationRule.type === 'envRename') {
+      envFound = envs[migrationRule.targetSlug]
+    }
+  }
+
+  const hasEnvOrResource =
+    envFound !== undefined || resourceJumpFound !== undefined
+  if (hasEnvOrResource) {
+    if (envFound === undefined) {
+      const [history, availabilityMatrix] = await Promise.all([
+        getEnvHistory(),
+        getAvailabilityMatrix(),
+      ])
+
+      const historyEnvSlugs = history
+        .map(
+          (historyItem) =>
+            envs[historyItem.envSlug] && envs[historyItem.envSlug]?.slug,
+        )
+        .filter((e) => e !== undefined)
+      const alreadyCheckedSlugs = new Set<string>()
+
+      const candidates: Array<AvailabilitySlugPair> = []
+      for (const envSlug of historyEnvSlugs) {
+        if (alreadyCheckedSlugs.has(envSlug)) {
+          continue
+        }
+        alreadyCheckedSlugs.add(envSlug)
+
+        const jumpResourcePairs = findAvailableResources({
+          envSlug,
+          resourceJumpSlug: resourceJumpFound
+            ? resourceJumpFound.slug
+            : undefined,
+          availabilityMatrix: availabilityMatrix,
+        })
+
+        candidates.push(...jumpResourcePairs)
+      }
+      const sortedByRelevance = sort(
+        candidates,
+        ({ availabilityVariant: { isDeployed, hasData, isHealthy } }) =>
+          (isDeployed && isHealthy && hasData ? 1 : 0) * 4 +
+          (isHealthy ? 1 : 0) * 3 +
+          (hasData ? 1 : 0) * 2 +
+          (isDeployed ? 1 : 0),
+        true,
+      )
+      const mostRelevantEnvSlug =
+        sortedByRelevance.length > 0 ? sortedByRelevance[0]?.envSlug : undefined
+      if (mostRelevantEnvSlug) {
+        envFound = envs[mostRelevantEnvSlug]
+      }
+    }
+  }
+
+  return {
+    resourceJump: resourceJumpFound,
+    env: envFound,
+  }
+}

package/src/modules/resourceJump/helpers.ts

@@ -0,0 +1,117 @@
+import type { EhAppIndexed, EhEnvIndexed } from '@env-hopper/backend-core'
+import type {
+  BaseAppAutoCompletableParent,
+  BaseAutoCompletableItem,
+} from '~/modules/pluginCore/types'
+import type { EhUrlParams } from '~/types/ehTypes'
+import type { ResourceJumpItem } from './types'
+import {
+  getRenderData,
+  isAutocompleteItem,
+} from '~/plugins/builtin/pageUrl/pageUrlAutoCompletePlugin'
+
+export function* mapDisplayedItems(
+  displayedItems: Array<BaseAutoCompletableItem>,
+) {
+  let lastParent: BaseAppAutoCompletableParent | undefined = undefined
+
+  for (const item of displayedItems) {
+    if (isAutocompleteItem(item)) {
+      const itemRenderData = getRenderData(item)
+      yield {
+        item,
+        itemRenderData,
+        isChild: item.parent === lastParent,
+      }
+    }
+    lastParent = item.parent
+  }
+}
+
+export function formatResourceTitle(resouceJump: ResourceJumpItem | undefined) {
+  if (resouceJump === undefined) {
+    return ''
+  }
+  return [resouceJump.parent?.displayName, resouceJump.slug]
+    .filter(Boolean)
+    .join(' :: ')
+}
+
+export function getByIdRelaxed<T extends { slug: string }>(
+  primarySearch: (slug: string | undefined) => T | undefined,
+  id: string | undefined,
+): [T | undefined, boolean] {
+  if (id !== undefined) {
+    const exactMatchResult = primarySearch(id)
+    if (exactMatchResult !== undefined) {
+      return [exactMatchResult, true]
+    }
+
+    // const items: SourceItem[] = options.map((e) => ({ title: e.slug, slug: e.slug }));
+    // const found = makeAutoCompleteFilter(items)(id.toLowerCase(), items);
+    // if (found.length === 1) {
+    //   return [primarySearch(found[0].id, options), false];
+    // }
+  }
+  return [undefined, false]
+}
+
+export interface PreselectedBasedOnParams {
+  rawUrlParams: EhUrlParams
+  config: {
+    envs: Record<string, EhEnvIndexed>
+    apps: Record<string, EhAppIndexed>
+  }
+  lastUsedEnvSlug: string | undefined
+  lastUsedAppSlug: string | undefined
+}
+
+export interface PreselectedBasedOnParamsReturn {
+  urlWasFixed: boolean
+  env: EhEnvIndexed | undefined
+  app: EhAppIndexed | undefined
+}
+
+export function loadEnvAndResouceByRawUrlParams({
+  rawUrlParams: urlParams,
+  config,
+  lastUsedEnvSlug: lastUsedEnvSlug,
+  lastUsedAppSlug: lastUsedAppSlug,
+}: PreselectedBasedOnParams): PreselectedBasedOnParamsReturn {
+  let selectedEnv: EhEnvIndexed | undefined = undefined
+  let selectedApp: EhAppIndexed | undefined = undefined
+  let urlWasFixed = false
+
+  const doGetEnvById = (envId: string | undefined) =>
+    envId ? config.envs[envId] : undefined
+  const doGetAppById = (appId: string | undefined) =>
+    appId ? config.apps[appId] : undefined
+
+  if (urlParams.envId !== undefined) {
+    let strictMatch
+    ;[selectedEnv, strictMatch] = getByIdRelaxed<EhEnvIndexed>(
+      doGetEnvById,
+      urlParams.envId,
+    )
+    if (!strictMatch) {
+      urlWasFixed = true
+    }
+  } else if (lastUsedEnvSlug !== undefined) {
+    ;[selectedEnv] = getByIdRelaxed(doGetEnvById, lastUsedEnvSlug)
+  }
+
+  if (urlParams.appId !== undefined) {
+    let strictMatch
+    ;[selectedApp, strictMatch] = getByIdRelaxed<EhAppIndexed>(
+      (appId) => (appId ? config.apps[appId] : undefined),
+      urlParams.appId,
+    )
+    if (!strictMatch) {
+      urlWasFixed = true
+    }
+  } else if (lastUsedAppSlug !== undefined) {
+    ;[selectedApp] = getByIdRelaxed(doGetAppById, lastUsedAppSlug)
+  }
+
+  return { urlWasFixed, env: selectedEnv, app: selectedApp }
+}

package/src/modules/resourceJump/routeLoader.ts

@@ -0,0 +1,58 @@
+import { ApiQueryMagazineHistory } from '../environment/ApiQueryMagazineEnvironment'
+import { makePluginInterfaceForCore } from '../pluginCore/makePluginManagerContext'
+import { ApiQueryMagazineResouceJump } from './ApiQueryMagazineResourceJump'
+import { findBestMatchByUrl } from './findBestMatchByUrl'
+import type { EhRouterContext } from '~/types/types'
+import type { ResourceJumpLoaderReturn } from './types'
+import { ApiQueryMagazine } from '~/api/ApiQueryMagazine'
+
+export interface RouteLoaderCtx {
+  params: {
+    envSlug?: string
+    appSlug?: string
+    subValue?: string
+  }
+  context: EhRouterContext
+}
+
+export async function routeLoader({
+  params,
+  context,
+}: RouteLoaderCtx): Promise<ResourceJumpLoaderReturn> {
+  const [bootstrapConfig, resourceJumps] = await Promise.all([
+    context.queryClient.ensureQueryData(ApiQueryMagazine.getConfig(context)),
+    context.queryClient.ensureQueryData(
+      ApiQueryMagazineResouceJump.getResourceJumps(),
+    ),
+  ])
+
+  const pluginInterfaceForCore = makePluginInterfaceForCore(context.plugins)
+  const resourceJumpItems =
+    await pluginInterfaceForCore.getResourceJumpsItems(bootstrapConfig)
+
+  const { env, resourceJump } = await findBestMatchByUrl({
+    urlEnvSlug: params.envSlug,
+    urlAppSlug: params.appSlug,
+    envs: bootstrapConfig.envs,
+    resourceJumps: resourceJumpItems,
+    getEnvHistory: () =>
+      context.queryClient.ensureQueryData(
+        ApiQueryMagazineHistory.getEnvSelectionHistory(context),
+      ),
+    getNameMigrations: (migrationParams) =>
+      context.queryClient.ensureQueryData(
+        ApiQueryMagazineResouceJump.getNameMigration(migrationParams),
+      ),
+    getAvailabilityMatrix: () =>
+      context.queryClient.ensureQueryData(
+        ApiQueryMagazineResouceJump.getAvailabilityMatrix(),
+      ),
+  })
+
+  return {
+    envSlug: env?.slug,
+    resourceSlug: resourceJump?.slug,
+    resourceJumps,
+    pluginInterfaceForCore,
+  }
+}

package/src/modules/resourceJump/types.ts

@@ -0,0 +1,21 @@
+import type { ResourceJumpsData } from '@env-hopper/backend-core'
+import type { PluginInterfaceForCore } from '../pluginCore/makePluginManagerContext'
+
+export interface ResouceJumpItemParent {
+  type: string
+  displayName: string
+  hasSingleChild: boolean
+}
+
+export interface ResourceJumpItem {
+  type: string
+  slug: string
+  parent?: ResouceJumpItemParent
+}
+
+export interface ResourceJumpLoaderReturn {
+  envSlug?: string
+  resourceSlug?: string
+  pluginInterfaceForCore: PluginInterfaceForCore
+  resourceJumps: ResourceJumpsData
+}