devpush 0.0.0-stage → 1.0.0-beta.4

package/src/lib/backup-database.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod'
+import { backupResourceNameSchema } from './backup-resource-schema'
+
+export const backupDatabaseEngines = [
+  {
+    value: 'postgres',
+    label: 'PostgreSQL',
+  },
+  {
+    value: 'mysql',
+    label: 'MySQL',
+  },
+  {
+    value: 'mariadb',
+    label: 'MariaDB',
+  },
+  {
+    value: 'mongo',
+    label: 'MongoDB',
+  },
+] as const
+const engineSchema = z.enum(backupDatabaseEngines.map((engine) => engine.value))
+export const backupDatabaseSchema = z.object({
+  service: backupResourceNameSchema,
+  engine: engineSchema,
+  database: z.string().trim().max(128).default(''),
+})
+export type BackupDatabase = z.infer<typeof backupDatabaseSchema>
+function databaseBackupFilename(index: number, target: BackupDatabase) {
+  return `${String(index + 1).padStart(2, '0')}-${target.service}.${target.engine === 'mongo' ? 'archive' : 'sql'}.gz`
+}
+
+export function databaseArtifactTarget(
+  objectKey: string,
+  targets: BackupDatabase[],
+) {
+  const filename = objectKey.split('/').at(-1)
+  return targets.find(
+    (target, index) => filename === databaseBackupFilename(index, target),
+  )
+}

package/src/lib/backup-feature.ts

@@ -0,0 +1,2 @@
+export const backupsEnabled =
+  import.meta.env.VITE_DEVPUSH_BACKUPS_ENABLED === 'true'

package/src/lib/backup-paths.ts

@@ -0,0 +1,7 @@
+export function getDefaultBackupPrefix(
+  projectId: string,
+  environmentId: string,
+  backupId: string,
+) {
+  return `projects/${projectId}/environments/${environmentId}/backups/${backupId}`
+}

package/src/lib/backup-policy-schema.ts

@@ -0,0 +1,85 @@
+import { backupDatabaseSchema } from './backup-database'
+import { backupStorageReferenceSchema } from './backup-storage-schema'
+import { z } from 'zod'
+import { backupResourceNameSchema } from './backup-resource-schema'
+import { isValidCron } from '#devpush/lib/backup-cron'
+
+export const backupScheduleSchema = z.object({
+  cron: z
+    .string()
+    .trim()
+    .refine(isValidCron, 'Enter a valid five-field cron expression.'),
+})
+
+export const backupVolumesSchema = z.object({
+  mode: z.enum(['none', 'allNamed', 'selected']),
+  names: z.array(backupResourceNameSchema),
+})
+
+export const backupRetentionSchema = z.object({
+  local: z.object({
+    count: z
+      .number()
+      .int('Enter a whole number.')
+      .min(0, 'Enter zero or a positive number.')
+      .max(10_000, 'Keep no more than 10,000 backups.'),
+    days: z
+      .number()
+      .int('Enter a whole number.')
+      .min(0, 'Enter zero or a positive number.')
+      .max(3650, 'Retention must be 3,650 days or fewer.'),
+    maxStorageGb: z
+      .number()
+      .min(0, 'Enter zero or a positive number.')
+      .max(100_000, 'Storage must be 100,000 GB or less.'),
+  }),
+  remote: z.object({
+    enabled: z.boolean(),
+    count: z
+      .number()
+      .int('Enter a whole number.')
+      .min(0, 'Enter zero or a positive number.')
+      .max(10_000, 'Keep no more than 10,000 backups.'),
+    days: z
+      .number()
+      .int('Enter a whole number.')
+      .min(0, 'Enter zero or a positive number.')
+      .max(3650, 'Retention must be 3,650 days or fewer.'),
+    maxStorageGb: z
+      .number()
+      .min(0, 'Enter zero or a positive number.')
+      .max(100_000, 'Storage must be 100,000 GB or less.'),
+  }),
+})
+
+export const backupConfigSchema = z.object({
+  id: z.string().trim().optional(),
+  name: z
+    .string()
+    .trim()
+    .min(1, 'Enter a backup policy name.')
+    .max(100, 'Backup policy names must be 100 characters or fewer.'),
+  environmentId: z.string().trim().min(1),
+  enabled: z.boolean(),
+  schedule: backupScheduleSchema,
+  destination: backupStorageReferenceSchema,
+  retention: backupRetentionSchema,
+  volumes: backupVolumesSchema,
+  databaseDumps: z.array(backupDatabaseSchema),
+})
+
+export type BackupPolicyInput = z.infer<typeof backupConfigSchema>
+
+export function normalizeBackupVolumes(
+  value: unknown,
+): z.infer<typeof backupVolumesSchema> {
+  const parsed = backupVolumesSchema.safeParse(value)
+  if (
+    !parsed.success ||
+    parsed.data.mode === 'allNamed' ||
+    (parsed.data.mode === 'selected' && parsed.data.names.length === 0)
+  ) {
+    return { mode: 'allNamed', names: [] }
+  }
+  return parsed.data.mode === 'none' ? { mode: 'none', names: [] } : parsed.data
+}

