npm - metaowl - Versions diffs - 0.4.1 → 0.5.0 - Mend

metaowl 0.4.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

package/CHANGELOG.md +22 -0
package/README.md +12 -0
package/build/runtime/bin/metaowl-build.js +10 -0
package/{bin → build/runtime/bin}/metaowl-create.js +96 -177
package/build/runtime/bin/metaowl-dev.js +10 -0
package/build/runtime/bin/metaowl-generate.js +231 -0
package/build/runtime/bin/metaowl-lint.js +58 -0
package/build/runtime/bin/utils.js +68 -0
package/build/runtime/index.js +141 -0
package/build/runtime/modules/app-mounter.js +65 -0
package/build/runtime/modules/auto-import.js +140 -0
package/build/runtime/modules/cache.js +49 -0
package/build/runtime/modules/composables.js +353 -0
package/build/runtime/modules/error-boundary.js +116 -0
package/build/runtime/modules/fetch.js +31 -0
package/build/runtime/modules/file-router.js +205 -0
package/build/runtime/modules/forms.js +193 -0
package/build/runtime/modules/i18n.js +167 -0
package/build/runtime/modules/layouts.js +163 -0
package/build/runtime/modules/link.js +141 -0
package/build/runtime/modules/meta.js +117 -0
package/build/runtime/modules/odoo-rpc.js +264 -0
package/build/runtime/modules/pwa.js +262 -0
package/build/runtime/modules/router.js +389 -0
package/build/runtime/modules/seo.js +186 -0
package/build/runtime/modules/store.js +196 -0
package/build/runtime/modules/templates-manager.js +52 -0
package/build/runtime/modules/test-utils.js +238 -0
package/build/runtime/vite/plugin.js +183 -0
package/eslint.js +29 -0
package/package.json +28 -10
package/CONTRIBUTING.md +0 -49
package/bin/metaowl-build.js +0 -12
package/bin/metaowl-dev.js +0 -12
package/bin/metaowl-generate.js +0 -339
package/bin/metaowl-lint.js +0 -71
package/bin/utils.js +0 -82
package/eslint.config.js +0 -3
package/index.js +0 -328
package/modules/app-mounter.js +0 -104
package/modules/auto-import.js +0 -225
package/modules/cache.js +0 -59
package/modules/composables.js +0 -600
package/modules/error-boundary.js +0 -228
package/modules/fetch.js +0 -51
package/modules/file-router.js +0 -478
package/modules/forms.js +0 -353
package/modules/i18n.js +0 -333
package/modules/layouts.js +0 -431
package/modules/link.js +0 -255
package/modules/meta.js +0 -119
package/modules/odoo-rpc.js +0 -511
package/modules/pwa.js +0 -515
package/modules/router.js +0 -769
package/modules/seo.js +0 -501
package/modules/store.js +0 -409
package/modules/templates-manager.js +0 -89
package/modules/test-utils.js +0 -532
package/test/auto-import.test.js +0 -110
package/test/cache.test.js +0 -55
package/test/composables.test.js +0 -103
package/test/dynamic-routes.test.js +0 -469
package/test/error-boundary.test.js +0 -126
package/test/fetch.test.js +0 -100
package/test/file-router.test.js +0 -55
package/test/forms.test.js +0 -203
package/test/i18n.test.js +0 -188
package/test/layouts.test.js +0 -395
package/test/link.test.js +0 -189
package/test/meta.test.js +0 -146
package/test/odoo-rpc.test.js +0 -547
package/test/pwa.test.js +0 -154
package/test/router-guards.test.js +0 -229
package/test/router.test.js +0 -77
package/test/seo.test.js +0 -353
package/test/store.test.js +0 -476
package/test/templates-manager.test.js +0 -83
package/test/test-utils.test.js +0 -314
package/vite/plugin.js +0 -290
package/vitest.config.js +0 -8

package/test/meta.test.js DELETED Viewed

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { JSDOM } from 'jsdom'
-import * as Meta from '../modules/meta.js'
-let dom
-beforeEach(() => {
-  dom = new JSDOM('<!doctype html><html><head></head><body></body></html>')
-  globalThis.document = dom.window.document
-})
-describe('Meta.title', () => {
-  it('sets document.title', () => {
-    Meta.title('My Page')
-    expect(document.title).toBe('My Page')
-  })
-  it('updates title on second call', () => {
-    Meta.title('First')
-    Meta.title('Second')
-    expect(document.title).toBe('Second')
-  })
-  it('does nothing when called with empty string', () => {
-    document.title = 'Original'
-    Meta.title('')
-    expect(document.title).toBe('Original')
-  })
-})
-describe('Meta name-based tags (description, keywords, author)', () => {
-  it('creates a meta[name="description"] tag', () => {
-    Meta.description('A test page')
-    const el = document.querySelector('meta[name="description"]')
-    expect(el).not.toBeNull()
-    expect(el.content).toBe('A test page')
-  })
-  it('updates description content on second call', () => {
-    Meta.description('First')
-    Meta.description('Second')
-    const els = document.querySelectorAll('meta[name="description"]')
-    expect(els).toHaveLength(1)
-    expect(els[0].content).toBe('Second')
-  })
-  it('creates meta[name="keywords"]', () => {
-    Meta.keywords('owl, odoo')
-    expect(document.querySelector('meta[name="keywords"]').content).toBe('owl, odoo')
-  })
-  it('creates meta[name="author"]', () => {
-    Meta.author('Dennis')
-    expect(document.querySelector('meta[name="author"]').content).toBe('Dennis')
-  })
-  it('does nothing for falsy value', () => {
-    Meta.description(null)
-    expect(document.querySelector('meta[name="description"]')).toBeNull()
-  })
-})
-describe('Meta.canonical', () => {
-  it('creates a link[rel="canonical"]', () => {
-    Meta.canonical('https://example.com/page')
-    const el = document.querySelector('link[rel="canonical"]')
-    expect(el).not.toBeNull()
-    expect(el.href).toBe('https://example.com/page')
-  })
-  it('updates href on second call without duplicating', () => {
-    Meta.canonical('https://example.com/a')
-    Meta.canonical('https://example.com/b')
-    const els = document.querySelectorAll('link[rel="canonical"]')
-    expect(els).toHaveLength(1)
-    expect(els[0].href).toBe('https://example.com/b')
-  })
-})
-describe('Meta Open Graph tags', () => {
-  it('creates og:title', () => {
-    Meta.ogTitle('OG Title')
-    expect(document.querySelector('meta[property="og:title"]').content).toBe('OG Title')
-  })
-  it('updates og:title on second call without duplicating', () => {
-    Meta.ogTitle('First')
-    Meta.ogTitle('Second')
-    expect(document.querySelectorAll('meta[property="og:title"]')).toHaveLength(1)
-    expect(document.querySelector('meta[property="og:title"]').content).toBe('Second')
-  })
-  it('creates og:description', () => {
-    Meta.ogDescription('Desc')
-    expect(document.querySelector('meta[property="og:description"]').content).toBe('Desc')
-  })
-  it('creates og:image', () => {
-    Meta.ogImage('https://example.com/img.png')
-    expect(document.querySelector('meta[property="og:image"]').content).toBe('https://example.com/img.png')
-  })
-  it('creates og:url', () => {
-    Meta.ogUrl('https://example.com')
-    expect(document.querySelector('meta[property="og:url"]').content).toBe('https://example.com')
-  })
-  it('creates og:type', () => {
-    Meta.ogType('website')
-    expect(document.querySelector('meta[property="og:type"]').content).toBe('website')
-  })
-  it('creates og:site_name', () => {
-    Meta.ogSiteName('My Site')
-    expect(document.querySelector('meta[property="og:site_name"]').content).toBe('My Site')
-  })
-})
-describe('Meta Twitter Card tags', () => {
-  it('creates twitter:card', () => {
-    Meta.twitterCard('summary_large_image')
-    expect(document.querySelector('meta[name="twitter:card"]').content).toBe('summary_large_image')
-  })
-  it('creates twitter:title', () => {
-    Meta.twitterTitle('TW Title')
-    expect(document.querySelector('meta[name="twitter:title"]').content).toBe('TW Title')
-  })
-  it('creates twitter:description', () => {
-    Meta.twitterDescription('TW Desc')
-    expect(document.querySelector('meta[name="twitter:description"]').content).toBe('TW Desc')
-  })
-  it('creates twitter:image', () => {
-    Meta.twitterImage('https://example.com/tw.png')
-    expect(document.querySelector('meta[name="twitter:image"]').content).toBe('https://example.com/tw.png')
-  })
-  it('updates twitter:card on second call without duplicating', () => {
-    Meta.twitterCard('summary')
-    Meta.twitterCard('summary_large_image')
-    expect(document.querySelectorAll('meta[name="twitter:card"]')).toHaveLength(1)
-    expect(document.querySelector('meta[name="twitter:card"]').content).toBe('summary_large_image')
-  })
-})

package/test/odoo-rpc.test.js DELETED Viewed

@@ -1,547 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import {
-  OdooService,
-  configure,
-  isConfigured,
-  isAuthenticated,
-  getSession,
-  getConfig,
-  onAuthChange,
-  authenticate,
-  logout,
-  searchRead,
-  call,
-  read,
-  create,
-  write,
-  unlink,
-  searchCount,
-  listDatabases,
-  versionInfo
-} from '../modules/odoo-rpc.js'
-describe('Odoo RPC Service', () => {
-  beforeEach(() => {
-    // Reset state
-    logout()
-    localStorage.clear()
-    vi.restoreAllMocks()
-  })
-  describe('Configuration', () => {
-    it('should configure with valid config', () => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        username: 'admin',
-        password: 'admin'
-      })
-      expect(isConfigured()).toBe(true)
-      expect(getConfig()).toMatchObject({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        username: 'admin',
-        password: 'admin',
-        persistSession: true
-      })
-    })
-    it('should not be configured without baseUrl', () => {
-      configure({
-        database: 'test_db'
-      })
-      expect(isConfigured()).toBe(false)
-    })
-    it('should not be configured without database', () => {
-      configure({
-        baseUrl: 'https://test.odoo.com'
-      })
-      expect(isConfigured()).toBe(false)
-    })
-    it('should allow apiKey instead of password', () => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        username: 'admin',
-        apiKey: 'test-api-key-123'
-      })
-      expect(getConfig().apiKey).toBe('test-api-key-123')
-      expect(getConfig().password).toBeUndefined()
-    })
-    it('should support disabling session persistence', () => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        persistSession: false
-      })
-      expect(getConfig().persistSession).toBe(false)
-    })
-  })
-  describe('Authentication', () => {
-    beforeEach(() => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        username: 'admin',
-        password: 'admin'
-      })
-    })
-    it('should authenticate successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: 1  // User ID
-        })
-      }).mockResolvedValueOnce({  // For user info search_read
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: [{
-            id: 1,
-            name: 'Administrator',
-            partner_id: [3, 'Administrator'],
-            lang: 'en_US',
-            tz: 'Europe/Brussels'
-          }]
-        })
-      })
-      const session = await authenticate()
-      expect(session.uid).toBe(1)
-      expect(session.username).toBe('admin')
-      expect(session.name).toBe('Administrator')
-      expect(isAuthenticated()).toBe(true)
-    })
-    it('should throw error without credentials', async () => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db'
-      })
-      await expect(authenticate()).rejects.toThrow('requires username and password')
-    })
-    it('should allow custom credentials in authenticate()', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: 2
-        })
-      }).mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: []
-        })
-      })
-      const session = await authenticate('custom_user', 'custom_pass')
-      expect(session.username).toBe('custom_user')
-    })
-    it('should handle authentication failure', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: false  // Authentication failed
-        })
-      })
-      await expect(authenticate()).rejects.toThrow('invalid credentials')
-    })
-    it('should logout and clear session', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: 1
-        })
-      }).mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: []
-        })
-      })
-      await authenticate()
-      expect(isAuthenticated()).toBe(true)
-      logout()
-      expect(isAuthenticated()).toBe(false)
-      expect(getSession()).toBeNull()
-    })
-    it('should notify auth listeners on change', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: 1
-        })
-      }).mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: []
-        })
-      })
-      const listener = vi.fn()
-      const unsubscribe = onAuthChange(listener)
-      await authenticate()
-      expect(listener).toHaveBeenCalledTimes(1)
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({ uid: 1 }))
-      unsubscribe()
-    })
-  })
-  describe('RPC Operations', () => {
-    beforeEach(() => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        username: 'admin',
-        password: 'admin'
-      })
-      // Mock successful authentication
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: 1
-        })
-      })
-    })
-    it('should throw if not authenticated', async () => {
-      await expect(searchRead('res.partner')).rejects.toThrow('Not authenticated')
-    })
-    it('should perform search_read', async () => {
-      const mockResult = [
-        { id: 1, name: 'Partner 1' },
-        { id: 2, name: 'Partner 2' }
-      ]
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: 1
-        })
-      }).mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: []
-        })
-      }).mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: mockResult
-        })
-      })
-      await authenticate()
-      const partners = await searchRead('res.partner', {
-        domain: [['is_company', '=', true]],
-        fields: ['name', 'email'],
-        limit: 10
-      })
-      expect(partners).toEqual(mockResult)
-    })
-    it('should call model methods', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 42 })
-        })
-      await authenticate()
-      const result = await call('res.partner', 'custom_method', [['arg1']])
-      expect(result).toBe(42)
-    })
-    it('should read specific records', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({
-            jsonrpc: '2.0',
-            id: 123,
-            result: [{ id: 1, name: 'Partner 1' }]
-          })
-        })
-      await authenticate()
-      const records = await read('res.partner', [1], ['name', 'email'])
-      expect(records).toEqual([{ id: 1, name: 'Partner 1' }])
-    })
-    it('should create records', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 123 })
-        })
-      await authenticate()
-      const newId = await create('res.partner', { name: 'New Partner' })
-      expect(newId).toBe(123)
-    })
-    it('should update records', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: true })
-        })
-      await authenticate()
-      const result = await write('res.partner', [1], { name: 'Updated Partner' })
-      expect(result).toBe(true)
-    })
-    it('should delete records', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: true })
-        })
-      await authenticate()
-      const result = await unlink('res.partner', [1])
-      expect(result).toBe(true)
-    })
-    it('should get search count', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers(),
-          json: async () => ({ jsonrpc: '2.0', id: 123, result: 42 })
-        })
-      await authenticate()
-      const count = await searchCount('res.partner', [['is_company', '=', true]])
-      expect(count).toBe(42)
-    })
-  })
-  describe('Database Operations', () => {
-    beforeEach(() => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db'
-      })
-    })
-    it('should list databases', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          result: ['db1', 'db2', 'db3']
-        })
-      })
-      const dbs = await listDatabases()
-      expect(dbs).toEqual(['db1', 'db2', 'db3'])
-    })
-    it('should get version info', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          result: {
-            server_version: '16.0',
-            server_version_info: [16, 0, 0, 'final', 0],
-            protocol_version: 1
-          }
-        })
-      })
-      const version = await versionInfo()
-      expect(version.server_version).toBe('16.0')
-    })
-  })
-  describe('Error Handling', () => {
-    beforeEach(() => {
-      configure({
-        baseUrl: 'https://test.odoo.com',
-        database: 'test_db',
-        username: 'admin',
-        password: 'admin'
-      })
-    })
-    it('should handle RPC errors', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        json: async () => ({
-          jsonrpc: '2.0',
-          id: 123,
-          error: {
-            message: 'Access Denied',
-            data: { message: 'You do not have permission' }
-          }
-        })
-      })
-      await expect(authenticate()).rejects.toThrow('Access Denied')
-    })
-    it('should handle HTTP errors', async () => {
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        headers: new Headers(),
-        json: async () => ({})
-      })
-      await expect(authenticate()).rejects.toThrow('HTTP 500')
-    })
-    it('should throw if not configured', async () => {
-      // Reset configuration by configuring with empty values
-      configure({ baseUrl: '', database: '' })
-      await expect(listDatabases()).rejects.toThrow('not configured')
-    })
-  })
-  describe('OdooService Namespace', () => {
-    it('should expose all methods via namespace', () => {
-      expect(OdooService.configure).toBe(configure)
-      expect(OdooService.authenticate).toBe(authenticate)
-      expect(OdooService.logout).toBe(logout)
-      expect(OdooService.searchRead).toBe(searchRead)
-      expect(OdooService.call).toBe(call)
-      expect(OdooService.isAuthenticated).toBe(isAuthenticated)
-    })
-  })
-})