davaux 0.8.0

package/src/create-multisite.ts

@@ -0,0 +1,310 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+export async function scaffoldMultisite(name: string | undefined, cwd: string) {
+  if (!name) {
+    console.error('Usage: davaux create-multisite <project-name>')
+    process.exit(1)
+  }
+
+  if (!/^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/.test(name)) {
+    console.error(
+      `[davaux] Invalid project name "${name}". Use lowercase letters, numbers, hyphens, underscores, or dots.`,
+    )
+    process.exit(1)
+  }
+
+  const dir = resolve(cwd, name)
+
+  if (existsSync(dir)) {
+    console.error(`[davaux] Directory "${name}" already exists.`)
+    process.exit(1)
+  }
+
+  const title = name.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
+
+  mkdirSync(join(dir, 'src', 'routes'), { recursive: true })
+  mkdirSync(join(dir, 'sites', 'main', 'routes'), { recursive: true })
+  mkdirSync(join(dir, 'public'), { recursive: true })
+
+  write(dir, 'package.json', packageJson(name))
+  write(dir, 'tsconfig.json', tsConfig())
+  write(dir, 'biome.json', biomeConfig())
+  write(dir, 'multisite.config.ts', multisiteConfig())
+  write(dir, 'server.ts', serverEntry())
+  write(dir, 'build.ts', buildEntry())
+  write(dir, 'src/routes/_layout.tsx', baseLayout(title))
+  write(dir, 'src/routes/index.page.tsx', baseIndexPage(title))
+  write(dir, 'sites/main/routes/_layout.tsx', siteLayout())
+  write(dir, 'sites/main/routes/index.page.tsx', siteIndexPage(title))
+
+  console.log(`\n  Created multisite project: ${name}\n`)
+  console.log('  Next steps:\n')
+  console.log(`    cd ${name}`)
+  console.log('    npm install')
+  console.log('    npm run dev\n')
+  console.log('  Docs: https://davaux.codeberg.page/docs/packages/multisite\n')
+}
+
+function write(dir: string, file: string, content: string) {
+  writeFileSync(join(dir, file), content, 'utf8')
+}
+
+function packageJson(name: string) {
+  return (
+    JSON.stringify(
+      {
+        name,
+        version: '0.1.0',
+        type: 'module',
+        scripts: {
+          dev: 'node --watch --import tsx/esm server.ts',
+          build: 'tsx build.ts',
+          start: 'NODE_ENV=production node dist/server.js',
+        },
+        dependencies: {
+          '@davaux/multisite': 'latest',
+          davaux: 'latest',
+        },
+        devDependencies: {
+          '@biomejs/biome': 'latest',
+          '@types/node': 'latest',
+          tsx: 'latest',
+        },
+      },
+      null,
+      2,
+    ) + '\n'
+  )
+}
+
+function tsConfig() {
+  return (
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: 'ESNext',
+          module: 'NodeNext',
+          moduleResolution: 'NodeNext',
+          jsx: 'react-jsx',
+          jsxImportSource: 'davaux',
+          strict: true,
+          lib: ['ESNext', 'DOM'],
+          allowImportingTsExtensions: true,
+          noEmit: true,
+          skipLibCheck: true,
+          types: ['node', 'davaux/env'],
+        },
+        include: ['src/**/*', 'sites/**/*', '*.ts'],
+      },
+      null,
+      2,
+    ) + '\n'
+  )
+}
+
+function biomeConfig() {
+  return (
+    JSON.stringify(
+      {
+        $schema: 'https://biomejs.dev/schemas/2.4.15/schema.json',
+        assist: { actions: { source: { organizeImports: 'on' } } },
+        linter: {
+          enabled: true,
+          rules: {
+            recommended: true,
+            correctness: {
+              noUnusedVariables: 'error',
+              noUnusedImports: 'error',
+            },
+            style: {
+              noNonNullAssertion: 'warn',
+            },
+          },
+        },
+        formatter: {
+          enabled: true,
+          indentStyle: 'space',
+          indentWidth: 2,
+          lineWidth: 100,
+        },
+        javascript: {
+          formatter: {
+            quoteStyle: 'single',
+            trailingCommas: 'all',
+            semicolons: 'asNeeded',
+          },
+        },
+        css: {
+          formatter: {
+            enabled: true,
+            quoteStyle: 'single',
+          },
+        },
+        files: {
+          includes: ['src/**', 'sites/**', '*.ts'],
+        },
+      },
+      null,
+      2,
+    ) + '\n'
+  )
+}
+
+function multisiteConfig() {
+  return `import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { defineSites } from '@davaux/multisite'
+
+const root = fileURLToPath(new URL('.', import.meta.url))
+
+export interface SiteConfig {
+  name: string
+  primaryColor: string
+}
+
+export const sites = defineSites<SiteConfig>({
+  baseDir: join(root, 'src/routes'),
+  sites: [
+    {
+      name: 'main',
+      hostname: 'localhost',
+      routesDir: join(root, 'sites/main/routes'),
+      config: { name: 'Main Site', primaryColor: '#1d4ed8' },
+    },
+    {
+      name: 'fallback',
+      hostname: '*',
+      config: { name: 'Fallback', primaryColor: '#374151' },
+    },
+  ],
+})
+`
+}
+
+function serverEntry() {
+  return `import { startMultisite } from '@davaux/multisite'
+import { sites } from './multisite.config.js'
+
+startMultisite(sites, { port: 3000, hostname: 'localhost', cwd: import.meta.dirname })
+`
+}
+
+function buildEntry() {
+  return `import { buildMultisite } from '@davaux/multisite/build'
+import { sites } from './multisite.config.js'
+
+await buildMultisite(sites, { cwd: import.meta.dirname })
+`
+}
+
+function baseLayout(title: string) {
+  return `import { defineLayout } from 'davaux'
+
+export default defineLayout(({ children, ctx }) => (
+  <html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>{ctx.head.title ?? '${title}'}</title>
+      {ctx.head.description && <meta name="description" content={ctx.head.description} />}
+      {Object.entries(ctx.head.meta).map(([name, content]) => (
+        <meta name={name} content={content} />
+      ))}
+      {ctx.head.stylesheets.map((href) => (
+        <link rel="stylesheet" href={href} />
+      ))}
+    </head>
+    <body>
+      {children as unknown as string}
+      {ctx.head.scripts.map((src) => (
+        <script type="module" src={src}></script>
+      ))}
+    </body>
+  </html>
+))
+`
+}
+
+function baseIndexPage(title: string) {
+  return `import { definePage } from 'davaux'
+
+export default definePage((ctx) => {
+  ctx.head.title = '${title}'
+  return (
+    <main>
+      <h1>Welcome to ${title}</h1>
+      <p>
+        This page is served from the shared base routes (<code>src/routes/</code>). It is visible
+        at any hostname not explicitly registered in <code>multisite.config.ts</code> — in this
+        project, that means any hostname other than <code>localhost</code>.
+      </p>
+      <h2>Get started</h2>
+      <ul>
+        <li>
+          <a href="https://davaux.codeberg.page/docs/packages/multisite">@davaux/multisite</a>
+          {' — '}concepts, API reference, and operating modes
+        </li>
+        <li>
+          <a href="https://davaux.codeberg.page/docs/routing">Routing</a>
+          {' — '}file-based routing, dynamic segments, layouts, and middlewares
+        </li>
+        <li>
+          <a href="https://davaux.codeberg.page/docs/getting-started">Getting started</a>
+          {' — '}core Davaux concepts
+        </li>
+      </ul>
+      <h2>Project structure</h2>
+      <ul>
+        <li>
+          <code>multisite.config.ts</code> — site definitions and per-site config
+        </li>
+        <li>
+          <code>src/routes/</code> — shared base routes (you are here)
+        </li>
+        <li>
+          <code>sites/main/routes/</code> — main site overrides (served at <code>localhost</code>)
+        </li>
+        <li>
+          <code>server.ts</code> — starts the dev and production server
+        </li>
+        <li>
+          <code>build.ts</code> — production build script
+        </li>
+      </ul>
+    </main>
+  )
+})
+`
+}
+
+function siteLayout() {
+  return `export { default } from '../../../src/routes/_layout.js'
+`
+}
+
+function siteIndexPage(title: string) {
+  return `import { definePage } from 'davaux'
+import { getSite } from '@davaux/multisite'
+import type { SiteConfig } from '../../../multisite.config.js'
+
+export default definePage((ctx) => {
+  const site = getSite<SiteConfig>(ctx)
+  ctx.head.title = site?.name ?? '${title}'
+  return (
+    <main>
+      <h1>Welcome to {site?.name ?? '${title}'}</h1>
+      <p>
+        You're looking at the <strong>main</strong> site. Edit{' '}
+        <code>sites/main/routes/index.page.tsx</code> to get started.
+      </p>
+      <p>
+        Site config is defined in <code>multisite.config.ts</code> and accessed here via{' '}
+        <code>getSite(ctx)</code>. Use it for per-site themes, database URLs, feature flags —
+        anything that varies between sites.
+      </p>
+    </main>
+  )
+})
+`
+}

