devpush 0.0.0-stage → 1.0.0-beta.3

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

@@ -0,0 +1,126 @@
+import { workspacePollInterval } from './workspace-updates'
+import type { TeamSummary } from '#devpush/server/teams/types'
+import { queryOptions } from '@tanstack/react-query'
+import type { QueryClient } from '@tanstack/react-query'
+import { redirect } from '@tanstack/react-router'
+
+import {
+  getTeamSectionContext,
+  getTeamShellContext,
+} from '#devpush/server/teams/functions'
+import type { TeamContextSection } from '#devpush/lib/team-context-schema'
+
+export type { TeamContextSection } from '#devpush/lib/team-context-schema'
+export type TeamShellContext = NonNullable<
+  Awaited<ReturnType<typeof getTeamShellContext>>
+>
+
+export function teamShellQueryOptions({ teamSlug }: { teamSlug: string }) {
+  return queryOptions({
+    queryKey: ['team-context', teamSlug, 'shell'],
+    queryFn: async () => {
+      const context = await getTeamShellContext({ data: { teamSlug } })
+
+      if (!context) {
+        throw redirect({ to: '/auth/login' })
+      }
+
+      return context
+    },
+  })
+}
+
+export function teamSectionQueryOptions({
+  section,
+  teamSlug,
+}: {
+  section: TeamContextSection
+  teamSlug: string
+}) {
+  return queryOptions({
+    queryKey: ['team-context', teamSlug, 'section', section],
+    refetchIntervalInBackground: false,
+    refetchOnWindowFocus: ['servers', 'overview'].includes(section)
+      ? 'always'
+      : false,
+    refetchInterval: (query) =>
+      section === 'servers'
+        ? workspacePollInterval(teamSlug, 5_000)
+        : query.state.data?.section === 'overview' &&
+            query.state.data.deployments.some((deployment) =>
+              ['queued', 'running'].includes(deployment.status),
+            )
+          ? workspacePollInterval(teamSlug, 2_000)
+          : section === 'overview'
+            ? workspacePollInterval(teamSlug, 15_000)
+            : false,
+    queryFn: async () => {
+      const context = await getTeamSectionContext({
+        data: { section, teamSlug },
+      })
+
+      if (!context) {
+        throw redirect({ to: '/auth/login' })
+      }
+
+      return context
+    },
+  })
+}
+
+export function invalidateTeamContext(
+  queryClient: QueryClient,
+  teamSlug?: string,
+) {
+  return queryClient.invalidateQueries({
+    queryKey: teamSlug ? ['team-context', teamSlug] : ['team-context'],
+  })
+}
+
+export function getCachedTeamContexts(
+  queryClient: QueryClient,
+  teamSlug: string,
+) {
+  return queryClient
+    .getQueriesData<TeamShellContext>({
+      queryKey: ['team-context', teamSlug, 'shell'],
+    })
+    .flatMap(([, context]) => (context ? [context] : []))
+}
+
+// Team metadata is embedded in navigation for both team and project pages.
+// Preserve each snapshot's age: changing a name does not refresh its other data.
+export async function setTeamContextQueryData(
+  queryClient: QueryClient,
+  team: TeamSummary,
+) {
+  const filters = {
+    predicate: ({ queryKey }: { queryKey: readonly unknown[] }) =>
+      (queryKey[0] === 'team-context' && queryKey[2] === 'shell') ||
+      ['project-context', 'deployment-context', 'project-logs'].includes(
+        String(queryKey[0]),
+      ),
+  }
+  await queryClient.cancelQueries(filters)
+  for (const query of queryClient.getQueryCache().findAll(filters)) {
+    const cached = query.state.data as
+      | Pick<TeamShellContext, 'team' | 'userContext'>
+      | undefined
+    if (!cached) continue
+    const replaceTeam = (current: TeamSummary) =>
+      current.id === team.id ? team : current
+    queryClient.setQueryData(
+      query.queryKey,
+      {
+        ...cached,
+        team: replaceTeam(cached.team),
+        userContext: {
+          ...cached.userContext,
+          teams: cached.userContext.teams.map(replaceTeam),
+          defaultTeam: replaceTeam(cached.userContext.defaultTeam),
+        },
+      },
+      { updatedAt: query.state.dataUpdatedAt },
+    )
+  }
+}

package/src/lib/team-context-schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod'
+
+export const teamContextSectionSchema = z.enum([
+  'overview',
+  'servers',
+  'settings',
+])
+export type TeamContextSection = z.infer<typeof teamContextSectionSchema>

