redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-06 02:15:48 +03:00
Code Activity

fix GRAPH

Browse Source
This commit is contained in:
dovi
2023-07-05 15:17:45 -04:00
parent 60d0433810
commit ddc44d3c49
15 changed files with 194 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
packages/graph/lib/commands/CONFIG_GET.spec.ts
View File

@@ -1,22 +1,22 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CONFIG_GET'; import CONFIG_GET from './CONFIG_GET';
describe('CONFIG GET', () => { describe('CONFIG GET', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('TIMEOUT'), CONFIG_GET.transformArguments('TIMEOUT'),
['GRAPH.CONFIG', 'GET', 'TIMEOUT'] ['GRAPH.CONFIG', 'GET', 'TIMEOUT']
); );
}); });
testUtils.testWithClient('client.graph.configGet', async client => { testUtils.testWithClient('client.graph.configGet', async client => {
assert.deepEqual( assert.deepEqual(
await client.graph.configGet('TIMEOUT'), await client.graph.configGet('TIMEOUT'),
[ [
'TIMEOUT', 'TIMEOUT',
0 0
] ]
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

23
packages/graph/lib/commands/CONFIG_GET.ts
View File

@@ -1,12 +1,15 @@
export const IS_READ_ONLY = true; import { RedisArgument, TuplesReply, ArrayReply, BlobStringReply, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(configKey: string): Array<string> { type ConfigItemReply = TuplesReply<[
configKey: BlobStringReply,
value: NumberReply
]>;
export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: true,
transformArguments(configKey: RedisArgument) {
return ['GRAPH.CONFIG', 'GET', configKey]; return ['GRAPH.CONFIG', 'GET', configKey];
} },
transformReply: undefined as unknown as () => ConfigItemReply | ArrayReply<ConfigItemReply>
type ConfigItem = [ } as const satisfies Command;
configKey: string,
value: number
];
export declare function transformReply(): ConfigItem | Array<ConfigItem>;

26
packages/graph/lib/commands/CONFIG_SET.spec.ts
View File

@@ -1,19 +1,19 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CONFIG_SET'; import CONFIG_SET from './CONFIG_SET';
describe('CONFIG SET', () => { describe('CONFIG SET', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('TIMEOUT', 0), CONFIG_SET.transformArguments('TIMEOUT', 0),
['GRAPH.CONFIG', 'SET', 'TIMEOUT', '0'] ['GRAPH.CONFIG', 'SET', 'TIMEOUT', '0']
); );
}); });
testUtils.testWithClient('client.graph.configSet', async client => { testUtils.testWithClient('client.graph.configSet', async client => {
assert.equal( assert.equal(
await client.graph.configSet('TIMEOUT', 0), await client.graph.configSet('TIMEOUT', 0),
'OK' 'OK'
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

23
packages/graph/lib/commands/CONFIG_SET.ts
View File

@@ -1,10 +1,15 @@
export function transformArguments(configKey: string, value: number): Array<string> { import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';
return [
'GRAPH.CONFIG',
'SET',
configKey,
value.toString()
];
}
export declare function transformReply(): 'OK'; export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: false,
transformArguments(configKey: RedisArgument, value: number) {
return [
'GRAPH.CONFIG',
'SET',
configKey,
value.toString()
];
},
transformReply: undefined as unknown as () => SimpleStringReply
} as const satisfies Command;

28
packages/graph/lib/commands/DELETE.spec.ts
View File

@@ -1,21 +1,21 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './DELETE'; import DELETE from './DELETE';
describe('', () => { describe('', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key'), DELETE.transformArguments('key'),
['GRAPH.DELETE', 'key'] ['GRAPH.DELETE', 'key']
); );
}); });
testUtils.testWithClient('client.graph.delete', async client => { testUtils.testWithClient('client.graph.delete', async client => {
await client.graph.query('key', 'RETURN 1'); await client.graph.query('key', 'RETURN 1');
assert.equal( assert.equal(
typeof await client.graph.delete('key'), typeof await client.graph.delete('key'),
'string' 'string'
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

13
packages/graph/lib/commands/DELETE.ts
View File

@@ -1,7 +1,10 @@
export const FIRST_KEY_INDEX = 1; import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string): Array<string> { export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument) {
return ['GRAPH.DELETE', key]; return ['GRAPH.DELETE', key];
} },
transformReply: undefined as unknown as () => SimpleStringReply
export declare function transformReply(): string; } as const satisfies Command;

30
packages/graph/lib/commands/EXPLAIN.spec.ts
View File

@@ -1,21 +1,21 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './EXPLAIN'; import EXPLAIN from './EXPLAIN';
describe('EXPLAIN', () => { describe('EXPLAIN', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key', 'RETURN 0'), EXPLAIN.transformArguments('key', 'RETURN 0'),
['GRAPH.EXPLAIN', 'key', 'RETURN 0'] ['GRAPH.EXPLAIN', 'key', 'RETURN 0']
); );
}); });
testUtils.testWithClient('client.graph.explain', async client => { testUtils.testWithClient('client.graph.explain', async client => {
const [, reply] = await Promise.all([ const [, reply] = await Promise.all([
client.graph.query('key', 'RETURN 0'), // make sure to create a graph first client.graph.query('key', 'RETURN 0'), // make sure to create a graph first
client.graph.explain('key', 'RETURN 0') client.graph.explain('key', 'RETURN 0')
]); ]);
assert.ok(Array.isArray(reply)); assert.ok(Array.isArray(reply));
assert.ok(!reply.find(x => typeof x !== 'string')); assert.ok(!reply.find(x => typeof x !== 'string'));
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

15
packages/graph/lib/commands/EXPLAIN.ts
View File

@@ -1,9 +1,10 @@
export const FIRST_KEY_INDEX = 1; import { RedisArgument, ArrayReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';
export const IS_READ_ONLY = true; export default {
FIRST_KEY_INDEX: 1,
export function transformArguments(key: string, query: string): Array<string> { IS_READ_ONLY: true,
transformArguments(key: RedisArgument, query: RedisArgument) {
return ['GRAPH.EXPLAIN', key, query]; return ['GRAPH.EXPLAIN', key, query];
} },
transformReply: undefined as unknown as () => ArrayReply<BlobStringReply>
export declare function transfromReply(): Array<string>; } as const satisfies Command;

26
packages/graph/lib/commands/LIST.spec.ts
View File

@@ -1,19 +1,19 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './LIST'; import LIST from './LIST';
describe('LIST', () => { describe('LIST', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments(), LIST.transformArguments(),
['GRAPH.LIST'] ['GRAPH.LIST']
); );
}); });
testUtils.testWithClient('client.graph.list', async client => { testUtils.testWithClient('client.graph.list', async client => {
assert.deepEqual( assert.deepEqual(
await client.graph.list(), await client.graph.list(),
[] []
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

13
packages/graph/lib/commands/LIST.ts
View File

@@ -1,7 +1,10 @@
export const IS_READ_ONLY = true; import { ArrayReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(): Array<string> { export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: true,
transformArguments() {
return ['GRAPH.LIST']; return ['GRAPH.LIST'];
} },
transformReply: undefined as unknown as () => ArrayReply<BlobStringReply>
export declare function transformReply(): Array<string>; } as const satisfies Command;

24
packages/graph/lib/commands/PROFILE.spec.ts
View File

@@ -1,18 +1,18 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PROFILE'; import PROFILE from './PROFILE';
describe('PROFILE', () => { describe('PROFILE', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key', 'RETURN 0'), PROFILE.transformArguments('key', 'RETURN 0'),
['GRAPH.PROFILE', 'key', 'RETURN 0'] ['GRAPH.PROFILE', 'key', 'RETURN 0']
); );
}); });
testUtils.testWithClient('client.graph.profile', async client => { testUtils.testWithClient('client.graph.profile', async client => {
const reply = await client.graph.profile('key', 'RETURN 0'); const reply = await client.graph.profile('key', 'RETURN 0');
assert.ok(Array.isArray(reply)); assert.ok(Array.isArray(reply));
assert.ok(!reply.find(x => typeof x !== 'string')); assert.ok(!reply.find(x => typeof x !== 'string'));
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

15
packages/graph/lib/commands/PROFILE.ts
View File

@@ -1,9 +1,10 @@
export const FIRST_KEY_INDEX = 1; import { RedisArgument, ArrayReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';
export const IS_READ_ONLY = true; export default {
FIRST_KEY_INDEX: 1,
export function transformArguments(key: string, query: string): Array<string> { IS_READ_ONLY: true,
transformArguments(key: RedisArgument, query: RedisArgument) {
return ['GRAPH.PROFILE', key, query]; return ['GRAPH.PROFILE', key, query];
} },
transformReply: undefined as unknown as () => ArrayReply<BlobStringReply>
export declare function transfromReply(): Array<string>; } as const satisfies Command;

22
packages/graph/lib/commands/QUERY.spec.ts
View File

@@ -1,17 +1,17 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './QUERY'; import QUERY from './QUERY';
describe('QUERY', () => { describe('QUERY', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key', 'query'), QUERY.transformArguments('key', 'query'),
['GRAPH.QUERY', 'key', 'query'] ['GRAPH.QUERY', 'key', 'query']
); );
}); });
testUtils.testWithClient('client.graph.query', async client => { testUtils.testWithClient('client.graph.query', async client => {
const { data } = await client.graph.query('key', 'RETURN 0'); const { data } = await client.graph.query('key', 'RETURN 0');
assert.deepEqual(data, [[0]]); assert.deepEqual(data, [[0]]);
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

60
packages/graph/lib/commands/QUERY.ts
View File

@@ -4,18 +4,18 @@ import { pushQueryArguments, QueryOptionsBackwardCompatible } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments( export function transformArguments(
graph: RedisCommandArgument, graph: RedisCommandArgument,
query: RedisCommandArgument, query: RedisCommandArgument,
options?: QueryOptionsBackwardCompatible, options?: QueryOptionsBackwardCompatible,
compact?: boolean compact?: boolean
): RedisCommandArguments { ): RedisCommandArguments {
return pushQueryArguments( return pushQueryArguments(
['GRAPH.QUERY'], ['GRAPH.QUERY'],
graph, graph,
query, query,
options, options,
compact compact
); );
} }
type Headers = Array<string>; type Headers = Array<string>;
@@ -25,31 +25,31 @@ type Data = Array<string | number | null | Data>;
type Metadata = Array<string>; type Metadata = Array<string>;
type QueryRawReply = [ type QueryRawReply = [
headers: Headers, headers: Headers,
data: Data, data: Data,
metadata: Metadata metadata: Metadata
] | [ ] | [
metadata: Metadata metadata: Metadata
]; ];
export type QueryReply = { export type QueryReply = {
headers: undefined; headers: undefined;
data: undefined; data: undefined;
metadata: Metadata; metadata: Metadata;
} | { } | {
headers: Headers; headers: Headers;
data: Data; data: Data;
metadata: Metadata; metadata: Metadata;
}; };
export function transformReply(reply: QueryRawReply): QueryReply { export function transformReply(reply: QueryRawReply): QueryReply {
return reply.length === 1 ? { return reply.length === 1 ? {
headers: undefined, headers: undefined,
data: undefined, data: undefined,
metadata: reply[0] metadata: reply[0]
} : { } : {
headers: reply[0], headers: reply[0],
data: reply[1], data: reply[1],
metadata: reply[2] metadata: reply[2]
}; };
} }

22
packages/graph/lib/commands/SLOWLOG.spec.ts
View File

@@ -3,16 +3,16 @@ import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './SLOWLOG'; import { transformArguments } from './SLOWLOG';
describe('SLOWLOG', () => { describe('SLOWLOG', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key'), transformArguments('key'),
['GRAPH.SLOWLOG', 'key'] ['GRAPH.SLOWLOG', 'key']
); );
}); });
testUtils.testWithClient('client.graph.slowLog', async client => { testUtils.testWithClient('client.graph.slowLog', async client => {
await client.graph.query('key', 'RETURN 1'); await client.graph.query('key', 'RETURN 1');
const reply = await client.graph.slowLog('key'); const reply = await client.graph.slowLog('key');
assert.equal(reply.length, 1); assert.equal(reply.length, 1);
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });