odac 1.4.1 → 1.4.3

package/test/Database/autoNanoid.test.js

@@ -0,0 +1,215 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+
+/**
+ * Tests the Database.js proxy's auto-nanoid insert interception and schema metadata loading.
+ * Why: Validates that columns with type 'nanoid' are auto-populated on insert
+ * without requiring manual Odac.DB.nanoid() calls — core to ODAC's zero-config philosophy.
+ */
+
+let tmpDir, knexLib, db
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-db-autonanoid-'))
+  knexLib = require('knex')
+  db = knexLib({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+  jest.resetModules()
+})
+
+function writeSchema(name, content) {
+  const dir = path.join(tmpDir, 'schema')
+  fs.mkdirSync(dir, {recursive: true})
+  fs.writeFileSync(path.join(dir, `${name}.js`), `module.exports = ${JSON.stringify(content, null, 2)}`)
+}
+
+describe('Database.js - Auto NanoID Insert', () => {
+  it('should auto-generate nanoid on single-row insert', async () => {
+    await db.schema.createTable('posts', table => {
+      table.string('id', 21).primary()
+      table.string('title', 255)
+    })
+
+    const DB = require('../../src/Database')
+    DB.connections = {default: db}
+    db._odacConnectionKey = 'default'
+    DB._nanoidColumns = {default: {posts: [{column: 'id', size: 21}]}}
+
+    // Access through the proxy — Odac.DB.posts.insert()
+    await DB.posts.insert({title: 'Hello World'})
+
+    const rows = await db('posts').select()
+    expect(rows).toHaveLength(1)
+    expect(rows[0].title).toBe('Hello World')
+    expect(typeof rows[0].id).toBe('string')
+    expect(rows[0].id.length).toBe(21)
+    expect(rows[0].id).toMatch(/^[a-zA-Z0-9]+$/)
+  })
+
+  it('should auto-generate unique nanoid for bulk inserts', async () => {
+    await db.schema.createTable('items', table => {
+      table.string('id', 21).primary()
+      table.string('name', 100)
+    })
+
+    const DB = require('../../src/Database')
+    DB.connections = {default: db}
+    db._odacConnectionKey = 'default'
+    DB._nanoidColumns = {default: {items: [{column: 'id', size: 21}]}}
+
+    await DB.items.insert([{name: 'Item A'}, {name: 'Item B'}, {name: 'Item C'}])
+
+    const rows = await db('items').select()
+    expect(rows).toHaveLength(3)
+
+    const ids = rows.map(r => r.id)
+    expect(new Set(ids).size).toBe(3) // all unique
+
+    for (const id of ids) {
+      expect(id.length).toBe(21)
+      expect(id).toMatch(/^[a-zA-Z0-9]+$/)
+    }
+  })
+
+  it('should NOT overwrite user-provided id', async () => {
+    await db.schema.createTable('docs', table => {
+      table.string('id', 21).primary()
+      table.string('content', 500)
+    })
+
+    const DB = require('../../src/Database')
+    DB.connections = {default: db}
+    db._odacConnectionKey = 'default'
+    DB._nanoidColumns = {default: {docs: [{column: 'id', size: 21}]}}
+
+    await DB.docs.insert({id: 'MY_CUSTOM_ID_1234567', content: 'Test'})
+
+    const rows = await db('docs').select()
+    expect(rows[0].id).toBe('MY_CUSTOM_ID_1234567')
+  })
+
+  it('should support custom nanoid length per column', async () => {
+    await db.schema.createTable('tokens', table => {
+      table.string('code', 8).primary()
+      table.string('label', 100)
+    })
+
+    const DB = require('../../src/Database')
+    DB.connections = {default: db}
+    db._odacConnectionKey = 'default'
+    DB._nanoidColumns = {default: {tokens: [{column: 'code', size: 8}]}}
+
+    await DB.tokens.insert({label: 'discount'})
+
+    const rows = await db('tokens').select()
+    expect(rows[0].code.length).toBe(8)
+    expect(rows[0].code).toMatch(/^[a-zA-Z0-9]+$/)
+  })
+
+  it('should NOT interfere with tables without nanoid columns', async () => {
+    await db.schema.createTable('logs', table => {
+      table.increments('id')
+      table.string('message', 500)
+    })
+
+    const DB = require('../../src/Database')
+    DB.connections = {default: db}
+    db._odacConnectionKey = 'default'
+    DB._nanoidColumns = {} // no nanoid metadata
+
+    await DB.logs.insert({message: 'test log'})
+
+    const rows = await db('logs').select()
+    expect(rows).toHaveLength(1)
+    expect(rows[0].message).toBe('test log')
+    expect(rows[0].id).toBe(1) // auto-increment
+  })
+})
+
+describe('Database._loadNanoidMeta()', () => {
+  it('should detect nanoid columns from schema files', () => {
+    writeSchema('users', {
+      columns: {
+        id: {type: 'nanoid', primary: true},
+        name: {type: 'string', length: 255}
+      }
+    })
+
+    const DB = require('../../src/Database')
+    global.__dir = tmpDir
+    DB._nanoidColumns = {}
+    DB._loadNanoidMeta()
+
+    expect(DB._nanoidColumns).toHaveProperty('default')
+    expect(DB._nanoidColumns.default).toHaveProperty('users')
+    expect(DB._nanoidColumns.default.users).toEqual([{column: 'id', size: 21}])
+  })
+
+  it('should detect multiple nanoid columns in a single table', () => {
+    writeSchema('events', {
+      columns: {
+        id: {type: 'nanoid', primary: true},
+        public_id: {type: 'nanoid', length: 12},
+        name: {type: 'string'}
+      }
+    })
+
+    const DB = require('../../src/Database')
+    global.__dir = tmpDir
+    DB._nanoidColumns = {}
+    DB._loadNanoidMeta()
+
+    expect(DB._nanoidColumns.default.events).toEqual([
+      {column: 'id', size: 21},
+      {column: 'public_id', size: 12}
+    ])
+  })
+
+  it('should skip tables without nanoid columns', () => {
+    writeSchema('logs', {
+      columns: {
+        id: {type: 'increments'},
+        message: {type: 'text'}
+      }
+    })
+
+    const DB = require('../../src/Database')
+    global.__dir = tmpDir
+    DB._nanoidColumns = {}
+    DB._loadNanoidMeta()
+
+    expect(DB._nanoidColumns.default).not.toHaveProperty('logs')
+  })
+
+  it('should handle missing schema directory gracefully', () => {
+    const DB = require('../../src/Database')
+    global.__dir = tmpDir
+    DB._nanoidColumns = {}
+    DB._loadNanoidMeta()
+
+    expect(DB._nanoidColumns).toEqual({})
+  })
+
+  it('should detect nanoid in subdirectory schemas (named connections)', () => {
+    const subDir = path.join(tmpDir, 'schema', 'analytics')
+    fs.mkdirSync(subDir, {recursive: true})
+    fs.writeFileSync(
+      path.join(subDir, 'metrics.js'),
+      `module.exports = ${JSON.stringify({columns: {id: {type: 'nanoid', length: 16}, value: {type: 'integer'}}})}`
+    )
+
+    const DB = require('../../src/Database')
+    global.__dir = tmpDir
+    DB._nanoidColumns = {}
+    DB._loadNanoidMeta()
+
+    expect(DB._nanoidColumns.analytics.metrics).toEqual([{column: 'id', size: 16}])
+  })
+})

