@svgrid/enterprise 2.5.2 → 2.6.0

package/src/studio/db-connect-string.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  buildConnectionString,
-  parseConnectionString,
-  redactConnectionString,
-  isFileDialect,
-  DEFAULT_PORT,
-  DRIVER_PACKAGE,
-} from './db-connect-string'
-
-describe('buildConnectionString', () => {
-  it('builds a postgres URL with the default port', () => {
-    expect(buildConnectionString('postgres', { host: 'db.example.com', database: 'app', user: 'admin', password: 'secret' }))
-      .toBe('postgresql://admin:secret@db.example.com:5432/app')
-  })
-
-  it('percent-encodes credentials with reserved characters', () => {
-    const url = buildConnectionString('postgres', { host: 'h', database: 'd', user: 'a@b', password: 'p:w/d?' })
-    expect(url).toBe('postgresql://a%40b:p%3Aw%2Fd%3F@h:5432/d')
-    // ...and round-trips back to the raw values.
-    const parts = parseConnectionString('postgres', url)
-    expect(parts.user).toBe('a@b')
-    expect(parts.password).toBe('p:w/d?')
-  })
-
-  it('treats supabase as postgres', () => {
-    expect(buildConnectionString('supabase', { host: 'x', database: 'd', user: 'u', password: 'p' }))
-      .toBe('postgresql://u:p@x:5432/d')
-  })
-
-  it('uses mysql / mssql schemes and default ports', () => {
-    expect(buildConnectionString('mysql', { host: 'h', database: 'd', user: 'u', password: 'p' }))
-      .toBe('mysql://u:p@h:3306/d')
-    expect(buildConnectionString('mssql', { host: 'h', database: 'd', user: 'u', password: 'p' }))
-      .toBe('mssql://u:p@h:1433/d')
-  })
-
-  it('honours a custom port and omits empty auth / db', () => {
-    expect(buildConnectionString('postgres', { host: 'h', port: 6543 })).toBe('postgresql://h:6543')
-    expect(buildConnectionString('postgres', { host: 'h', port: '5432', user: 'u' })).toBe('postgresql://u@h:5432')
-  })
-
-  it('adds the correct SSL param per dialect', () => {
-    expect(buildConnectionString('postgres', { host: 'h', database: 'd', ssl: true })).toContain('?sslmode=require')
-    expect(buildConnectionString('mssql', { host: 'h', database: 'd', ssl: true })).toContain('encrypt=true')
-    expect(buildConnectionString('mysql', { host: 'h', database: 'd', ssl: true })).toContain('ssl=')
-  })
-
-  it('returns a bare file path for sqlite', () => {
-    expect(buildConnectionString('sqlite', { file: './data/app.db' })).toBe('./data/app.db')
-    expect(buildConnectionString('sqlite', { database: 'app.db' })).toBe('app.db')
-    expect(() => buildConnectionString('sqlite', {})).toThrow(/file path/)
-  })
-})
-
-describe('parseConnectionString', () => {
-  it('splits a URL back into form fields', () => {
-    expect(parseConnectionString('postgres', 'postgresql://u:p@host:5432/mydb?sslmode=require')).toEqual({
-      host: 'host', port: 5432, database: 'mydb', user: 'u', password: 'p', ssl: true,
-    })
-  })
-  it('treats a sqlite value as a file path', () => {
-    expect(parseConnectionString('sqlite', '/var/data/app.db')).toEqual({ file: '/var/data/app.db' })
-  })
-  it('returns {} for unparseable input', () => {
-    expect(parseConnectionString('postgres', 'not a url')).toEqual({})
-    expect(parseConnectionString('postgres', '')).toEqual({})
-  })
-})
-
-describe('redactConnectionString', () => {
-  it('masks the password in a URL', () => {
-    expect(redactConnectionString('postgresql://u:secret@h:5432/d')).toBe('postgresql://u:***@h:5432/d')
-  })
-  it('masks password= tokens in key/value strings', () => {
-    expect(redactConnectionString('Server=h;Database=d;User Id=u;Password=secret;'))
-      .toBe('Server=h;Database=d;User Id=u;Password=***;')
-  })
-  it('leaves passwordless strings untouched', () => {
-    expect(redactConnectionString('postgresql://h:5432/d')).toBe('postgresql://h:5432/d')
-    expect(redactConnectionString('./app.db')).toBe('./app.db')
-  })
-})
-
-describe('metadata tables', () => {
-  it('maps every dialect to a driver + default port', () => {
-    expect(DRIVER_PACKAGE.postgres).toBe('pg')
-    expect(DRIVER_PACKAGE.sqlite).toBe('better-sqlite3')
-    expect(DEFAULT_PORT.mysql).toBe(3306)
-    expect(DEFAULT_PORT.sqlite).toBeNull()
-    expect(isFileDialect('sqlite')).toBe(true)
-    expect(isFileDialect('postgres')).toBe(false)
-  })
-})