package/src/lib/backup-resource-schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+
+// Docker/Compose names must not be interpreted as command-line options.
+export const backupResourceNameSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(128)
+  .regex(
+    /^[A-Za-z0-9][A-Za-z0-9_.-]*$/,
+    'Select a valid Compose service or named volume.',
+  )

package/src/lib/backup-restore-schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod'
+import { backupResourceNameSchema } from './backup-resource-schema'
+
+export const backupRestoreArtifactSchema = z.discriminatedUnion('type', [
+  z.object({
+    artifactId: z.string().min(1),
+    type: z.literal('volume'),
+    targetVolume: backupResourceNameSchema,
+  }),
+  z.object({
+    artifactId: z.string().min(1),
+    type: z.literal('database'),
+    targetService: backupResourceNameSchema,
+  }),
+])

package/src/lib/backup-storage-schema.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+const singleLine = z
+  .string()
+  .trim()
+  .refine((value) => !/[\r\n\0]/.test(value), 'Enter a single-line value.')
+export const backupStorageSchema = z.object({
+  id: z.string().min(1).optional(),
+  name: z.string().trim().min(1, 'Enter a storage name.').max(100),
+  bucket: z
+    .string()
+    .trim()
+    .min(3)
+    .max(63)
+    .regex(
+      /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/,
+      'Enter a DNS-compatible bucket name.',
+    ),
+  region: singleLine.min(1).max(100),
+  endpoint: z.union([
+    z.literal(''),
+    z
+      .string()
+      .trim()
+      .url()
+      .refine(
+        (value) => ['http:', 'https:'].includes(new URL(value).protocol),
+        'Use an HTTP or HTTPS endpoint.',
+      ),
+  ]),
+  accessKeyId: singleLine.min(1, 'Enter an access key ID.').max(256),
+  secretAccessKey: singleLine.max(1024),
+})
+export type BackupStorageInput = z.infer<typeof backupStorageSchema>
+export type BackupStorageSummary = {
+  settingsVersion: number
+  id: string
+  name: string
+  bucket: string
+  region: string
+  endpoint: string | null
+  accessKeyId?: string
+  hasSecret: boolean
+}
+export type BackupStorageReference = { storageId?: string; prefix?: string }
+export const backupStorageReferenceSchema = z.object({
+  storageId: z.string().trim().min(1).optional(),
+  prefix: singleLine
+    .max(512)
+    .refine(
+      (value) => !value.split('/').includes('..'),
+      'Object prefixes cannot contain .. segments.',
+    )
+    .optional(),
+})

package/src/lib/deferred-module.ts

@@ -0,0 +1,38 @@
+import { useEffect, useSyncExternalStore } from 'react'
+
+export type DeferredModule<T> = ReturnType<typeof createDeferredModule<T>>
+
+// Pending views can reuse an already-loaded page without pulling that page into
+// every route. A skeleton remains available while its module loads.
+export function createDeferredModule<T>(importModule: () => Promise<T>) {
+  let value: T | undefined
+  let pending: Promise<void> | undefined
+  const listeners = new Set<() => void>()
+  const load = () => {
+    if (value !== undefined) return Promise.resolve()
+    return (pending ??= importModule().then(
+      (result) => {
+        value = result
+        for (const listener of listeners) listener()
+      },
+      () => {
+        pending = undefined
+      },
+    ))
+  }
+  function useModule(enabled: boolean) {
+    const module = useSyncExternalStore(
+      (listener) => {
+        listeners.add(listener)
+        return () => listeners.delete(listener)
+      },
+      () => value,
+      () => undefined,
+    )
+    useEffect(() => {
+      if (enabled) void load()
+    }, [enabled])
+    return module
+  }
+  return { load, useModule }
+}

