odac 1.4.2 → 1.4.4

package/test/Route/set.test.js

@@ -1,7 +1,11 @@
 const Route = require('../../src/Route')
+const path = require('path')
+const fs = require('fs')
+const os = require('os')
 
 describe('Route.set()', () => {
   let route
+  let consoleSpy
 
   beforeEach(() => {
     route = new Route()
@@ -10,9 +14,11 @@ describe('Route.set()', () => {
       Config: {}
     }
     global.__dir = process.cwd()
+    consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
   })
 
   afterEach(() => {
+    consoleSpy.mockRestore()
     delete global.Odac
     delete global.__dir
   })
@@ -49,4 +55,100 @@ describe('Route.set()', () => {
     expect(route.routes.test_route.get['/test']).toBeDefined()
     expect(route.routes.test_route.get['/test/']).toBeUndefined()
   })
+
+  it('should log "Controller not found" when file does not exist', async () => {
+    global.Odac.Route.buff = 'test_route'
+
+    route.set('get', '/missing', 'nonexistent_controller')
+
+    await Promise.all(route._pendingRouteLoads)
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Controller not found'))
+  })
+
+  it('should log the actual error message when controller has a load error', async () => {
+    global.Odac.Route.buff = 'test_route'
+
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-test-'))
+    const controllerDir = path.join(tmpDir, 'controller', 'get')
+    fs.mkdirSync(controllerDir, {recursive: true})
+    fs.writeFileSync(path.join(controllerDir, 'broken.js'), "const x = require('nonexistent_module_xyz_12345');")
+
+    global.__dir = tmpDir
+
+    route.set('get', '/broken', 'broken')
+
+    await Promise.all(route._pendingRouteLoads)
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to load controller'))
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('nonexistent_module_xyz_12345'))
+
+    fs.rmSync(tmpDir, {recursive: true, force: true})
+  })
+
+  describe('hot reload', () => {
+    it('should update inline function reference on hot reload', async () => {
+      global.Odac.Route.buff = 'app'
+
+      const originalHandler = jest.fn(() => 'original')
+      route.set('get', '/api/test', originalHandler)
+      await Promise.all(route._pendingRouteLoads)
+      route._pendingRouteLoads = []
+
+      expect(route.routes.app.get['/api/test'].cache).toBe(originalHandler)
+      expect(route.routes.app.get['/api/test'].type).toBe('function')
+
+      const updatedHandler = jest.fn(() => 'updated')
+      route.set('get', '/api/test', updatedHandler)
+      await Promise.all(route._pendingRouteLoads)
+      route._pendingRouteLoads = []
+
+      expect(route.routes.app.get['/api/test'].cache).toBe(updatedHandler)
+      expect(route.routes.app.get['/api/test'].file).toBe(updatedHandler)
+    })
+
+    it('should update middlewares on inline function hot reload', async () => {
+      global.Odac.Route.buff = 'app'
+
+      const mw1 = jest.fn()
+      const handler = jest.fn()
+
+      route._pendingMiddlewares = [mw1]
+      route.set('get', '/mw-test', handler)
+      await Promise.all(route._pendingRouteLoads)
+      route._pendingRouteLoads = []
+      route._pendingMiddlewares = []
+
+      expect(route.routes.app.get['/mw-test'].middlewares).toEqual([mw1])
+
+      const mw2 = jest.fn()
+      route._pendingMiddlewares = [mw2]
+      const newHandler = jest.fn()
+      route.set('get', '/mw-test', newHandler)
+      await Promise.all(route._pendingRouteLoads)
+      route._pendingRouteLoads = []
+      route._pendingMiddlewares = []
+
+      expect(route.routes.app.get['/mw-test'].middlewares).toEqual([mw2])
+      expect(route.routes.app.get['/mw-test'].cache).toBe(newHandler)
+    })
+
+    it('should update token option on inline function hot reload', async () => {
+      global.Odac.Route.buff = 'app'
+
+      const handler = jest.fn()
+      route.set('get', '/token-test', handler, {token: false})
+      await Promise.all(route._pendingRouteLoads)
+      route._pendingRouteLoads = []
+
+      expect(route.routes.app.get['/token-test'].token).toBe(false)
+
+      const newHandler = jest.fn()
+      route.set('get', '/token-test', newHandler, {token: true})
+      await Promise.all(route._pendingRouteLoads)
+      route._pendingRouteLoads = []
+
+      expect(route.routes.app.get['/token-test'].token).toBe(true)
+    })
+  })
 })

