@quatrain/app 1.1.17 → 1.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/app",
-  "version": "1.1.17",
+  "version": "1.1.19",
   "license": "AGPL-3.0-only",
   "description": "Quatrain App Bootloader and configuration helpers",
   "main": "dist/index.js",
@@ -21,20 +21,19 @@
   "author": "Quatrain Développement SAS <developers@quatrain.com>",
   "dependencies": {
     "@quatrain/api": "^1.1.5",
-    "@quatrain/api-client": "^1.1.4",
+    "@quatrain/api-client": "^1.1.5",
     "@quatrain/api-server": "^1.1.9",
-    "@quatrain/api-server-express": "^1.1.10",
-    "@quatrain/auth": "^1.2.1",
-    "@quatrain/auth-basic": "^1.0.1",
-    "@quatrain/auth-oidc": "^1.1.4",
-    "@quatrain/backend": "^1.2.6",
-    "@quatrain/backend-migrations": "^1.1.4",
-    "@quatrain/core": "^1.2.5",
-    "@quatrain/log": "^1.2.1",
-    "@quatrain/messaging": "^1.1.2",
-    "@quatrain/queue": "^1.2.2",
-    "@quatrain/storage": "^1.2.3",
-    "@quatrain/ui-form-react": "^1.1.5",
+    "@quatrain/api-server-express": "^1.1.13",
+    "@quatrain/auth": "^1.2.3",
+    "@quatrain/auth-basic": "^1.0.3",
+    "@quatrain/auth-oidc": "^1.1.5",
+    "@quatrain/backend": "^1.2.12",
+    "@quatrain/backend-migrations": "^1.1.6",
+    "@quatrain/core": "^1.2.15",
+    "@quatrain/log": "^1.2.3",
+    "@quatrain/messaging": "^1.1.4",
+    "@quatrain/queue": "^1.2.3",
+    "@quatrain/storage": "^1.2.9",
     "yaml": "^2.4.0"
   },
   "devDependencies": {

package/src/Bootloader.test.ts

@@ -0,0 +1,173 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { AppBootloader } from './Bootloader'
+import { Backend } from '@quatrain/backend'
+import { Auth } from '@quatrain/auth'
+import { Queue } from '@quatrain/queue'
+import { Storage } from '@quatrain/storage'
+import { Messaging } from '@quatrain/messaging'
+import { Log } from '@quatrain/log'
+
+// Mock dynamic require targets as virtual modules
+jest.mock('mock-backend', () => ({
+   MockBackend: jest.fn().mockImplementation(() => ({ name: 'mock-backend' }))
+}), { virtual: true })
+
+jest.mock('mock-auth', () => ({
+   MockAuth: jest.fn().mockImplementation(() => ({ name: 'mock-auth' }))
+}), { virtual: true })
+
+jest.mock('mock-queue', () => ({
+   MockQueue: jest.fn().mockImplementation(() => ({ name: 'mock-queue' }))
+}), { virtual: true })
+
+jest.mock('mock-storage', () => ({
+   MockStorage: jest.fn().mockImplementation(() => ({ name: 'mock-storage' }))
+}), { virtual: true })
+
+jest.mock('mock-messaging', () => ({
+   MockMessaging: jest.fn().mockImplementation(() => ({ name: 'mock-messaging' }))
+}), { virtual: true })
+
+describe('AppBootloader', () => {
+   describe('resolveEnv', () => {
+      beforeEach(() => {
+         process.env.TEST_VAR = 'value1'
+         process.env.ANOTHER_VAR = 'value2'
+      })
+
+      afterEach(() => {
+         delete process.env.TEST_VAR
+         delete process.env.ANOTHER_VAR
+      })
+
+      it('should parse env(VAR) strings to environment variables values', () => {
+         const resolved = (AppBootloader as any).resolveEnv('env(TEST_VAR)')
+         expect(resolved).toBe('value1')
+      })
+
+      it('should parse raw strings as is', () => {
+         const resolved = (AppBootloader as any).resolveEnv('just-a-string')
+         expect(resolved).toBe('just-a-string')
+      })
+
+      it('should resolve env markers nested inside arrays', () => {
+         const input = ['just-a-string', 'env(TEST_VAR)', 'env(ANOTHER_VAR)']
+         const resolved = (AppBootloader as any).resolveEnv(input)
+         expect(resolved).toEqual(['just-a-string', 'value1', 'value2'])
+      })
+
+      it('should resolve env markers nested inside objects', () => {
+         const input = {
+            plain: 'string',
+            secret: 'env(TEST_VAR)',
+            nested: {
+               key: 'env(ANOTHER_VAR)'
+            }
+         }
+         const resolved = (AppBootloader as any).resolveEnv(input)
+         expect(resolved).toEqual({
+            plain: 'string',
+            secret: 'value1',
+            nested: {
+               key: 'value2'
+            }
+         })
+      })
+
+      it('should return default empty strings for undefined environment variables', () => {
+         const resolved = (AppBootloader as any).resolveEnv('env(UNDEFINED_VAR)')
+         expect(resolved).toBe('')
+      })
+   })
+
+   describe('bootstrap', () => {
+      let existsSpy: jest.SpyInstance
+      let readSpy: jest.SpyInstance
+
+      beforeEach(() => {
+         existsSpy = jest.spyOn(fs, 'existsSync').mockReturnValue(true)
+         readSpy = jest.spyOn(fs, 'readFileSync').mockReturnValue('{}')
+
+         // Spy on manager classes to prevent real registrations polluting other test runs
+         jest.spyOn(Backend, 'addBackend').mockImplementation(() => {})
+         jest.spyOn(Auth, 'addProvider').mockImplementation(() => {})
+         jest.spyOn(Queue, 'addQueue').mockImplementation(() => {})
+         jest.spyOn(Storage, 'addStorage').mockImplementation(() => {})
+         jest.spyOn(Messaging, 'addMessager').mockImplementation(() => {})
+         jest.spyOn(Log, 'info').mockImplementation(() => {})
+         jest.spyOn(Log, 'error').mockImplementation(() => {})
+      })
+
+      afterEach(() => {
+         jest.restoreAllMocks()
+      })
+
+      it('should throw an error if configuration file is not found', async () => {
+         existsSpy.mockReturnValue(false)
+         await expect(AppBootloader.bootstrap('missing.json')).rejects.toThrow(
+            '[Bootloader] Configuration file not found'
+         )
+      })
+
+      it('should bootstrap active configured adapters from configuration JSON', async () => {
+         const config = {
+            logLevel: 'debug',
+            backend: {
+               package: 'mock-backend',
+               adapter: 'MockBackend',
+               config: { db: 'test' }
+            },
+            auth: {
+               package: 'mock-auth',
+               adapter: 'MockAuth',
+               config: {}
+            },
+            queue: {
+               package: 'mock-queue',
+               adapter: 'MockQueue',
+               config: {}
+            },
+            storage: {
+               package: 'mock-storage',
+               adapter: 'MockStorage',
+               config: {}
+            },
+            messaging: {
+               package: 'mock-messaging',
+               adapter: 'MockMessaging',
+               config: {}
+            }
+         }
+
+         readSpy.mockReturnValue(JSON.stringify(config))
+
+         await AppBootloader.bootstrap('quatrain-test.json')
+
+         expect(Log.info).toHaveBeenCalledWith(expect.stringContaining('[Bootloader] Initializing application'))
+         expect(Backend.addBackend).toHaveBeenCalled()
+         expect(Auth.addProvider).toHaveBeenCalled()
+         expect(Queue.addQueue).toHaveBeenCalled()
+         expect(Storage.addStorage).toHaveBeenCalled()
+         expect(Messaging.addMessager).toHaveBeenCalled()
+      })
+
+      it('should catch and log loading errors gracefully on package load failures', async () => {
+         const config = {
+            backend: {
+               package: 'invalid-backend-package',
+               adapter: 'InvalidBackend',
+               config: {}
+            }
+         }
+
+         readSpy.mockReturnValue(JSON.stringify(config))
+
+         await AppBootloader.bootstrap('quatrain-test.json')
+
+         expect(Log.error).toHaveBeenCalledWith(
+            expect.stringContaining('[Bootloader] Failed to load backend')
+         )
+      })
+   })
+})

package/src/CodeGenerator.test.ts

@@ -0,0 +1,125 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { CodeGenerator } from './CodeGenerator'
+import { Log } from '@quatrain/log'
+
+describe('CodeGenerator', () => {
+   const targetTestDir = path.resolve(__dirname, 'temp_codegen_test')
+
+   beforeEach(() => {
+      jest.spyOn(Log, 'info').mockImplementation(() => {})
+      if (fs.existsSync(targetTestDir)) {
+         fs.rmSync(targetTestDir, { recursive: true, force: true })
+      }
+   })
+
+   afterEach(() => {
+      if (fs.existsSync(targetTestDir)) {
+         fs.rmSync(targetTestDir, { recursive: true, force: true })
+      }
+      jest.restoreAllMocks()
+   })
+
+   it('should generate a complete, valid application with isolated directories', () => {
+      const mockConfig = {
+         name: 'TestApp',
+         authMode: 'basic',
+         backend: {
+            adapter: 'SQLiteAdapter'
+         },
+         models: [
+            {
+               name: 'Book',
+               collectionName: 'books',
+               properties: [
+                  { name: 'title', type: 'StringProperty', mandatory: true, htmlType: 'text' },
+                  { name: 'price', type: 'NumberProperty', mandatory: false }
+               ]
+            }
+         ],
+         widgets: [
+            {
+               modelName: 'Book',
+               widgetType: 'form',
+               layout: [
+                  { type: 'field', name: 'title' },
+                  { type: 'group', fields: ['price'] }
+               ]
+            }
+         ]
+      }
+
+      CodeGenerator.generate(mockConfig, targetTestDir)
+
+      // Assert basic configuration files exist
+      expect(fs.existsSync(path.join(targetTestDir, 'package.json'))).toBe(true)
+      expect(fs.existsSync(path.join(targetTestDir, 'tsconfig.json'))).toBe(true)
+
+      // Assert server-side model and API routes exist
+      expect(fs.existsSync(path.join(targetTestDir, 'src/models/Book.ts'))).toBe(true)
+      expect(fs.existsSync(path.join(targetTestDir, 'src/api/BookApi.ts'))).toBe(true)
+      expect(fs.existsSync(path.join(targetTestDir, 'src/index.ts'))).toBe(true)
+
+      // Assert database migrations generated
+      const migrationsDir = path.join(targetTestDir, 'data/migrations/default')
+      expect(fs.existsSync(migrationsDir)).toBe(true)
+      const migrationFiles = fs.readdirSync(migrationsDir)
+      expect(migrationFiles.length).toBe(1)
+      expect(migrationFiles[0]).toMatch(/_init\.ts$/)
+
+      // Assert frontend codebases scaffolded correctly
+      const webDir = path.join(targetTestDir, 'web')
+      expect(fs.existsSync(path.join(webDir, 'package.json'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'tsconfig.json'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'vite.config.ts'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'index.html'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'src/main.tsx'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'src/api.ts'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'src/App.tsx'))).toBe(true)
+
+      // Assert frontend React CRUD pages compiled
+      const pagesDir = path.join(webDir, 'src/pages')
+      expect(fs.existsSync(path.join(pagesDir, 'BookList.tsx'))).toBe(true)
+      expect(fs.existsSync(path.join(pagesDir, 'BookForm.tsx'))).toBe(true)
+
+      // Assert Docker integration exists
+      expect(fs.existsSync(path.join(webDir, 'Dockerfile'))).toBe(true)
+      expect(fs.existsSync(path.join(webDir, 'nginx.conf'))).toBe(true)
+
+      // Let's verify layout code inside BookForm.tsx
+      const formCode = fs.readFileSync(path.join(pagesDir, 'BookForm.tsx'), 'utf8')
+      expect(formCode).toContain('TextInput label="title"')
+      expect(formCode).toContain('TextInput label="price"')
+      expect(formCode).toContain('<Group grow align="flex-start">')
+   })
+
+   it('should generate fallback CoreForm components when layout is missing', () => {
+      const mockConfig = {
+         name: 'FallbackApp',
+         authMode: 'oauth',
+         backend: {
+            adapter: 'PostgresAdapter'
+         },
+         models: [
+            {
+               name: 'Customer',
+               collectionName: 'customers',
+               properties: [
+                  { name: 'fullName', type: 'string', mandatory: true }
+               ]
+            }
+         ],
+         widgets: [] // Empty widgets list should trigger dynamic fallback
+      }
+
+      CodeGenerator.generate(mockConfig, targetTestDir)
+
+      const formCode = fs.readFileSync(path.join(targetTestDir, 'web/src/pages/CustomerForm.tsx'), 'utf8')
+      expect(formCode).toContain('CoreForm')
+      expect(formCode).toContain('CustomerForm')
+
+      const packageCode = fs.readFileSync(path.join(targetTestDir, 'package.json'), 'utf8')
+      expect(packageCode).toContain('@quatrain/auth-oidc')
+      expect(packageCode).toContain('@quatrain/backend-postgres')
+   })
+})