odac 1.4.0 → 1.4.2

package/test/Config/init.test.js

@@ -0,0 +1,66 @@
+const fs = require('fs')
+const os = require('os')
+const Config = require('../../src/Config')
+
+jest.mock('fs')
+jest.mock('os')
+
+describe('Config.init()', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock/project'
+    Config.system = undefined
+    Config.encrypt.key = 'odac'
+  })
+
+  it('should load system config from home directory', () => {
+    os.homedir.mockReturnValue('/home/user')
+    fs.readFileSync.mockImplementation(path => {
+      if (path === '/home/user/.odac/config.json') {
+        return JSON.stringify({deviceId: '123'})
+      }
+      return '{}'
+    })
+    fs.existsSync.mockReturnValue(false)
+
+    Config.init()
+
+    expect(Config.system).toEqual({deviceId: '123'})
+    expect(fs.readFileSync).toHaveBeenCalledWith('/home/user/.odac/config.json')
+  })
+
+  it('should load project config and merge it', () => {
+    os.homedir.mockReturnValue('/home/user')
+    fs.existsSync.mockImplementation(path => {
+      if (path === '/mock/project/odac.json') return true
+      return false
+    })
+    fs.readFileSync.mockImplementation(path => {
+      if (path === '/mock/project/odac.json') {
+        return JSON.stringify({encrypt: {key: 'secret'}})
+      }
+      return '{}'
+    })
+
+    Config.init()
+
+    // The key gets hashed in init(), so it won't be 'secret' anymore
+    expect(Config.encrypt.key).not.toBe('secret')
+    expect(Config.encrypt.key).toBeInstanceOf(Buffer)
+  })
+
+  it('should interpolate variables in config', () => {
+    process.env.TEST_VAR = 'env_value'
+    os.homedir.mockReturnValue('/home/user')
+    fs.existsSync.mockReturnValue(true)
+    fs.readFileSync.mockReturnValue(
+      JSON.stringify({
+        custom: 'value-${TEST_VAR}'
+      })
+    )
+
+    Config.init()
+
+    expect(Config.custom).toBe('value-env_value')
+  })
+})

package/test/Config/interpolate.test.js

@@ -0,0 +1,35 @@
+const Config = require('../../src/Config')
+
+describe('Config._interpolate()', () => {
+  it('should replace ${VAR} with environment variables', () => {
+    process.env.FOO = 'bar'
+    const result = Config._interpolate('hello-${FOO}')
+    expect(result).toBe('hello-bar')
+  })
+
+  it('should replace ${VAR} when variable name includes hyphen', () => {
+    process.env['MY-VAR'] = 'hyphen-value'
+    const result = Config._interpolate('hello-${MY-VAR}')
+    expect(result).toBe('hello-hyphen-value')
+    delete process.env['MY-VAR']
+  })
+
+  it('should replace ${odac} with client path', () => {
+    // __dirname in Config.js is /.../src, so it replaces /src with /client
+    const result = Config._interpolate('path-${odac}')
+    expect(result).toMatch(/\/client$/)
+  })
+
+  it('should handle nested objects and arrays', () => {
+    process.env.VAR = 'x'
+    const obj = {
+      a: ['${VAR}'],
+      b: {c: '${VAR}'}
+    }
+    const result = Config._interpolate(obj)
+    expect(result).toEqual({
+      a: ['x'],
+      b: {c: 'x'}
+    })
+  })
+})

package/test/Database/ConnectionFactory/buildConnectionConfig.test.js

@@ -0,0 +1,13 @@
+const {buildConnectionConfig} = require('../../../src/Database/ConnectionFactory')
+
+describe('ConnectionFactory.buildConnectionConfig()', () => {
+  it('should create sqlite filename config', () => {
+    const config = buildConnectionConfig({database: 'db.sqlite3'}, 'sqlite3')
+    expect(config).toEqual({filename: 'db.sqlite3'})
+  })
+
+  it('should create host based config for non-sqlite', () => {
+    const config = buildConnectionConfig({user: 'root', password: 'secret', database: 'app', port: 3306}, 'mysql2')
+    expect(config).toEqual({host: '127.0.0.1', user: 'root', password: 'secret', database: 'app', port: 3306})
+  })
+})

package/test/Database/ConnectionFactory/buildConnections.test.js