package/test/View/Image/buildFilename.test.js

@@ -0,0 +1,62 @@
+const Image = require('../../../src/View/Image')
+
+describe('Image.buildFilename()', () => {
+  test('should produce {name}-{width}-{hash}.{ext} format with width', () => {
+    const result = Image.buildFilename('/images/logo.jpg', {width: 250, format: 'webp'})
+    expect(result).toMatch(/^logo-250-[a-f0-9]{8}\.webp$/)
+  })
+
+  test('should use "o" for dimension when no width specified', () => {
+    const result = Image.buildFilename('/images/hero.png', {format: 'avif'})
+    expect(result).toMatch(/^hero-o-[a-f0-9]{8}\.avif$/)
+  })
+
+  test('should fall back to source extension when no format specified', () => {
+    const result = Image.buildFilename('/images/photo.png', {width: 800})
+    expect(result).toMatch(/^photo-800-[a-f0-9]{8}\.png$/)
+  })
+
+  test('should sanitize special characters in basename', () => {
+    const result = Image.buildFilename('/images/my photo (1).jpg', {width: 100, format: 'webp'})
+    expect(result).not.toContain(' ')
+    expect(result).not.toContain('(')
+    expect(result).toMatch(/^my_photo__1_-100-[a-f0-9]{8}\.webp$/)
+  })
+
+  test('should produce different filenames for same name in different directories', () => {
+    const a = Image.buildFilename('/images/blog/logo.jpg', {width: 250, format: 'webp'})
+    const b = Image.buildFilename('/images/brand/logo.jpg', {width: 250, format: 'webp'})
+    // Same basename but different hash due to different full src path
+    expect(a).not.toBe(b)
+    expect(a).toMatch(/^logo-250-/)
+    expect(b).toMatch(/^logo-250-/)
+  })
+
+  test('should produce different filenames for same file with different quality', () => {
+    const a = Image.buildFilename('/images/logo.jpg', {width: 250, quality: 80, format: 'webp'})
+    const b = Image.buildFilename('/images/logo.jpg', {width: 250, quality: 50, format: 'webp'})
+    expect(a).not.toBe(b)
+  })
+
+  test('should be deterministic for identical inputs', () => {
+    const opts = {width: 300, format: 'webp', quality: 80}
+    const a = Image.buildFilename('/images/hero.jpg', opts)
+    const b = Image.buildFilename('/images/hero.jpg', opts)
+    expect(a).toBe(b)
+  })
+
+  test('should handle nested paths correctly', () => {
+    const result = Image.buildFilename('/uploads/2024/03/cover.png', {width: 600, format: 'webp'})
+    expect(result).toMatch(/^cover-600-[a-f0-9]{8}\.webp$/)
+  })
+
+  test('should produce different filenames when mtime changes', () => {
+    const opts = {width: 250, format: 'webp'}
+    const a = Image.buildFilename('/images/logo.jpg', opts, 1000000)
+    const b = Image.buildFilename('/images/logo.jpg', opts, 2000000)
+    expect(a).not.toBe(b)
+    // Both should have same prefix, different hash
+    expect(a).toMatch(/^logo-250-/)
+    expect(b).toMatch(/^logo-250-/)
+  })
+})

package/test/View/Image/hash.test.js

