devpush 0.0.0-stage → 1.0.0-beta.4

package/src/lib/project-context-query.ts

@@ -0,0 +1,257 @@
+import { workspacePollInterval } from './workspace-updates'
+import { invalidateResourceQueries } from './resource-cache'
+import { queryOptions } from '@tanstack/react-query'
+import { redirect } from '@tanstack/react-router'
+import type { QueryClient } from '@tanstack/react-query'
+
+import {
+  getDeployment,
+  getProject,
+  getProjectLogs,
+  getProjectSection,
+} from '#devpush/server/projects/functions'
+import type {
+  PluginContext,
+  ProjectContext,
+  ProjectLogsContext,
+  ProjectSectionContext,
+} from '#devpush/server/projects/types'
+
+export type ProjectContextKeyParams = {
+  projectName: string
+  teamSlug: string
+}
+
+export type ProjectContextParams = ProjectContextKeyParams & {
+  scope: ProjectSectionContext['scope']
+}
+
+function projectContextQueryKey({
+  projectName,
+  scope,
+  teamSlug,
+}: ProjectContextParams) {
+  return ['project-context', teamSlug, projectName, scope] as const
+}
+
+export function projectContextQueryOptions(
+  params: ProjectContextParams,
+  queryClient: QueryClient,
+) {
+  return queryOptions({
+    queryKey: projectContextQueryKey(params),
+    refetchIntervalInBackground: false,
+    refetchOnWindowFocus: ['overview', 'deployments', 'backups'].includes(
+      params.scope,
+    ),
+    refetchInterval: (query) => {
+      if (!['overview', 'deployments', 'backups'].includes(params.scope))
+        return false
+      if (
+        query.state.data?.deployments.some((deployment) =>
+          ['queued', 'running'].includes(deployment.status),
+        ) ||
+        (params.scope === 'backups' &&
+          (query.state.data?.backupRuns.some((run) =>
+            ['queued', 'running'].includes(run.status),
+          ) ||
+            query.state.data?.backupRestores.some((restore) =>
+              ['queued', 'running'].includes(restore.status),
+            )))
+      )
+        return workspacePollInterval(params.teamSlug, 2_000)
+      return workspacePollInterval(params.teamSlug, 15_000)
+    },
+    queryFn: async () => {
+      const [shell, section] = await loadProjectSection(
+        queryClient,
+        params,
+        () => getProjectSection({ data: params }),
+      )
+
+      return mergeProjectSection(shell, section)
+    },
+  })
+}
+
+export function projectShellQueryOptions(params: ProjectContextKeyParams) {
+  return queryOptions({
+    queryKey: ['project-context', params.teamSlug, params.projectName, 'shell'],
+    queryFn: () => fetchProjectContext(params),
+  })
+}
+
+export function pluginContextQueryOptions(
+  params: ProjectContextKeyParams & { deploymentId: string },
+  queryClient: QueryClient,
+) {
+  return queryOptions({
+    refetchIntervalInBackground: false,
+    refetchOnWindowFocus: true,
+    refetchInterval: (query) =>
+      ['queued', 'running'].includes(query.state.data?.deployment.status ?? '')
+        ? workspacePollInterval(params.teamSlug, 2_000)
+        : workspacePollInterval(params.teamSlug, 15_000),
+    queryKey: [
+      'deployment-context',
+      params.teamSlug,
+      params.projectName,
+      params.deploymentId,
+    ],
+    queryFn: async (): Promise<PluginContext> => {
+      const [shell, section] = await loadProjectSection(
+        queryClient,
+        params,
+        () => getDeployment({ data: params }),
+      )
+
+      return {
+        userContext: shell.userContext,
+        team: shell.team,
+        project: shell.project,
+        teamProjects: shell.teamProjects,
+        latestDeployments: section.latestDeployments,
+        environment: shell.environment,
+        environments: shell.environments,
+        servers: shell.servers,
+        deployment: section.deployment,
+        visitAliases: section.visitAliases,
+        logs: [],
+      }
+    },
+  })
+}
+
+export type ProjectLogsQueryParams = ProjectContextKeyParams & {
+  branch?: string | null
+  date?: string | null
+  deploymentId?: string | null
+  environmentId?: string | null
+  keyword?: string | null
+}
+
+export function projectLogsQueryOptions(
+  params: ProjectLogsQueryParams,
+  queryClient: QueryClient,
+) {
+  return queryOptions({
+    refetchIntervalInBackground: false,
+    refetchInterval: () => workspacePollInterval(params.teamSlug, 2_000),
+    queryKey: [
+      'project-logs',
+      params.teamSlug,
+      params.projectName,
+      params.branch ?? null,
+      params.date ?? null,
+      params.deploymentId ?? null,
+      params.environmentId ?? null,
+      params.keyword ?? null,
+    ],
+    queryFn: async (): Promise<ProjectLogsContext> => {
+      const [shell, section] = await loadProjectSection(
+        queryClient,
+        params,
+        () => getProjectLogs({ data: params }),
+      )
+
+      return { ...shell, ...section }
+    },
+  })
+}
+
+export function invalidateProjectLogs(
+  queryClient: QueryClient,
+  params: ProjectLogsQueryParams,
+) {
+  return queryClient.invalidateQueries({
+    queryKey: [
+      'project-logs',
+      params.teamSlug,
+      params.projectName,
+      params.branch ?? null,
+      params.date ?? null,
+      params.deploymentId ?? null,
+      params.environmentId ?? null,
+      params.keyword ?? null,
+    ],
+  })
+}
+
+export async function setProjectContextQueryData(
+  queryClient: QueryClient,
+  context: ProjectContext,
+  scope: ProjectSectionContext['scope'],
+) {
+  await invalidateResourceQueries(queryClient, context.team.slug)
+  const prefix = ['project-context', context.team.slug, context.project.name]
+
+  queryClient.setQueryData([...prefix, 'shell'], context)
+  queryClient.setQueryData([...prefix, scope], context)
+}
+
+export function invalidateProjectContext(
+  queryClient: QueryClient,
+  params: ProjectContextKeyParams,
+) {
+  return queryClient.invalidateQueries({
+    queryKey: ['project-context', params.teamSlug, params.projectName],
+  })
+}
+
+async function fetchProjectContext(
+  params: ProjectContextKeyParams,
+): Promise<ProjectContext> {
+  const context = await getProject({ data: params })
+
+  if (!context) {
+    throw redirect({ to: '/auth/login' })
+  }
+
+  return context
+}
+
+async function loadProjectSection<T extends { projectId: string }>(
+  queryClient: QueryClient,
+  params: ProjectContextKeyParams,
+  loadSection: () => Promise<T | null>,
+): Promise<[ProjectContext, T]> {
+  const [shell, section] = await Promise.all([
+    queryClient.fetchQuery(projectShellQueryOptions(params)),
+    loadSection(),
+  ])
+
+  if (!section) throw redirect({ to: '/auth/login' })
+  if (section.projectId !== shell.project.id) {
+    throw new Error('Project context changed while loading.')
+  }
+
+  return [shell, section]
+}
+
+function mergeProjectSection(
+  shell: ProjectContext,
+  section: ProjectSectionContext,
+): ProjectContext {
+  if (section.scope === 'overview') {
+    return {
+      ...shell,
+      deployments: section.deployments,
+      environment: { ...shell.environment, runtime: section.runtime },
+    }
+  }
+
+  if (section.scope === 'deployments') {
+    return { ...shell, deployments: section.deployments }
+  }
+
+  if (section.scope === 'settings') return section.context
+
+  return {
+    ...shell,
+    backupStorage: section.backupStorage,
+    backupConfigs: section.backupConfigs,
+    backupRuns: section.backupRuns,
+    backupRestores: section.backupRestores,
+    composeMetadata: section.composeMetadata,
+  }
+}

