feat: addl build testing -d

Author: arpowers

.fiction/config.ts

@@ -6,6 +6,7 @@
 export interface CompiledServiceConfig {
   commands: 'bundle' | 'release' | 'render'
   vars:
+    | 'APOLLO_API_KEY'
     | 'AWS_ACCESS_KEY'
     | 'AWS_ACCESS_KEY_SECRET'
     | 'AWS_BUCKET_MEDIA'

@fiction/analytics/index.ts

@@ -7,7 +7,7 @@ import { FictionBeacon } from './plugin-beacon'
 vars.register(() => [new EnvVar({ name: 'CLICKHOUSE_URL' })])
 
 type FictionAnalyticsSettings = {
-  clickhouseUrl?: string
+  clickhouseUrl: string
   fictionServer: FictionServer
   fictionUser?: FictionUser
   fictionCache: FictionCache
@@ -21,11 +21,7 @@ export class FictionAnalytics extends FictionPlugin<FictionAnalyticsSettings> {
     super('FictionAnalytics', { root: safeDirname(import.meta.url), ...settings })
 
     this.fictionClickhouse = new FictionClickHouse({ fictionAnalytics: this, ...this.settings })
-    this.fictionBeacon = new FictionBeacon({
-      fictionAnalytics: this,
-      fictionClickHouse: this.fictionClickhouse,
-      ...this.settings,
-    })
+    this.fictionBeacon = new FictionBeacon({ fictionAnalytics: this, fictionClickHouse: this.fictionClickhouse, ...this.settings })
   }
 
   async close() {

@fiction/analytics/plugin-clickhouse/index.ts

@@ -16,7 +16,7 @@ export * from './types.js'
 vars.register(() => [new EnvVar({ name: 'CLICKHOUSE_URL' })])
 
 type FictionClickHouseSettings = {
-  clickhouseUrl?: string
+  clickhouseUrl: string
   fictionServer: FictionServer
   fictionUser?: FictionUser
   fictionAnalytics?: FictionAnalytics
@@ -54,16 +54,21 @@ export class FictionClickHouse extends FictionPlugin<FictionClickHouseSettings>
   constructor(settings: FictionClickHouseSettings) {
     super('clickhouse', settings)
 
-    if (settings.clickhouseUrl)
+    if (!settings.clickhouseUrl && !this.fictionEnv.isApp.value) {
+      throw new Error('no clickhouse connection url')
+    }
+    else if (settings.clickhouseUrl) {
       this.connectionUrl = new URL(settings.clickhouseUrl)
+    }
   }
 
   async close() {
     // close the connection
+    await this.db.destroy()
   }
 
   async init() {
-    if (!isNode())
+    if (this.fictionEnv.isApp.value)
       return
 
     if (!this.connectionUrl)

@fiction/core/plugin-env/index.ts

@@ -2,7 +2,7 @@ import path from 'node:path'
 import dotenv from 'dotenv'
 import { FictionObject } from '../plugin.js'
 import type { HookType, UserNotification } from '../utils/index.js'
-import { camelToUpperSnake, crossVar, isApp, isCi, isDev, isNode, isTest, onResetUi, resetUi, runHooks, runHooksSync, shortId, toSlug, vue } from '../utils/index.js'
+import { camelToUpperSnake, crossVar, isApp, isCi, isDev, isNode, isTest, onResetUi, resetUi, runHooks, runHooksSync, shortId, toSlug, vue, waitFor } from '../utils/index.js'
 import { version as fictionVersion } from '../package.json'
 import type { RunVars } from '../inject.js'
 import { TypedEventTarget } from '../utils/eventTarget.js'
@@ -417,7 +417,8 @@ export class FictionEnv<
 
     if (cliCommand.options.exit) {
       const reason = `--exit flag set`
-      this.log.info(`shutting down`, { data: { reason } })
+      this.log.warn(`shutting down`, { data: { reason } })
+      await waitFor(1000)
       this.events.emit('shutdown', { reason })
     }
   }

@fiction/core/test-utils/buildTest.ts

@@ -301,9 +301,10 @@ export async function appBuildTests(config: { moduleName?: string, cwd?: string,
 
   const logger = log.contextLogger('UIUX')
   const BUILD_TIMEOUT = 180_000
-  const { portOptions } = getModifiedCommands(config.commands)
+  const { portOptions, commands } = getModifiedCommands(config.commands)
 
-  const checkRunCommand = async (runCommand: string) => {
+  const checkRunCommand = async (runCommand: string, opts: { portCommand?: string } = {}) => {
+    const { portCommand = '' } = opts
     const command = [`npm -w ${moduleName} exec -- fiction run ${runCommand} --exit`, ...portOptions].join(' ')
 
     try {
@@ -312,6 +313,23 @@ export async function appBuildTests(config: { moduleName?: string, cwd?: string,
         envVars: { IS_TEST: '1', TEST_ENV: 'unit' },
         timeout: BUILD_TIMEOUT,
         resolveText: '[ready]',
+        beforeResolve: async () => {
+          const url = commands.find(_ => _.command === runCommand || (portCommand && _.command === portCommand))?.url.value
+          try {
+            logger.info(`RUN CHECK START`, { data: { command, url } })
+
+            if (!url)
+              throw new Error('no url')
+
+            await fetch(url)
+
+            logger.info('RUN CHECK DONE', { data: { url } })
+          }
+          catch (error) {
+            logger.error('FETCH PROBLEM', { error, data: { commands, runCommand, url } })
+            throw error
+          }
+        },
       })
 
       expect(r.stdout).toContain('[ready]')
@@ -346,7 +364,7 @@ export async function appBuildTests(config: { moduleName?: string, cwd?: string,
     }, BUILD_TIMEOUT)
 
     it(`RUNS DEV: ${moduleName}`, async () => {
-      await checkRunCommand('dev')
+      await checkRunCommand('dev', { portCommand: 'app' })
     }, BUILD_TIMEOUT)
 
     it(`LOADS WITHOUT ERROR: ${moduleName}`, async () => {

@fiction/core/utils/nodeUtils.ts

@@ -11,6 +11,7 @@ import type { PackageJson } from '../types'
 import { log } from '../plugin-log'
 import { isNode } from './vars'
 import { formatBytes } from './number'
+import { waitFor } from './utils.js'
 
 interface WhichModule {
   moduleName?: string
@@ -42,6 +43,7 @@ export async function executeCommand(args: {
   envVars?: { [key: string]: string }
   timeout?: number
   resolveText?: string
+  beforeResolve?: () => Promise<void>
   triggerText?: string
   onTrigger?: (args: { stdout: string, stderr: string, text: string, close: () => void, cp: ResultPromise }) => Promise<void> | void
 }) {
@@ -68,23 +70,34 @@ export async function executeCommand(args: {
         resolve(1)
       }
 
-      const onText = (text: string) => {
-        if (resolveText && text.includes(resolveText))
+      const onText = async (text: string) => {
+        if (resolveText && text.includes(resolveText)) {
+          if (args.beforeResolve) {
+            try {
+              await args.beforeResolve()
+              await waitFor(1000)
+            }
+            catch (error) {
+              reject(error)
+            }
+          }
+
           resolve(text)
+        }
         // close()
 
         if (args.triggerText && text.includes(args.triggerText) && args.onTrigger)
           void args.onTrigger({ ...commandDetails(), text, close, cp })
       }
 
-      cp.stdout?.on('data', (d: Buffer) => {
+      cp.stdout?.on('data', async (d: Buffer) => {
         output.push(d.toString())
-        onText(d.toString())
+        await onText(d.toString())
       })
 
       cp.stderr?.on('data', async (d: Buffer) => {
         errorsOutput.push(d.toString())
-        onText(d.toString())
+        await onText(d.toString())
       })
 
       void cp.on('close', (code) => {