@@ -0,0 +1,31 @@
+const mockKnex = jest.fn()
+jest.mock(
+  'knex',
+  () =>
+    (...args) =>
+      mockKnex(...args)
+)
+
+const {buildConnections} = require('../../../src/Database/ConnectionFactory')
+
+describe('ConnectionFactory.buildConnections()', () => {
+  beforeEach(() => {
+    mockKnex.mockReset()
+    mockKnex.mockImplementation(options => ({options, raw: jest.fn()}))
+  })
+
+  it('should support single database config', () => {
+    const connections = buildConnections({type: 'mysql', user: 'root', database: 'app'})
+    expect(Object.keys(connections)).toEqual(['default'])
+    expect(mockKnex).toHaveBeenCalledTimes(1)
+  })
+
+  it('should support multi database config', () => {
+    const connections = buildConnections({
+      analytics: {type: 'postgres', user: 'u', database: 'a'},
+      default: {type: 'sqlite', filename: './dev.sqlite3'}
+    })
+    expect(Object.keys(connections).sort()).toEqual(['analytics', 'default'])
+    expect(mockKnex).toHaveBeenCalledTimes(2)
+  })
+})

package/test/Database/ConnectionFactory/resolveClient.test.js

@@ -0,0 +1,12 @@
+const {resolveClient} = require('../../../src/Database/ConnectionFactory')
+
+describe('ConnectionFactory.resolveClient()', () => {
+  it('should map known database aliases', () => {
+    expect(resolveClient('postgres')).toBe('pg')
+    expect(resolveClient('postgresql')).toBe('pg')
+    expect(resolveClient('pg')).toBe('pg')
+    expect(resolveClient('sqlite')).toBe('sqlite3')
+    expect(resolveClient('sqlite3')).toBe('sqlite3')
+    expect(resolveClient('mysql')).toBe('mysql2')
+  })
+})

package/test/Database/Migration/migrate_column.test.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-column-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+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('Migration.migrate() - Column Diff', () => {
+  it('should add a new column to an existing table', async () => {
+    writeSchema('posts', {columns: {id: {type: 'increments'}, title: {type: 'string'}}})
+    await Migration.migrate()
+
+    writeSchema('posts', {columns: {id: {type: 'increments'}, title: {type: 'string'}, body: {type: 'text', nullable: true}}})
+    const result = await Migration.migrate()
+    const addOps = result.default.schema.filter(op => op.type === 'add_column')
+
+    expect(addOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'add_column', column: 'body', table: 'posts'})]))
+    const info = await db('posts').columnInfo()
+    expect(info).toHaveProperty('body')
+  })
+
+  it('should drop a column removed from schema', async () => {
+    writeSchema('items', {columns: {id: {type: 'increments'}, name: {type: 'string'}, obsolete: {type: 'string'}}})
+    await Migration.migrate()
+
+    writeSchema('items', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    const result = await Migration.migrate()
+    const dropOps = result.default.schema.filter(op => op.type === 'drop_column')
+
+    expect(dropOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'drop_column', column: 'obsolete', table: 'items'})]))
+  })
+})

package/test/Database/Migration/migrate_files.test.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-files-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+function writeMigrationFile(name, upFn, downFn) {
+  const dir = path.join(tmpDir, 'migration')
+  fs.mkdirSync(dir, {recursive: true})
+
+  const content = `
+    module.exports = {
+      up: ${upFn.toString()},
+      down: ${downFn ? downFn.toString() : 'undefined'}
+    }
+  `
+  fs.writeFileSync(path.join(dir, name), content)
+}
+
+describe('Migration.migrate() - Migration Files', () => {
+  it('should run pending migration files in order', async () => {
+    await db.schema.createTable('counters', t => {
+      t.increments('id')
+      t.string('name')
+      t.integer('value').defaultTo(0)
+    })
+
+    writeMigrationFile('20260225_001_init.js', async db => {
+      await db('counters').insert({name: 'visits', value: 0})
+    })
+    writeMigrationFile('20260225_002_add.js', async db => {
+      await db('counters').insert({name: 'signups', value: 0})
+    })
+
+    const result = await Migration.migrate()
+    expect(result.default.files).toHaveLength(2)
+
+    const rows = await db('counters').select()
+    expect(rows).toHaveLength(2)
+  })
+
+  it('should not re-run already applied migration files', async () => {
+    await db.schema.createTable('data', t => {
+      t.increments('id')
+      t.string('value')
+    })
+
+    writeMigrationFile('20260225_001_insert.js', async db => {
+      await db('data').insert({value: 'test'})
+    })
+    await Migration.migrate()
+    const result2 = await Migration.migrate()
+    expect(result2.default.files).toHaveLength(0)
+  })
+})

