@startsimpli/hooks 0.4.11 → 0.4.15

package/src/useReducedMotion.native.ts

@@ -0,0 +1,34 @@
+/**
+ * useReducedMotion — React Native implementation.
+ *
+ * Web uses window.matchMedia('(prefers-reduced-motion: reduce)'); React Native
+ * exposes the same preference through AccessibilityInfo. Metro resolves this
+ * file over useReducedMotion.ts on native builds.
+ */
+
+import { useEffect, useState } from 'react'
+import { AccessibilityInfo } from 'react-native'
+
+export function useReducedMotion(): boolean {
+  const [prefersReducedMotion, setPrefersReducedMotion] = useState(false)
+
+  useEffect(() => {
+    let active = true
+
+    AccessibilityInfo.isReduceMotionEnabled().then((enabled) => {
+      if (active) setPrefersReducedMotion(enabled)
+    })
+
+    const subscription = AccessibilityInfo.addEventListener(
+      'reduceMotionChanged',
+      (enabled) => setPrefersReducedMotion(enabled)
+    )
+
+    return () => {
+      active = false
+      subscription.remove()
+    }
+  }, [])
+
+  return prefersReducedMotion
+}

package/src/useRefetchOnFocus.native.ts

@@ -0,0 +1,50 @@
+import { useEffect, useRef } from 'react'
+import { AppState } from 'react-native'
+
+/**
+ * useRefetchOnFocus — React Native implementation.
+ *
+ * Web listens for document 'visibilitychange'; React Native has no document, so
+ * this watches AppState for the app returning to the foreground ('active'). The
+ * pathname-change behaviour and 2s debounce are identical to the web version.
+ * Metro resolves this file over useRefetchOnFocus.ts on native builds.
+ */
+export function useRefetchOnFocus(
+  refetch: () => void,
+  pathname: string,
+  enabled = true
+): void {
+  const mounted = useRef(false)
+  const lastRefetch = useRef(0)
+
+  useEffect(() => {
+    if (!enabled) return
+
+    if (!mounted.current) {
+      mounted.current = true
+      return
+    }
+
+    const now = Date.now()
+    if (now - lastRefetch.current < 2000) return
+
+    lastRefetch.current = now
+    refetch()
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [pathname, enabled])
+
+  useEffect(() => {
+    if (!enabled) return
+
+    const subscription = AppState.addEventListener('change', (state) => {
+      if (state === 'active' && mounted.current) {
+        const now = Date.now()
+        if (now - lastRefetch.current < 2000) return
+        lastRefetch.current = now
+        refetch()
+      }
+    })
+
+    return () => subscription.remove()
+  }, [refetch, enabled])
+}

package/src/useVault.ts

@@ -0,0 +1,142 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import type {
+  VaultAccessKeyInput,
+  VaultApi,
+  VaultEnvironmentInput,
+  VaultListParams,
+  VaultSecretInput,
+} from '@startsimpli/api'
+
+/** TanStack Query hooks over VaultApi (startsim-d30.3.2).
+ *
+ * Each hook takes the VaultApi instance (e.g. `api.vault`), matching the
+ * useMessages convention. Secrets are revealed on demand (a mutation), never
+ * auto-fetched, so values are only pulled when the user asks.
+ */
+
+const ENVIRONMENTS_KEY = ['vault', 'environments'] as const
+const environmentKey = (slug: string) => ['vault', 'environment', slug]
+const secretsKey = (slug: string) => ['vault', 'secrets', slug]
+const accessKeysKey = (slug: string) => ['vault', 'access-keys', slug]
+
+/** Secret mutations alter the env's `secret_count`, so refresh the list +
+ * detail too — otherwise the /environments page shows a stale count
+ * (startsim-drl). */
+function invalidateSecretQueries(qc: ReturnType<typeof useQueryClient>, slug: string) {
+  qc.invalidateQueries({ queryKey: secretsKey(slug) })
+  qc.invalidateQueries({ queryKey: ENVIRONMENTS_KEY })
+  qc.invalidateQueries({ queryKey: environmentKey(slug) })
+}
+
+// --- Environments ---
+export function useEnvironments(api: VaultApi, params?: VaultListParams) {
+  return useQuery({
+    queryKey: ['vault', 'environments', params],
+    queryFn: () => api.listEnvironments(params),
+  })
+}
+
+export function useEnvironment(api: VaultApi, slug: string) {
+  return useQuery({
+    queryKey: ['vault', 'environment', slug],
+    queryFn: () => api.getEnvironment(slug),
+    enabled: !!slug,
+  })
+}
+
+export function useCreateEnvironment(api: VaultApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (data: VaultEnvironmentInput) => api.createEnvironment(data),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ENVIRONMENTS_KEY }),
+  })
+}
+
+export function useUpdateEnvironment(api: VaultApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: ({ slug, data }: { slug: string; data: Partial<VaultEnvironmentInput> }) =>
+      api.updateEnvironment(slug, data),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ENVIRONMENTS_KEY }),
+  })
+}
+
+export function useDeleteEnvironment(api: VaultApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (slug: string) => api.deleteEnvironment(slug),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ENVIRONMENTS_KEY }),
+  })
+}
+
+// --- Secrets ---
+export function useSecrets(api: VaultApi, slug: string, params?: VaultListParams) {
+  return useQuery({
+    queryKey: ['vault', 'secrets', slug, params],
+    queryFn: () => api.listSecrets(slug, params),
+    enabled: !!slug,
+  })
+}
+
+export function useCreateSecret(api: VaultApi, slug: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (data: VaultSecretInput) => api.createSecret(slug, data),
+    onSuccess: () => invalidateSecretQueries(qc, slug),
+  })
+}
+
+export function useUpdateSecret(api: VaultApi, slug: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: Partial<VaultSecretInput> }) =>
+      api.updateSecret(slug, id, data),
+    onSuccess: () => invalidateSecretQueries(qc, slug),
+  })
+}
+
+export function useDeleteSecret(api: VaultApi, slug: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api.deleteSecret(slug, id),
+    onSuccess: () => invalidateSecretQueries(qc, slug),
+  })
+}
+
+export function useRevealSecret(api: VaultApi, slug: string) {
+  return useMutation({ mutationFn: (id: string) => api.revealSecret(slug, id) })
+}
+
+// --- Access keys ---
+export function useAccessKeys(api: VaultApi, slug: string, params?: VaultListParams) {
+  return useQuery({
+    queryKey: ['vault', 'access-keys', slug, params],
+    queryFn: () => api.listAccessKeys(slug, params),
+    enabled: !!slug,
+  })
+}
+
+export function useCreateAccessKey(api: VaultApi, slug: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (data: VaultAccessKeyInput) => api.createAccessKey(slug, data),
+    onSuccess: () => qc.invalidateQueries({ queryKey: accessKeysKey(slug) }),
+  })
+}
+
+export function useDeleteAccessKey(api: VaultApi, slug: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api.deleteAccessKey(slug, id),
+    onSuccess: () => qc.invalidateQueries({ queryKey: accessKeysKey(slug) }),
+  })
+}
+
+// --- Audit ---
+export function useAuditLog(api: VaultApi, slug: string, params?: VaultListParams) {
+  return useQuery({
+    queryKey: ['vault', 'audit', slug, params],
+    queryFn: () => api.listAudit(slug, params),
+    enabled: !!slug,
+  })
+}