@@ -0,0 +1,59 @@
+const Image = require('../../../src/View/Image')
+
+describe('Image.hash()', () => {
+  test('should produce an 8-character hex string', () => {
+    const result = Image.hash('/images/hero.jpg', {width: 400, height: 300})
+    expect(result).toMatch(/^[a-f0-9]{8}$/)
+  })
+
+  test('should be deterministic for identical inputs', () => {
+    const options = {width: 800, format: 'webp', quality: 80}
+    const a = Image.hash('/images/photo.png', options)
+    const b = Image.hash('/images/photo.png', options)
+    expect(a).toBe(b)
+  })
+
+  test('should produce different hashes for different sources', () => {
+    const options = {width: 400}
+    const a = Image.hash('/images/a.jpg', options)
+    const b = Image.hash('/images/b.jpg', options)
+    expect(a).not.toBe(b)
+  })
+
+  test('should produce different hashes for different dimensions', () => {
+    const a = Image.hash('/images/hero.jpg', {width: 400})
+    const b = Image.hash('/images/hero.jpg', {width: 800})
+    expect(a).not.toBe(b)
+  })
+
+  test('should produce different hashes for different formats', () => {
+    const a = Image.hash('/images/hero.jpg', {format: 'webp'})
+    const b = Image.hash('/images/hero.jpg', {format: 'avif'})
+    expect(a).not.toBe(b)
+  })
+
+  test('should produce different hashes for different quality values', () => {
+    const a = Image.hash('/images/hero.jpg', {quality: 80})
+    const b = Image.hash('/images/hero.jpg', {quality: 50})
+    expect(a).not.toBe(b)
+  })
+
+  test('should handle empty options gracefully', () => {
+    const result = Image.hash('/images/hero.jpg')
+    expect(result).toMatch(/^[a-f0-9]{8}$/)
+  })
+
+  test('should produce different hashes when mtime changes', () => {
+    const opts = {width: 400, format: 'webp'}
+    const a = Image.hash('/images/hero.jpg', opts, 1000000)
+    const b = Image.hash('/images/hero.jpg', opts, 2000000)
+    expect(a).not.toBe(b)
+  })
+
+  test('should produce same hash for same mtime', () => {
+    const opts = {width: 400, format: 'webp'}
+    const a = Image.hash('/images/hero.jpg', opts, 1000000)
+    const b = Image.hash('/images/hero.jpg', opts, 1000000)
+    expect(a).toBe(b)
+  })
+})

package/test/View/Image/isAvailable.test.js

@@ -0,0 +1,15 @@
+const Image = require('../../../src/View/Image')
+
+describe('Image.isAvailable()', () => {
+  test('should return a boolean', () => {
+    // Reset memoized state by accessing the class fresh
+    const result = Image.isAvailable()
+    expect(typeof result).toBe('boolean')
+  })
+
+  test('should return consistent results on repeated calls', () => {
+    const first = Image.isAvailable()
+    const second = Image.isAvailable()
+    expect(first).toBe(second)
+  })
+})

package/test/View/Image/parse.test.js