package/src/create.ts

@@ -0,0 +1,194 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+export async function scaffold(name: string | undefined, cwd: string) {
+  if (!name) {
+    console.error('Usage: davaux create <project-name>')
+    process.exit(1)
+  }
+
+  if (!/^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/.test(name)) {
+    console.error(
+      `[davaux] Invalid project name "${name}". Use lowercase letters, numbers, hyphens, underscores, or dots.`,
+    )
+    process.exit(1)
+  }
+
+  const dir = resolve(cwd, name)
+
+  if (existsSync(dir)) {
+    console.error(`[davaux] Directory "${name}" already exists.`)
+    process.exit(1)
+  }
+
+  const title = name.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
+
+  mkdirSync(join(dir, 'src', 'routes'), { recursive: true })
+  mkdirSync(join(dir, 'public'), { recursive: true })
+
+  write(dir, 'package.json', packageJson(name))
+  write(dir, 'tsconfig.json', tsConfig())
+  write(dir, 'davaux.config.ts', davauxConfig())
+  write(dir, 'biome.json', biomeConfig())
+  write(dir, 'src/routes/_layout.tsx', layout(title))
+  write(dir, 'src/routes/index.page.tsx', indexPage(title))
+
+  console.log(`\n  Created project: ${name}\n`)
+  console.log('  Next steps:\n')
+  console.log(`    cd ${name}`)
+  console.log('    npm install')
+  console.log('    npm run dev\n')
+}
+
+function write(dir: string, file: string, content: string) {
+  writeFileSync(join(dir, file), content, 'utf8')
+}
+
+function packageJson(name: string) {
+  return (
+    JSON.stringify(
+      {
+        name,
+        version: '0.1.0',
+        type: 'module',
+        scripts: {
+          dev: 'davaux dev',
+          build: 'davaux build',
+          start: 'davaux start',
+        },
+        dependencies: {
+          davaux: 'latest',
+        },
+        devDependencies: {
+          '@biomejs/biome': 'latest',
+          '@types/node': 'latest',
+        },
+      },
+      null,
+      2,
+    ) + '\n'
+  )
+}
+
+function tsConfig() {
+  return (
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: 'ESNext',
+          module: 'NodeNext',
+          moduleResolution: 'NodeNext',
+          jsx: 'react-jsx',
+          jsxImportSource: 'davaux',
+          strict: true,
+          lib: ['ESNext', 'DOM'],
+          allowImportingTsExtensions: true,
+          noEmit: true,
+          skipLibCheck: true,
+          types: ['node', 'davaux/env'],
+        },
+        include: ['src/**/*'],
+      },
+      null,
+      2,
+    ) + '\n'
+  )
+}
+
+function davauxConfig() {
+  return `import { defineConfig } from 'davaux/config'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+    hostname: 'localhost',
+  },
+})
+`
+}
+
+function biomeConfig() {
+  return (
+    JSON.stringify(
+      {
+        $schema: 'https://biomejs.dev/schemas/2.4.15/schema.json',
+        assist: { actions: { source: { organizeImports: 'on' } } },
+        linter: {
+          enabled: true,
+          rules: {
+            recommended: true,
+            correctness: {
+              noUnusedVariables: 'error',
+              noUnusedImports: 'error',
+            },
+            style: {
+              noNonNullAssertion: 'warn',
+            },
+          },
+        },
+        formatter: {
+          enabled: true,
+          indentStyle: 'space',
+          indentWidth: 2,
+          lineWidth: 100,
+        },
+        javascript: {
+          formatter: {
+            quoteStyle: 'single',
+            trailingCommas: 'all',
+            semicolons: 'asNeeded',
+          },
+        },
+        css: {
+          formatter: {
+            enabled: true,
+            quoteStyle: 'single',
+          },
+        },
+        files: {
+          includes: ['src/**'],
+        },
+      },
+      null,
+      2,
+    ) + '\n'
+  )
+}
+
+function layout(title: string) {
+  return `import { defineLayout } from 'davaux'
+
+export default defineLayout(({ children, ctx }) => (
+  <html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>{ctx.head.title ?? '${title}'}</title>
+      {ctx.head.description && <meta name="description" content={ctx.head.description} />}
+      {Object.entries(ctx.head.meta).map(([name, content]) => (
+        <meta name={name} content={content} />
+      ))}
+      {ctx.head.stylesheets.map((href) => (
+        <link rel="stylesheet" href={href} />
+      ))}
+    </head>
+    <body>
+      {children as unknown as string}
+      {ctx.head.scripts.map((src) => (
+        <script type="module" src={src}></script>
+      ))}
+    </body>
+  </html>
+))
+`
+}
+
+function indexPage(title: string) {
+  return `import { definePage } from 'davaux'
+
+export default definePage((ctx) => {
+  ctx.head.title = '${title}'
+  return <h1>Welcome to ${title}</h1>
+})
+`
+}

