feat: add incr api

src/momento-redis-adapter.ts

@@ -9,6 +9,7 @@ import {
   CacheDictionarySetFields,
   CacheFlush,
   CacheGet,
+  CacheIncrement,
   CacheItemGetTtl,
   CacheSet,
   CacheSetIfAbsent,
@@ -91,6 +92,8 @@ export interface MomentoIORedis {
     nx: 'NX'
   ): Promise<'OK' | null>;
 
+  incr(key: RedisKey): Promise<number | null>;
+
   ttl(key: RedisKey): Promise<number | null>;
 
   pttl(key: RedisKey): Promise<number | null>;
@@ -395,6 +398,23 @@ export class MomentoRedisAdapter
     return null;
   }
 
+  async incr(key: RedisKey): Promise<number | null> {
+    if (this.useCompression) {
+      this.emitError('incr', 'compression-not-supported');
+      return null;
+    }
+
+    const rsp = await this.momentoClient.increment(this.cacheName, key);
+    if (rsp instanceof CacheIncrement.Success) {
+      return rsp.value();
+    } else if (rsp instanceof CacheIncrement.Error) {
+      this.emitError('incr', rsp.message(), rsp.errorCode());
+    } else {
+      this.emitError('incr', `unexpected-response ${rsp.toString()}`);
+    }
+    return null;
+  }
+
   async hset(
     ...args: [
       RedisKey,

test/increment-compression.test.ts

@@ -0,0 +1,28 @@
+import {v4} from 'uuid';
+
+import {SetupIntegrationTest} from './integration-setup';
+
+const {client} = SetupIntegrationTest();
+
+describe('increment, with compression client', () => {
+  it('should return error saying compression not supported', async () => {
+    const key = v4();
+    const value = 5;
+
+    // Set initial key value
+    await client.set(key, value);
+
+    // Increment the value of the key
+    try {
+      await client.incr(key);
+    } catch (error) {
+      const momentoError = error as {
+        code: string;
+        context: {code: string; msg: string; op: string; platform: string};
+      };
+      expect(momentoError.context.op).toBe('incr');
+      expect(momentoError.context.platform).toBe('momento');
+      expect(momentoError.context.msg).toBe('compression-not-supported');
+    }
+  });
+});

test/increment.test.ts

@@ -0,0 +1,70 @@
+import {SetupIntegrationTest} from './integration-setup';
+import {v4} from 'uuid';
+
+const {client} = SetupIntegrationTest(false);
+
+describe('increment', () => {
+  it('should increment the value of the key by 1 if the key exists', async () => {
+    const key = v4();
+    const value = 5;
+
+    // Set initial key value
+    await client.set(key, value);
+
+    // Increment the value of the key
+    const incrResp = await client.incr(key);
+    expect(incrResp).toBe(value + 1);
+  });
+
+  it('should increment the value of the key to 1 if the key does not exists', async () => {
+    const key = v4();
+
+    // Increment the value of the key that is not set
+    const incrResp = await client.incr(key);
+    expect(incrResp).toBe(1);
+  });
+
+  it('should error out if the key contains a value of wrong type or contains a string that can be represented as integer', async () => {
+    const key = v4();
+    const value = 'monkey';
+
+    // Set initial key value
+    await client.set(key, value);
+
+    // Increment the value of the key that is not set
+    try {
+      await client.incr(key);
+    } catch (error) {
+      if (process.env.MOMENTO_ENABLED === 'true') {
+        const momentoError = error as {
+          code: string;
+          context: {code: string; msg: string; op: string; platform: string};
+        };
+        expect(momentoError.code).toBe('ERR_UNHANDLED_ERROR');
+        expect(momentoError.context.code).toBe('FAILED_PRECONDITION_ERROR');
+        expect(momentoError.context.msg).toBe(
+          "System is not in a state required for the operation's execution: 9 FAILED_PRECONDITION: failed to parse value into long"
+        );
+        expect(momentoError.context.op).toBe('incr');
+        expect(momentoError.context.platform).toBe('momento');
+      } else {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe(
+          'ERR value is not an integer or out of range'
+        );
+      }
+    }
+  });
+
+  it('should increment the value of key that contains a string that can be represented as integer', async () => {
+    const key = v4();
+    const value = '10';
+
+    // Set initial key value
+    await client.set(key, value);
+
+    // Increment the value of the key that is not set
+    const incrResp = await client.incr(key);
+    expect(incrResp).toBe(11);
+  });
+});

test/integration-setup.ts

@@ -16,10 +16,6 @@ export function testCacheName(): string {
   return name + v4();
 }
 
-function useCompression(): boolean {
-  return process.env.COMPRESSION === 'true';
-}
-
 const deleteCacheIfExists = async (momento: CacheClient, cacheName: string) => {
   const deleteResponse = await momento.deleteCache(cacheName);
   if (deleteResponse instanceof DeleteCache.Error) {
@@ -45,17 +41,17 @@ export function isRedisBackedTest() {
   return process.env.MOMENTO_ENABLED !== 'true';
 }
 
-export function SetupIntegrationTest(): {
+export function SetupIntegrationTest(useCompression = true): {
   client: MomentoIORedis;
 } {
   if (isRedisBackedTest()) {
     return setupIntegrationTestWithRedis();
   } else {
-    return setupIntegrationTestWithMomento();
+    return setupIntegrationTestWithMomento(useCompression);
   }
 }
 
-function setupIntegrationTestWithMomento() {
+function setupIntegrationTestWithMomento(useCompression = true) {
   const cacheName = testCacheName();
 
   beforeAll(async () => {
@@ -82,7 +78,7 @@ function setupIntegrationTestWithMomento() {
     momentoClient,
     cacheName,
     {
-      useCompression: useCompression(),
+      useCompression: useCompression,
     }
   );