package/src/useWorkflows.ts

@@ -0,0 +1,122 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import type {
+  WorkflowsApi,
+  WorkflowInput,
+  WorkflowListParams,
+  ExecutionListParams,
+  RunStatus,
+} from '@startsimpli/api'
+
+/** TanStack Query hooks over WorkflowsApi (epic startsim-xsh.12).
+ *
+ * Each hook takes the WorkflowsApi instance (e.g. `api.workflows`), matching
+ * the usePresentations / useVault convention. Executions are async on the
+ * backend, so the execution detail query self-polls while a run is in flight
+ * and stops on a terminal status.
+ */
+
+const WORKFLOWS_KEY = ['workflows', 'list'] as const
+const workflowKey = (id: string) => ['workflows', 'detail', id]
+const executionKey = (executionId: string) => ['workflows', 'execution', executionId]
+const executionsKey = (workflowId: string) => ['workflows', 'executions', workflowId]
+
+const POLL_MS = 1000
+
+/** Refetch interval for the execution detail query: poll while a run is live. */
+export function executionRefetchInterval(status: RunStatus | undefined): number | false {
+  return status === 'running' || status === 'pending' || status === 'waiting' ? POLL_MS : false
+}
+
+// --- Workflows ---
+export function useWorkflows(api: WorkflowsApi, params?: WorkflowListParams) {
+  return useQuery({
+    queryKey: ['workflows', 'list', params],
+    queryFn: () => api.listWorkflows(params),
+  })
+}
+
+export function useWorkflow(api: WorkflowsApi, id: string) {
+  return useQuery({
+    queryKey: workflowKey(id),
+    queryFn: () => api.getWorkflow(id),
+    enabled: !!id,
+  })
+}
+
+export function useWorkflowNodeTypes(api: WorkflowsApi) {
+  return useQuery({
+    queryKey: ['workflows', 'node-types'],
+    queryFn: () => api.getNodeTypes(),
+  })
+}
+
+export function useCreateWorkflow(api: WorkflowsApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (data: WorkflowInput) => api.createWorkflow(data),
+    onSuccess: () => qc.invalidateQueries({ queryKey: WORKFLOWS_KEY }),
+  })
+}
+
+export function useUpdateWorkflow(api: WorkflowsApi, id: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (data: Partial<WorkflowInput>) => api.updateWorkflow(id, data),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: workflowKey(id) })
+      qc.invalidateQueries({ queryKey: WORKFLOWS_KEY })
+    },
+  })
+}
+
+export function useDeleteWorkflow(api: WorkflowsApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api.deleteWorkflow(id),
+    onSuccess: () => qc.invalidateQueries({ queryKey: WORKFLOWS_KEY }),
+  })
+}
+
+// --- Execution ---
+/** Kick off a run; the mutation result surfaces the executionId. */
+export function useExecuteWorkflow(api: WorkflowsApi, id: string) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (contextData?: Record<string, unknown>) => api.executeWorkflow(id, contextData),
+    onSuccess: () => qc.invalidateQueries({ queryKey: executionsKey(id) }),
+  })
+}
+
+/** Self-polling execution detail; stops when the run reaches a terminal state. */
+export function useWorkflowExecution(api: WorkflowsApi, executionId: string, enabled = true) {
+  return useQuery({
+    queryKey: executionKey(executionId),
+    queryFn: () => api.getExecution(executionId),
+    enabled: enabled && !!executionId,
+    refetchInterval: (query) => executionRefetchInterval(query.state.data?.status),
+  })
+}
+
+export function useWorkflowExecutions(api: WorkflowsApi, workflowId: string, params?: ExecutionListParams) {
+  return useQuery({
+    queryKey: ['workflows', 'executions', workflowId, params],
+    queryFn: () => api.listExecutions(workflowId, params),
+    enabled: !!workflowId,
+  })
+}
+
+export function useCancelExecution(api: WorkflowsApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (executionId: string) => api.cancelExecution(executionId),
+    onSuccess: (_data, executionId) => qc.invalidateQueries({ queryKey: executionKey(executionId) }),
+  })
+}
+
+export function useRetryExecution(api: WorkflowsApi) {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (executionId: string) => api.retryExecution(executionId),
+    onSuccess: (_data, executionId) => qc.invalidateQueries({ queryKey: executionKey(executionId) }),
+  })
+}