package/test/Database/nanoid.test.js

@@ -0,0 +1,19 @@
+const DB = require('../../src/Database')
+
+describe('Database.nanoid()', () => {
+  it('should generate a string of default length (21)', () => {
+    const id = DB.nanoid()
+    expect(typeof id).toBe('string')
+    expect(id.length).toBe(21)
+  })
+
+  it('should generate a string of specified length', () => {
+    const id = DB.nanoid(10)
+    expect(id.length).toBe(10)
+  })
+
+  it('should generate only alphanumeric characters', () => {
+    const id = DB.nanoid(100)
+    expect(id).toMatch(/^[a-zA-Z0-9]+$/)
+  })
+})

package/test/Lang/constructor.test.js

@@ -0,0 +1,25 @@
+const Lang = require('../../src/Lang')
+
+describe('Lang.constructor()', () => {
+  let mockOdac
+
+  beforeEach(() => {
+    mockOdac = {
+      Config: {lang: {default: 'en'}},
+      Var: jest.fn(() => ({is: () => true})),
+      Request: {header: jest.fn()}
+    }
+    global.__dir = '/mock'
+  })
+
+  it('should initialize successfully', () => {
+    const lang = new Lang(mockOdac)
+    expect(lang).toBeDefined()
+  })
+
+  it('should call Var if lang is provided', () => {
+    const lang = new Lang(mockOdac)
+    lang.set('en')
+    expect(mockOdac.Var).toHaveBeenCalledWith('en')
+  })
+})