package/src/lib/team-forms-schema.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod'
+
+export const createTeamSchema = z.object({
+  name: z
+    .string()
+    .trim()
+    .min(1, 'Enter a team name.')
+    .max(100, 'Team names must be 100 characters or fewer.'),
+})
+const emailSchema = z
+  .string()
+  .trim()
+  .min(1, 'Enter an email address.')
+  .email('Enter a valid email address.')
+  .max(320, 'Email addresses must be 320 characters or fewer.')
+const inviteSchema = z.object({
+  teamSlug: z.string().min(1),
+  email: emailSchema,
+  role: z.enum(['admin', 'member']),
+})
+export function parseInviteEmails(value: string) {
+  return [
+    ...new Set(
+      value
+        .split(/[\s,]+/)
+        .map((email) => email.trim().toLowerCase())
+        .filter((email) => emailSchema.safeParse(email).success),
+    ),
+  ]
+}
+export const bulkInviteSchema = inviteSchema.omit({ email: true }).extend({
+  emails: z
+    .string()
+    .trim()
+    .min(1, 'Enter at least one email address.')
+    .max(20000, 'Enter at most 20,000 characters at a time.')
+    .superRefine((value, ctx) => {
+      const emails = parseInviteEmails(value)
+      if (!emails.length)
+        ctx.addIssue({
+          code: 'custom',
+          message: 'Enter at least one valid email address.',
+        })
+    }),
+})

package/src/lib/team-role.ts

@@ -0,0 +1,13 @@
+export type TeamRole = 'owner' | 'admin' | 'member'
+
+export function canManageTeamSettings(role: TeamRole) {
+  return role === 'owner' || role === 'admin'
+}
+
+export function canManageTeamMembers(role: TeamRole) {
+  return role === 'owner' || role === 'admin'
+}
+
+export function canDeleteTeam(role: TeamRole) {
+  return role === 'owner'
+}

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

@@ -0,0 +1,48 @@
+import { settingsVersionSchema } from '#devpush/lib/settings-version'
+import { z } from 'zod'
+import { avatarDataUrlSchema } from '#devpush/lib/avatar-schema'
+import type { FormErrors } from './form-errors'
+
+export const teamGeneralSchema = z.object({
+  settingsVersion: settingsVersionSchema,
+  teamId: z.string().min(1),
+  teamSlug: z.string().min(1),
+  name: z
+    .string()
+    .trim()
+    .min(1, 'Enter a team name.')
+    .max(100, 'Team names must be 100 characters or fewer.'),
+  slug: z
+    .string()
+    .trim()
+    .min(2, 'Enter a slug with at least 2 characters.')
+    .max(100, 'Slugs must be 100 characters or fewer.')
+    .regex(
+      /^[A-Za-z0-9][A-Za-z0-9._-]*[A-Za-z0-9]$/,
+      'Use letters, numbers, dots, underscores, or hyphens. Start and end with a letter or number.',
+    ),
+  avatarDataUrl: avatarDataUrlSchema,
+  deleteAvatar: z.boolean().optional(),
+})
+
+export function teamSettingsErrors(error: unknown): FormErrors | null {
+  if (!(error instanceof Error)) return null
+  if (error.message === 'Team name is required.')
+    return { name: 'Enter a team name.' }
+  if (
+    [
+      'This slug is reserved.',
+      'A team with this slug already exists.',
+    ].includes(error.message)
+  )
+    return { slug: 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 }
+  return null
+}

package/src/lib/urls.ts

@@ -0,0 +1,3 @@
+export function routeUrl({ host, https }: { host: string; https: boolean }) {
+  return `${https ? 'https' : 'http'}://${host}`
+}

package/src/lib/use-avatar-input.ts