package/test/Database/Migration/migrate_index.test.js

@@ -0,0 +1,89 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-index-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+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('Migration.migrate() - Index Diff', () => {
+  it('should add a new index to an existing table', async () => {
+    writeSchema('articles', {
+      columns: {id: {type: 'increments'}, slug: {type: 'string', length: 255}, status: {type: 'string', length: 50}},
+      indexes: []
+    })
+    await Migration.migrate()
+
+    writeSchema('articles', {
+      columns: {id: {type: 'increments'}, slug: {type: 'string', length: 255}, status: {type: 'string', length: 50}},
+      indexes: [{columns: ['slug'], unique: true}]
+    })
+
+    const result = await Migration.migrate()
+    const indexOps = result.default.schema.filter(op => op.type === 'add_index')
+    expect(indexOps).toHaveLength(1)
+  })
+
+  it('should drop an index removed from schema', async () => {
+    writeSchema('tags', {
+      columns: {id: {type: 'increments'}, name: {type: 'string', length: 100}},
+      indexes: [{columns: ['name'], unique: false}]
+    })
+    await Migration.migrate()
+
+    writeSchema('tags', {
+      columns: {id: {type: 'increments'}, name: {type: 'string', length: 100}},
+      indexes: []
+    })
+
+    const result = await Migration.migrate()
+    const dropIndexOps = result.default.schema.filter(op => op.type === 'drop_index')
+    expect(dropIndexOps.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('should normalize column-level unique into indexes and be idempotent', async () => {
+    writeSchema('apps', {
+      columns: {id: {type: 'increments'}, name: {type: 'string', length: 100, unique: true}},
+      indexes: []
+    })
+
+    await Migration.migrate()
+    const result2 = await Migration.migrate()
+    const indexOps2 = result2.default.schema.filter(op => op.type === 'add_index' || op.type === 'drop_index')
+    expect(indexOps2).toHaveLength(0)
+  })
+
+  it('should survive add_index when constraint already exists (idempotent)', async () => {
+    await db.schema.createTable('apps_ext', t => {
+      t.increments('id')
+      t.string('name', 100).notNullable()
+      t.unique(['name'])
+    })
+
+    writeSchema('apps_ext', {
+      columns: {id: {type: 'increments'}, name: {type: 'string', length: 100, nullable: false, unique: true}},
+      indexes: []
+    })
+
+    await expect(Migration.migrate()).resolves.toBeDefined()
+  })
+})

package/test/Database/Migration/migrate_nanoid.test.js

@@ -0,0 +1,160 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-nanoid-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+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('Migration - NanoID Column Type', () => {
+  it('should create a nanoid column as string(21) by default', async () => {
+    writeSchema('tokens', {
+      columns: {
+        id: {type: 'nanoid', primary: true},
+        name: {type: 'string', length: 100}
+      }
+    })
+
+    await Migration.migrate()
+    const exists = await db.schema.hasTable('tokens')
+    expect(exists).toBe(true)
+
+    const info = await db('tokens').columnInfo()
+    expect(info).toHaveProperty('id')
+    expect(info.id.type).toBe('varchar')
+    expect(Number(info.id.maxLength)).toBe(21)
+  })
+
+  it('should support custom length for nanoid column', async () => {
+    writeSchema('short_ids', {
+      columns: {
+        id: {type: 'nanoid', length: 12, primary: true},
+        label: {type: 'string'}
+      }
+    })
+
+    await Migration.migrate()
+    const info = await db('short_ids').columnInfo()
+    expect(Number(info.id.maxLength)).toBe(12)
+  })
+
+  it('should auto-generate nanoid for seed data', async () => {
+    writeSchema('articles', {
+      columns: {
+        id: {type: 'nanoid', primary: true},
+        title: {type: 'string', length: 255},
+        slug: {type: 'string', length: 255}
+      },
+      seed: [{title: 'Hello World', slug: 'hello-world'}],
+      seedKey: 'slug'
+    })
+
+    await Migration.migrate()
+    const row = await db('articles').where('slug', 'hello-world').first()
+
+    expect(row).toBeDefined()
+    expect(row.id).toBeDefined()
+    expect(typeof row.id).toBe('string')
+    expect(row.id.length).toBe(21)
+    expect(row.id).toMatch(/^[a-zA-Z0-9]+$/)
+  })
+
+  it('should not overwrite nanoid if seed data provides it explicitly', async () => {
+    writeSchema('tags', {
+      columns: {
+        id: {type: 'nanoid', primary: true},
+        name: {type: 'string', length: 100}
+      },
+      seed: [{id: 'EXPLICIT_ID_12345678', name: 'featured'}],
+      seedKey: 'name'
+    })
+
+    await Migration.migrate()
+    const row = await db('tags').where('name', 'featured').first()
+
+    expect(row.id).toBe('EXPLICIT_ID_12345678')
+  })
+
+  it('should preserve nanoid value on subsequent seed runs (idempotent)', async () => {
+    writeSchema('categories', {
+      columns: {
+        id: {type: 'nanoid', primary: true},
+        name: {type: 'string', length: 100}
+      },
+      seed: [{name: 'tech'}],
+      seedKey: 'name'
+    })
+
+    await Migration.migrate()
+    const firstRow = await db('categories').where('name', 'tech').first()
+    const firstId = firstRow.id
+
+    // Run migrate again — should not change the ID
+    await Migration.migrate()
+    const secondRow = await db('categories').where('name', 'tech').first()
+
+    expect(secondRow.id).toBe(firstId)
+  })
+
+  it('should respect custom length in seed nanoid generation', async () => {
+    writeSchema('codes', {
+      columns: {
+        code: {type: 'nanoid', length: 8, primary: true},
+        label: {type: 'string', length: 50}
+      },
+      seed: [{label: 'discount-10'}],
+      seedKey: 'label'
+    })
+
+    await Migration.migrate()
+    const row = await db('codes').where('label', 'discount-10').first()
+
+    expect(row.code).toBeDefined()
+    expect(row.code.length).toBe(8)
+  })
+
+  it('should add nanoid column to existing table via diff', async () => {
+    writeSchema('events', {
+      columns: {
+        id: {type: 'increments'},
+        name: {type: 'string'}
+      }
+    })
+    await Migration.migrate()
+
+    writeSchema('events', {
+      columns: {
+        id: {type: 'increments'},
+        public_id: {type: 'nanoid', length: 16},
+        name: {type: 'string'}
+      }
+    })
+
+    const result = await Migration.migrate()
+    const addOps = result.default.schema.filter(op => op.type === 'add_column')
+    expect(addOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'add_column', column: 'public_id'})]))
+
+    const info = await db('events').columnInfo()
+    expect(info).toHaveProperty('public_id')
+    expect(Number(info.public_id.maxLength)).toBe(16)
+  })
+})

