close #2192 close #2193 close #2194 close #2195 close #2196 close #2197

close #2198 - support for TimeSeries 1.8 (#2200)
redis · Aug 31, 2022 · 5dd7d31 · 5dd7d31
1 parent b10a656
commit 5dd7d31
Show file tree

Hide file tree

Showing 25 changed files with 369 additions and 181 deletions.
diff --git a/packages/time-series/lib/commands/ALTER.spec.ts b/packages/time-series/lib/commands/ALTER.spec.ts
@@ -1,4 +1,5 @@
 import { strict as assert } from 'assert';
+import { TimeSeriesDuplicatePolicies } from '.';
 import testUtils, { GLOBAL } from '../test-utils';
 import { transformArguments } from './ALTER';
 
@@ -20,6 +21,24 @@ describe('ALTER', () => {
             );
         });
 
+        it('with CHUNK_SIZE', () => {
+            assert.deepEqual(
+                transformArguments('key', {
+                    CHUNK_SIZE: 1
+                }),
+                ['TS.ALTER', 'key', 'CHUNK_SIZE', '1']
+            );
+        });
+
+        it('with DUPLICATE_POLICY', () => {
+            assert.deepEqual(
+                transformArguments('key', {
+                    DUPLICATE_POLICY: TimeSeriesDuplicatePolicies.BLOCK
+                }),
+                ['TS.ALTER', 'key', 'DUPLICATE_POLICY', 'BLOCK']
+            );
+        });
+
         it('with LABELS', () => {
             assert.deepEqual(
                 transformArguments('key', {
@@ -29,19 +48,21 @@ describe('ALTER', () => {
             );
         });
 
-        it('with RETENTION, LABELS', () => {
+        it('with RETENTION, CHUNK_SIZE, DUPLICATE_POLICY, LABELS', () => {
             assert.deepEqual(
                 transformArguments('key', {
                     RETENTION: 1,
+                    CHUNK_SIZE: 1,
+                    DUPLICATE_POLICY: TimeSeriesDuplicatePolicies.BLOCK,
                     LABELS: { label: 'value' }
                 }),
-                ['TS.ALTER', 'key', 'RETENTION', '1', 'LABELS', 'label', 'value']
+                ['TS.ALTER', 'key', 'RETENTION', '1', 'CHUNK_SIZE', '1', 'DUPLICATE_POLICY', 'BLOCK', 'LABELS', 'label', 'value']
             );
         });
     });
 
     testUtils.testWithClient('client.ts.alter', async client => {
-        await client.ts.create('key'); 
+        await client.ts.create('key');
 
         assert.equal(
             await client.ts.alter('key', { RETENTION: 1 }),

diff --git a/packages/time-series/lib/commands/ALTER.ts b/packages/time-series/lib/commands/ALTER.ts
@@ -1,9 +1,11 @@
-import { pushRetentionArgument, Labels, pushLabelsArgument } from '.';
+import { pushRetentionArgument, Labels, pushLabelsArgument, TimeSeriesDuplicatePolicies, pushChunkSizeArgument, pushDuplicatePolicy } from '.';
 
 export const FIRST_KEY_INDEX = 1;
 
 interface AlterOptions {
     RETENTION?: number;
+    CHUNK_SIZE?: number;
+    DUPLICATE_POLICY?: TimeSeriesDuplicatePolicies;
     LABELS?: Labels;
 }
 
@@ -12,6 +14,10 @@ export function transformArguments(key: string, options?: AlterOptions): Array<s
 
     pushRetentionArgument(args, options?.RETENTION);
 
+    pushChunkSizeArgument(args, options?.CHUNK_SIZE);
+
+    pushDuplicatePolicy(args, options?.DUPLICATE_POLICY);
+
     pushLabelsArgument(args, options?.LABELS);
 
     return args;

diff --git a/packages/time-series/lib/commands/CREATE.ts b/packages/time-series/lib/commands/CREATE.ts
@@ -5,7 +5,8 @@ import {
     pushChunkSizeArgument,
     TimeSeriesDuplicatePolicies,
     Labels,
-    pushLabelsArgument
+    pushLabelsArgument,
+    pushDuplicatePolicy
 } from '.';
 
 export const FIRST_KEY_INDEX = 1;
@@ -27,12 +28,7 @@ export function transformArguments(key: string, options?: CreateOptions): Array<
 
     pushChunkSizeArgument(args, options?.CHUNK_SIZE);
 
-    if (options?.DUPLICATE_POLICY) {
-        args.push(
-            'DUPLICATE_POLICY',
-            options.DUPLICATE_POLICY
-        );
-    }
+    pushDuplicatePolicy(args, options?.DUPLICATE_POLICY);
 
     pushLabelsArgument(args, options?.LABELS);
 

diff --git a/packages/time-series/lib/commands/CREATERULE.spec.ts b/packages/time-series/lib/commands/CREATERULE.spec.ts
@@ -4,11 +4,20 @@ import testUtils, { GLOBAL } from '../test-utils';
 import { transformArguments } from './CREATERULE';
 
 describe('CREATERULE', () => {
-    it('transformArguments', () => {
-        assert.deepEqual(
-            transformArguments('source', 'destination', TimeSeriesAggregationType.AVERAGE, 1),
-            ['TS.CREATERULE', 'source', 'destination', 'AGGREGATION', 'avg', '1']
-        );
+    describe('transformArguments', () => {
+        it('without options', () => {
+            assert.deepEqual(
+                transformArguments('source', 'destination', TimeSeriesAggregationType.AVERAGE, 1),
+                ['TS.CREATERULE', 'source', 'destination', 'AGGREGATION', 'AVG', '1']
+            );
+        });
+
+        it('with alignTimestamp', () => {
+            assert.deepEqual(
+                transformArguments('source', 'destination', TimeSeriesAggregationType.AVERAGE, 1, 1),
+                ['TS.CREATERULE', 'source', 'destination', 'AGGREGATION', 'AVG', '1', '1']
+            );
+        });
     });
 
     testUtils.testWithClient('client.ts.createRule', async client => {

diff --git a/packages/time-series/lib/commands/CREATERULE.ts b/packages/time-series/lib/commands/CREATERULE.ts
@@ -6,16 +6,23 @@ export function transformArguments(
     sourceKey: string,
     destinationKey: string,
     aggregationType: TimeSeriesAggregationType,
-    timeBucket: number
+    bucketDuration: number,
+    alignTimestamp?: number
 ): Array<string> {
-    return [
+    const args = [
         'TS.CREATERULE',
         sourceKey,
         destinationKey,
         'AGGREGATION',
         aggregationType,
-        timeBucket.toString()
+        bucketDuration.toString()
     ];
+
+    if (alignTimestamp) {
+        args.push(alignTimestamp.toString());
+    }
+
+    return args;
 }
 
 export declare function transformReply(): 'OK';
diff --git a/packages/time-series/lib/commands/DELETERULE.ts b/packages/time-series/lib/commands/DELETERULE.ts
@@ -4,7 +4,7 @@ export function transformArguments(sourceKey: string, destinationKey: string): A
     return [
         'TS.DELETERULE',
         sourceKey,
-        destinationKey,
+        destinationKey
     ];
 }
 

diff --git a/packages/time-series/lib/commands/GET.spec.ts b/packages/time-series/lib/commands/GET.spec.ts
@@ -3,11 +3,22 @@ import testUtils, { GLOBAL } from '../test-utils';
 import { transformArguments } from './GET';
 
 describe('GET', () => {
-    it('transformArguments', () => {
-        assert.deepEqual(
-            transformArguments('key'),
-            ['TS.GET', 'key']
-        );
+    describe('transformArguments', () => {
+        it('without options', () => {
+            assert.deepEqual(
+                transformArguments('key'),
+                ['TS.GET', 'key']
+            );
+        });
+
+        it('with LATEST', () => {
+            assert.deepEqual(
+                transformArguments('key', {
+                    LATEST: true
+                }),
+                ['TS.GET', 'key', 'LATEST']
+            );
+        });
     });
 
     describe('client.ts.get', () => {

diff --git a/packages/time-series/lib/commands/GET.ts b/packages/time-series/lib/commands/GET.ts
@@ -1,11 +1,16 @@
-import { SampleRawReply, SampleReply, transformSampleReply } from '.';
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { pushLatestArgument, SampleRawReply, SampleReply, transformSampleReply } from '.';
 
 export const FIRST_KEY_INDEX = 1;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string): Array<string> {
-    return ['TS.GET', key];
+interface GetOptions {
+    LATEST?: boolean;
+}
+
+export function transformArguments(key: string, options?: GetOptions): RedisCommandArguments {
+    return pushLatestArgument(['TS.GET', key], options?.LATEST);
 }
 
 export function transformReply(reply: [] | SampleRawReply): null | SampleReply {

diff --git a/packages/time-series/lib/commands/INFO.spec.ts b/packages/time-series/lib/commands/INFO.spec.ts
@@ -1,7 +1,7 @@
 import { strict as assert } from 'assert';
 import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.';
 import testUtils, { GLOBAL } from '../test-utils';
-import { transformArguments } from './INFO';
+import { InfoReply, transformArguments } from './INFO';
 
 describe('INFO', () => {
     it('transformArguments', () => {
@@ -14,37 +14,40 @@ describe('INFO', () => {
     testUtils.testWithClient('client.ts.info', async client => {
         await Promise.all([
             client.ts.create('key', {
-                LABELS: { id: "2" },
+                LABELS: { id: '1' },
                 DUPLICATE_POLICY: TimeSeriesDuplicatePolicies.LAST
             }),
             client.ts.create('key2'),
             client.ts.createRule('key', 'key2', TimeSeriesAggregationType.COUNT, 5),
             client.ts.add('key', 1, 10)
         ]);
 
-        assert.deepEqual(
-            await client.ts.info('key'),
-            {
-                totalSamples: 1,
-                memoryUsage: 4261,
-                firstTimestamp: 1,
-                lastTimestamp: 1,
-                retentionTime: 0,
-                chunkCount: 1,
-                chunkSize: 4096,
-                chunkType: 'compressed',
-                duplicatePolicy: 'last',
-                labels: [{
-                    name: 'id',
-                    value: '2'
-                }],
-                rules: [{
-                    aggregationType: 'COUNT',
-                    key: 'key2',
-                    timeBucket: 5
-                }],
-                sourceKey: null
-            }
-        );
+        assertInfo(await client.ts.info('key'));
     }, GLOBAL.SERVERS.OPEN);
 });
+
+export function assertInfo(info: InfoReply): void {
+    assert.equal(typeof info.totalSamples, 'number');
+    assert.equal(typeof info.memoryUsage, 'number');
+    assert.equal(typeof info.firstTimestamp, 'number');
+    assert.equal(typeof info.lastTimestamp, 'number');
+    assert.equal(typeof info.retentionTime, 'number');
+    assert.equal(typeof info.chunkCount, 'number');
+    assert.equal(typeof info.chunkSize, 'number');
+    assert.equal(typeof info.chunkType, 'string');
+    assert.equal(typeof info.duplicatePolicy, 'string');
+    assert.ok(Array.isArray(info.labels));
+    for (const label of info.labels) {
+        assert.equal(typeof label, 'object');
+        assert.equal(typeof label.name, 'string');
+        assert.equal(typeof label.value, 'string');
+    }
+    assert.ok(Array.isArray(info.rules));
+    for (const rule of info.rules) {
+        assert.equal(typeof rule, 'object');
+        assert.equal(typeof rule.aggregationType, 'string');
+        assert.equal(typeof rule.key, 'string');
+        assert.equal(typeof rule.timeBucket, 'number');
+    }
+    assert.ok(info.sourceKey === null || typeof info.sourceKey === 'string');
+}
diff --git a/packages/time-series/lib/commands/INFO.ts b/packages/time-series/lib/commands/INFO.ts
@@ -9,30 +9,30 @@ export function transformArguments(key: string): Array<string> {
 }
 
 export type InfoRawReply = [
-    _: string,
-    totalSamples: number,
-    _: string,
-    memoryUsage: number,
-    _: string,
-    firstTimestamp: number,
-    _: string,
-    lastTimestamp: number,
-    _: string,
-    retentionTime: number,
-    _: string,
-    chunkCount: number,
-    _: string,
-    chunkSize: number,
-    _: string,
-    chunkType: string,
-    _: string,
-    duplicatePolicy: TimeSeriesDuplicatePolicies | null,
-    _: string,
-    labels: Array<[name: string, value: string]>,
-    _: string,
-    sourceKey: string | null,
-    _: string,
-    rules: Array<[key: string, timeBucket: number, aggregationType: TimeSeriesAggregationType]>
+    'totalSamples',
+    number,
+    'memoryUsage',
+    number,
+    'firstTimestamp',
+    number,
+    'lastTimestamp',
+    number,
+    'retentionTime',
+    number,
+    'chunkCount',
+    number,
+    'chunkSize',
+    number,
+    'chunkType',
+    string,
+    'duplicatePolicy',
+    TimeSeriesDuplicatePolicies | null,
+    'labels',
+    Array<[name: string, value: string]>,
+    'sourceKey',
+    string | null,
+    'rules',
+    Array<[key: string, timeBucket: number, aggregationType: TimeSeriesAggregationType]>
 ];
 
 export interface InfoReply {