@@ -0,0 +1,61 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+// A reset, removal, or newer selection invalidates the previous file read.
+export function useAvatarInput() {
+  const [dataUrl, setDataUrlState] = useState<string | null>(null)
+  const [pending, setPending] = useState(false)
+  const cancelRef = useRef<(() => void) | null>(null)
+  const cancelRead = useCallback(() => {
+    cancelRef.current?.()
+    cancelRef.current = null
+    setPending(false)
+  }, [])
+  useEffect(() => () => cancelRef.current?.(), [])
+  const setDataUrl = useCallback(
+    (value: string | null) => {
+      cancelRead()
+      setDataUrlState(value)
+    },
+    [cancelRead],
+  )
+  const read = useCallback(
+    (file: File) => {
+      cancelRead()
+      setPending(true)
+      return new Promise<string | null>((resolve, reject) => {
+        const reader = new FileReader()
+        let settled = false
+        const finish = (value: string | null, error?: Error) => {
+          if (settled) return
+          settled = true
+          reader.onload = reader.onerror = reader.onabort = null
+          cancelRef.current = null
+          setPending(false)
+          if (error) reject(error)
+          else resolve(value)
+        }
+        cancelRef.current = () => {
+          if (settled) return
+          settled = true
+          reader.onload = reader.onerror = reader.onabort = null
+          if (reader.readyState === FileReader.LOADING) reader.abort()
+          resolve(null)
+        }
+        reader.onload = () => {
+          if (typeof reader.result === 'string') finish(reader.result)
+          else finish(null, new Error('Unable to read image file.'))
+        }
+        reader.onerror = () =>
+          finish(null, new Error('Unable to read image file.'))
+        reader.onabort = () => finish(null)
+        try {
+          reader.readAsDataURL(file)
+        } catch {
+          finish(null, new Error('Unable to read image file.'))
+        }
+      })
+    },
+    [cancelRead],
+  )
+  return { dataUrl, setDataUrl, read, cancelRead, pending }
+}

package/src/lib/use-refresh-error.ts

@@ -0,0 +1,18 @@
+import { useEffect } from 'react'
+import { toast } from 'sonner'
+
+export function useRefreshError(error: unknown, id: string) {
+  useEffect(() => {
+    if (error) {
+      toast.error(
+        'Unable to refresh. Displayed information may be out of date. Please reload.',
+        { id },
+      )
+    } else {
+      toast.dismiss(id)
+    }
+    return () => {
+      toast.dismiss(id)
+    }
+  }, [error, id])
+}

package/src/lib/use-settings-version.ts

@@ -0,0 +1,23 @@
+import { useEffect, useRef } from 'react'
+
+// Clean forms adopt an authoritative snapshot. Dirty forms keep the version
+// they started from, so a refresh cannot silently turn a stale draft into a save.
+export function useSettingsVersion({
+  version,
+  dirty,
+  saving,
+  refresh,
+}: {
+  version: number
+  dirty: boolean
+  saving: boolean
+  refresh: () => void
+}) {
+  const originalVersion = useRef(version)
+  useEffect(() => {
+    if (dirty || saving || version <= originalVersion.current) return
+    originalVersion.current = version
+    refresh()
+  }, [version, dirty, saving, refresh])
+  return originalVersion
+}

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/lib/validation.ts

@@ -0,0 +1,5 @@
+export function isValidEmail(value: string) {
+  return /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/.test(
+    value,
+  )
+}

package/src/lib/workspace-updates.ts

@@ -0,0 +1,53 @@
+const connections = new Set<string>()
+export type UpdateKind = 'deployments' | 'servers' | 'logs'
+
+export function setWorkspaceConnected(slug: string, connected: boolean) {
+  if (connected) connections.add(slug)
+  else connections.delete(slug)
+}
+
+export function workspacePollInterval(slug: string, fallback: number) {
+  return connections.has(slug) ? 60_000 : fallback
+}
+
+export function matchesWorkspaceUpdate(
+  key: readonly unknown[],
+  slug: string,
+  kind?: UpdateKind,
+) {
+  if (key[1] !== slug) return false
+  const family = String(key[0])
+  if (!kind)
+    return [
+      'team-context',
+      'project-context',
+      'server-context',
+      'server-metrics',
+      'manual-deploy-options',
+      'operation-logs',
+      'deployment-context',
+      'deployment-logs',
+      'project-logs',
+    ].includes(family)
+  if (kind === 'logs') return family === 'project-logs'
+  if (kind === 'servers')
+    return (
+      family === 'server-context' ||
+      (family === 'team-context' &&
+        ['shell', 'servers'].includes(String(key.at(-1)))) ||
+      (family === 'project-context' && key.at(-1) === 'shell')
+    )
+  return (
+    [
+      'deployment-context',
+      'deployment-logs',
+      'project-logs',
+      'manual-deploy-options',
+    ].includes(family) ||
+    (family === 'team-context' && key.at(-1) === 'overview') ||
+    (family === 'project-context' &&
+      ['overview', 'deployments', 'shell', 'backups'].includes(
+        String(key.at(-1)),
+      ))
+  )
+}

package/src/package/config.ts

@@ -0,0 +1,10 @@
+import type { DevpushPlugin } from './plugins'
+
+export interface DevpushOptions {
+  /** Consumer project directory. Defaults to process.cwd(). */
+  root?: string
+  plugins?: readonly DevpushPlugin[]
+  target?: 'node' | 'cloudflare'
+  /** Wrangler configuration owned by the consumer. */
+  wranglerConfig?: string
+}

