feat(sequelize-adapter): ensure snake_case gate keys for Ruby compatibility

Enable cross-language compatibility with Ruby Flipper by storing
percentage gates (percentage_of_actors, percentage_of_time) in snake_case
rather than camelCase. The adapter now reads and writes both formats to
avoid data inconsistencies. Added helper methods to convert keys and
tests to verify reading and migration of gate keys.

- Store new gates in snake_case format
- Read and clean up both camelCase and snake_case keys
- Add tests for Ruby compatibility in gate key handling

Author: jonmagic

packages/flipper-sequelize/src/SequelizeAdapter.ts

@@ -374,7 +374,7 @@ class SequelizeAdapter implements IAdapter {
     try {
       await this.Gate.create({
         featureKey: feature.key,
-        key: gate.key,
+        key: this.storageKey(gate),
         value: String(thing.value),
       })
     } catch (error) {
@@ -412,7 +412,7 @@ class SequelizeAdapter implements IAdapter {
     try {
       await this.Gate.create({
         featureKey: feature.key,
-        key: gate.key,
+        key: this.storageKey(gate),
         value,
       })
     } catch (error) {
@@ -434,7 +434,7 @@ class SequelizeAdapter implements IAdapter {
     await this.Gate.destroy({
       where: {
         featureKey: feature.key,
-        key: gate.key,
+        key: this.storageKeys(gate),
       },
     })
   }
@@ -446,7 +446,7 @@ class SequelizeAdapter implements IAdapter {
     await this.Gate.destroy({
       where: {
         featureKey: feature.key,
-        key: gate.key,
+        key: this.storageKeys(gate),
         value,
       },
     })
@@ -465,7 +465,7 @@ class SequelizeAdapter implements IAdapter {
 
     for (const gate of feature.gates) {
       const gateKey = gate.key
-      const gateRows = validRows.filter(row => row.key === gateKey)
+      const gateRows = validRows.filter(row => this.storageKeys(gate).includes(row.key ?? ''))
 
       if (gateRows.length === 0) {
         continue
@@ -541,6 +541,32 @@ class SequelizeAdapter implements IAdapter {
       return value
     }
   }
+
+  /**
+   * Return the primary storage key for a gate, using snake_case for cross-language compatibility.
+   * Ruby Flipper stores percentage gates as `percentage_of_actors`/`percentage_of_time`, so we
+   * mirror that format while still accepting camelCase keys that may already exist in the DB.
+   */
+  private storageKey(gate: IGate): string {
+    return this.toSnakeCase(gate.key)
+  }
+
+  /**
+   * Return all accepted storage keys for a gate (camelCase + snake_case) so we can read and clean
+   * up data regardless of which client wrote it.
+   */
+  private storageKeys(gate: IGate): string[] {
+    const keys = [gate.key]
+    const snake = this.toSnakeCase(gate.key)
+    if (!keys.includes(snake)) {
+      keys.push(snake)
+    }
+    return keys
+  }
+
+  private toSnakeCase(key: string): string {
+    return key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase()
+  }
 }
 
 export default SequelizeAdapter

packages/flipper-sequelize/src/index.test.ts

@@ -253,6 +253,37 @@ describe('SequelizeAdapter', () => {
     })
   })
 
+  describe('Ruby compatibility for percentage gate keys', () => {
+    it('reads percentage gates stored in snake_case', async () => {
+      const featureKey = 'ruby-feature'
+      await FeatureModel.create({ key: featureKey })
+      await GateModel.create({ featureKey, key: 'percentage_of_actors', value: '10' })
+      await GateModel.create({ featureKey, key: 'percentage_of_time', value: '15' })
+
+      const feature = new Feature(featureKey, adapter, {})
+      const state = await adapter.get(feature)
+
+      expect(state.percentageOfActors).toBe(10)
+      expect(state.percentageOfTime).toBe(15)
+    })
+
+    it('writes percentage gates using snake_case for storage', async () => {
+      await flipper.enablePercentageOfActors('ts-feature', 20)
+      await flipper.enablePercentageOfTime('ts-feature', 30)
+
+      const gates = await GateModel.findAll({
+        where: { featureKey: 'ts-feature' },
+        order: [['key', 'ASC']],
+      })
+
+      const keys = gates.map((g: { key: string }) => g.key).sort()
+      expect(keys).toEqual(expect.arrayContaining(['percentage_of_actors', 'percentage_of_time']))
+      // Ensure we did not leave camelCase duplicates
+      expect(keys).not.toContain('percentageOfActors')
+      expect(keys).not.toContain('percentageOfTime')
+    })
+  })
+
   describe('export', () => {
     it('exports features as JSON', async () => {
       await flipper.enable('test-feature')
@@ -335,11 +366,14 @@ describe('SequelizeAdapter', () => {
 
       // Assertions
       expect(spyFindAll).toHaveBeenCalled()
-      const findAllArgs = spyFindAll.mock.calls[0]?.[0]
+      const findAllArgs = spyFindAll.mock.calls[0]?.[0] as { useMaster?: boolean } | undefined
       expect(findAllArgs).toMatchObject({ useMaster: true })
 
       // Ensure at least one findOne received useMaster true
-      const findOneCallWithUseMaster = spyFindOne.mock.calls.find(call => call[0]?.useMaster === true)
+      const findOneCallWithUseMaster = spyFindOne.mock.calls.find(call => {
+        const args = call[0] as { useMaster?: boolean } | undefined
+        return args?.useMaster === true
+      })
       expect(findOneCallWithUseMaster).toBeTruthy()
 
       // Cleanup spies
@@ -350,7 +384,7 @@ describe('SequelizeAdapter', () => {
     it('defaults to replica (no useMaster) when option not set', async () => {
       const spyFindAll = jest.spyOn(FeatureModel, 'findAll')
       await adapter.features()
-      const findAllArgs = spyFindAll.mock.calls[0]?.[0]
+      const findAllArgs = spyFindAll.mock.calls[0]?.[0] as { useMaster?: boolean } | undefined
       expect(findAllArgs?.useMaster).toBe(false)
       spyFindAll.mockRestore()
     })