tungsten 0.2.1 → 0.2.3

package/dist/Servers/hono/DevServerHono.js

@@ -0,0 +1,427 @@
+// import type { Server } from 'http'
+// //import express, { Request, Response, NextFunction, RequestHandler } from 'express'
+// import { Context, Hono } from 'hono'
+// import type { BlankEnv, BlankSchema, Handler, Next } from 'hono/types'
+// import { serve } from '@hono/node-server'
+// import { serveStatic } from '@hono/node-server/serve-static'
+// import { join } from 'path'
+// import { allObj as promiseAllObj } from 'sxy-lib/promises.js'
+// import type { FrameworkConfigComplete, ServerMiddlewareInfo } from '../../FrameworkConfig.js'
+// import type { CompilationInfo } from '../../build/CompilationInfo.js'
+// import type { ApiRoutes } from '../../api/ApiRoutes.js'
+// import {
+//     staticFolder, assetsFolder, publicFolder, packagesFolder, clientFolder, componentCssFolder
+// } from '../../settings.js'
+// import { rootToHtmlDev as renderRootToHtmlDev } from '../../render/rootToHtmlDev.js'
+// import { contentToHtmlDev as renderContentToHtmlDev } from '../../render/contentToHtmlDev.js'
+// import { Instance } from '../../Instance/Instance.js'
+// import { Framework } from '../../Framework.js'
+// import { TungstenError } from '../../TungstenError.js'
+// import { makeInstanceConfigFromFrameworkConfig } from '../../makeInstanceConfigFromFrameworkConfig.js'
+// import { cliNews, cliOut, cliWarn, cliLog, cliDebug, cliTodo, cliAlert } from '../../cliOutput.js' // eslint-disable-line @typescript-eslint/no-unused-vars
+// import { existsSync } from 'fs'
+// import { getApiRoutes } from '../../api/getApiRoutes.js'
+// import { getApiRoutesHono } from '../../api/getApiRoutesHono.js'
+// import { standardizeWebPath } from '../../standardizeWebPath.js'
+// import { log } from '../../appOutput.js'
+// import { throwError } from '../../throwError.js'
+// import { getRoutesDev } from '../../getRoutesDevs.js'
+// import { getComponentDev } from '../../getComponentDev.js'
+// import { ReqRes } from '../../ReqRes.js'
+// import sxyLoaderConfig from '../../../sxy-loader.config.js'
+// import { createLoad } from 'sxy-loader'
+// import { routing } from '../routing.jsx'
+// import { GlobalData, globalDataFunc } from '../../routing/registerGlobalData.js'
+// import { ServerDataLoading } from '../../Store/ServerDataLoading.js'
+// import { TungstenServer } from '../TungstenServer.jsx'
+// import { Routes } from '../../routing/Routes.js'
+// import { RedirectCode, RoutingRedirect } from '../../routing/RoutingRedirect.js'
+// import { portError } from '../portError.js'
+// import { loadEnvsDev } from '../loadEnvsDev.js'
+// import { initStores } from '../initStores.js'
+// import { AppRoutes } from '../../routing/AppRoutes.js'
+// import { AnyComponentType } from '../../AnyComponentType.js'
+// import { MatchedRouteInfo } from '../MatchedRouteInfo.js'
+// import { MatchedRoute } from '../../routing/MatchedRoute.js'
+// import { ContentNodeIsClassComponent } from '../../ContentNode.js'
+// import { $props, $type } from '../../contentNodeSymbols.js'
+// import { RedirectComponent } from '../../components/RedirectComponent.js'
+// import { Path } from '../../routing/RouteTypes.js'
+// import type { ApiRoutesHono } from '../../api/ApiRoutesHono.js'
+// import { TungstenServerHono } from './TungstenServerHono.jsx'
+export {};
+// //import cookieParser from 'cookie-parser'
+// function debug(...texts: any[]) { // eslint-disable-line @typescript-eslint/no-unused-vars
+//     // console.log(...texts)
+// }
+// export class DevServerHono extends TungstenServerHono { 
+//     framework: Framework
+//     config: FrameworkConfigComplete
+//     compilationInfo: CompilationInfo
+//     port: number
+//     location: string | null = null
+//     initialProcessEnv: Record<string, string>
+//     app: Hono<BlankEnv, BlankSchema, '/'>
+//     apiRoutes?: ApiRoutesHono
+//     apiPath?: string
+//     server?: Server
+//     reqId: number
+//     firstRender: boolean = true
+//     constructor(
+//         framework: Framework, config: FrameworkConfigComplete, compilationInfo: CompilationInfo,
+//         initialProcessEnv: Record<string, string> = {}/* FIX ME */
+//     ) {
+//         super()
+//         try {
+//             this.framework = framework
+//             this.config = config
+//             this.compilationInfo = compilationInfo
+//             // if (tungstenPrivateEnv.TUNGSTEN_SERVER_PORT === -999) {
+//             //     throwError(
+//             //         'DevServer',
+//             //         'TUNGSTEN_SERVER_PORT environment variable has not been set,'
+//             //         + '\n Ensure that you have an env schema with this field, and a matching env file'
+//             //     )
+//             // }
+//             const proto = tungstenPrivateEnv.FRONTEND_PROTO ?? 'http'
+//             const host = tungstenPrivateEnv.FRONTEND_HOST ?? 'localhost'
+//             const port = tungstenPrivateEnv.TUNGSTEN_SERVER_PORT ?? 3000
+//             if (isNaN(port) || port === 0) throwError('DevServer', portError(port))
+//             this.port = port
+//             //this.port = _port
+//             this.location = `${proto}://${host}:${port}` 
+//             this.initialProcessEnv = initialProcessEnv
+//             this.app = new Hono()
+//             this.reqId = 0
+//             //this.app.use(cookieParser)
+//             let reqId = 0
+//             this.app.use(async (c, next) => {
+//                 reqId++
+//                 await next()   
+//             })
+//             //if (tungstenPrivateEnv.DEBUG === true) {
+//             this.app.use(async (c, next) => {
+//                 const { req } = c
+//                 const urlObj = new URL(c.req.url)
+//                 //const targetOrigin = urlObj.protocol + '://' + String(req.header('host'))
+//                 const targetOrigin = urlObj.origin
+//                 const target = targetOrigin + req.url
+//                 const origin = req.header('origin')
+//                 // request log
+//                 let message = 'Received request at ' + target
+//                 if (origin !== undefined) {
+//                     message += ' from ' + String(req.header('origin'))
+//                     // should we use referrer as a backup option?
+//                     // not sure what that is
+//                 }
+//                 cliOut(message)
+//                 if ((this.config.suppressOriginMismatchWarning !== true)) {
+//                 // origin-target mismatch warning
+//                     if (origin !== undefined && origin === this.location && origin !== targetOrigin) {
+//                         cliWarn(
+//                             `Received a request from the frontend, but it's origin`
+//                         + ` is not the same as the request origin.`
+//                         + ` This may indicate a misconfiguration, and may prevent`
+//                         + ` the passing of cookies to the tungsten server.`
+//                         )
+//                         cliWarn(`source: ${targetOrigin}`)
+//                         cliWarn(`target: ${target}`)
+//                     }
+//                 }
+//                 next()
+//             })
+//                 // this.app.use((req, res, next) => {
+//                 //     cliDebug(`Received request [${res.locals.reqId}] for ${req.url}`)
+//                 //     next()   
+//                 // })
+//             //}
+//             if (config.serverMiddleware) { this.addServerMiddleware(config.serverMiddleware) }
+//             /// CHECK: Do we need to do this with hono?
+//             // can we set the mime type for .cjs files?
+//             //express.static.mime.define({'application/javascript': ['cjs']})
+//             this.app.use(
+//                 `/.tungsten.config.js`,
+//                 //express.static(join(this.compilationInfo.location, '.tungsten.config.js'))
+//                 serveStatic({ root: join(this.compilationInfo.location, '.tungsten.config.js') })
+//             ) // config file
+//             this.app.use(
+//                 `/${packagesFolder}/`,
+//                 //express.static(join(this.compilationInfo.location, packagesFolder))
+//                 serveStatic({ root: join(this.compilationInfo.location, packagesFolder) })
+//             ) // compiled packages
+//             this.app.use(
+//                 `/${clientFolder}/`,
+//                 //express.static(join(this.compilationInfo.location, clientFolder))
+//                 serveStatic({ root: join(this.compilationInfo.location, clientFolder) })
+//             ) // ?
+//             this.app.use(
+//                 `/${componentCssFolder}/`,
+//                 //express.static(join(this.compilationInfo.location, componentCssFolder))
+//                 serveStatic({ root: join(this.compilationInfo.location, componentCssFolder) })
+//             ) // app component css?/s
+//             this.app.use(
+//                 //express.static(join(this.compilationInfo.location, staticFolder))
+//                 serveStatic({ root: join(this.compilationInfo.location, staticFolder) })
+//             ) // compiled stylesheets? -- etag: false to disable caching (from express days...)
+//             const publicLocation = join(this.compilationInfo.location, publicFolder)
+//             if (existsSync(publicLocation)) {
+//                 //this.app.use(express.static(publicLocation)) // files from public folder
+//                 this.app.use(serveStatic({ root: publicLocation })) // files from public folder
+//             }
+//             //cliWarn(`assets dir:`, this.config.assetsDir)
+//             if (this.config.assetsDir !== undefined) {
+//                 this.app.use(
+//                     `/${this.config.assetsDir}`,
+//                     //express.static(join(this.compilationInfo.location, assetsFolder))
+//                     serveStatic({ root: join(this.compilationInfo.location, assetsFolder) })
+//                 ) // files from assets folder
+//             }
+//             this.app.use(
+//                 //express.static(this.compilationInfo.location, { dotfiles:'allow' })
+//                 serveStatic({ root: this.compilationInfo.location })
+//             ) // serving the app files themselves
+//             //this.app.use('/__server_rpc__', this.handleRpc)
+//             // seems there was a plan to have API routes built into the main app
+//             // can't remember this much
+//             if (typeof config.apiRoutes === 'string' && config.apiRoutes !== '') {
+//                 const apiPath = this.apiPath = standardizeWebPath(this.config.apiPath)
+//                 cliOut(`API listening at ${this.apiPath}`)
+//                 // should not be needed with hono
+//                 // this.app.use(apiPath, express.json())
+//                 //throwError('DevServerHono', 'Support for app apiRoutes not yet implemented')
+//                 this.app.use(apiPath, this.handleRequestApi)
+//             }
+//             this.app.use(this.handleRequest)
+//             // !!! obsolete?
+//             // start hooking into require to rewrite react requires to tungsten
+//             //addRequireResolveHooks() // we need this for server side
+//             // we will need a server side import loader too
+//         } catch (e) {
+//             throw new TungstenError(`${this.constructor.name} construction error: ${e}`)
+//         }
+//     }
+//     private addServerMiddleware = (serverMiddleware: ServerMiddlewareInfo): void => {
+//         //console.log('addServerMiddleware')
+//         const [middlewareFile, middlewareExportName, middlewarePath] = serverMiddleware
+//         const path = middlewarePath.startsWith('/') ? middlewarePath : '/' + middlewarePath
+//         this.app.use(path, async (c) => {
+//             // this is going to reload the server application on each request
+//             // will cause trouble if anything depends on memory
+//             // but should be OK for an ordinary DB based system, including DB based sessions
+//             // [*] We could look into replacing this with a watcher + reload based system
+//             // we'd have to set up a watcher which triggers a reload of middleware to
+//             // a variable that can be accessed here. Probably in a promise format so
+//             // that a loading middleware can be awaited instead of running the outdated
+//             // code
+//             // [*] const middlewares = await middlewaresPromise
+//             const load = await createLoad(import.meta.url, sxyLoaderConfig)
+//             const fullFilePath = 'file://' + join(this.compilationInfo.codeLocation, middlewareFile)
+//             const middlewareModule = await load(fullFilePath)
+//             if ( ! (middlewareExportName in middlewareModule) ) {
+//                 throwError(
+//                     'DevServer',
+//                     `export ${middlewareExportName} not found in ${middlewareFile}`
+//                     + ` when trying to load server middleware`
+//                 )
+//             }
+//             const middlewares = middlewareModule[middlewareExportName] as Handler[] // eslint-disable-line no-type-assertion/no-type-assertion
+//             // TODO should we add a manual type check here?
+//             if (!Array.isArray(middlewares)) throwError('addServerMiddleware', `Expected middlewares to be an array`)
+//             if (!(0 in middlewares)) throwError('addServerMiddleware', `No middleware entry at index 0`)
+//             const firstMiddleware = middlewares[0]
+//             if (!(typeof firstMiddleware === 'function')) {
+//                 throwError('addServerMiddleware', `Expected middleware to be a function`)
+//             }
+//             // mimicing hono here so we can modify behaviour on each run
+//             let i = 0
+//             const next: Next = async () => {
+//                 i++
+//                 const m = middlewares[i]
+//                 if (m !== undefined) {
+//                     m(c, next)
+//                 }
+//             }
+//             firstMiddleware(c, next)
+//         })
+//         cliOut(`Server Middleware added to server at ${path}`)
+//     }
+//     // private handleRpc = async (req: Request, res: Response, next: NextFunction) => {
+//     //     //
+//     //     console.log('Server is handling server rpc')
+//     // }
+//     private handleRequestApi = async (c: Context, next: Next): Promise<Response> => {
+//         const { req } = c
+//         this.apiRoutes = await getApiRoutesHono(this.config, this.compilationInfo, 'dev')
+//         //const requestPath = standardizeWebPath(req.baseUrl + req.path)
+//         const subPath = standardizeWebPath(req.path)
+//         //console.log('received an API req', req.originalUrl, res.locals.reqId)
+//         for (const [path, route] of Object.entries(this.apiRoutes)) {
+//             if (route.method === req.method && standardizeWebPath(path) === subPath) {
+//                 //console.log('API route matched', path)
+//                 return await route.endpoint(c, next)
+//             }
+//         }
+//         // otherwise
+//         //res.sendStatus(404)
+//         return c.notFound()
+//     }
+//     private handleRequest = async (c: Context, next: Next): Promise<Response> => {
+//         const { req } = c
+//         if (/\.(css|scss|sass|js|jsx|png|jpg|jpeg|svg|ico)$/.test(req.path)) {
+//             // warn(
+//             //     `Dev server received request ${req.url} which was not matched by a static file.`
+//             //     + '\nBlocking request to prevent pointless app render'
+//             // )
+//             cliLog(`Requested asset file ${req.url} was not found`)
+//             return c.notFound()
+//             //res.status(404).end()
+//             //return
+//         }
+//         try {
+//             const _firstRender = this.firstRender
+//             this.firstRender = false
+//             //console.log('received a frontend req', req.originalUrl, res.locals.reqId)
+//             //// I think we need to pass req, (res?) to the app
+//             //// so that it can set response codes
+//             //// or
+//             //// the app has to return some data other than response string
+//             ////
+//             //// perhaps, set some return data in the instance
+//             //// then return html string + other data
+//             const location = req.url
+//             const instanceConfig = makeInstanceConfigFromFrameworkConfig(this.config, true)
+//             if (this.framework.frameworkModules === undefined) {
+//                 throwError('DevServer.handleRequest()',
+//                     'framework.frameworkModules is undefined'
+//                 )
+//             }
+//             if (this.framework.clientImportAliases === undefined) {
+//                 throwError('DevServer.handleRequest()',
+//                     'framework.frameworkModules is undefined'
+//                 )
+//             }
+//             globalDataFunc.value = undefined
+//             const load = await createLoad(import.meta.url, sxyLoaderConfig)
+//             await loadEnvsDev(this.config, load, this.initialProcessEnv, false)
+//             // we are delaying instance creation until after we load the app code, to lets things initialise?
+//             //const reqRes: ReqRes = { req, res }
+//             //const honoContext = c
+//             // Save some state. I think this is a placeholder for later
+//             const serverDataLoading: ServerDataLoading = { value: false }
+//             const routingPromise = getRoutesDev(this.compilationInfo, this.config, load).then(
+//                 async (appRoutes) => {
+//                     const routes = (typeof appRoutes === 'function') ? appRoutes(c) : appRoutes
+//                     // load data, and do routing
+//                     return promiseAllObj({
+//                         appRoutes,
+//                         routes,
+//                         globalData: (globalDataFunc.value !== undefined) ? globalDataFunc.value(c) : {},
+//                         matchedRouteInfo: routing(location, routes, serverDataLoading)
+//                     })
+//                 }
+//             )
+//             let appRoutes: AppRoutes
+//             let routes: Routes
+//             let globalData: GlobalData
+//             let matchedRouteInfo: MatchedRouteInfo
+//             let RootComponentClass: AnyComponentType | null = null
+//             if (this.config.useRootComponent) {
+//                 const rootComponentFileFull = join(this.compilationInfo.location, this.config.rootComponent)
+//                 ;({ routing: { appRoutes, routes, globalData, matchedRouteInfo }, RootComponentClass }
+//                     = await promiseAllObj({
+//                         routing: routingPromise,
+//                         RootComponentClass: getComponentDev(rootComponentFileFull, this.config.rootComponent, load)
+//                     }))
+//             } else {
+//                 ({ appRoutes, routes, globalData, matchedRouteInfo } = await routingPromise)
+//                 //throwError('DevServer', 'useRootComponent = false not implemented yet')
+//             }
+//             // get routes (running the getRoutes function if needed)
+//             //const routes = (typeof appRoutes === 'function') ? appRoutes(reqRes) : appRoutes
+//             // load data, and do routing
+//             // const [globalData, matchedRouteInfo] = await Promise.all([
+//             //     (globalDataFunc !== undefined) ? globalDataFunc(reqRes) : {},
+//             //     routing(location, routes, serverDataLoading)
+//             // ])
+//             const redirected = this.handleRedirects(c, matchedRouteInfo)
+//             if (redirected) return // end early
+//             // make stores
+//             const { internalStore, stores, storeSubscriptions }
+//                 = initStores(location, c, globalData, matchedRouteInfo, serverDataLoading)
+//             // create the instance
+//             const instance = new Instance(    
+//                 location, instanceConfig, c, appRoutes, routes, internalStore,
+//                 stores, storeSubscriptions, globalData, matchedRouteInfo
+//             )
+//             let html: string
+//             if (RootComponentClass) {
+//                 html = await renderRootToHtmlDev(
+//                     this.compilationInfo, this.framework.clientImportAliases,
+//                     RootComponentClass, instance, this.config, global.tungstenPublicEnv,
+//                     '' // siteBasePathOverride
+//                 )
+//             } else {
+//                 html = await renderRootToHtmlDev(
+//                     this.compilationInfo, this.framework.clientImportAliases,
+//                     MatchedRoute, instance, this.config, global.tungstenPublicEnv,
+//                     '' // siteBasePathOverride
+//                 )
+//                 // const { params, data } = matchedRouteInfo
+//                 // let { content } = matchedRouteInfo
+//                 // if (typeof content === 'function') {
+//                 //     content = content(data, params, {} /* props */, globalData, location)
+//                 //     //throwError('DevServer', 'route content is a function')
+//                 // }
+//                 // //console.log('content to render', content)
+//                 // html = await renderContentToHtmlDev(
+//                 //     this.compilationInfo, this.framework.clientImportAliases,
+//                 //     content, instance, this.config, global.tungstenPublicEnv,
+//                 //     '' // siteBasePathOverride
+//                 // )
+//             }
+//             //debug('html', html)
+//             res.setHeader('Content-Type', 'text/html')
+//             res.status((instance.matchedRouteInfo.key === '404') ? 404 : 200)
+//             res.send(html)
+//         } catch(e) {
+//             cliLog('error', e)
+//             res.setHeader('Content-Type', 'text/html')
+//             res.status(500)
+//             this.errorLog(e)
+//             res.send(this.errorPage(e))
+//         }
+//     }
+//     // private async handlePost(req: express.Request, res: express.Response): Promise<void> {
+//     //     throw new TungstenError(`Err - Dev server received a post request. Not supported yet.`)
+//     // }
+//     errorLog = (error: unknown) => {
+//         log((typeof error === 'object' && error !== null && 'stack' in error) ? error.stack : error)
+//     }
+//     errorPage = (error: unknown) => {
+//         return `<!DOCTYPE html>
+// </html>
+//   <head>
+//     <title>Error</title>
+//     <style>html { font-family: arial }</style>
+//   </head>
+//   <body>
+//     <h1>Application Error</h1>
+//     <section>
+//         <pre>${(typeof error === 'object' && error !== null && 'stack' in error) ? error.stack : error}</pre>
+//     </section>
+//   </body>
+// </html>`
+//     }
+//     start = (): Promise<string> => {
+//         return new Promise( resolve => {
+//             this.server = this.app.listen(this.port, () => {
+//                 cliNews(`Dev server ready at ${this.location}`)
+//                 resolve(this.location ?? '')
+//             })
+//         })
+//     }
+//     stop = () => {
+//         if (this.server !== undefined) this.server.close()
+//     }
+//     //treeToHtml = treeToHtml
+// }

package/dist/Servers/hono/ProdServerHono.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ProdServerHono.d.ts.map

package/dist/Servers/hono/ProdServerHono.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProdServerHono.d.ts","sourceRoot":"","sources":["../../../src/Servers/hono/ProdServerHono.ts"],"names":[],"mappings":""}