package/src/lib/project-creation-schema.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod'
+import { projectMachineNameSchema } from './project-settings-schema'
+import {
+  maxLifecycleCommandLength,
+  repositoryComposePathSchema,
+} from '#devpush/lib/project-runtime-config'
+
+export const envVarSchema = z.object({
+  key: z
+    .string()
+    .trim()
+    .min(1, 'Enter a variable key.')
+    .regex(
+      /^[A-Za-z_][A-Za-z0-9_]*$/,
+      'Environment variable keys must use shell-compatible names.',
+    ),
+  value: z.string(),
+  environment: z.string().trim().optional(),
+})
+
+export const createProjectSchema = z.object({
+  teamSlug: z.string().min(1),
+  installationId: z.number().int().positive(),
+  serverId: z.string().trim().optional().nullable(),
+  composePath: repositoryComposePathSchema.or(z.literal('')).optional(),
+  readinessPath: z
+    .string()
+    .trim()
+    .refine((value) => !value || value.startsWith('/'), {
+      message: 'Health check paths must start with /.',
+    })
+    .optional(),
+  releaseCommand: z
+    .string()
+    .trim()
+    .max(
+      maxLifecycleCommandLength,
+      'Commands must be 16,384 characters or fewer.',
+    )
+    .optional(),
+  releaseService: z.string().trim().optional(),
+  envVars: z
+    .array(envVarSchema)
+    .superRefine((rows, ctx) => {
+      const keys = new Set<string>()
+      rows.forEach((row, index) => {
+        const key = JSON.stringify([row.environment || 'production', row.key])
+        if (keys.has(key))
+          ctx.addIssue({
+            code: 'custom',
+            path: [index, 'key'],
+            message:
+              'Environment variable keys must be unique per environment.',
+          })
+        keys.add(key)
+      })
+    })
+    .optional(),
+  projectName: projectMachineNameSchema,
+  repoFullName: z
+    .string()
+    .min(1)
+    .regex(/^[^/\s]+\/[^/\s]+$/, 'Select a valid GitHub repository.'),
+})

