odac 1.4.1 → 1.4.3

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)
+  })
+})

package/test/Database/Migration/migrate_table.test.js

@@ -0,0 +1,88 @@
+'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-table-'))
+  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() - Table Creation', () => {
+  it('should create a new table from a schema file', async () => {
+    writeSchema('products', {
+      columns: {
+        id: {type: 'increments'},
+        name: {type: 'string', length: 100, nullable: false},
+        price: {type: 'decimal', precision: 10, scale: 2},
+        is_active: {type: 'boolean', default: true}
+      }
+    })
+
+    await Migration.migrate()
+    const exists = await db.schema.hasTable('products')
+    expect(exists).toBe(true)
+
+    const info = await db('products').columnInfo()
+    expect(info).toHaveProperty('id')
+    expect(info).toHaveProperty('name')
+  })
+
+  it('should create a table with timestamps virtual type', async () => {
+    writeSchema('logs', {
+      columns: {
+        id: {type: 'increments'},
+        message: {type: 'text'},
+        timestamps: {type: 'timestamps'}
+      }
+    })
+
+    await Migration.migrate()
+    const info = await db('logs').columnInfo()
+    expect(info).toHaveProperty('created_at')
+    expect(info).toHaveProperty('updated_at')
+  })
+
+  it('should create a table with indexes', async () => {
+    writeSchema('users', {
+      columns: {
+        id: {type: 'increments'},
+        email: {type: 'string', length: 255, nullable: false},
+        role: {type: 'string', length: 50}
+      },
+      indexes: [{columns: ['email'], unique: true}, {columns: ['role']}]
+    })
+
+    await Migration.migrate()
+    const exists = await db.schema.hasTable('users')
+    expect(exists).toBe(true)
+  })
+
+  it('should skip creation if table already exists', async () => {
+    writeSchema('existing', {
+      columns: {id: {type: 'increments'}, name: {type: 'string'}}
+    })
+
+    await Migration.migrate()
+    const result2 = await Migration.migrate()
+    const createOps = result2.default.schema.filter(op => op.type === 'create_table')
+    expect(createOps).toHaveLength(0)
+  })
+})

package/test/Database/Migration/rollback.test.js

@@ -0,0 +1,61 @@
+'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-rollback-'))
+  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.rollback()', () => {
+  it('should rollback the last batch', async () => {
+    await db.schema.createTable('entries', t => {
+      t.increments('id')
+      t.string('name')
+    })
+
+    writeMigrationFile(
+      '20260225_001_add_entry.js',
+      async db => {
+        await db('entries').insert({name: 'first'})
+      },
+      async db => {
+        await db('entries').where('name', 'first').del()
+      }
+    )
+
+    await Migration.migrate()
+    const result = await Migration.rollback()
+    expect(result.default).toEqual(
+      expect.arrayContaining([expect.objectContaining({type: 'rolled_back', name: '20260225_001_add_entry.js'})])
+    )
+
+    const rows = await db('entries').select()
+    expect(rows).toHaveLength(0)
+  })
+})

package/test/Database/Migration/snapshot.test.js

@@ -0,0 +1,38 @@
+'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-snapshot-'))
+  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})
+})
+
+describe('Migration.snapshot()', () => {
+  it('should reverse-engineer existing tables into schema files', async () => {
+    await db.schema.createTable('customers', t => {
+      t.increments('id')
+      t.string('name', 100)
+      t.boolean('vip').defaultTo(false)
+    })
+
+    const result = await Migration.snapshot()
+    const files = result.default
+
+    expect(files.length).toBeGreaterThanOrEqual(1)
+    const customerFile = files.find(f => f.includes('customers'))
+    expect(customerFile).toBeDefined()
+    expect(fs.existsSync(customerFile)).toBe(true)
+  })
+})

package/test/Database/Migration/status.test.js

@@ -0,0 +1,41 @@
+'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-status-'))
+  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.status()', () => {
+  it('should show pending changes without applying them (dry run)', async () => {
+    writeSchema('preview', {
+      columns: {id: {type: 'increments'}, name: {type: 'string'}},
+      indexes: []
+    })
+
+    const result = await Migration.status()
+    expect(result.default.schema).toEqual(expect.arrayContaining([expect.objectContaining({type: 'create_table', table: 'preview'})]))
+
+    const exists = await db.schema.hasTable('preview')
+    expect(exists).toBe(false)
+  })
+})