package/test/Lang/get.test.js

@@ -0,0 +1,65 @@
+const fs = require('fs')
+const Lang = require('../../src/Lang')
+
+jest.mock('fs')
+
+describe('Lang.get()', () => {
+  let mockOdac
+  let lang
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock'
+
+    mockOdac = {
+      Config: {lang: {default: 'en'}},
+      Var: jest.fn(val => ({
+        is: jest.fn(type => type === 'alpha' && /^[a-zA-Z]+$/.test(val))
+      })),
+      Request: {
+        header: jest.fn()
+      }
+    }
+
+    fs.existsSync.mockReturnValue(false)
+    fs.mkdirSync.mockImplementation(() => {})
+    fs.writeFileSync.mockImplementation(() => {})
+    fs.readFileSync.mockImplementation(() => {
+      throw new Error('ENOENT')
+    })
+
+    lang = new Lang(mockOdac)
+  })
+
+  it('should return matching string and support placeholders', () => {
+    fs.existsSync.mockImplementation(path => path.includes('/tr.json'))
+    fs.readFileSync.mockReturnValue(
+      JSON.stringify({
+        welcome: 'Merhaba %s!'
+      })
+    )
+
+    lang.set('tr')
+    expect(lang.get('welcome', 'Emre')).toBe('Merhaba Emre!')
+  })
+
+  it('should support numbered placeholders', () => {
+    fs.existsSync.mockImplementation(path => path.includes('/en.json'))
+    fs.readFileSync.mockReturnValue(
+      JSON.stringify({
+        order: 'First: %s1, Second: %s2'
+      })
+    )
+
+    lang.set('en')
+    expect(lang.get('order', 'A', 'B')).toBe('First: A, Second: B')
+  })
+
+  it('should auto-save new keys', () => {
+    lang.set('en')
+    const result = lang.get('new_key')
+
+    expect(result).toBe('new_key')
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/en.json'), expect.stringContaining('"new_key": "new_key"'))
+  })
+})

package/test/Lang/set.test.js

@@ -0,0 +1,49 @@
+const fs = require('fs')
+const Lang = require('../../src/Lang')
+
+jest.mock('fs')
+
+describe('Lang.set()', () => {
+  let mockOdac
+  let lang
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock'
+
+    mockOdac = {
+      Config: {lang: {default: 'en'}},
+      Var: jest.fn(val => ({
+        is: jest.fn(type => type === 'alpha' && /^[a-zA-Z]+$/.test(val))
+      })),
+      Request: {
+        header: jest.fn()
+      }
+    }
+
+    fs.existsSync.mockReturnValue(false)
+    fs.readFileSync.mockImplementation(() => {
+      throw new Error('ENOENT')
+    })
+  })
+
+  it('should default to en when no config or header', () => {
+    lang = new Lang(mockOdac)
+    lang.set()
+    // No Var call here because lang is falsy
+  })
+
+  it('should use lang from header if available', () => {
+    mockOdac.Request.header.mockReturnValue('tr-TR')
+    lang = new Lang(mockOdac)
+    lang.set()
+    // Verifying it uses 'tr' can be tricky since it's private, but constructor calls set()
+    expect(mockOdac.Request.header).toHaveBeenCalledWith('ACCEPT-LANGUAGE')
+  })
+
+  it('should use explicit lang in set()', () => {
+    lang = new Lang(mockOdac)
+    lang.set('fr')
+    expect(mockOdac.Var).toHaveBeenCalledWith('fr')
+  })
+})