package/src/lib/project-env-schema.ts

@@ -0,0 +1,23 @@
+import { settingsVersionSchema } from '#devpush/lib/settings-version'
+import { z } from 'zod'
+import { envVarSchema } from './project-creation-schema'
+
+export const projectEnvVarsSchema = z.object({
+  settingsVersion: settingsVersionSchema,
+  projectId: z.string().min(1),
+  teamSlug: z.string().min(1),
+  projectName: z.string().min(1),
+  envVars: z.array(envVarSchema).superRefine((rows, ctx) => {
+    const seen = new Set<string>()
+    rows.forEach((row, index) => {
+      const key = JSON.stringify([row.environment || '', row.key])
+      if (seen.has(key))
+        ctx.addIssue({
+          code: 'custom',
+          path: [index, 'key'],
+          message: 'Environment variable keys must be unique per environment.',
+        })
+      seen.add(key)
+    })
+  }),
+})

package/src/lib/project-environments-schema.ts

@@ -0,0 +1,56 @@
+import { settingsVersionSchema } from '#devpush/lib/settings-version'
+import { z } from 'zod'
+
+const projectEnvironmentSchema = z.object({
+  id: z.string().trim().min(1),
+  name: z
+    .string()
+    .trim()
+    .min(1, 'Enter an environment name.')
+    .max(255, 'Names must be 255 characters or fewer.'),
+  slug: z
+    .string()
+    .trim()
+    .min(2, 'Enter an identifier with at least two characters.')
+    .max(255, 'Identifiers must be 255 characters or fewer.')
+    .regex(
+      /^[A-Za-z0-9][A-Za-z0-9._-]*[A-Za-z0-9]$/,
+      'Environment identifiers can only contain letters, numbers, hyphens, underscores and dots. They cannot start or end with a dot, underscore or hyphen.',
+    ),
+  branch: z
+    .string()
+    .trim()
+    .min(1, 'Enter a branch pattern.')
+    .max(255, 'Branch patterns must be 255 characters or fewer.'),
+  color: z.string().trim().min(1).max(32),
+  position: z.number().int().nonnegative(),
+  status: z.enum(['active', 'deleted']),
+})
+
+export const projectEnvironmentsSchema = z.object({
+  settingsVersion: settingsVersionSchema,
+  projectId: z.string().min(1),
+  teamSlug: z.string().min(1),
+  projectName: z.string().min(1),
+  environments: z
+    .array(projectEnvironmentSchema)
+    .min(1, 'Production environment is required.')
+    .superRefine((rows, ctx) => {
+      const seen = new Set<string>()
+      rows.forEach((row, index) => {
+        if (row.status !== 'active') return
+        if (seen.has(row.slug))
+          ctx.addIssue({
+            code: 'custom',
+            path: [index, 'slug'],
+            message: 'Environment identifiers must be unique.',
+          })
+        seen.add(row.slug)
+      })
+      if (!seen.has('production'))
+        ctx.addIssue({
+          code: 'custom',
+          message: 'Production environment is required.',
+        })
+    }),
+})