@@ -0,0 +1,83 @@
+const Image = require('../../../src/View/Image')
+
+describe('Image.parse()', () => {
+  test('should convert <odac:img> with static src to <script:odac> block', () => {
+    const input = '<odac:img src="/images/hero.jpg" width="200" />'
+    const result = Image.parse(input)
+
+    expect(result).toContain('<script:odac>')
+    expect(result).toContain('Odac.View.Image.render(')
+    expect(result).toContain('"src":"/images/hero.jpg"')
+    expect(result).toContain('"width":"200"')
+    expect(result).toContain('</script:odac>')
+  })
+
+  test('should convert {{ }} expressions to live JS with Odac.Var', () => {
+    const input = '<odac:img src="{{ post.cover }}" alt="{{ post.title }}" />'
+    const result = Image.parse(input)
+
+    expect(result).toContain('(await Odac.Var(await  post.cover ).html())')
+    expect(result).toContain('(await Odac.Var(await  post.title ).html())')
+    expect(result).not.toContain('{{')
+    expect(result).not.toContain('}}')
+  })
+
+  test('should convert {!! !!} expressions to raw JS', () => {
+    const input = '<odac:img src="{!! getImageUrl() !!}" />'
+    const result = Image.parse(input)
+
+    expect(result).toContain('(await  getImageUrl() )')
+    expect(result).not.toContain('{!!')
+    expect(result).not.toContain('!!}')
+  })
+
+  test('should leave tag unchanged when src is missing', () => {
+    const input = '<odac:img alt="no source" />'
+    const result = Image.parse(input)
+
+    expect(result).toBe(input)
+  })
+
+  test('should not affect non-img odac tags', () => {
+    const input = '<odac var="title" /> <odac:img src="/a.jpg" />'
+    const result = Image.parse(input)
+
+    expect(result).toContain('<odac var="title" />')
+    expect(result).toContain('<script:odac>')
+  })
+
+  test('should handle self-closing tag without trailing slash', () => {
+    const input = '<odac:img src="/a.jpg">'
+    const result = Image.parse(input)
+
+    // Both <odac:img ... /> and <odac:img ...> are valid — parser handles both
+    expect(result).toContain('<script:odac>')
+    expect(result).toContain('"/a.jpg"')
+  })
+
+  test('should handle multiple img tags in one template', () => {
+    const input = ['<odac:img src="/a.jpg" width="100" />', '<p>text</p>', '<odac:img src="/b.png" format="avif" />'].join('\n')
+    const result = Image.parse(input)
+
+    const scriptCount = (result.match(/<script:odac>/g) || []).length
+    expect(scriptCount).toBe(2)
+    expect(result).toContain('"/a.jpg"')
+    expect(result).toContain('"/b.png"')
+  })
+
+  test('should preserve boolean attributes', () => {
+    const input = '<odac:img src="/a.jpg" loading />'
+    const result = Image.parse(input)
+
+    expect(result).toContain('"loading":true')
+  })
+
+  test('should handle mixed static and dynamic attributes', () => {
+    const input = '<odac:img src="{{ item.image }}" class="rounded" width="300" />'
+    const result = Image.parse(input)
+
+    expect(result).toContain('(await Odac.Var(await  item.image ).html())')
+    expect(result).toContain('"class":"rounded"')
+    expect(result).toContain('"width":"300"')
+  })
+})

package/test/View/Image/process.test.js

@@ -0,0 +1,38 @@
+const Image = require('../../../src/View/Image')
+
+describe('Image.process()', () => {
+  test('should return null when sharp is unavailable', async () => {
+    const originalIsAvailable = Image.isAvailable
+    Image.isAvailable = () => false
+
+    try {
+      const result = await Image.process('/images/hero.jpg', {width: 400})
+      expect(result).toBeNull()
+    } finally {
+      Image.isAvailable = originalIsAvailable
+    }
+  })
+
+  test('should return null for unsupported source extensions', async () => {
+    if (!Image.isAvailable()) return
+
+    const result = await Image.process('/images/document.pdf', {width: 400})
+    expect(result).toBeNull()
+  })
+
+  test('should return null for non-existent source files', async () => {
+    if (!Image.isAvailable()) return
+
+    global.__dir = process.cwd()
+    const result = await Image.process('/nonexistent/image.jpg', {width: 400})
+    expect(result).toBeNull()
+  })
+
+  test('should return null for path traversal attempts', async () => {
+    if (!Image.isAvailable()) return
+
+    global.__dir = process.cwd()
+    const result = await Image.process('/../../../etc/passwd', {width: 400})
+    expect(result).toBeNull()
+  })
+})

package/test/View/Image/render.test.js