package/test/Database/Migration/migrate_seed.test.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-seed-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+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('Migration.migrate() - Seed Data', () => {
+  it('should insert seed data on first migrate', async () => {
+    writeSchema('roles', {
+      columns: {id: {type: 'increments'}, name: {type: 'string', length: 50}, level: {type: 'integer', default: 0}},
+      seed: [
+        {name: 'admin', level: 100},
+        {name: 'user', level: 1}
+      ],
+      seedKey: 'name'
+    })
+
+    const result = await Migration.migrate()
+    expect(result.default.seeds).toHaveLength(2)
+
+    const rows = await db('roles').select()
+    expect(rows).toHaveLength(2)
+  })
+
+  it('should update seed data if values changed', async () => {
+    writeSchema('settings', {
+      columns: {id: {type: 'increments'}, key: {type: 'string', length: 100}, value: {type: 'string', length: 255}},
+      seed: [{key: 'site_name', value: 'My App'}],
+      seedKey: 'key'
+    })
+
+    await Migration.migrate()
+
+    writeSchema('settings', {
+      columns: {id: {type: 'increments'}, key: {type: 'string', length: 100}, value: {type: 'string', length: 255}},
+      seed: [{key: 'site_name', value: 'New App Name'}],
+      seedKey: 'key'
+    })
+
+    await Migration.migrate()
+    const row = await db('settings').where('key', 'site_name').first()
+    expect(row.value).toBe('New App Name')
+  })
+
+  it('should handle JSON/JSONB seeds without false positives', async () => {
+    writeSchema('apps_json', {
+      columns: {id: {type: 'increments'}, name: {type: 'string', length: 100}, config: {type: 'json'}},
+      seed: [{name: 'myapp', config: JSON.stringify({host: 'data'})}],
+      seedKey: 'name'
+    })
+
+    await Migration.migrate()
+    const result2 = await Migration.migrate()
+    expect(result2.default.seeds.filter(s => s.type === 'seed_update')).toHaveLength(0)
+  })
+})