@eighty4/dank 0.0.5-1 → 0.0.5-3

package/lib/build.ts

@@ -1,6 +1,5 @@
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { createBuildTag } from './build_tag.ts'
 import { loadConfig, type ResolvedDankConfig } from './config.ts'
 import { type DefineDankGlobal, createGlobalDefinitions } from './define.ts'
 import type { DankDirectories } from './dirs.ts'
@@ -14,7 +13,7 @@ export async function buildWebsite(
     if (!c) {
         c = await loadConfig('build', process.cwd())
     }
-    const buildTag = await createBuildTag(c.flags)
+    const buildTag = await c.buildTag()
     console.log(
         c.flags.minify
             ? c.flags.production

package/lib/build_tag.ts

@@ -1,25 +1,129 @@
 import { exec } from 'node:child_process'
+import type { DankConfig } from './dank.ts'
 import type { DankFlags } from './flags.ts'
 
-export async function createBuildTag(flags: DankFlags): Promise<string> {
+export async function createBuildTag(
+    projectDir: string,
+    flags: DankFlags,
+    buildTagSource?: DankConfig['buildTag'],
+): Promise<string> {
+    if (typeof buildTagSource === 'function') {
+        buildTagSource = await buildTagSource({ production: flags.production })
+    }
+    if (typeof buildTagSource === 'undefined' || buildTagSource === null) {
+        buildTagSource = await resolveExpressionDefault(projectDir)
+    }
+    if (typeof buildTagSource !== 'string') {
+        throw TypeError(
+            'DankConfig.buildTag must resolve to a string expession',
+        )
+    }
+    const params: BuildTagParams = {}
     const now = new Date()
+    const paramPattern = new RegExp(/{{\s*(?<name>[a-z][A-Za-z]+)\s*}}/g)
+    let paramMatch: RegExpExecArray | null
+    let buildTag = buildTagSource
+    let offset = 0
+    while ((paramMatch = paramPattern.exec(buildTagSource)) != null) {
+        const paramName = paramMatch.groups!.name.trim() as keyof BuildTagParams
+        let paramValue: string
+        if (params[paramName]) {
+            paramValue = params[paramName]
+        } else {
+            paramValue = params[paramName] = await getParamValue(
+                projectDir,
+                paramName,
+                now,
+                buildTagSource,
+            )
+        }
+        buildTag =
+            buildTag.substring(0, paramMatch.index + offset) +
+            paramValue +
+            buildTag.substring(paramMatch.index + paramMatch[0].length + offset)
+        offset += paramValue.length - paramMatch[0].length
+    }
+    const validate = /^[A-Za-z\d][A-Za-z\d-_\.]+$/
+    if (!validate.test(buildTag)) {
+        throw Error(
+            `build tag ${buildTag} does not pass pattern ${validate.source} validation`,
+        )
+    }
+    return buildTag
+}
+
+async function resolveExpressionDefault(projectDir: string): Promise<string> {
+    const base = '{{ date }}-{{ timeMS }}'
+    const isGitRepo = await new Promise(res =>
+        exec('git rev-parse --is-inside-work-tree', { cwd: projectDir }, err =>
+            res(!err),
+        ),
+    )
+    return isGitRepo ? base + '-{{ gitHash }}' : base
+}
+
+type BuildTagParams = {
+    date?: string
+    gitHash?: string
+    timeMS?: string
+}
+
+async function getParamValue(
+    projectDir: string,
+    name: keyof BuildTagParams,
+    now: Date,
+    buildTagSource: string,
+): Promise<string> {
+    switch (name) {
+        case 'date':
+            return getDate(now)
+        case 'gitHash':
+            try {
+                return await getGitHash(projectDir)
+            } catch (e) {
+                if (e === 'not-repo') {
+                    throw Error(
+                        `buildTag cannot use \`gitHash\` in \`${buildTagSource}\` outside of a git repository`,
+                    )
+                } else {
+                    throw e
+                }
+            }
+        case 'timeMS':
+            return getTimeMS(now)
+        default:
+            throw Error(name + ' is not a supported build tag param')
+    }
+}
+
+function getDate(now: Date): string {
+    return now.toISOString().substring(0, 10)
+}
+
+async function getGitHash(projectDir: string): Promise<string> {
+    return await new Promise((res, rej) =>
+        exec(
+            'git rev-parse --short HEAD',
+            { cwd: projectDir },
+            (err, stdout, stderr) => {
+                if (err) {
+                    if (stderr.includes('not a git repository')) {
+                        rej('not-repo')
+                    } else {
+                        rej(err)
+                    }
+                }
+                res(stdout.trim())
+            },
+        ),
+    )
+}
+
+function getTimeMS(now: Date): string {
     const ms =
         now.getUTCMilliseconds() +
         now.getUTCSeconds() * 1000 +
         now.getUTCMinutes() * 1000 * 60 +
         now.getUTCHours() * 1000 * 60 * 60
-    const date = now.toISOString().substring(0, 10)
-    const time = String(ms).padStart(8, '0')
-    const when = `${date}-${time}`
-    if (flags.production) {
-        const gitHash = await new Promise((res, rej) =>
-            exec('git rev-parse --short HEAD', (err, stdout) => {
-                if (err) rej(err)
-                res(stdout.trim())
-            }),
-        )
-        return `${when}-${gitHash}`
-    } else {
-        return when
-    }
+    return String(ms).padStart(8, '0')
 }

package/lib/config.ts

@@ -1,4 +1,5 @@
 import { isAbsolute, resolve } from 'node:path'
+import { createBuildTag } from './build_tag.ts'
 import type {
     DankConfig,
     DankDetails,
@@ -34,6 +35,8 @@ export type ResolvedDankConfig = {
     get devPages(): Readonly<DankConfig['devPages']>
     get services(): Readonly<DankConfig['services']>
 
+    buildTag(): Promise<string>
+
     reload(): Promise<void>
 }
 
@@ -60,6 +63,7 @@ export async function loadConfig(
 }
 
 class DankConfigInternal implements ResolvedDankConfig {
+    #buildTag: DankConfig['buildTag']
     #dirs: Readonly<DankDirectories>
     #flags: Readonly<DankFlags>
     #mode: 'build' | 'serve'
@@ -119,11 +123,20 @@ class DankConfigInternal implements ResolvedDankConfig {
         return this.#services
     }
 
+    async buildTag(): Promise<string> {
+        return await createBuildTag(
+            this.#dirs.projectRootAbs,
+            this.#flags,
+            this.#buildTag,
+        )
+    }
+
     async reload() {
         const userConfig = await resolveConfig(
             this.#modulePath,
             resolveDankDetails(this.#mode, this.#flags),
         )
+        this.#buildTag = userConfig.buildTag
         this.#dankPort = resolveDankPort(this.#flags, userConfig)
         this.#esbuildPort = resolveEsbuildPort(this.#flags, userConfig)
         this.#esbuild = Object.freeze(userConfig.esbuild)
@@ -173,6 +186,7 @@ function resolveDankDetails(
 function validateDankConfig(c: Partial<DankConfig>) {
     try {
         validatePorts(c)
+        validateBuildTag(c.buildTag)
         validatePages(c.pages)
         validateDevPages(c.devPages)
         validateDevServices(c.services)
@@ -202,6 +216,20 @@ function validatePorts(c: Partial<DankConfig>) {
     }
 }
 
+function validateBuildTag(buildTag: DankConfig['buildTag']) {
+    if (buildTag === null) {
+        return
+    }
+    switch (typeof buildTag) {
+        case 'undefined':
+        case 'string':
+        case 'function':
+            return
+        default:
+            throw Error('DankConfig.buildTag must be a string or function')
+    }
+}
+
 function validateEsbuildConfig(esbuild?: EsbuildConfig) {
     if (esbuild?.loaders !== null && typeof esbuild?.loaders !== 'undefined') {
         if (typeof esbuild.loaders !== 'object') {

package/lib/dank.ts

@@ -1,8 +1,8 @@
 import type { Plugin as EsbuildPlugin } from 'esbuild'
 
 export type DankConfig = {
-    // used for releases and service worker caching
-    // buildTag?:  (() => Promise<string> | string) | string
+    // used for service worker caching
+    buildTag?: string | BuildTagBuilder
 
     // customize esbuild configs
     esbuild?: EsbuildConfig
@@ -26,6 +26,14 @@ export type DankConfig = {
     services?: Array<DevService>
 }
 
+export type BuildTagParams = {
+    production: boolean
+}
+
+export type BuildTagBuilder = (
+    build: BuildTagParams,
+) => Promise<string> | string
+
 // extend an html entrypoint with url rewriting similar to cdn configurations
 // after trying all webpage, bundle and asset paths, mapping patterns
 // will be tested in the alphabetical order of the webpage paths

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)
+}