package/test/Odac/init.test.js

@@ -0,0 +1,42 @@
+const Odac = require('../../src/Odac')
+
+// Mock all dependencies
+jest.mock('../../src/Storage', () => ({init: jest.fn()}))
+jest.mock('../../src/Env', () => ({init: jest.fn(), get: jest.fn()}))
+jest.mock('../../src/Config', () => ({
+  init: jest.fn(),
+  request: {timeout: 10000},
+  lang: {default: 'en'}
+}))
+jest.mock('../../src/Database', () => ({init: jest.fn()}))
+jest.mock('../../src/Ipc', () => ({init: jest.fn(), subscribe: jest.fn(), unsubscribe: jest.fn()}))
+jest.mock('../../src/Route', () => {
+  return jest.fn().mockImplementation(() => ({
+    init: jest.fn(),
+    routes: {
+      www: {}
+    }
+  }))
+})
+jest.mock('../../src/Server', () => ({init: jest.fn()}))
+
+describe('Odac.init()', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock/project'
+    delete global.Odac
+  })
+
+  it('should initialize all components and set global.Odac', async () => {
+    await Odac.init()
+    expect(global.Odac).toBeDefined()
+    expect(global.Odac.Storage).toBeDefined()
+    expect(global.Odac.Config).toBeDefined()
+    expect(global.Odac.Env).toBeDefined()
+    expect(global.Odac.Database).toBeDefined()
+    expect(global.Odac.Ipc).toBeDefined()
+    expect(global.Odac.Route).toBeDefined()
+    expect(global.Odac.Server).toBeDefined()
+    expect(typeof global.__).toBe('function')
+  })
+})

package/test/Odac/instance.test.js

@@ -0,0 +1,58 @@
+const Odac = require('../../src/Odac')
+
+describe('Odac.instance()', () => {
+  let mockOdac
+
+  beforeEach(() => {
+    mockOdac = {
+      Config: {request: {timeout: 1000}},
+      DB: {init: jest.fn(), close: jest.fn()},
+      Auth: {constructor: jest.fn()},
+      Route: {
+        init: jest.fn(),
+        routes: {www: {}}
+      },
+      Storage: {get: jest.fn(), put: jest.fn()},
+      Env: {get: jest.fn()}
+    }
+    global.Odac = mockOdac
+    global.__dir = '/mock'
+  })
+
+  afterEach(() => {
+    delete global.Odac
+    delete global.__dir
+  })
+
+  it('should create a context object with req/res', () => {
+    const mockReq = {
+      method: 'GET',
+      url: '/',
+      headers: {host: 'www.example.com'},
+      connection: {remoteAddress: '127.0.0.1'},
+      on: jest.fn()
+    }
+    const mockRes = {on: jest.fn(), writeHead: jest.fn(), end: jest.fn()}
+
+    const ctx = Odac.instance('id', mockReq, mockRes)
+
+    expect(ctx.Request).toBeDefined()
+    expect(ctx.Request.id).toBe('id')
+  })
+
+  it('should provide helper methods on the context', () => {
+    const mockReq = {
+      method: 'GET',
+      url: '/',
+      headers: {host: 'www.example.com'},
+      connection: {remoteAddress: '127.0.0.1'},
+      on: jest.fn()
+    }
+    const mockRes = {on: jest.fn()}
+    const ctx = Odac.instance('id', mockReq, mockRes)
+
+    expect(typeof ctx.abort).toBe('function')
+    expect(typeof ctx.cookie).toBe('function')
+    expect(typeof ctx.env).toBe('function')
+  })
+})

