add support for all hash field expiration commands

packages/client/lib/commands/HEXPIRE.spec.ts

@@ -0,0 +1,40 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HEXPIRE from './HEXPIRE';
+
+describe('HEXPIRE', () => {
+  testUtils.isVersionGreaterThanHook([7, 4]);
+
+  describe('transformArguments', () => {
+    it('string', () => {
+      assert.deepEqual(
+        HEXPIRE.transformArguments('key', 'field', 1),
+        ['HEXPIRE', 'key', '1', '1', 'field']
+      );
+    });
+
+    it('array', () => {
+      assert.deepEqual(
+        HEXPIRE.transformArguments('key', ['field1', 'field2'], 1),
+        ['HEXPIRE', 'key', '1', '2', 'field1', 'field2']
+      );
+    });
+
+    it('with set option', () => {
+      assert.deepEqual(
+        HEXPIRE.transformArguments('key', 'field1', 1, 'NX'),
+        ['HEXPIRE', 'key', '1', 'NX', '1', 'field1']
+      );
+    });
+  });
+
+  testUtils.testAll('hExpire', async client => {
+    assert.equal(
+      await client.hExpire('key', ['field1'], 0),
+      null
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/HEXPIRE.ts

@@ -0,0 +1,34 @@
+import { Command, NullReply, RedisArgument } from "../RESP/types";
+import { RedisVariadicArgument, pushVariadicArgument } from "./generic-transformers";
+
+export const HASH_EXPIRATION = {
+  /** The field does not exist */
+  FIELD_NOT_EXISTS: -2,
+  /** Specified NX | XX | GT | LT condition not met */
+  CONDITION_NOT_MET: 0,
+  /** Expiration time was set or updated */
+  UPDATED: 1,
+  /** Field deleted because the specified expiration time is in the past */
+  DELETED: 2
+} as const;
+
+export type HashExpiration = typeof HASH_EXPIRATION[keyof typeof HASH_EXPIRATION];
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  transformArguments(
+    key: RedisArgument, 
+    fields: RedisVariadicArgument,
+    seconds: number,
+    mode?: 'NX' | 'XX' | 'GT' | 'LT',
+  ) {
+    const args = ['HEXPIRE', key, seconds.toString()];
+
+    if (mode) {
+      args.push(mode);
+    }
+
+    return pushVariadicArgument(args, fields);
+  },
+  transformReply: undefined as unknown as () => NullReply | Array<HashExpiration>
+} as const satisfies Command;

packages/client/lib/commands/HEXPIREAT.spec.ts

@@ -0,0 +1,48 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HEXPIREAT from './HEXPIREAT';
+
+describe('HEXPIREAT', () => {
+  testUtils.isVersionGreaterThanHook([7, 4]);
+
+  describe('transformArguments', () => {
+    it('string + number', () => {
+      assert.deepEqual(
+        HEXPIREAT.transformArguments('key', 'field', 1),
+        ['HEXPIREAT', 'key', '1', '1', 'field']
+      );
+    });
+
+    it('array + number', () => {
+      assert.deepEqual(
+        HEXPIREAT.transformArguments('key', ['field1', 'field2'], 1),
+        ['HEXPIREAT', 'key', '1', '2', 'field1', 'field2']
+      );
+    });
+
+    it('date', () => {
+      const d = new Date();
+      assert.deepEqual(
+        HEXPIREAT.transformArguments('key', ['field1'], d),
+        ['HEXPIREAT', 'key', Math.floor(d.getTime() / 1000).toString(), '1', 'field1']
+      );
+    });
+
+    it('with set option', () => {
+      assert.deepEqual(
+        HEXPIREAT.transformArguments('key', 'field1', 1, 'GT'),
+        ['HEXPIREAT', 'key', '1', 'GT', 1, 'field1']
+      );
+    });
+  });
+
+  testUtils.testAll('expireAt', async client => {
+    assert.equal(
+      await client.hExpireAt('key', 'field1', 1),
+      null
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/HEXPIREAT.ts

@@ -0,0 +1,23 @@
+import { RedisArgument, Command, NullReply } from '../RESP/types';
+import { HashExpiration } from './HEXPIRE';
+import { RedisVariadicArgument, pushVariadicArgument, transformEXAT } from './generic-transformers';
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  IS_READ_ONLY: true,
+  transformArguments(
+    key: RedisArgument,
+    fields: RedisVariadicArgument,
+    timestamp: number | Date,
+    mode?: 'NX' | 'XX' | 'GT' | 'LT'
+  ) {
+    const args = ['HEXPIREAT', key, transformEXAT(timestamp)];
+
+    if (mode) {
+      args.push(mode);
+    }
+
+    return pushVariadicArgument(args, fields);
+  },
+  transformReply: undefined as unknown as () => NullReply | Array<HashExpiration>
+} as const satisfies Command;

packages/client/lib/commands/HEXPIRETIME.spec.ts

@@ -0,0 +1,33 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HEXPIRETIME from './HEXPIRETIME';
+
+describe('HEXPIRETIME', () => {
+  testUtils.isVersionGreaterThanHook([7, 4]);
+
+  describe('transformArguments', () => {
+    it('string', () => {
+      assert.deepEqual(
+        HEXPIRETIME.transformArguments('key', 'field'),
+        ['HEXPIRETIME', 'key', '1', 'field']
+      );
+    });
+
+    it('array', () => {
+      assert.deepEqual(
+        HEXPIRETIME.transformArguments('key', ['field1', 'field2']),
+        ['HEXPIRETIME', 'key', '2', 'field1', 'field2']
+      );
+    });
+  })
+
+  testUtils.testAll('hExpireTime', async client => {
+    assert.equal(
+      await client.hExpireTime('key', 'field'),
+      null
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/HEXPIRETIME.ts

@@ -0,0 +1,11 @@
+import { RedisArgument, NumberReply, Command, NullReply, ArrayReply } from '../RESP/types';
+import { RedisVariadicArgument, pushVariadicArgument } from './generic-transformers';
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  IS_READ_ONLY: true,
+  transformArguments(key: RedisArgument, fields: RedisVariadicArgument) {
+    return pushVariadicArgument(['HEXPIRETIME', key], fields);
+  },
+  transformReply: undefined as unknown as () => NullReply | ArrayReply<NumberReply>
+} as const satisfies Command;

packages/client/lib/commands/HPERSIST.spec.ts

@@ -0,0 +1,33 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HPERSIST from './HPERSIST';
+
+describe('HPERSIST', () => {
+  testUtils.isVersionGreaterThanHook([7, 4]);
+
+  describe('transformArguments', () => {
+    it('string', () => {
+      assert.deepEqual(
+        HPERSIST.transformArguments('key', 'field'),
+        ['HPERSIST', 'key', '1', 'field']
+      );
+    });
+
+    it('array', () => {
+      assert.deepEqual(
+        HPERSIST.transformArguments('key', ['field1', 'field2']),
+        ['HPERSIST', 'key', '2', 'field1', 'field2']
+      );
+    });
+  })
+
+  testUtils.testAll('hPersist', async client => {
+    assert.equal(
+      await client.hPersist('key', 'field1'),
+      null
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/HPERSIST.ts

@@ -0,0 +1,10 @@
+import { RedisArgument, NumberReply, Command, NullReply, ArrayReply } from '../RESP/types';
+import { RedisVariadicArgument, pushVariadicArgument } from './generic-transformers';
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  transformArguments(key: RedisArgument, fields: RedisVariadicArgument) {
+    return pushVariadicArgument(['HPERSIST', key], fields);
+  },
+  transformReply: undefined as unknown as () => NullReply | ArrayReply<NumberReply>
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIRE.spec.ts

@@ -0,0 +1,40 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HPEXPIRE from './HPEXPIRE';
+
+describe('HPEXPIRE', () => {
+  testUtils.isVersionGreaterThanHook([7, 4]);
+
+  describe('transformArguments', () => {
+    it('string', () => {
+      assert.deepEqual(
+        HPEXPIRE.transformArguments('key', 'field', 1),
+        ['HPEXPIRE', 'key', '1', '1', 'field']
+      );
+    });
+
+    it('array', () => {
+      assert.deepEqual(
+        HPEXPIRE.transformArguments('key', ['field1', 'field2'], 1),
+        ['HPEXPIRE', 'key', '1', '2', 'field1', 'field2']
+      );
+    });
+
+    it('with set option', () => {
+      assert.deepEqual(
+        HPEXPIRE.transformArguments('key', ['field1'], 1, 'NX'),
+        ['HPEXPIRE', 'key', '1', 'NX', '1', 'field1']
+      );
+    });
+  });
+
+  testUtils.testAll('hpRxpire', async client => {
+    assert.equal(
+      await client.hpExpire('key', ['field'], 0),
+      null
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/HPEXPIRE.ts

@@ -0,0 +1,22 @@
+import { Command, NullReply, RedisArgument } from "../RESP/types";
+import { HashExpiration } from "./HEXPIRE";
+import { RedisVariadicArgument, pushVariadicArgument } from "./generic-transformers";
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  transformArguments(
+    key: RedisArgument, 
+    fields: RedisVariadicArgument,
+    ms: number,
+    mode?: 'NX' | 'XX' | 'GT' | 'LT',
+  ) {
+    const args = ['HPEXPIRE', key, ms.toString()];
+
+    if (mode) {
+      args.push(mode);
+    }
+
+    return pushVariadicArgument(args, fields);
+  },
+  transformReply: undefined as unknown as () => NullReply | Array<HashExpiration>
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIREAT.spec.ts

@@ -0,0 +1,48 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HPEXPIREAT from './HPEXPIREAT';
+
+describe('HPEXPIREAT', () => {
+  testUtils.isVersionGreaterThanHook([7, 4]);
+
+  describe('transformArguments', () => {
+    it('string + number', () => {
+      assert.deepEqual(
+        HPEXPIREAT.transformArguments('key', 'field', 1),
+        ['HPEXPIREAT', 'key', '1', '1', 'field']
+      );
+    });
+
+    it('array + number', () => {
+      assert.deepEqual(
+        HPEXPIREAT.transformArguments('key', ['field1', 'field2'], 1),
+        ['HPEXPIREAT', 'key', '1', '2', 'field1', 'field2']
+      );
+    });
+
+    it('date', () => {
+      const d = new Date();
+      assert.deepEqual(
+        HPEXPIREAT.transformArguments('key', ['field1'], d),
+        ['HPEXPIREAT', 'key', d.getTime().toString(), '1', 'field1']
+      );
+    });
+
+    it('with set option', () => {
+      assert.deepEqual(
+        HPEXPIREAT.transformArguments('key', ['field1'], 1, 'XX'),
+        ['HPEXPIREAT', 'key', '1', 'XX', '1', 'field1']
+      );
+    });
+  });
+
+  testUtils.testAll('hpExpireAt', async client => {
+    assert.equal(
+      await client.hpExpireAt('key', ['field1'], 1),
+      null,
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/HPEXPIREAT.ts

@@ -0,0 +1,23 @@
+import { RedisArgument, Command, NullReply } from '../RESP/types';
+import { HashExpiration } from './HEXPIRE';
+import { RedisVariadicArgument, pushVariadicArgument, transformEXAT } from './generic-transformers';
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  IS_READ_ONLY: true,
+  transformArguments(
+    key: RedisArgument,
+    fields: RedisVariadicArgument,
+    timestamp: number | Date,
+    mode?: 'NX' | 'XX' | 'GT' | 'LT'
+  ) {
+    const args = ['HPEXPIREAT', key, transformEXAT(timestamp)];
+
+    if (mode) {
+      args.push(mode);
+    }
+
+    return pushVariadicArgument(args, fields);
+  },
+  transformReply: undefined as unknown as () => NullReply | Array<HashExpiration>
+} as const satisfies Command;