@eighty4/dank 0.0.5-0 → 0.0.5-2

package/lib/developer.ts

@@ -32,44 +32,101 @@ export type LogEvent = {
 
 type LogEventData =
     | LogEventDatum
-    | Array<LogEventDatum>
-    | Set<LogEventDatum>
-    | Record<string, LogEventDatum>
+    | LogEventDataArray
+    | LogEventDataRecord
+    | LogEventDataSet
 
 type LogEventDatum = boolean | number | string | null | undefined
 
+type LogEventDataArray = Array<LogEventDatum> | Array<LogEventDataRecord>
+
+type LogEventDataRecord = Record<
+    string,
+    LogEventDatum | LogEventDataArray | LogEventDataSet
+>
+
+type LogEventDataSet = Set<LogEventDatum>
+
 function toStringLogEvent(logEvent: LogEvent): string {
     const when = new Date().toISOString()
     const message = `[${logEvent.realm}] ${logEvent.message}\n${when}\n`
-    if (!logEvent.data) {
+    if (logEvent.data) {
+        const data: string = Object.keys(logEvent.data)
+            .sort()
+            .map(key => toStringData(key, logEvent.data![key]))
+            .join('')
+        return `${message}\n${data}`
+    } else {
         return message
     }
-    let data = ''
-    for (const k of Object.keys(logEvent.data).sort()) {
-        data += `\n    ${k} = ${toStringData(logEvent.data[k])}`
-    }
-    return `${message}${data}\n`
 }
 
-function toStringData(datum: LogEventData): string {
-    if (datum instanceof Set) {
-        datum = Array.from(datum)
+const PAD = '    '
+const nextIndent = (pad: string) => pad + PAD
+
+function toStringData(
+    key: string,
+    data: LogEventData,
+    pad: string = PAD,
+): string {
+    const prepend = `${pad}${key} = `
+    if (isDataAbsentOrScalar(data)) {
+        return `${prepend}${toStringDatum(data)}`
     }
-    if (
-        datum !== null &&
-        typeof datum === 'object' &&
-        datum.constructor.name === 'Object'
-    ) {
-        datum = Object.entries(datum).map(([k, v]) => `${k} = ${v}`)
+    if (data instanceof Set) {
+        data = Array.from(data)
     }
-    if (Array.isArray(datum)) {
-        if (datum.length === 0) {
-            return '[]'
-        } else {
-            return `[\n        ${datum.join('\n        ')}\n    ]`
-        }
+    if (Array.isArray(data)) {
+        return `${prepend}${toStringArray(data, pad)}`
     } else {
-        return `${datum}`
+        return `${prepend}${toStringRecord(data, pad)}`
+    }
+}
+
+function toStringDatum(datum: LogEventDatum): string {
+    return `${datum}\n`
+}
+
+function toStringArray(array: LogEventDataArray, padEnding: string): string {
+    if (array.length === 0) {
+        return '[]'
+    }
+    const padIndent = nextIndent(padEnding)
+    const content = array
+        .map(datum => {
+            if (isDataAbsentOrScalar(datum)) {
+                return toStringDatum(datum)
+            } else {
+                return toStringRecord(datum, padIndent)
+            }
+        })
+        .join(padIndent)
+    return `[\n${padIndent}${content}${padEnding}]\n`
+}
+
+function toStringRecord(record: LogEventDataRecord, padEnding: string): string {
+    const keys = Object.keys(record)
+    if (keys.length === 0) {
+        return '{}'
+    }
+    const padIndent = nextIndent(padEnding)
+    const content = keys
+        .map(key => toStringData(key, record[key], padIndent))
+        .join('')
+    return `{\n${content}${padEnding}}\n`
+}
+
+function isDataAbsentOrScalar(
+    data: LogEventData,
+): data is undefined | null | string | boolean | number {
+    switch (typeof data) {
+        case 'undefined':
+        case 'string':
+        case 'boolean':
+        case 'number':
+            return true
+        default:
+            return data === null
     }
 }
 
@@ -79,7 +136,7 @@ function logToConsoleAndFile(out: string) {
 }
 
 function logToConsole(out: string) {
-    console.log('\n' + out)
+    console.log(out)
 }
 
 function logToFile(out: string) {

package/lib/dirs.ts

@@ -7,8 +7,7 @@ export type DankDirectories = {
     buildWatch: string
     buildDist: string
     pages: string
-    pagesResolved: string
-    projectResolved: string
+    pagesAbs: string
     projectRootAbs: string
     public: string
 }
@@ -17,18 +16,18 @@ export async function defaultProjectDirs(
     projectRootAbs: string,
 ): Promise<Readonly<DankDirectories>> {
     if (!isAbsolute(projectRootAbs)) {
-        throw Error()
+        throw Error('must use an absolute project root path')
+    }
+    if ((await realpath(projectRootAbs)) !== projectRootAbs) {
+        throw Error('must use a real project root path')
     }
-    const projectResolved = await realpath(projectRootAbs)
     const pages = 'pages'
-    const pagesResolved = join(projectResolved, pages)
     return Object.freeze({
         buildRoot: 'build',
         buildDist: join('build', 'dist'),
         buildWatch: join('build', 'watch'),
         pages,
-        pagesResolved,
-        projectResolved,
+        pagesAbs: join(projectRootAbs, pages),
         projectRootAbs,
         public: 'public',
     })
@@ -63,8 +62,8 @@ export class Resolver {
 
     // `p` is expected to be a relative path resolvable from the project dir
     isProjectSubpathInPagesDir(p: string): boolean {
-        return resolve(join(this.#dirs.projectResolved, p)).startsWith(
-            this.#dirs.pagesResolved,
+        return resolve(join(this.#dirs.projectRootAbs, p)).startsWith(
+            this.#dirs.pagesAbs,
         )
     }
 

package/lib/http.ts

@@ -18,7 +18,7 @@ import type {
     WebsiteManifest,
     WebsiteRegistry,
 } from './registry.ts'
-import type { HttpServices } from './services.ts'
+import type { DevServices } from './services.ts'
 
 export type FrontendFetcher = (
     url: URL,
@@ -33,7 +33,7 @@ export function startWebServer(
     dirs: DankDirectories,
     urlRewriteProvider: UrlRewriteProvider,
     frontendFetcher: FrontendFetcher,
-    httpServices: HttpServices,
+    devServices: DevServices,
 ) {
     const serverAddress = 'http://localhost:' + port
     const handler = (req: IncomingMessage, res: ServerResponse) => {
@@ -47,7 +47,7 @@ export function startWebServer(
                     req,
                     url,
                     headers,
-                    httpServices,
+                    devServices,
                     flags,
                     dirs,
                     urlRewriteProvider,
@@ -69,7 +69,7 @@ async function onNotFound(
     req: IncomingMessage,
     url: URL,
     headers: Headers,
-    httpServices: HttpServices,
+    devServices: DevServices,
     flags: DankFlags,
     dirs: DankDirectories,
     urlRewriteProvider: UrlRewriteProvider,
@@ -87,7 +87,7 @@ async function onNotFound(
             return
         }
     }
-    const fetchResponse = await tryHttpServices(req, url, headers, httpServices)
+    const fetchResponse = await tryHttpServices(req, url, headers, devServices)
     if (fetchResponse) {
         sendFetchResponse(res, fetchResponse)
     } else {
@@ -131,14 +131,13 @@ async function tryHttpServices(
     req: IncomingMessage,
     url: URL,
     headers: Headers,
-    httpServices: HttpServices,
+    devServices: DevServices,
 ): Promise<Response | null> {
     if (url.pathname.startsWith('/.well-known/')) {
         return null
     }
     const body = await collectReqBody(req)
-    const { running } = httpServices
-    for (const httpService of running) {
+    for (const httpService of devServices.httpServices) {
         const proxyUrl = new URL(url)
         proxyUrl.port = `${httpService.port}`
         try {
@@ -198,7 +197,7 @@ export function createBuiltDistFilesFetcher(
         if (manifest.pageUrls.has(url.pathname)) {
             streamFile(
                 join(
-                    dirs.projectResolved,
+                    dirs.projectRootAbs,
                     dirs.buildDist,
                     url.pathname,
                     'index.html',
@@ -207,7 +206,7 @@ export function createBuiltDistFilesFetcher(
             )
         } else if (manifest.files.has(url.pathname)) {
             streamFile(
-                join(dirs.projectResolved, dirs.buildDist, url.pathname),
+                join(dirs.projectRootAbs, dirs.buildDist, url.pathname),
                 res,
             )
         } else {

package/lib/serve.ts

@@ -13,7 +13,7 @@ import {
     startWebServer,
 } from './http.ts'
 import { WebsiteRegistry, type UrlRewrite } from './registry.ts'
-import { startDevServices, updateDevServices } from './services.ts'
+import { DevServices, type ManagedServiceLabel } from './services.ts'
 import { watch } from './watch.ts'
 
 let c: ResolvedDankConfig
@@ -21,20 +21,18 @@ let c: ResolvedDankConfig
 export async function serveWebsite(): Promise<never> {
     c = await loadConfig('serve', process.cwd())
     await rm(c.dirs.buildRoot, { force: true, recursive: true })
-    const abortController = new AbortController()
-    process.once('exit', () => abortController.abort())
     if (c.flags.preview) {
-        await startPreviewMode(abortController.signal)
+        await startPreviewMode()
     } else {
-        await startDevMode(abortController.signal)
+        await startDevMode()
     }
     return new Promise(() => {})
 }
 
-async function startPreviewMode(signal: AbortSignal) {
+async function startPreviewMode() {
     const manifest = await buildWebsite(c)
     const frontend = createBuiltDistFilesFetcher(c.dirs, manifest)
-    const devServices = startDevServices(c.services, signal)
+    const devServices = launchDevServices()
     const urlRewrites: Array<UrlRewrite> = Object.keys(c.pages)
         .sort()
         .map(url => {
@@ -50,8 +48,17 @@ async function startPreviewMode(signal: AbortSignal) {
         c.dirs,
         { urlRewrites },
         frontend,
-        devServices.http,
+        devServices,
     )
+    const controller = new AbortController()
+    watch('dank.config.ts', controller.signal, async filename => {
+        console.log(filename, 'was updated!')
+        console.log(
+            'config updates are not hot reloaded during `dank serve --preview`',
+        )
+        console.log('restart DANK to reload configuration')
+        controller.abort()
+    })
 }
 
 type BuildContextState =
@@ -61,12 +68,12 @@ type BuildContextState =
     | 'disposing'
     | null
 
-async function startDevMode(signal: AbortSignal) {
+async function startDevMode() {
     const registry = new WebsiteRegistry(c)
     await mkdir(c.dirs.buildWatch, { recursive: true })
     let buildContext: BuildContextState = null
 
-    watch('dank.config.ts', signal, async filename => {
+    watch('dank.config.ts', async filename => {
         LOG({
             realm: 'serve',
             message: 'config watch event',
@@ -80,10 +87,10 @@ async function startDevMode(signal: AbortSignal) {
             return
         }
         registry.configSync()
-        updateDevServices(c.services)
+        devServices.update(c.services)
     })
 
-    watch(c.dirs.pages, signal, filename => {
+    watch(c.dirs.pages, { recursive: true }, filename => {
         LOG({
             realm: 'serve',
             message: 'pages dir watch event',
@@ -163,15 +170,8 @@ async function startDevMode(signal: AbortSignal) {
     resetBuildContext()
 
     const frontend = createDevServeFilesFetcher(c.esbuildPort, c.dirs, registry)
-    const devServices = startDevServices(c.services, signal)
-    startWebServer(
-        c.dankPort,
-        c.flags,
-        c.dirs,
-        registry,
-        frontend,
-        devServices.http,
-    )
+    const devServices = launchDevServices()
+    startWebServer(c.dankPort, c.flags, c.dirs, registry, frontend, devServices)
 }
 
 async function startEsbuildWatch(
@@ -220,3 +220,47 @@ async function writeHtml(html: HtmlEntrypoint, output: string) {
     })
     await writeFile(path, output)
 }
+
+function launchDevServices(): DevServices {
+    const services = new DevServices(c.services)
+    services.on('error', (label, cause) =>
+        console.log(formatServiceLabel(label), 'errored:', cause),
+    )
+    services.on('exit', (label, code) => {
+        if (code) {
+            console.log(formatServiceLabel(label), 'exited', code)
+        } else {
+            console.log(formatServiceLabel(label), 'exited')
+        }
+    })
+    services.on('launch', label =>
+        console.log(formatServiceLabel(label), 'starting'),
+    )
+    services.on('stdout', (label, output) =>
+        printServiceOutput(label, 32, output),
+    )
+    services.on('stderr', (label, output) =>
+        printServiceOutput(label, 31, output),
+    )
+    return services
+}
+
+function formatServiceLabel(label: ManagedServiceLabel): string {
+    return `| \u001b[2m${label.cwd}\u001b[22m ${label.command} |`
+}
+
+function formatServiceOutputLabel(
+    label: ManagedServiceLabel,
+    color: 31 | 32,
+): string {
+    return `\u001b[${color}m${formatServiceLabel(label)}\u001b[39m`
+}
+
+function printServiceOutput(
+    label: ManagedServiceLabel,
+    color: 31 | 32,
+    output: Array<string>,
+) {
+    const formattedLabel = formatServiceOutputLabel(label, color)
+    for (const line of output) console.log(formattedLabel, line)
+}