epos 1.2.5 → 1.3.0

package/eslint.config.js

@@ -0,0 +1,19 @@
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  { languageOptions: { globals: globals.browser } },
+  pluginJs.configs.recommended,
+  {
+    languageOptions: {
+      globals: {
+        Self: false,
+        process: false,
+      },
+    },
+    rules: {
+      'no-unused-labels': 0,
+    },
+  },
+]

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "epos",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "author": "imkost",
   "description": "",
   "keywords": [],
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "dev": "node ./src/kit/kit-bin.js"
+    "dev": "node ./src/kit/kit-bin.js",
+    "lint": "eslint ./src",
+    "publish": "npm publish --loglevel=error"
   },
   "bin": {
     "epos": "src/kit/kit-bin.js"
@@ -27,5 +29,10 @@
     "mime": "^4.0.6",
     "prettier": "^3.4.2",
     "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.18.0",
+    "eslint": "^9.18.0",
+    "globals": "^15.14.0"
   }
 }

package/src/kit/kit-server.js

@@ -6,58 +6,86 @@ import $yaml from 'js-yaml'
 import $chokidar from 'chokidar'
 import * as $ws from 'ws'
 
-// TODO: handle 'port in use' error
-// TODO: epos-kit as separate package (?) but bin: epos
 const $server = {
-  async init(dir = '/Users/imkost/z/epos') {
+  async init(dir) {
     this._dir = dir
     this._port = 4322
     this._maxFiles = 10_000
+
     this._pkgs = {} // { [path]: { name, dir, watcher } }
-    const httpServer = await this._startHttpServer()
-    await this._startMainWatcher()
-    this._wss = await this._startWebSocketServer(httpServer)
-    console.log('⚡ running')
+    this._server = null
+    this._wss = null
+
+    await this._initServer()
+    await this._initWebSocket()
+    await this._startWatcher()
+
+    console.log('🟢 ready')
   },
 
-  async _startWebSocketServer(httpServer) {
-    // TODO: handle port in use error
-    const wss = new $ws.WebSocketServer({ server: httpServer })
-    wss.on('error', e => {
-      console.warn('##############')
+  async _initServer() {
+    const ready = Promise.withResolvers()
+
+    this._server = $http.createServer(async (req, res) => {
+      try {
+        const { data, type } = await this._handleRequest(req)
+        res.writeHead(200, { 'Content-Type': type })
+        res.end(data)
+      } catch (e) {
+        if (e === 404) {
+          res.writeHead(404, { 'Content-Type': 'text/plain' })
+          res.end('404: File Not Found')
+        } else {
+          console.error(e)
+          res.writeHead(500, { 'Content-Type': 'text/plain' })
+          res.end('500: Internal Server Error')
+        }
+      }
+    })
+
+    this._server.listen(this._port, () => {
+      ready.resolve()
     })
-    wss.on('open', () => {
-      console.warn('connection')
+
+    this._server.on('error', e => {
+      if (e.code === 'EADDRINUSE') {
+        console.log(`🔴 port ${this._port} is already in use`)
+        process.exit()
+      }
+      ready.reject(e)
     })
-    return wss
+
+    await ready.promise
+  },
+
+  async _initWebSocket() {
+    this._wss = new $ws.WebSocketServer({ server: this._server })
   },
 
-  async _startMainWatcher() {
-    const watcherReady = Promise.withResolvers()
+  async _startWatcher() {
+    const ready = Promise.withResolvers()
     const watcher = $chokidar.watch(this._dir, { ignored: this._ignored })
 
     // initial scan
-    let isInitialScan = true
-    let initialFileCount = 0
-    watcher.on('all', async (event, path) => {
-      if (!isInitialScan) return
-      initialFileCount += 1
-      if (initialFileCount < this._maxFiles) return
-      console.error('⛔ too many files')
-      console.error(`More than ${this._maxFiles} files in the directory.`)
-      console.error(`Please point to a directory with less files.`)
+    let done = false
+    let files = 0
+    watcher.on('add', async () => {
+      if (done) return
+      files += 1
+      if (files < this._maxFiles) return
+      console.log(`🔴 too many files in ${this._dir}`)
+      console.log('ℹ️ select directory with fewer files')
       process.exit()
     })
     watcher.on('ready', () => {
-      isInitialScan = false
-      watcherReady.resolve()
+      done = false
+      ready.resolve()
     })
 
     // watch added manifest files
     const variants = new Set(['epos.json', 'epos.yaml', 'epos.yml'])
     watcher.on('add', async path => {
-      const isEposManifest = variants.has($path.basename(path))
-      if (!isEposManifest) return
+      if (!variants.has($path.basename(path))) return
       const pkg = await this._createPkgWatcher(path)
       if (!pkg) return
       this._pkgs[path] = pkg
@@ -70,73 +98,63 @@ const $server = {
       delete this._pkgs[path]
     })
 
-    await watcherReady.promise
-  },
-
-  async _startHttpServer() {
-    const httpServerReady = Promise.withResolvers()
-    const httpServer = $http.createServer(async (req, res) => {
-      const pkgName = req.url.split('/')[1]
-      const pkg = Object.values(this._pkgs).find(p => p.name === pkgName)
-      if (!pkg) {
-        res.writeHead(404, { 'Content-Type': 'text/plain' })
-        res.end('404: File Not Found')
-        return
-      }
-
-      const filePath = $path.join(pkg.dir, req.url.split('/').slice(2).join('/'))
-      const contentType = $mime.getType(filePath) || 'application/octet-stream'
-      try {
-        const data = await $fs.readFile(filePath)
-        res.writeHead(200, { 'Content-Type': contentType })
-        res.end(data)
-      } catch (e) {
-        if (e.code === 'ENOENT') {
-          res.writeHead(404, { 'Content-Type': 'text/plain' })
-          res.end('404: File Not Found')
-        } else {
-          res.writeHead(500, { 'Content-Type': 'text/plain' })
-          res.end('500: Internal Server Error')
-        }
-      }
-    })
-    httpServer.listen(this._port, () => {
-      httpServerReady.resolve()
-    })
-
-    httpServer.on('error', e => {
-      console.warn(e)
-    })
-
-    await httpServerReady.promise
-    return httpServer
+    await ready.promise
   },
 
   async _createPkgWatcher(manifestPath) {
+    // read manifest
     const isJson = manifestPath.endsWith('.json')
     const content = await $fs.readFile(manifestPath, 'utf-8')
     const manifest = isJson ? JSON.parse(content) : $yaml.load(content)
-    const pkgName = manifest.name
-    if (!pkgName) return null
 
+    // no name? -> ignore
+    const name = manifest.name
+    if (!name) return null
+
+    // create pkg dir watcher
     const dir = $path.dirname(manifestPath)
     const watcher = $chokidar.watch(dir, {
       ignored: this._ignored,
       ignoreInitial: true,
     })
 
+    // broadcast changes
     watcher.on('all', (event, path) => {
-      const data = JSON.stringify({ name: pkgName, path: $path.relative(dir, path) })
+      const data = JSON.stringify({ name, path: $path.relative(dir, path) })
       for (const client of this._wss.clients) {
         if (client.readyState !== 1) continue
         client.send(data)
       }
     })
 
-    return {
-      watcher,
-      name: pkgName,
-      dir,
+    return { name, dir, watcher }
+  },
+
+  async _handleRequest(req) {
+    // /<pkgName>/some/path/to/file.jsx
+    const [pkgName, ...filePath] = req.url.split('/').slice(1)
+
+    // pkg not found? -> 404
+    const pkg = Object.values(this._pkgs).find(p => p.name === pkgName)
+    if (!pkg) throw 404
+
+    // file not found? -> 404
+    const path = $path.join(pkg.dir, ...filePath)
+    const exists = await this._fileExists(path)
+    if (!exists) throw 404
+
+    // respond file
+    const data = await $fs.readFile(path)
+    const type = $mime.getType(path) || 'application/octet-stream'
+    return { data, type }
+  },
+
+  async _fileExists(path) {
+    try {
+      await $fs.access(path, $fs.constants.F_OK)
+      return true
+    } catch {
+      return false
     }
   },