package/test/Route/{Middleware.test.js → Middleware/chaining.test.js}

@@ -1,6 +1,6 @@
-const Route = require('../../src/Route.js')
+const Route = require('../../../src/Route.js')
 
-describe('Middleware System', () => {
+describe('Middleware Chaining Integration', () => {
   let route
 
   beforeEach(() => {
@@ -9,38 +9,21 @@ describe('Middleware System', () => {
     global.__dir = __dirname
   })
 
-  test('use() should return MiddlewareChain', () => {
-    const chain = route.use('auth', 'logger')
-    expect(chain).not.toBe(route)
-    expect(chain._middlewares).toEqual(['auth', 'logger'])
-  })
-
-  test('use() should support chaining with more middlewares', () => {
-    const chain = route.use('auth').use('logger')
-    expect(chain._middlewares).toEqual(['auth', 'logger'])
-  })
-
-  test('page() should return this for chaining', () => {
+  test('page() should return this for chaining when not on a chain', () => {
     const result = route.page('/', 'index')
     expect(result).toBe(route)
   })
 
-  test('post() should return this for chaining', () => {
+  test('post() should return this for chaining when not on a chain', () => {
     const result = route.post('/api', 'api')
     expect(result).toBe(route)
   })
 
-  test('get() should return this for chaining', () => {
+  test('get() should return this for chaining when not on a chain', () => {
     const result = route.get('/api', 'api')
     expect(result).toBe(route)
   })
 
-  test('auth.use() should return MiddlewareChain', () => {
-    const chain = route.auth.use('admin')
-    expect(chain).not.toBe(route)
-    expect(chain._middlewares).toEqual(['admin'])
-  })
-
   test('chaining should work: use().page().page()', () => {
     route
       .use('auth')
@@ -75,11 +58,4 @@ describe('Middleware System', () => {
     route.use('cors', 'rateLimit').post('/api/upload', () => {})
     expect(route.routes.test.post['/api/upload'].middlewares).toEqual(['cors', 'rateLimit'])
   })
-
-  test('separate use() chains should be independent', () => {
-    route.use('auth').page('/profile', () => {})
-    route.use('cors').page('/api', () => {})
-    expect(route.routes.test.page['/profile'].middlewares).toEqual(['auth'])
-    expect(route.routes.test.page['/api'].middlewares).toEqual(['cors'])
-  })
 })

package/test/Route/Middleware/use.test.js

@@ -0,0 +1,35 @@
+const Route = require('../../../src/Route.js')
+
+describe('MiddlewareChain.use()', () => {
+  let route
+
+  beforeEach(() => {
+    route = new Route()
+    global.Odac = {Route: {buff: 'test'}}
+    global.__dir = __dirname
+  })
+
+  test('use() should return MiddlewareChain', () => {
+    const chain = route.use('auth', 'logger')
+    expect(chain).not.toBe(route)
+    expect(chain._middlewares).toEqual(['auth', 'logger'])
+  })
+
+  test('use() should support chaining with more middlewares', () => {
+    const chain = route.use('auth').use('logger')
+    expect(chain._middlewares).toEqual(['auth', 'logger'])
+  })
+
+  test('auth.use() should return MiddlewareChain', () => {
+    const chain = route.auth.use('admin')
+    expect(chain).not.toBe(route)
+    expect(chain._middlewares).toEqual(['admin'])
+  })
+
+  test('separate use() chains should be independent', () => {
+    route.use('auth').page('/profile', () => {})
+    route.use('cors').page('/api', () => {})
+    expect(route.routes.test.page['/profile'].middlewares).toEqual(['auth'])
+    expect(route.routes.test.page['/api'].middlewares).toEqual(['cors'])
+  })
+})