@@ -0,0 +1,117 @@
+const Image = require('../../../src/View/Image')
+
+describe('Image.render()', () => {
+  test('should return a standard <img> tag when sharp is unavailable', async () => {
+    const originalIsAvailable = Image.isAvailable
+    Image.isAvailable = () => false
+
+    try {
+      const html = await Image.render({
+        src: '/images/hero.jpg',
+        width: '400',
+        height: '300',
+        alt: 'Hero image',
+        class: 'rounded'
+      })
+
+      expect(html).toContain('<img src="/images/hero.jpg"')
+      expect(html).toContain('alt="Hero image"')
+      expect(html).toContain('class="rounded"')
+      expect(html).toContain('height="300"')
+      expect(html).toContain('width="400"')
+      expect(html).not.toContain('format=')
+      expect(html).not.toContain('quality=')
+      expect(html).toMatch(/>$/)
+    } finally {
+      Image.isAvailable = originalIsAvailable
+    }
+  })
+
+  test('should exclude processing attributes (format, quality) from HTML output', async () => {
+    const originalIsAvailable = Image.isAvailable
+    Image.isAvailable = () => false
+
+    try {
+      const html = await Image.render({
+        src: '/images/photo.png',
+        width: '800',
+        format: 'webp',
+        quality: '90',
+        alt: 'Photo'
+      })
+
+      expect(html).not.toContain('format=')
+      expect(html).not.toContain('quality=')
+      expect(html).toContain('alt="Photo"')
+    } finally {
+      Image.isAvailable = originalIsAvailable
+    }
+  })
+
+  test('should return fallback <img> when src is empty', async () => {
+    const html = await Image.render({src: '', alt: 'Empty'})
+    expect(html).toContain('<img src=""')
+    expect(html).toContain('alt="Empty"')
+  })
+
+  test('should render boolean attributes without value', async () => {
+    const originalIsAvailable = Image.isAvailable
+    Image.isAvailable = () => false
+
+    try {
+      const html = await Image.render({
+        src: '/images/hero.jpg',
+        loading: 'lazy',
+        decoding: 'async'
+      })
+
+      expect(html).toContain('loading="lazy"')
+      expect(html).toContain('decoding="async"')
+    } finally {
+      Image.isAvailable = originalIsAvailable
+    }
+  })
+
+  test('should output HTML attributes in alphabetical order', async () => {
+    const originalIsAvailable = Image.isAvailable
+    Image.isAvailable = () => false
+
+    try {
+      const html = await Image.render({
+        src: '/images/hero.jpg',
+        width: '400',
+        alt: 'Test',
+        class: 'img'
+      })
+
+      const altPos = html.indexOf('alt=')
+      const classPos = html.indexOf('class=')
+      const widthPos = html.indexOf('width=')
+
+      expect(altPos).toBeLessThan(classPos)
+      expect(classPos).toBeLessThan(widthPos)
+    } finally {
+      Image.isAvailable = originalIsAvailable
+    }
+  })
+
+  test('should escape HTML special characters in attribute values to prevent XSS', async () => {
+    const originalIsAvailable = Image.isAvailable
+    Image.isAvailable = () => false
+
+    try {
+      const html = await Image.render({
+        src: '/img.jpg" onload="alert(1)',
+        alt: '<script>xss</script>'
+      })
+
+      // Quotes are escaped so the injected onload never becomes a real attribute
+      expect(html).toContain('&quot; onload=&quot;')
+      expect(html).not.toContain('<script>')
+      expect(html).toContain('&quot;')
+      expect(html).toContain('&lt;script&gt;')
+    } finally {
+      Image.isAvailable = originalIsAvailable
+    }
+  })
+})

package/test/View/Image/serve.test.js

