@jseeio/jsee 0.3.7 → 0.3.9

package/test/test-basic.test.js

@@ -1,16 +1,16 @@
 require('expect-puppeteer')
+const path = require('path')
 
 page.setDefaultTimeout(10000)
 
-// Tests require a server to be running on port 8080
-// If you have php installed: php -S localhost:8080
-// Python: python -m http.server 8080
-// Node: npm install -g http-server && http-server -p 8080
+// Server on port 8484 is auto-started by jest-puppeteer (see jest-puppeteer.config.js)
 
-const port = 8080
+const port = 8484
 const urlSchema = (name) => `http://localhost:${port}/load/?s=/test/${name}.schema.json`
 const urlHTML = (name) => `http://localhost:${port}/test/${name}.html`
 const urlQuery = (schema) => `http://localhost:${port}/load/?s=${JSON.stringify(schema)}`
+const urlQueryEscaped = (schema) => `http://localhost:${port}/load/?s=${encodeURIComponent(JSON.stringify(schema))}`
+const uploadFixture = path.resolve(__dirname, 'fixtures', 'upload-sample.csv')
 
 describe('Initial test', () => {
   beforeAll(async () => {
@@ -52,12 +52,12 @@ describe('Initial test (worker)', () => {
 describe('Minimal examples', () => {
   const schema = {
     'model': {
-      'code': 'function (a, b) { return a / b }', // TODO: check '+'
+      'code': 'function (a, b) { return a / b }',
     }
   }
   test('Code only (text) (main window)', async () => {
     schema.model.worker = false
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toFill('#a', '100')
     await expect(page).toFill('#b', '4')
     await expect(page).toClick('button', { text: 'Run' })
@@ -115,6 +115,42 @@ describe('Load code directly', () => {
     await expect(page).toClick('button', { text: 'Run' })
     await expect(page).toMatchTextContent('15')
   })
+
+  test('Window infers function type for URL-loaded JS when type is omitted', async () => {
+    const schema = {
+      model: {
+        name: 'sum',
+        container: 'args',
+        url: '/test/example-sum.js',
+        worker: false
+      },
+      inputs: [
+        { name: 'a', type: 'int', default: 8 },
+        { name: 'b', type: 'int', default: 7 }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('15')
+  })
+
+  test('Worker infers function type for URL-loaded JS when type is omitted', async () => {
+    const schema = {
+      model: {
+        name: 'sum',
+        container: 'args',
+        url: '/test/example-sum.js',
+        worker: true
+      },
+      inputs: [
+        { name: 'a', type: 'int', default: 8 },
+        { name: 'b', type: 'int', default: 7 }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('15')
+  })
 })
 
 describe('Classes', () => {
@@ -133,14 +169,14 @@ describe('Classes', () => {
 
   test('Window', async () => {
     schema.model.worker = false
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toClick('button', { text: 'Run' })
     await expect(page).toMatchTextContent('200')
   })
 
   test('Worker', async () => {
     schema.model.worker = true
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toClick('button', { text: 'Run' })
     await expect(page).toMatchTextContent('200')
   })
@@ -154,7 +190,7 @@ describe('Some edge cases', () => {
       }
     }
     schema.model.worker = false
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toFill('#a', '0')
     await expect(page).toFill('#b', '0')
     await expect(page).toClick('button', { text: 'Run' })
@@ -174,21 +210,34 @@ describe('Imports', () => {
       }
       `
     },
-    'imports': 'lodash@4.17.21/lodash.min.js',
+    'imports': `http://localhost:${port}/test/fixtures/lodash-like.js`,
     'inputs': [
       { 'name': 'str', 'type': 'string', 'default': 'FooBar' },
     ]
   }
   test('Window', async () => {
     schema.model.worker = false
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toClick('button', { text: 'Run' })
     await expect(page).toMatchTextContent('foo-bar')
   })
   test('Worker', async () => {
     schema.model.worker = true
-    await page.goto(urlQuery(schema))
-    await expect(page).toClick('button', { text: 'Run' })
+    await page.goto(urlQueryEscaped(schema))
+    const runUntilReady = async (attempts=3) => {
+      if (attempts <= 0) {
+        return false
+      }
+      await expect(page).toClick('button', { text: 'Run' })
+      try {
+        await page.waitForFunction(() => document.body.innerText.includes('foo-bar'), { timeout: 5000 })
+        return true
+      } catch (error) {
+        return runUntilReady(attempts - 1)
+      }
+    }
+    const ready = await runUntilReady()
+    expect(ready).toBe(true)
     await expect(page).toMatchTextContent('foo-bar')
     // await (new Promise(resolve => setTimeout(resolve, 1000)))
   })
@@ -209,14 +258,14 @@ describe('Buttons, button titles and caller', () => {
   }
   test('Window', async () => {
     schema.model.worker = false
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toMatchTextContent('Test Button')
     await expect(page).toClick('button', { text: 'Test Button' })
     await expect(page).toMatchTextContent('test_button')
   })
   test('Worker', async () => {
     schema.model.worker = true
-    await page.goto(urlQuery(schema))
+    await page.goto(urlQueryEscaped(schema))
     await expect(page).toClick('button', { text: 'Test Button' })
     await expect(page).toMatchTextContent('test_button')
   })
@@ -234,4 +283,321 @@ describe('Pipeline', () => {
     await expect(page).toClick('button', { text: 'Run' })
     await expect(page).toMatchTextContent((Math.pow((a + b), 2) + 2).toString())
   })
-})
+})
+
+describe('File uploads', () => {
+  test('default file input reads uploaded text', async () => {
+    const schema = {
+      model: {
+        worker: false,
+        code: `function filePreview (inputs) {
+          return {
+            preview: inputs.file.split('\\n')[0]
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file' }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await page.waitForSelector('#vfp-filePicker')
+    const fileInput = await page.$('#vfp-filePicker')
+    await fileInput.uploadFile(uploadFixture)
+    await page.waitForFunction(() => document.body.innerText.includes('Selected 1 file(s)'))
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('name,age')
+  })
+
+  test('raw file input passes File object (not text content)', async () => {
+    const schema = {
+      model: {
+        worker: false,
+        code: `function fileRawMeta (inputs) {
+          const isFileObject = !!inputs.file
+            && (typeof inputs.file === 'object')
+            && (typeof inputs.file.name === 'string')
+            && (typeof inputs.file.text === 'function')
+          return {
+            is_file_object: isFileObject,
+            is_string: typeof inputs.file === 'string',
+            file_name: inputs.file && inputs.file.name ? inputs.file.name : '',
+            content_prefix: typeof inputs.file === 'string' ? inputs.file.slice(0, 10) : 'NONE'
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file', raw: true }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await page.waitForSelector('#vfp-filePicker')
+    const fileInput = await page.$('#vfp-filePicker')
+    await fileInput.uploadFile(uploadFixture)
+    await page.waitForFunction(() => document.body.innerText.includes('Selected 1 file(s)'))
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('is_file_object')
+    await expect(page).toMatchTextContent('true')
+    await expect(page).toMatchTextContent('file_name')
+    await expect(page).toMatchTextContent('upload-sample.csv')
+    await expect(page).toMatchTextContent('content_prefix')
+    await expect(page).toMatchTextContent('NONE')
+  })
+
+  test('raw url input passes URL handle (not fetched text content)', async () => {
+    const schema = {
+      model: {
+        worker: false,
+        code: `function fileRawUrlMeta (inputs) {
+          const isUrlHandle = !!inputs.file
+            && (typeof inputs.file === 'object')
+            && (inputs.file.kind === 'url')
+            && (typeof inputs.file.url === 'string')
+          return {
+            is_url_handle: isUrlHandle,
+            is_string: typeof inputs.file === 'string',
+            url_value: isUrlHandle ? inputs.file.url : '',
+            content_prefix: typeof inputs.file === 'string' ? inputs.file.slice(0, 10) : 'NONE'
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file', raw: true }
+      ]
+    }
+    const rawUrl = 'http://127.0.0.1:9999/nope.csv'
+    await page.goto(urlQueryEscaped(schema))
+    await expect(page).toClick('button', { text: 'From URL' })
+    await page.waitForSelector('input.vfp-urlInput[type="text"]')
+    await page.click('input.vfp-urlInput[type="text"]', { clickCount: 3 })
+    await page.type('input.vfp-urlInput[type="text"]', rawUrl)
+    await page.evaluate(() => {
+      const loadButton = Array.from(document.querySelectorAll('button'))
+        .find(btn => btn.textContent.trim() === 'Load')
+      if (!loadButton) throw new Error('Load button not found')
+      loadButton.click()
+    })
+    await expect(page).toClick('button', { text: 'Run' })
+    await page.waitForFunction((expectedUrl) => {
+      return document.querySelector('#outputs').innerText.includes(expectedUrl)
+    }, {}, rawUrl)
+    await expect(page).toMatchTextContent('is_url_handle')
+    await expect(page).toMatchTextContent('true')
+    await expect(page).toMatchTextContent('url_value')
+    await expect(page).toMatchTextContent(rawUrl)
+    await expect(page).toMatchTextContent('content_prefix')
+    await expect(page).toMatchTextContent('NONE')
+  })
+
+  test('file query param auto-loads URL without clicking Load', async () => {
+    const schema = {
+      model: {
+        worker: false,
+        code: `function filePreviewFromQuery (inputs) {
+          return {
+            preview: inputs.file.split('\\n')[0]
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file' }
+      ]
+    }
+    const fileUrl = `http://localhost:${port}/test/fixtures/upload-sample.csv`
+    await page.goto(`${urlQueryEscaped(schema)}&file=${encodeURIComponent(fileUrl)}`)
+    await page.waitForFunction(() => document.body.innerText.includes('Loaded from URL:'), { timeout: 5000 })
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('preview')
+    await expect(page).toMatchTextContent('name,age')
+  })
+})
+
+describe('Streamed file inputs', () => {
+  test('main thread receives uploaded file as async iterable stream', async () => {
+    const schema = {
+      model: {
+        worker: false,
+        code: `async function streamMainFile (inputs) {
+          const reader = inputs.file
+          const isIterable = !!reader
+            && typeof reader[Symbol.asyncIterator] === 'function'
+            && typeof reader.text === 'function'
+            && typeof reader.bytes === 'function'
+            && typeof reader.lines === 'function'
+          if (!isIterable) {
+            return { is_iterable: false, header: 'NONE' }
+          }
+          const text = await reader.text()
+          return {
+            is_iterable: true,
+            header: text.split('\\n')[0]
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file', raw: true, stream: true }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await page.waitForSelector('#vfp-filePicker')
+    const fileInput = await page.$('#vfp-filePicker')
+    await fileInput.uploadFile(uploadFixture)
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('is_iterable')
+    await expect(page).toMatchTextContent('true')
+    await expect(page).toMatchTextContent('header')
+    await expect(page).toMatchTextContent('name,age')
+  })
+
+  test('stream metadata is preserved for downstream pipeline models', async () => {
+    const schema = {
+      model: [
+        {
+          worker: false,
+          code: `function streamStageOne (inputs) {
+            return {
+              stage1_name: inputs.file && inputs.file.name ? inputs.file.name : 'NONE'
+            }
+          }`
+        },
+        {
+          worker: false,
+          code: `function streamStageTwo (inputs) {
+            return {
+              stage2_name: inputs.file && inputs.file.name ? inputs.file.name : 'NONE',
+              stage2_size: inputs.file && typeof inputs.file.size === 'number' ? inputs.file.size : -1
+            }
+          }`
+        }
+      ],
+      inputs: [
+        { name: 'file', type: 'file', raw: true, stream: true }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await page.waitForSelector('#vfp-filePicker')
+    const fileInput = await page.$('#vfp-filePicker')
+    await fileInput.uploadFile(uploadFixture)
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('stage1_name')
+    await expect(page).toMatchTextContent('stage2_name')
+    await expect(page).toMatchTextContent('upload-sample.csv')
+    await expect(page).toMatchTextContent('stage2_size')
+  })
+
+  test('main thread receives URL source as async iterable stream', async () => {
+    const schema = {
+      model: {
+        worker: false,
+        code: `async function streamMainUrl (inputs) {
+          const reader = inputs.file
+          const text = await reader.text()
+          return {
+            is_iterable: typeof reader[Symbol.asyncIterator] === 'function',
+            header: text.split('\\n')[0]
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file', raw: true, stream: true }
+      ]
+    }
+    const sampleUrl = `http://localhost:${port}/test/fixtures/upload-sample.csv`
+    await page.goto(urlQueryEscaped(schema))
+    await expect(page).toClick('button', { text: 'From URL' })
+    await page.waitForSelector('input.vfp-urlInput[type="text"]')
+    await page.click('input.vfp-urlInput[type="text"]', { clickCount: 3 })
+    await page.type('input.vfp-urlInput[type="text"]', sampleUrl)
+    await page.evaluate(() => {
+      const loadButton = Array.from(document.querySelectorAll('button'))
+        .find(btn => btn.textContent.trim() === 'Load')
+      if (!loadButton) throw new Error('Load button not found')
+      loadButton.click()
+    })
+    await expect(page).toClick('button', { text: 'Run' })
+    await page.waitForFunction(() => {
+      const outputs = document.querySelector('#outputs')
+      return outputs && outputs.innerText.includes('header')
+    }, { timeout: 5000 })
+    await expect(page).toMatchTextContent('is_iterable')
+    await expect(page).toMatchTextContent('true')
+    await expect(page).toMatchTextContent('header')
+    await expect(page).toMatchTextContent('name,age')
+  })
+
+  test('worker receives uploaded file as async iterable stream', async () => {
+    const schema = {
+      model: {
+        worker: true,
+        code: `async function streamWorkerFile (inputs) {
+          const reader = inputs.file
+          const lines = []
+          for await (const line of reader.lines()) {
+            lines.push(line)
+          }
+          return {
+            is_iterable: typeof reader.text === 'function',
+            header: lines[0] || 'NONE'
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file', raw: true, stream: true }
+      ]
+    }
+    await page.goto(urlQueryEscaped(schema))
+    await page.waitForSelector('#vfp-filePicker')
+    const fileInput = await page.$('#vfp-filePicker')
+    await fileInput.uploadFile(uploadFixture)
+    await expect(page).toClick('button', { text: 'Run' })
+    await expect(page).toMatchTextContent('is_iterable')
+    await expect(page).toMatchTextContent('true')
+    await expect(page).toMatchTextContent('header')
+    await expect(page).toMatchTextContent('name,age')
+  })
+
+  test('worker receives URL source as async iterable stream', async () => {
+    const schema = {
+      model: {
+        worker: true,
+        code: `async function streamWorkerUrl (inputs) {
+          const reader = inputs.file
+          const decoder = new TextDecoder()
+          let text = ''
+          for await (const chunk of reader) {
+            text += decoder.decode(chunk, { stream: true })
+          }
+          text += decoder.decode()
+          return {
+            is_iterable: typeof reader.bytes === 'function',
+            header: text.split('\\n')[0]
+          }
+        }`
+      },
+      inputs: [
+        { name: 'file', type: 'file', raw: true, stream: true }
+      ]
+    }
+    const sampleUrl = `http://localhost:${port}/test/fixtures/upload-sample.csv`
+    await page.goto(urlQueryEscaped(schema))
+    await expect(page).toClick('button', { text: 'From URL' })
+    await page.waitForSelector('input.vfp-urlInput[type="text"]')
+    await page.click('input.vfp-urlInput[type="text"]', { clickCount: 3 })
+    await page.type('input.vfp-urlInput[type="text"]', sampleUrl)
+    await page.evaluate(() => {
+      const loadButton = Array.from(document.querySelectorAll('button'))
+        .find(btn => btn.textContent.trim() === 'Load')
+      if (!loadButton) throw new Error('Load button not found')
+      loadButton.click()
+    })
+    await expect(page).toClick('button', { text: 'Run' })
+    await page.waitForFunction(() => {
+      const outputs = document.querySelector('#outputs')
+      return outputs && outputs.innerText.includes('header')
+    }, { timeout: 5000 })
+    await expect(page).toMatchTextContent('is_iterable')
+    await expect(page).toMatchTextContent('true')
+    await expect(page).toMatchTextContent('header')
+    await expect(page).toMatchTextContent('name,age')
+  })
+})

package/test/test-python.test.js

@@ -2,12 +2,9 @@ require('expect-puppeteer')
 
 page.setDefaultTimeout(30000)
 
-// Tests require a server to be running on port 8080
-// If you have php installed: php -S localhost:8080
-// Python: python -m http.server 8080
-// Node: npm install -g http-server && http-server -p 8080
+// Server on port 8484 is auto-started by jest-puppeteer (see jest-puppeteer.config.js)
 
-const port = 8080
+const port = 8484
 const urlSchema = (name) => `http://localhost:${port}/load/?s=/test/${name}.schema.json`
 const urlHTML = (name) => `http://localhost:${port}/test/${name}.html`
 const urlQuery = (schema) => `http://localhost:${port}/load/?s=${JSON.stringify(schema)}`

package/test/unit/cli-fetch.test.js

@@ -0,0 +1,126 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const gen = require('../../src/cli')
+const { collectFetchBundleBlocks, resolveFetchImport, resolveRuntimeMode } = gen
+
+describe('collectFetchBundleBlocks', () => {
+  test('collects model, view and render blocks', () => {
+    const schema = {
+      model: { name: 'model', url: './model.js' },
+      view: { name: 'view', url: './view.js' },
+      render: { name: 'render', url: './render.js' }
+    }
+
+    const blocks = collectFetchBundleBlocks(schema)
+
+    expect(blocks.map(b => b.name)).toEqual(['model', 'view', 'render'])
+  })
+
+  test('supports arrays and skips missing sections', () => {
+    const schema = {
+      model: [
+        { name: 'm1', url: './m1.js' },
+        { name: 'm2', url: './m2.js' }
+      ],
+      view: [{ name: 'v1', url: './v1.js' }]
+    }
+
+    const blocks = collectFetchBundleBlocks(schema)
+
+    expect(blocks.map(b => b.name)).toEqual(['m1', 'm2', 'v1'])
+  })
+})
+
+describe('resolveFetchImport', () => {
+  test('resolves local relative import paths against model location', () => {
+    const cwd = '/tmp/jsee-workspace'
+    const result = resolveFetchImport('./helpers/math.js', 'apps/qrcode/model.js', cwd)
+
+    expect(result.schemaImport).toBe('apps/qrcode/helpers/math.js')
+    expect(result.importUrl).toBe('https://cdn.jsdelivr.net/npm/apps/qrcode/helpers/math.js')
+    expect(result.localFilePath).toBe(path.join(cwd, 'apps/qrcode/helpers/math.js'))
+    expect(result.remoteUrl).toBeNull()
+  })
+
+  test('keeps package imports as remote URLs', () => {
+    const result = resolveFetchImport('chart.js', 'apps/qrcode/model.js', '/tmp/jsee-workspace')
+
+    expect(result.schemaImport).toBe('chart.js')
+    expect(result.importUrl).toBe('https://cdn.jsdelivr.net/npm/chart.js')
+    expect(result.localFilePath).toBeNull()
+    expect(result.remoteUrl).toBe('https://cdn.jsdelivr.net/npm/chart.js')
+  })
+
+  test('supports object imports and preserves extra fields', () => {
+    const result = resolveFetchImport(
+      { url: './helpers/math.js', integrity: 'sha-123' },
+      'apps/qrcode/model.js',
+      '/tmp/jsee-workspace'
+    )
+
+    expect(result.schemaEntry).toEqual({
+      url: 'apps/qrcode/helpers/math.js',
+      integrity: 'sha-123'
+    })
+    expect(result.importUrl).toBe('https://cdn.jsdelivr.net/npm/apps/qrcode/helpers/math.js')
+    expect(result.localFilePath).toBe(path.join('/tmp/jsee-workspace', 'apps/qrcode/helpers/math.js'))
+    expect(result.remoteUrl).toBeNull()
+  })
+})
+
+describe('resolveRuntimeMode', () => {
+  test('defaults to cdn for generated output when fetch is disabled', () => {
+    expect(resolveRuntimeMode('auto', false, true)).toBe('cdn')
+  })
+
+  test('defaults to local for served apps when fetch is disabled', () => {
+    expect(resolveRuntimeMode('auto', false, false)).toBe('local')
+  })
+
+  test('uses inline mode when fetch is enabled', () => {
+    expect(resolveRuntimeMode('auto', true, true)).toBe('inline')
+  })
+
+  test('honors explicit runtime mode', () => {
+    expect(resolveRuntimeMode('local', true, true)).toBe('local')
+    expect(resolveRuntimeMode('inline', false, false)).toBe('inline')
+  })
+
+  test('throws on invalid runtime mode', () => {
+    expect(() => resolveRuntimeMode('invalid', false, false)).toThrow('Invalid runtime mode')
+  })
+})
+
+describe('output writes', () => {
+  test('writes absolute output paths and keeps json output intact', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsee-cli-output-'))
+    const schemaPath = path.join(tmpDir, 'schema.json')
+    const jsonOutputPath = path.join(tmpDir, 'result.json')
+    const htmlOutputPath = path.join(tmpDir, 'result.html')
+
+    fs.writeFileSync(schemaPath, JSON.stringify({
+      model: [
+        {
+          name: 'demo',
+          type: 'function',
+          code: 'function demo () { return 1 }'
+        }
+      ],
+      inputs: [],
+      outputs: []
+    }, null, 2))
+
+    try {
+      await gen(['--inputs', schemaPath, '--outputs', `${jsonOutputPath},${htmlOutputPath}`])
+
+      const jsonContent = fs.readFileSync(jsonOutputPath, 'utf8')
+      const htmlContent = fs.readFileSync(htmlOutputPath, 'utf8')
+
+      expect(() => JSON.parse(jsonContent)).not.toThrow()
+      expect(htmlContent).toContain('<!DOCTYPE html>')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})