package/src/lib/deployment-logs-query.ts

@@ -0,0 +1,63 @@
+import { workspacePollInterval } from './workspace-updates'
+import type { QueryClient } from '@tanstack/react-query'
+import { queryOptions } from '@tanstack/react-query'
+import { isRedirect, redirect } from '@tanstack/react-router'
+
+import { getDeploymentLogs } from '#devpush/server/projects/functions'
+
+export function deploymentLogsQueryOptions({
+  completed,
+  deploymentId,
+  projectName,
+  teamSlug,
+  queryClient,
+}: {
+  completed: boolean
+  deploymentId: string
+  projectName: string
+  teamSlug: string
+  queryClient?: QueryClient
+}) {
+  const runningLogs = completed
+    ? queryClient?.getQueryData<Awaited<ReturnType<typeof getDeploymentLogs>>>([
+        'deployment-logs',
+        teamSlug,
+        projectName,
+        deploymentId,
+        false,
+      ])
+    : undefined
+  return queryOptions({
+    // These reads tolerate a brief network interruption. Most application
+    // queries disable retries, but one failed poll must not raise a log alert.
+    retry: (failures, error) => failures < 2 && !isRedirect(error),
+    retryDelay: (attempt) => Math.min(1_000 * 2 ** attempt, 4_000),
+    // Preserve this deployment's output while fetching its final snapshot.
+    initialData: runningLogs ?? undefined,
+    initialDataUpdatedAt: runningLogs ? 0 : undefined,
+    refetchOnWindowFocus: !completed,
+    refetchOnReconnect: !completed,
+    // Completion gets a fresh snapshot even if the last running poll just finished.
+    queryKey: [
+      'deployment-logs',
+      teamSlug,
+      projectName,
+      deploymentId,
+      completed,
+    ],
+    refetchIntervalInBackground: false,
+    refetchInterval: () =>
+      completed ? false : workspacePollInterval(teamSlug, 2_000),
+    queryFn: async () => {
+      const logs = await getDeploymentLogs({
+        data: { deploymentId, projectName, teamSlug },
+      })
+
+      if (!logs) {
+        throw redirect({ to: '/auth/login' })
+      }
+
+      return logs
+    },
+  })
+}

package/src/lib/display-name.ts