@@ -0,0 +1,56 @@
+const fs = require('fs')
+const fsPromises = fs.promises
+const path = require('path')
+const Image = require('../../../src/View/Image')
+
+const IMG_CACHE_DIR = './storage/.cache/img'
+
+describe('Image.serve()', () => {
+  const testFilename = 'testserve1234567.webp'
+  const testFilePath = path.join(IMG_CACHE_DIR, testFilename)
+
+  beforeAll(async () => {
+    await fsPromises.mkdir(IMG_CACHE_DIR, {recursive: true})
+    await fsPromises.writeFile(testFilePath, Buffer.from('fake-image-data'))
+  })
+
+  afterAll(async () => {
+    await fsPromises.unlink(testFilePath).catch(() => {})
+  })
+
+  test('should return stream, type, and size for a cached file', async () => {
+    const result = await Image.serve(testFilename)
+
+    expect(result).not.toBeNull()
+    expect(result.type).toBe('image/webp')
+    expect(result.size).toBe(Buffer.from('fake-image-data').length)
+    expect(typeof result.stream.pipe).toBe('function')
+
+    result.stream.on('error', () => {})
+    result.stream.destroy()
+  })
+
+  test('should return null for non-existent files', async () => {
+    const result = await Image.serve('nonexistent00000.webp')
+    expect(result).toBeNull()
+  })
+
+  test('should block path traversal attempts', async () => {
+    const result = await Image.serve('../../../etc/passwd')
+    expect(result).toBeNull()
+  })
+
+  test('should resolve jpg extension to image/jpeg MIME type', async () => {
+    const jpgFilename = 'testservejpg0000.jpg'
+    const jpgPath = path.join(IMG_CACHE_DIR, jpgFilename)
+    await fsPromises.writeFile(jpgPath, Buffer.from('fake-jpg'))
+
+    const result = await Image.serve(jpgFilename)
+    expect(result).not.toBeNull()
+    expect(result.type).toBe('image/jpeg')
+    result.stream.on('error', () => {})
+    result.stream.destroy()
+
+    await fsPromises.unlink(jpgPath).catch(() => {})
+  })
+})

package/test/View/Image/url.test.js

@@ -0,0 +1,53 @@
+const fs = require('fs')
+const fsPromises = fs.promises
+const path = require('path')
+const Image = require('../../../src/View/Image')
+
+describe('Image.url()', () => {
+  const publicDir = path.join(process.cwd(), 'public')
+  const testImageDir = path.join(publicDir, 'images')
+  const testImagePath = path.join(testImageDir, 'url-test.jpg')
+
+  beforeAll(async () => {
+    await fsPromises.mkdir(testImageDir, {recursive: true})
+    await fsPromises.writeFile(testImagePath, Buffer.from('fake-jpg-data'))
+  })
+
+  afterAll(async () => {
+    await fsPromises.unlink(testImagePath).catch(() => {})
+  })
+
+  test('should return empty string for empty src', async () => {
+    const result = await Image.url('')
+    expect(result).toBe('')
+  })
+
+  test('should return empty string for null/undefined src', async () => {
+    expect(await Image.url(null)).toBe('')
+    expect(await Image.url(undefined)).toBe('')
+  })
+
+  test('should return original src when sharp is unavailable', async () => {
+    // sharp is not installed in test env
+    const result = await Image.url('/images/url-test.jpg')
+    expect(result).toBe('/images/url-test.jpg')
+  })
+
+  test('should return original src when source file does not exist', async () => {
+    // Force isAvailable to true temporarily to test file-not-found path
+    const original = Image.isAvailable
+    Image.isAvailable = () => true
+
+    const result = await Image.url('/images/nonexistent.jpg')
+    expect(result).toBe('/images/nonexistent.jpg')
+
+    Image.isAvailable = original
+  })
+
+  test('should accept options parameter without error', async () => {
+    const result = await Image.url('/images/url-test.jpg', {width: 300, format: 'webp', quality: 80})
+    // Returns original src since sharp is unavailable in test
+    expect(typeof result).toBe('string')
+    expect(result.length).toBeGreaterThan(0)
+  })
+})

package/test/View/constructor.test.js

@@ -19,4 +19,14 @@ describe('View.constructor()', () => {
     new View(mockOdac)
     expect(global.Odac.View.Form).toBeDefined()
   })
+
+  it('should set global.Odac.View.Image', () => {
+    new View(mockOdac)
+    expect(global.Odac.View.Image).toBeDefined()
+  })
+
+  it('should expose Image on the instance for compiled templates', () => {
+    const view = new View(mockOdac)
+    expect(view.Image).toBe(global.Odac.View.Image)
+  })
 })