package/src/dev/blueprints.ts

@@ -0,0 +1,75 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { extname, join } from 'node:path'
+import { renderToHtml } from '../oml/render.js'
+import type { OmlBlueprint, OmlPropSchema, OmlPropType } from '../oml/types.js'
+import { parseOmlBlueprint } from '../oml/types.js'
+
+export type BlueprintEntry = {
+  id: string
+  name: string
+  props: Record<string, OmlPropSchema>
+  previewHtml: string
+  jsxSnippet: string
+  imports: Record<string, string>
+}
+
+function collectJsonFiles(dir: string, out: string[]): void {
+  if (!existsSync(dir)) return
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry)
+    if (statSync(full).isDirectory()) {
+      collectJsonFiles(full, out)
+    } else if (extname(entry) === '.json') {
+      out.push(full)
+    }
+  }
+}
+
+function propPlaceholder(schema: OmlPropSchema): string {
+  if (schema.default !== undefined) {
+    const d = schema.default
+    if (typeof d === 'string') return `"${d}"`
+    return `{${JSON.stringify(d)}}`
+  }
+  const placeholders: Record<OmlPropType, string> = {
+    string: '"example"',
+    number: '{0}',
+    boolean: '{false}',
+    function: '{() => {}}',
+    node: '"content"',
+    array: '{[]}',
+  }
+  return placeholders[schema.type] ?? '"example"'
+}
+
+function toUsageJsx(bp: OmlBlueprint): string {
+  const entries = Object.entries(bp.props)
+  if (entries.length === 0) return `<${bp.name} />`
+  const lines = entries.map(([name, schema]) => `  ${name}=${propPlaceholder(schema)}`)
+  return `<${bp.name}\n${lines.join('\n')}\n/>`
+}
+
+export function scanBlueprints(cwd: string): BlueprintEntry[] {
+  const files: string[] = []
+  collectJsonFiles(join(cwd, 'src', 'blueprints'), files)
+  collectJsonFiles(join(cwd, 'src', 'components'), files)
+
+  const results: BlueprintEntry[] = []
+  for (const filePath of files) {
+    try {
+      const raw = JSON.parse(readFileSync(filePath, 'utf-8'))
+      const bp = parseOmlBlueprint(raw)
+      results.push({
+        id: bp.id,
+        name: bp.name,
+        props: bp.props,
+        previewHtml: bp.output ? renderToHtml(bp.output) : '',
+        jsxSnippet: toUsageJsx(bp),
+        imports: bp.imports ?? {},
+      })
+    } catch {
+      // Skip files that aren't valid blueprints
+    }
+  }
+  return results
+}