package/src/studio/db-connect-string.ts

@@ -1,128 +0,0 @@
-/**
- * Connection-string helpers for the Studio "connect your database" flow. A
- * guided form collects host / port / database / user / password / SSL and
- * `buildConnectionString` assembles the driver-ready URL, so users never have to
- * hand-write `postgresql://user:pass@host:5432/db`. `parseConnectionString` does
- * the reverse (best-effort) to pre-fill the form from a pasted URL, and
- * `redactConnectionString` masks the password for display / logs.
- *
- * Pure and node-safe (no driver, no node APIs) - shared by the designer server,
- * the CLI, and the (private) designer SPA, which imports it from
- * `@svgrid/enterprise/studio`.
- */
-import type { SqlDialectName } from './introspect-db.js'
-
-export type SqlConnectionParts = {
-  host?: string
-  port?: number | string
-  database?: string
-  user?: string
-  password?: string
-  /** Require TLS (adds the dialect's SSL query param). */
-  ssl?: boolean
-  /** SQLite only: path to the `.db` file (host / user / etc are ignored). */
-  file?: string
-}
-
-/** The npm driver package each dialect needs installed to connect. */
-export const DRIVER_PACKAGE: Record<SqlDialectName, string> = {
-  postgres: 'pg',
-  supabase: 'pg',
-  mysql: 'mysql2',
-  mssql: 'mssql',
-  sqlite: 'better-sqlite3',
-}
-
-/** The default TCP port per dialect (null for the file-based SQLite). */
-export const DEFAULT_PORT: Record<SqlDialectName, number | null> = {
-  postgres: 5432,
-  supabase: 5432,
-  mysql: 3306,
-  mssql: 1433,
-  sqlite: null,
-}
-
-/** SQLite is a file on disk - the form shows a path field, not host/port/auth. */
-export function isFileDialect(dialect: SqlDialectName): boolean {
-  return dialect === 'sqlite'
-}
-
-function urlScheme(dialect: SqlDialectName): string {
-  if (dialect === 'mysql') return 'mysql'
-  if (dialect === 'mssql') return 'mssql'
-  return 'postgresql' // postgres + supabase
-}
-
-function sslQuery(dialect: SqlDialectName, ssl?: boolean): string {
-  if (!ssl) return ''
-  if (dialect === 'mysql') return `?ssl=${encodeURIComponent('{"rejectUnauthorized":true}')}`
-  if (dialect === 'mssql') return '?encrypt=true&trustServerCertificate=true'
-  return '?sslmode=require' // postgres + supabase
-}
-
-/**
- * Assemble a driver-ready connection string from the guided-form fields. SQLite
- * returns the bare file path (what better-sqlite3 expects); every other dialect
- * returns a URL with the credentials percent-encoded so passwords containing
- * `@`, `:` or `/` don't corrupt it.
- */
-export function buildConnectionString(dialect: SqlDialectName, parts: SqlConnectionParts): string {
-  if (isFileDialect(dialect)) {
-    const file = (parts.file ?? parts.database ?? '').trim()
-    if (!file) throw new Error('buildConnectionString: SQLite needs a database file path')
-    return file
-  }
-  const host = (parts.host ?? '').trim() || 'localhost'
-  const portRaw = parts.port != null && `${parts.port}`.trim() !== '' ? Number(parts.port) : DEFAULT_PORT[dialect]
-  const port = Number.isFinite(portRaw as number) ? (portRaw as number) : null
-  const db = (parts.database ?? '').trim()
-  const user = (parts.user ?? '').trim()
-  const pass = parts.password ?? ''
-  const auth = user
-    ? `${encodeURIComponent(user)}${pass ? `:${encodeURIComponent(pass)}` : ''}@`
-    : ''
-  const hostPort = port ? `${host}:${port}` : host
-  const dbPath = db ? `/${encodeURIComponent(db)}` : ''
-  return `${urlScheme(dialect)}://${auth}${hostPort}${dbPath}${sslQuery(dialect, parts.ssl)}`
-}
-
-/**
- * Best-effort inverse of `buildConnectionString` - split a pasted URL back into
- * form fields so the guided form can pre-fill. Returns `{}` when the input isn't
- * a parseable URL (the caller keeps whatever the user typed).
- */
-export function parseConnectionString(dialect: SqlDialectName, value: string): SqlConnectionParts {
-  const raw = (value ?? '').trim()
-  if (!raw) return {}
-  if (isFileDialect(dialect)) return { file: raw }
-  try {
-    const u = new URL(raw)
-    const parts: SqlConnectionParts = {}
-    if (u.hostname) parts.host = u.hostname
-    if (u.port) parts.port = Number(u.port)
-    const db = u.pathname.replace(/^\//, '')
-    if (db) parts.database = decodeURIComponent(db)
-    if (u.username) parts.user = decodeURIComponent(u.username)
-    if (u.password) parts.password = decodeURIComponent(u.password)
-    const q = u.searchParams
-    if (q.get('sslmode') === 'require' || q.has('ssl') || q.get('encrypt') === 'true') parts.ssl = true
-    return parts
-  } catch {
-    return {}
-  }
-}
-
-/** Mask the password in a connection string for display / logging. */
-export function redactConnectionString(value: string): string {
-  const raw = (value ?? '').trim()
-  if (!raw) return raw
-  try {
-    const u = new URL(raw)
-    if (!u.password) return raw
-    u.password = '***'
-    return u.toString()
-  } catch {
-    // key=value strings (e.g. mssql "Password=...") and bare paths.
-    return raw.replace(/(password|pwd)=([^;&\s]+)/gi, '$1=***')
-  }
-}

package/src/studio/deploy-cli.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { deployCommands, missingEnvKeys, resolveDeployTarget } from './deploy-cli'
-
-describe('resolveDeployTarget', () => {
-  it('an explicit --target wins and is validated', () => {
-    expect(resolveDeployTarget({ flag: 'netlify', configJson: '{"deploy":"vercel"}' })).toEqual({ ok: true, provider: 'netlify', source: 'flag' })
-    const bad = resolveDeployTarget({ flag: 'heroku' })
-    expect(bad.ok).toBe(false)
-    if (!bad.ok) expect(bad.reason).toMatch(/Unknown --target "heroku"/)
-  })
-
-  it('falls back to studio.config.json deploy, ignoring auto/unset (never guesses)', () => {
-    expect(resolveDeployTarget({ configJson: '{"deploy":"cloudflare"}' })).toEqual({ ok: true, provider: 'cloudflare', source: 'config' })
-    expect(resolveDeployTarget({ configJson: '{"deploy":"auto"}' }).ok).toBe(false)
-    expect(resolveDeployTarget({ configJson: '{}' }).ok).toBe(false)
-    expect(resolveDeployTarget({ configJson: 'not json' }).ok).toBe(false)
-  })
-
-  it('detects the provider from a pinned SvelteKit adapter', () => {
-    const cfg = "import adapter from '@sveltejs/adapter-vercel'\nexport default { kit: { adapter: adapter() } }"
-    expect(resolveDeployTarget({ svelteConfig: cfg })).toEqual({ ok: true, provider: 'vercel', source: 'adapter' })
-    // adapter-auto is not a concrete provider - refuse with guidance.
-    const auto = resolveDeployTarget({ svelteConfig: "import adapter from '@sveltejs/adapter-auto'" })
-    expect(auto.ok).toBe(false)
-    if (!auto.ok) expect(auto.reason).toMatch(/No deploy target configured/)
-  })
-
-  it('config beats adapter; flag beats both', () => {
-    const svelteConfig = "import adapter from '@sveltejs/adapter-node'"
-    expect(resolveDeployTarget({ configJson: '{"deploy":"netlify"}', svelteConfig })).toMatchObject({ provider: 'netlify', source: 'config' })
-    expect(resolveDeployTarget({ flag: 'cloudflare', configJson: '{"deploy":"netlify"}', svelteConfig })).toMatchObject({ provider: 'cloudflare', source: 'flag' })
-  })
-})
-
-describe('deployCommands', () => {
-  it('providers build first, then run the same one-liners the generated deploy script uses', () => {
-    expect(deployCommands('vercel')).toMatchObject({ build: 'npm run build', deploy: 'npx vercel deploy --prod' })
-    expect(deployCommands('netlify').deploy).toBe('npx netlify deploy --build --prod')
-    expect(deployCommands('cloudflare').deploy).toBe('npx wrangler pages deploy')
-  })
-
-  it('node has no provider command - instructions only', () => {
-    const plan = deployCommands('node')
-    expect(plan.deploy).toBeNull()
-    expect(plan.notes.join('\n')).toMatch(/docker build/)
-  })
-})
-
-describe('missingEnvKeys', () => {
-  it('flags declared-but-unset keys, ignoring comments and filled values', () => {
-    const example = '# note\nDATABASE_URL=\nSESSION_SECRET=change-me\n# VITE_SVPRO_KEY=\n'
-    expect(missingEnvKeys(example, 'DATABASE_URL=postgres://x\n')).toEqual(['SESSION_SECRET'])
-    expect(missingEnvKeys(example, null)).toEqual(['DATABASE_URL', 'SESSION_SECRET'])
-    expect(missingEnvKeys(null, null)).toEqual([])
-  })
-})

package/src/studio/deploy-cli.ts

@@ -1,100 +0,0 @@
-/**
- * `svgrid-studio deploy` - the pure, testable core. Resolves WHICH provider to
- * deploy to (explicit flag > studio.config.json's deploy target > the SvelteKit
- * adapter in svelte.config.js - never a guess) and WHAT commands that means.
- * The thin CLI in @svgrid/studio does the file reads + process spawning.
- */
-
-export type DeployProvider = 'vercel' | 'netlify' | 'cloudflare' | 'node'
-
-export type DeployResolution =
-  | { ok: true; provider: DeployProvider; source: 'flag' | 'config' | 'adapter' }
-  | { ok: false; reason: string }
-
-const PROVIDERS: DeployProvider[] = ['vercel', 'netlify', 'cloudflare', 'node']
-
-/** Adapter package -> provider (what svelte.config.js imports). */
-const ADAPTERS: Array<[string, DeployProvider]> = [
-  ['@sveltejs/adapter-vercel', 'vercel'],
-  ['@sveltejs/adapter-netlify', 'netlify'],
-  ['@sveltejs/adapter-cloudflare', 'cloudflare'],
-  ['@sveltejs/adapter-node', 'node'],
-]
-
-const GUIDANCE =
-  'Set a target: pass --target vercel|netlify|cloudflare|node, pick a deploy target in the Studio designer ' +
-  '(saved to studio.config.json), or pin a concrete SvelteKit adapter in svelte.config.js.'
-
-/** Resolve the deploy provider from the inputs the CLI gathered (all optional). */
-export function resolveDeployTarget(inputs: { flag?: string; configJson?: string | null; svelteConfig?: string | null }): DeployResolution {
-  const { flag, configJson, svelteConfig } = inputs
-  if (flag !== undefined) {
-    if ((PROVIDERS as string[]).includes(flag)) return { ok: true, provider: flag as DeployProvider, source: 'flag' }
-    return { ok: false, reason: `Unknown --target "${flag}". Use one of: ${PROVIDERS.join(' | ')}.` }
-  }
-  if (configJson) {
-    try {
-      const deploy = (JSON.parse(configJson) as { deploy?: string }).deploy
-      if (deploy && (PROVIDERS as string[]).includes(deploy)) return { ok: true, provider: deploy as DeployProvider, source: 'config' }
-      // 'auto' (or unset) means the project never chose a provider - don't guess one.
-    } catch {
-      /* unreadable config - fall through to the adapter */
-    }
-  }
-  if (svelteConfig) {
-    for (const [pkg, provider] of ADAPTERS) if (svelteConfig.includes(pkg)) return { ok: true, provider, source: 'adapter' }
-  }
-  return { ok: false, reason: `No deploy target configured. ${GUIDANCE}` }
-}
-
-export type DeployPlanCommands = {
-  provider: DeployProvider
-  /** Run first - validates the app compiles before anything leaves the machine. */
-  build: string
-  /** The provider CLI command, or null when there's nothing to run (node target). */
-  deploy: string | null
-  /** Shown before running (login hints, what the command does). */
-  notes: string[]
-}
-
-/** The commands a provider deploy runs - same one-liners the generated `deploy` script uses. */
-export function deployCommands(provider: DeployProvider): DeployPlanCommands {
-  switch (provider) {
-    case 'vercel':
-      return { provider, build: 'npm run build', deploy: 'npx vercel deploy --prod', notes: ['Needs a Vercel login (npx vercel login) and a linked project (first run prompts to link).'] }
-    case 'netlify':
-      return { provider, build: 'npm run build', deploy: 'npx netlify deploy --build --prod', notes: ['Needs a Netlify login (npx netlify login) and a linked site (npx netlify link).'] }
-    case 'cloudflare':
-      return { provider, build: 'npm run build', deploy: 'npx wrangler pages deploy', notes: ['Needs a Cloudflare login (npx wrangler login).'] }
-    case 'node':
-      return {
-        provider,
-        build: 'npm run build',
-        deploy: null,
-        notes: [
-          'The node target has no hosted provider - after the build, run it yourself:',
-          '  node build            # serves on PORT (default 3000)',
-          '  docker build -t app . && docker run -p 3000:3000 --env-file .env app',
-        ],
-      }
-  }
-}
-
-/** Env keys declared in .env.example (uncommented `KEY=` lines) that are absent
- *  from the local .env - surfaced as a preflight warning before deploying. */
-export function missingEnvKeys(envExample: string | null, envLocal: string | null): string[] {
-  if (!envExample) return []
-  const declared = envExample
-    .split('\n')
-    .map((l) => l.trim())
-    .filter((l) => /^[A-Z][A-Z0-9_]*=/.test(l))
-    .map((l) => l.slice(0, l.indexOf('=')))
-  const present = new Set(
-    (envLocal ?? '')
-      .split('\n')
-      .map((l) => l.trim())
-      .filter((l) => /^[A-Z][A-Z0-9_]*=.+/.test(l))
-      .map((l) => l.slice(0, l.indexOf('='))),
-  )
-  return declared.filter((k) => !present.has(k))
-}