package/src/lib/project-routing-schema.ts

@@ -0,0 +1,94 @@
+import { settingsVersionSchema } from '#devpush/lib/settings-version'
+import { z } from 'zod'
+
+const routeSchema = z
+  .object({
+    service: z
+      .string()
+      .trim()
+      .min(1, 'Enter a service name.')
+      .regex(
+        /^[A-Za-z0-9._-]+$/,
+        'Route services can only contain letters, numbers, dots, underscores, and hyphens.',
+      ),
+    port: z
+      .number()
+      .int('Enter a whole-number port.')
+      .min(1, 'Route ports must be between 1 and 65535.')
+      .max(65535, 'Route ports must be between 1 and 65535.'),
+    path: z
+      .string()
+      .trim()
+      .min(1, 'Enter a route path.')
+      .regex(/^\//, 'Route paths must start with /.')
+      .regex(
+        /^[^\s`?#]+$/,
+        'Route paths cannot contain spaces, backticks, queries or fragments.',
+      ),
+    stripPrefix: z.boolean().optional().default(false),
+    environmentId: z.string().trim().min(1).optional(),
+  })
+  .superRefine((route, context) => {
+    if (route.stripPrefix && route.path.includes(',')) {
+      context.addIssue({
+        code: 'custom',
+        path: ['path'],
+        message: 'Comma paths cannot use prefix stripping.',
+      })
+    }
+  })
+
+const domainSchema = z.object({
+  host: z
+    .string()
+    .toLowerCase()
+    .trim()
+    .min(1, 'Enter a domain hostname.')
+    .max(253, 'Hostnames must be 253 characters or fewer.')
+    .regex(
+      /^(?!-)[a-z0-9-]{1,63}(?<!-)(\.(?!-)[a-z0-9-]{1,63}(?<!-))*$/,
+      'Domains must be valid DNS hostnames without protocol, path, wildcard, or port.',
+    ),
+  environmentId: z.string().trim().min(1),
+  basePath: z.string().trim(),
+  https: z.boolean(),
+})
+
+export const projectRoutesSchema = z.object({
+  settingsVersion: settingsVersionSchema,
+  projectId: z.string().min(1),
+  teamSlug: z.string().min(1),
+  projectName: z.string().min(1),
+  routes: z.array(routeSchema).superRefine((routes, ctx) => {
+    const seen = new Set<string>()
+    routes.forEach((route, index) => {
+      const key = JSON.stringify([route.environmentId ?? null, route.path])
+      if (seen.has(key))
+        ctx.addIssue({
+          code: 'custom',
+          path: [index, 'path'],
+          message: 'Each route path can only be configured once per scope.',
+        })
+      seen.add(key)
+    })
+  }),
+})
+
+export const projectDomainsSchema = z.object({
+  settingsVersion: settingsVersionSchema,
+  projectId: z.string().min(1),
+  teamSlug: z.string().min(1),
+  projectName: z.string().min(1),
+  domains: z.array(domainSchema).superRefine((domains, ctx) => {
+    const seen = new Set<string>()
+    domains.forEach((domain, index) => {
+      if (seen.has(domain.host))
+        ctx.addIssue({
+          code: 'custom',
+          path: [index, 'host'],
+          message: 'Each domain can only be added once.',
+        })
+      seen.add(domain.host)
+    })
+  }),
+})

package/src/lib/project-runtime-config.ts

@@ -0,0 +1,131 @@
+import { PublicError } from '#devpush/lib/public-error'
+import { z } from 'zod'
+
+export const maxLifecycleCommandLength = 16 * 1024
+
+const lifecycleCommandSchema = z
+  .string()
+  .trim()
+  .max(
+    maxLifecycleCommandLength,
+    'Commands must be 16,384 characters or fewer.',
+  )
+  .nullable()
+
+export const repositoryComposePathSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(255, 'Compose paths must be 255 characters or fewer.')
+  .refine(isRepositoryRelativePath, {
+    message: 'Compose paths must stay within the repository.',
+  })
+
+const composeRuntimeConfigSchema = z.strictObject({
+  type: z.literal('compose'),
+  path: repositoryComposePathSchema.nullable(),
+  releaseCommand: lifecycleCommandSchema,
+  releaseService: z.string().trim().min(1).nullable(),
+  readinessPath: z
+    .string()
+    .trim()
+    .regex(/^\//, 'Readiness paths must start with /.')
+    .nullable(),
+  deployCommand: lifecycleCommandSchema,
+  rollbackCommand: lifecycleCommandSchema,
+  timeoutSeconds: z
+    .number()
+    .int('Enter a whole number of seconds.')
+    .min(60, 'Timeout must be at least 60 seconds.')
+    .max(7200, 'Timeout must be 7,200 seconds or fewer.'),
+})
+
+export const projectRuntimeConfigSchema = composeRuntimeConfigSchema
+
+export type ComposeRuntimeConfig = z.infer<typeof composeRuntimeConfigSchema>
+
+// Add future runtime kinds as new members of this discriminated union.
+export type ProjectRuntimeConfig = ComposeRuntimeConfig
+
+export function createComposeRuntimeConfig(
+  overrides: Partial<Omit<ComposeRuntimeConfig, 'type'>> = {},
+): ComposeRuntimeConfig {
+  return {
+    type: 'compose',
+    path: null,
+    releaseCommand: null,
+    releaseService: null,
+    readinessPath: null,
+    deployCommand: null,
+    rollbackCommand: null,
+    timeoutSeconds: 1800,
+    ...overrides,
+  }
+}
+
+export function parseProjectRuntimeConfig(
+  value: unknown,
+): ProjectRuntimeConfig | null {
+  const result = projectRuntimeConfigSchema.safeParse(value)
+  return result.success ? result.data : null
+}
+
+export function requireProjectRuntimeConfig(
+  value: unknown,
+): ProjectRuntimeConfig {
+  const config = parseProjectRuntimeConfig(value)
+  if (!config) {
+    throw new PublicError('PROJECT_RUNTIME_CONFIG_INVALID')
+  }
+  return config
+}
+
+function isRepositoryRelativePath(value: string) {
+  if (
+    value.startsWith('/') ||
+    value.includes('\\') ||
+    Array.from(value).some((character) => {
+      const code = character.charCodeAt(0)
+      return code <= 31 || code === 127
+    })
+  ) {
+    return false
+  }
+
+  const segments = value.split('/')
+  return segments.every(
+    (segment) => segment.length > 0 && segment !== '.' && segment !== '..',
+  )
+}
+
+export function hostLifecycleCommandsChanged(
+  current: ProjectRuntimeConfig,
+  next: ProjectRuntimeConfig,
+) {
+  return (
+    current.deployCommand !== next.deployCommand ||
+    current.rollbackCommand !== next.rollbackCommand
+  )
+}
+
+export function hostLifecycleCommandsUseChangedSource({
+  currentRepoFullName,
+  currentRuntimeConfig,
+  nextRepoFullName,
+  nextRuntimeConfig,
+}: {
+  currentRepoFullName: string
+  currentRuntimeConfig: ProjectRuntimeConfig
+  nextRepoFullName: string
+  nextRuntimeConfig: ProjectRuntimeConfig
+}) {
+  const hasHostCommand = Boolean(
+    nextRuntimeConfig.deployCommand || nextRuntimeConfig.rollbackCommand,
+  )
+
+  return (
+    hasHostCommand &&
+    (nextRepoFullName !== currentRepoFullName ||
+      nextRuntimeConfig.path !== currentRuntimeConfig.path)
+  )
+}

package/src/lib/project-settings-schema.ts

@@ -0,0 +1,75 @@
+import { settingsVersionSchema } from '#devpush/lib/settings-version'
+import { z } from 'zod'
+import { avatarDataUrlSchema } from '#devpush/lib/avatar-schema'
+import { projectRuntimeConfigSchema } from '#devpush/lib/project-runtime-config'
+import { formErrors } from './form-errors'
+import type { FormErrors } from './form-errors'
+
+export const projectMachineNameSchema = z
+  .string()
+  .trim()
+  .min(2, 'Enter a project name with at least 2 characters.')
+  .max(100, 'Project names must be 100 characters or fewer.')
+  .regex(
+    /^[A-Za-z0-9][A-Za-z0-9._-]*[A-Za-z0-9]$/,
+    'Project names must start and end with a letter or number and only use letters, numbers, dots, underscores, or hyphens.',
+  )
+
+export const projectSettingsSchema = z.object({
+  settingsVersion: settingsVersionSchema,
+  projectId: z.string().min(1),
+  section: z.enum(['general', 'build']),
+  teamSlug: z.string().min(1),
+  currentProjectName: z.string().min(1),
+  projectName: projectMachineNameSchema,
+  repoFullName: z
+    .string()
+    .regex(/^[^/\s]+\/[^/\s]+$/, 'Select a valid GitHub repository.'),
+  installationId: z.number().int().positive().nullable(),
+  avatarDataUrl: avatarDataUrlSchema,
+  deleteAvatar: z.boolean().optional(),
+  runtimeConfig: projectRuntimeConfigSchema,
+})
+
+export function projectSettingsErrors(error: unknown): FormErrors | null {
+  if (!(error instanceof Error)) return null
+  if (error.message === 'Project names must be unique within a team.')
+    return { projectName: error.message }
+  if (
+    [
+      'Upload a PNG, JPEG, or WebP image.',
+      'Avatars must be 2 MB or smaller.',
+      'The uploaded file does not match its image type.',
+    ].includes(error.message)
+  )
+    return { avatarDataUrl: error.message }
+  if (
+    [
+      'Select a GitHub App installation for this repository.',
+      'Connect GitHub before changing the repository.',
+      'Install the GitHub app for this repository to continue.',
+      'You need push access to use this repository.',
+    ].includes(error.message)
+  )
+    return { repoFullName: error.message }
+  return null
+}
+
+export function projectValidationErrors(
+  issues: Array<{ path: PropertyKey[]; message: string }>,
+): FormErrors {
+  const errors = formErrors(issues)
+  if (errors.installationId) {
+    errors.repoFullName ??=
+      'Select a valid GitHub App installation for this repository.'
+    delete errors.installationId
+  }
+  for (const key of ['teamSlug', 'currentProjectName']) {
+    if (errors[key]) {
+      errors.form ??=
+        'This project could not be identified. Reload the page and try again.'
+      delete errors[key]
+    }
+  }
+  return errors
+}