package/src/dev/components.ts

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { basename, extname, join, relative } from 'node:path'
+import type { OmlPropSchema, OmlPropType } from '../oml/types.js'
+
+export type ComponentEntry = {
+  name: string
+  file: string
+  importPath: string
+  props: Record<string, OmlPropSchema>
+  hasBlueprintAlready: boolean
+}
+
+function mapTsType(rawType: string): OmlPropType {
+  const t = rawType
+    .trim()
+    .replace(/\s*[|&]\s*(undefined|null)$/g, '')
+    .trim()
+  if (t === 'string') return 'string'
+  if (t === 'number') return 'number'
+  if (t === 'boolean') return 'boolean'
+  if (/ReactNode|JSX\.Element|React\.ReactNode|OmlNode|OmlChild|VNode/.test(t)) return 'node'
+  if (/Array<|[[\]]/.test(t)) return 'array'
+  if (/=>/.test(t) || t === 'Function' || t.startsWith('(')) return 'function'
+  return 'string'
+}
+
+function extractProps(source: string): Record<string, OmlPropSchema> {
+  const props: Record<string, OmlPropSchema> = {}
+  const m = source.match(/(?:interface\s+Props|type\s+Props\s*=)\s*\{([\s\S]*?)\}/)
+  if (!m) return props
+  for (const line of m[1].split('\n')) {
+    const pm = line.match(/^\s*([a-zA-Z_$][a-zA-Z0-9_$]*)(\?)?\s*:\s*([^;,\n]+)/)
+    if (!pm) continue
+    const name = pm[1]
+    if (name === 'children') continue
+    props[name] = { type: mapTsType(pm[3].trim()), required: pm[2] !== '?' }
+  }
+  return props
+}
+
+function collectComponentFiles(dir: string, out: string[]): void {
+  if (!existsSync(dir)) return
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry)
+    if (statSync(full).isDirectory()) {
+      collectComponentFiles(full, out)
+    } else if (['.tsx', '.ts', '.jsx', '.js'].includes(extname(entry)) && /^[A-Z]/.test(entry)) {
+      out.push(full)
+    }
+  }
+}
+
+export function scanComponents(dir: string, cwd: string, blueprintsDir: string): ComponentEntry[] {
+  const files: string[] = []
+  collectComponentFiles(dir, files)
+  const routesDir = join(cwd, 'src', 'routes')
+  return files.map((filePath) => {
+    const name = basename(filePath, extname(filePath))
+    let props: Record<string, OmlPropSchema> = {}
+    try {
+      props = extractProps(readFileSync(filePath, 'utf-8'))
+    } catch {}
+    const noExt = filePath.replace(/\.(tsx?|jsx?)$/, '')
+    const rel = relative(routesDir, noExt)
+    const importPath = rel.startsWith('.') ? rel : `../${rel}`
+    return {
+      name,
+      file: relative(cwd, filePath),
+      importPath,
+      props,
+      hasBlueprintAlready: existsSync(join(blueprintsDir, `${name}.oml.json`)),
+    }
+  })
+}
+
+export function updateBlueprint(
+  id: string,
+  name: string,
+  props: Record<string, OmlPropSchema>,
+  blueprintsDir: string,
+): { saved: boolean; error?: string } {
+  const filePath = join(blueprintsDir, `${id}.oml.json`)
+  try {
+    let existing: Record<string, unknown> = {}
+    if (existsSync(filePath)) existing = JSON.parse(readFileSync(filePath, 'utf-8'))
+    writeFileSync(filePath, JSON.stringify({ ...existing, id, name, props }, null, 2), 'utf-8')
+    return { saved: true }
+  } catch (e) {
+    return { saved: false, error: String(e) }
+  }
+}
+
+export function saveBlueprint(
+  name: string,
+  props: Record<string, OmlPropSchema>,
+  imports: Record<string, string>,
+  blueprintsDir: string,
+): { saved: boolean; file?: string; error?: string } {
+  try {
+    if (!existsSync(blueprintsDir)) mkdirSync(blueprintsDir, { recursive: true })
+    const bp = { id: name, name, props, return: null, imports }
+    const filePath = join(blueprintsDir, `${name}.oml.json`)
+    writeFileSync(filePath, JSON.stringify(bp, null, 2), 'utf-8')
+    return { saved: true, file: filePath }
+  } catch (e) {
+    return { saved: false, error: String(e) }
+  }
+}