@@ -0,0 +1,7 @@
+export function displayNameFromSlug(slug: string) {
+  return slug
+    .split(/[-_]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ')
+}

package/src/lib/error-message.ts

@@ -0,0 +1,119 @@
+export function getErrorMessage(error: unknown, fallback: string) {
+  const message = getMessage(error)
+  if (!message) return fallback
+  return presentMessage(
+    error,
+    getValidationErrorMessage(message) ?? message,
+    fallback,
+  )
+}
+
+export function getFieldErrorMessage({
+  error,
+  fallback,
+  field,
+}: {
+  error: unknown
+  fallback: string
+  field: string
+}) {
+  const message = getMessage(error)
+  if (!message) return fallback
+
+  const validationIssue = getValidationIssues(message).find((issue) => {
+    const path = issue.path ?? []
+    return path.at(-1) === field || path.join('.') === field
+  })
+
+  return presentMessage(
+    error,
+    validationIssue?.message ?? getValidationErrorMessage(message) ?? message,
+    fallback,
+  )
+}
+
+function presentMessage(error: unknown, message: string, fallback: string) {
+  const status = getStatus(error)
+  if (status !== undefined && status >= 500) return fallback
+  if (status === 429)
+    return 'Too many attempts. Please wait a moment and try again.'
+  if (
+    /^(failed to fetch|fetch failed|load failed|networkerror\b|network request failed)/i.test(
+      message,
+    )
+  ) {
+    return 'Unable to connect. Check your connection and try again.'
+  }
+  // Framework, database, and provider diagnostics belong in logs. Callers
+  // supply the action-specific explanation; keep business validation intact.
+  if (
+    /^(HTTPError|Error|Unknown error|Internal server error|Internal error|Something went wrong|Bad gateway|Service unavailable|Gateway timeout)[.!]?$/i.test(
+      message,
+    ) ||
+    /^(Failed query:|D1_|SQLITE_|LibsqlError|Resend failed to send email:|TypeError:|ReferenceError:|SyntaxError:|Cannot read properties of|Unexpected token|Unexpected end of JSON|<!doctype|<html)/i.test(
+      message,
+    ) ||
+    /\n\s+at\s/.test(message)
+  )
+    return fallback
+  return message
+}
+
+function getStatus(error: unknown) {
+  if (!error || typeof error !== 'object') return undefined
+  if ('status' in error && typeof error.status === 'number') return error.status
+  if ('statusCode' in error && typeof error.statusCode === 'number')
+    return error.statusCode
+  return undefined
+}
+
+function getMessage(error: unknown) {
+  if (error instanceof Error) return error.message.trim()
+  if (typeof error === 'string') return error.trim()
+  if (
+    error &&
+    typeof error === 'object' &&
+    'message' in error &&
+    typeof error.message === 'string'
+  ) {
+    return error.message.trim()
+  }
+
+  return ''
+}
+
+function getValidationErrorMessage(message: string) {
+  const issue = getValidationIssues(message).find((item) => item.message)
+  return issue?.message ?? null
+}
+
+function getValidationIssues(message: string): Array<{
+  message?: string
+  path?: Array<string | number>
+}> {
+  try {
+    const issues = JSON.parse(message) as unknown
+    if (!Array.isArray(issues)) return []
+
+    return issues.filter(
+      (
+        item,
+      ): item is {
+        message?: string
+        path?: Array<string | number>
+      } => {
+        if (!item || typeof item !== 'object') return false
+        if ('message' in item && typeof item.message !== 'string') return false
+        if (!('path' in item)) return true
+        if (!Array.isArray(item.path)) return false
+
+        const path: Array<unknown> = item.path
+        return path.every(
+          (part) => typeof part === 'string' || typeof part === 'number',
+        )
+      },
+    )
+  } catch {
+    return []
+  }
+}

package/src/lib/form-errors.ts

@@ -0,0 +1,10 @@
+export type FormErrors = Record<string, string | undefined>
+
+export function formErrors(
+  issues: Array<{ path: PropertyKey[]; message: string }>,
+): FormErrors {
+  const errors: FormErrors = {}
+  for (const issue of issues)
+    errors[issue.path.map(String).join('.') || 'form'] ??= issue.message
+  return errors
+}

package/src/lib/internal-redirect.ts

@@ -0,0 +1,25 @@
+const internalOrigin = 'https://devpush.invalid'
+
+export function getSafeRedirectPath(value: string | null) {
+  if (!value || !value.startsWith('/')) {
+    return '/'
+  }
+
+  try {
+    const target = new URL(value, internalOrigin)
+    if (target.origin !== internalOrigin) {
+      return '/'
+    }
+
+    const path = `${target.pathname}${target.search}${target.hash}`
+
+    // Path normalization can produce a protocol-relative string such as `//host`.
+    if (new URL(path, internalOrigin).origin !== internalOrigin) {
+      return '/'
+    }
+
+    return path
+  } catch {
+    return '/'
+  }
+}

package/src/lib/manual-deploy-options-query.ts

@@ -0,0 +1,21 @@
+import { queryOptions } from '@tanstack/react-query'
+import { getProjectDeployOptions } from '#devpush/server/projects/functions'
+
+export function manualDeployOptionsQueryOptions(params: {
+  teamSlug: string
+  projectName: string
+  branch?: string
+  environmentId: string
+}) {
+  return queryOptions({
+    queryKey: [
+      'manual-deploy-options',
+      params.teamSlug,
+      params.projectName,
+      params.environmentId,
+      params.branch ?? null,
+    ],
+    staleTime: 30_000,
+    queryFn: ({ signal }) => getProjectDeployOptions({ data: params, signal }),
+  })
+}

package/src/lib/notification-preferences.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod'
+
+export const notificationCategories = [
+  {
+    id: 'deployments',
+    label: 'Deployment alerts',
+    description: 'Failed deployments and recovery after a failure.',
+  },
+  {
+    id: 'backups',
+    label: 'Backup and restore alerts',
+    description:
+      'Failed backups or restores, and recovery after a backup failure.',
+  },
+  {
+    id: 'domains',
+    label: 'Domain alerts',
+    description: 'Domain verification failures and recovery.',
+  },
+  {
+    id: 'servers',
+    label: 'Server alerts',
+    description: 'Disconnected servers, low disk space and recovery.',
+  },
+] as const
+export type NotificationCategory = (typeof notificationCategories)[number]['id']
+export const notificationPreferencesSchema = z.object({
+  deployments: z.boolean(),
+  backups: z.boolean(),
+  domains: z.boolean(),
+  servers: z.boolean(),
+})
+export const defaultNotificationPreferences = {
+  deployments: true,
+  backups: true,
+  domains: true,
+  servers: true,
+}
+export const notificationScopeSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('workspace'), id: z.string().min(1) }),
+  z.object({ kind: z.literal('project'), id: z.string().min(1) }),
+])
+export type NotificationScope = z.infer<typeof notificationScopeSchema>