package/src/package/env.mjs

@@ -0,0 +1,54 @@
+import { parseEnv } from "node:util";
+
+// Accept only encodings that round-trip through the runtime's dotenv parser.
+export function encodeEnvValue(value) {
+  const candidates = [JSON.stringify(value)];
+  for (const quote of ["'", '"', "`"]) {
+    if (!value.includes(quote)) candidates.push(`${quote}${value}${quote}`);
+  }
+  candidates.push(value);
+  const encoded = candidates.find(
+    (candidate) => parseEnv(`VALUE=${candidate}\n`).VALUE === value,
+  );
+  if (encoded === undefined)
+    throw new Error("An environment value cannot be represented safely.");
+  return encoded;
+}
+
+export function updateEnvSource(source, updates) {
+  const lines = source.split(/\r?\n/u);
+  const seen = new Set();
+  const output = [];
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const match = line.match(
+      /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/u,
+    );
+    if (!match) {
+      output.push(line);
+      continue;
+    }
+    const [, key, value] = match;
+    const block = [line];
+    const quote = value[0];
+    if (["'", '"', "`"].includes(quote) && !value.slice(1).includes(quote)) {
+      while (++index < lines.length) {
+        block.push(lines[index]);
+        if (lines[index].includes(quote)) break;
+      }
+      if (index === lines.length)
+        throw new Error(
+          "Cannot update an unterminated quoted environment value.",
+        );
+    }
+    if (Object.hasOwn(updates, key) && updates[key] !== undefined) {
+      output.push(`${key}=${encodeEnvValue(String(updates[key]))}`);
+      seen.add(key);
+    } else output.push(...block);
+  }
+  for (const [key, value] of Object.entries(updates)) {
+    if (value !== undefined && !seen.has(key))
+      output.push(`${key}=${encodeEnvValue(String(value))}`);
+  }
+  return `${output.join("\n").replace(/\n+$/gu, "")}\n`;
+}

package/src/package/migrate-api.d.ts

@@ -0,0 +1,5 @@
+/** Apply the packaged main and log migrations to the configured Node databases. */
+export declare function migrateNode(
+  environment?: Record<string, string | undefined>,
+  options?: { migrationsDirectory?: string },
+): Promise<void>

package/src/package/migrate.ts

@@ -0,0 +1,56 @@
+import { createClient } from '@libsql/client/web'
+import { migrateLibsql } from '../server/db/migrate-libsql'
+import { remoteDatabaseConfig } from '../server/db/remote-config'
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+
+import { migrateSqliteFile } from '../server/db/migrate-sqlite'
+import { assertSeparateSqliteFiles } from '../server/db/sqlite-files'
+
+export async function migrateNode(
+  environment: Record<string, string | undefined> = process.env,
+  options: { migrationsDirectory?: string } = {},
+) {
+  const migrationsDirectory =
+    options.migrationsDirectory ??
+    fileURLToPath(new URL('../../src/server/db', import.meta.url))
+  const remote = remoteDatabaseConfig(environment)
+  if (remote) {
+    for (const [database, directory] of [
+      [remote.main, 'migrations-sqlite'],
+      [remote.logs, 'migrations-logs'],
+    ] as const) {
+      const client = createClient(database)
+      try {
+        await migrateLibsql(client, join(migrationsDirectory, directory))
+      } finally {
+        client.close()
+      }
+    }
+    console.log('Remote libSQL database migrations applied.')
+  } else {
+    const path = environment.DEVPUSH_DATABASE_PATH
+    const logPath = environment.DEVPUSH_LOG_DATABASE_PATH
+    if (!path && environment.NODE_ENV === 'production') {
+      throw new Error('DEVPUSH_DATABASE_PATH is required in production.')
+    }
+    if (!logPath && environment.NODE_ENV === 'production') {
+      throw new Error('DEVPUSH_LOG_DATABASE_PATH is required in production.')
+    }
+
+    assertSeparateSqliteFiles(
+      path ?? '.data/devpush.sqlite',
+      logPath ?? '.data/logs.sqlite',
+    )
+
+    migrateSqliteFile(
+      path ?? '.data/devpush.sqlite',
+      join(migrationsDirectory, 'migrations-sqlite'),
+    )
+    migrateSqliteFile(
+      logPath ?? '.data/logs.sqlite',
+      join(migrationsDirectory, 'migrations-logs'),
+    )
+    console.log('SQLite database migrations applied.')
+  }
+}