pinokiod 8.0.0 → 8.0.1

package/kernel/index.js

@@ -276,14 +276,17 @@ class Kernel {
       ]
     }
     if (config) {
-      if (config.dns) {
+      const configuredDns = config.dns
+      config = {
+        ...config,
+        dns: configuredDns ? { ...configuredDns } : dns
+      }
+      if (configuredDns) {
         for(let key in config.dns) {
           if (config.dns[key]) {
             config.dns[key] = config.dns[key].concat(dns[key])
           }
         }
-      } else {
-        config.dns = dns
       }
     } else {
       config = {

package/kernel/loader.js

@@ -57,6 +57,14 @@ class Loader {
     try { config = require(filepath) } catch (e) {
       console.log("> load", e, filepath)
     }
+    if (
+      config &&
+      typeof config === "object" &&
+      Object.prototype.hasOwnProperty.call(config, "default") &&
+      (config.__esModule === true || config[Symbol.toStringTag] === "Module")
+    ) {
+      config = config.default
+    }
     try {
       // if the required module is a class, return the instantiated object
       return new config();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "description": "",
   "main": "index.js",
   "scripts": {

package/test/dns-static-routes.test.js

@@ -144,3 +144,42 @@ test('dns keeps dynamic local and port routes without adding a static folder rou
   ])
   assert.equal(harness.buildStaticRoutes()['dynamic-app'], undefined)
 })
+
+test('dns derives routes without mutating a frozen launcher config', async (t) => {
+  const harness = await createDnsHarness()
+  t.after(async () => {
+    await fs.rm(harness.root, { recursive: true, force: true })
+  })
+
+  const config = Object.freeze({ title: 'Frozen app' })
+  await harness.addApp('frozen-app', { script: config })
+
+  await harness.kernel.dns({ path: path.join(harness.apiRoot, 'frozen-app') })
+
+  assert.equal(Object.hasOwn(config, 'dns'), false)
+  assert.equal(harness.kernel.pinokio_configs['frozen-app'].title, 'Frozen app')
+  assert.deepEqual(harness.kernel.pinokio_configs['frozen-app'].dns['@'], [
+    '$local.url@start',
+  ])
+})
+
+test('dns derives routes from a frozen dns map', async (t) => {
+  const harness = await createDnsHarness()
+  t.after(async () => {
+    await fs.rm(harness.root, { recursive: true, force: true })
+  })
+
+  const configuredRoutes = Object.freeze([':7860'])
+  const configuredDns = Object.freeze({ '@': configuredRoutes })
+  const config = Object.freeze({ dns: configuredDns })
+  await harness.addApp('frozen-dns-app', { script: config })
+
+  await harness.kernel.dns({ path: path.join(harness.apiRoot, 'frozen-dns-app') })
+
+  assert.equal(config.dns, configuredDns)
+  assert.deepEqual(configuredRoutes, [':7860'])
+  assert.deepEqual(harness.kernel.pinokio_configs['frozen-dns-app'].dns['@'], [
+    ':7860',
+    '$local.url@start',
+  ])
+})

package/test/loader-esm.test.js

@@ -0,0 +1,29 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+
+const Loader = require('../kernel/loader')
+
+test('loader unwraps an ESM namespace default export', async (t) => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-loader-esm-'))
+  const filepath = path.join(root, 'pinokio.js')
+  t.after(async () => {
+    await fs.rm(root, { recursive: true, force: true })
+  })
+
+  await fs.writeFile(path.join(root, 'package.json'), JSON.stringify({ type: 'module' }))
+  await fs.writeFile(filepath, `
+    export default {
+      title: 'ESM launcher',
+      menu: async () => []
+    }
+  `)
+
+  const loaded = await new Loader().load(filepath)
+
+  assert.equal(loaded.resolved.title, 'ESM launcher')
+  assert.equal(typeof loaded.resolved.menu, 'function')
+  assert.equal(Object.hasOwn(loaded.resolved, 'default'), false)
+})