package/src/lib/onboarding.ts

@@ -0,0 +1,11 @@
+import { getSafeRedirectPath } from './internal-redirect'
+
+export function onboardingDestination(
+  path: string | undefined,
+  teamSlug: string,
+) {
+  const destination = getSafeRedirectPath(path ?? '/')
+  return destination === '/' || destination.startsWith('/onboarding')
+    ? `/${encodeURIComponent(teamSlug)}`
+    : destination
+}

package/src/lib/operation-logs-query.ts

@@ -0,0 +1,51 @@
+import { queryOptions } from '@tanstack/react-query'
+import type { QueryClient } from '@tanstack/react-query'
+
+type OperationLogs = { content: string; nextOffset: number }
+export function operationLogsQueryOptions(
+  params: { teamSlug: string; type: 'backup' | 'restore'; id: string },
+  queryClient: QueryClient,
+) {
+  const queryKey = ['operation-logs', params.teamSlug, params.type, params.id]
+  return queryOptions({
+    queryKey,
+    retry: false,
+    staleTime: 5_000,
+    gcTime: 60_000,
+    refetchInterval: 5_000,
+    refetchIntervalInBackground: false,
+    refetchOnWindowFocus: true,
+    queryFn: async ({ signal }): Promise<OperationLogs> => {
+      let cached = queryClient.getQueryData<OperationLogs>(queryKey)
+      let offset = cached?.nextOffset ?? 0
+      const search = new URLSearchParams({
+        type: params.type,
+        id: params.id,
+        offset: String(offset),
+      })
+      let response = await fetch(`/api/agents/job-logs?${search}`, { signal })
+      if (response.status === 409 && cached) {
+        // Retention may remove chunks beyond an old cursor. Restart from the
+        // retained output, keeping the old display until that read succeeds.
+        cached = undefined
+        offset = 0
+        search.set('offset', '0')
+        response = await fetch(`/api/agents/job-logs?${search}`, { signal })
+      }
+      if (!response.ok) throw new Error('Unable to load logs. Try again.')
+      const result = (await response.json()) as OperationLogs
+      if (
+        typeof result.content !== 'string' ||
+        !Number.isSafeInteger(result.nextOffset) ||
+        result.nextOffset < offset ||
+        result.nextOffset <
+          offset + new TextEncoder().encode(result.content).length
+      )
+        throw new Error('Invalid operation log response. Try again.')
+      return {
+        content: (cached?.content ?? '') + result.content,
+        nextOffset: result.nextOffset,
+      }
+    },
+  })
+}

package/src/lib/page-head.ts

@@ -0,0 +1,14 @@
+/** Keep browser and social titles consistent across route heads. */
+export function pageHead(...parts: Array<string | undefined>) {
+  const context = parts.filter((part) => part?.trim()).join(' – ')
+  const title = context ? `${context} | devpush` : 'devpush'
+
+  return {
+    meta: [
+      { title },
+      { name: 'title', content: title },
+      { property: 'og:title', content: title },
+      { name: 'twitter:title', content: title },
+    ],
+  }
+}