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

more commands

Browse Source
This commit is contained in:
dovi
2023-07-06 15:51:12 -04:00
parent d986ff52b6
commit e64946566a
20 changed files with 295 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
packages/json/lib/commands/DEBUG_MEMORY.spec.ts
View File

@@ -1,28 +1,28 @@
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 './DEBUG_MEMORY'; import DEBUG_MEMORY from './DEBUG_MEMORY';
describe('DEBUG MEMORY', () => { describe('DEBUG MEMORY', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('without path', () => { it('without path', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key'), DEBUG_MEMORY.transformArguments('key'),
['JSON.DEBUG', 'MEMORY', 'key'] ['JSON.DEBUG', 'MEMORY', 'key']
); );
});
it('with path', () => {
assert.deepEqual(
transformArguments('key', '$'),
['JSON.DEBUG', 'MEMORY', 'key', '$']
);
});
}); });
testUtils.testWithClient('client.json.arrTrim', async client => { it('with path', () => {
assert.deepEqual( assert.deepEqual(
await client.json.debugMemory('key', '$'), DEBUG_MEMORY.transformArguments('key', '$'),
[] ['JSON.DEBUG', 'MEMORY', 'key', '$']
); );
}, GLOBAL.SERVERS.OPEN); });
});
testUtils.testWithClient('client.json.arrTrim', async client => {
assert.deepEqual(
await client.json.debugMemory('key', '$'),
[]
);
}, GLOBAL.SERVERS.OPEN);
}); });

15
packages/json/lib/commands/DEBUG_MEMORY.ts
View File

@@ -1,13 +1,16 @@
export const FIRST_KEY_INDEX = 2; import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path?: string): Array<string> { export default {
FIRST_KEY_INDEX: 2,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.DEBUG', 'MEMORY', key]; const args = ['JSON.DEBUG', 'MEMORY', key];
if (path) { if (path) {
args.push(path); args.push(path);
} }
return args; return args;
} },
transformReply: undefined as unknown as () => NumberReply
export declare function transformReply(): number; } as const satisfies Command;

43
packages/json/lib/commands/DEL.spec.ts
View File

@@ -1,28 +1,29 @@
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 './DEL'; import DEL from './DEL';
describe('DEL', () => { describe('DEL', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('key', () => { it('key', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key'), DEL.transformArguments('key'),
['JSON.DEL', 'key'] ['JSON.DEL', 'key']
); );
});
it('key, path', () => {
assert.deepEqual(
transformArguments('key', '$.path'),
['JSON.DEL', 'key', '$.path']
);
});
}); });
testUtils.testWithClient('client.json.del', async client => { it('key, path', () => {
assert.deepEqual( assert.deepEqual(
await client.json.del('key'), DEL.transformArguments('key', '$.path'),
0 ['JSON.DEL', 'key', '$.path']
); );
}, GLOBAL.SERVERS.OPEN); });
});
testUtils.testWithClient('client.json.del', async client => {
assert.deepEqual(
await client.json.del('key'),
0
);
}, GLOBAL.SERVERS.OPEN);
}); });

15
packages/json/lib/commands/DEL.ts
View File

@@ -1,13 +1,16 @@
export const FIRST_KEY_INDEX = 1; import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path?: string): Array<string> { export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.DEL', key]; const args = ['JSON.DEL', key];
if (path) { if (path) {
args.push(path); args.push(path);
} }
return args; return args;
} },
transformReply: undefined as unknown as () => NumberReply
export declare function transformReply(): number; } as const satisfies Command;

42
packages/json/lib/commands/FORGET.spec.ts
View File

@@ -1,28 +1,28 @@
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 './FORGET'; import FORGET from './FORGET';
describe('FORGET', () => { describe('FORGET', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('key', () => { it('key', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key'), FORGET.transformArguments('key'),
['JSON.FORGET', 'key'] ['JSON.FORGET', 'key']
); );
});
it('key, path', () => {
assert.deepEqual(
transformArguments('key', '$.path'),
['JSON.FORGET', 'key', '$.path']
);
});
}); });
testUtils.testWithClient('client.json.forget', async client => { it('key, path', () => {
assert.deepEqual( assert.deepEqual(
await client.json.forget('key'), FORGET.transformArguments('key', '$.path'),
0 ['JSON.FORGET', 'key', '$.path']
); );
}, GLOBAL.SERVERS.OPEN); });
});
testUtils.testWithClient('client.json.forget', async client => {
assert.deepEqual(
await client.json.forget('key'),
0
);
}, GLOBAL.SERVERS.OPEN);
}); });

15
packages/json/lib/commands/FORGET.ts
View File

@@ -1,13 +1,16 @@
export const FIRST_KEY_INDEX = 1; import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path?: string): Array<string> { export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.FORGET', key]; const args = ['JSON.FORGET', key];
if (path) { if (path) {
args.push(path); args.push(path);
} }
return args; return args;
} },
transformReply: undefined as unknown as () => NumberReply
export declare function transformReply(): number; } as const satisfies Command;

42
packages/search/lib/commands/DICTADD.spec.ts
View File

@@ -1,28 +1,28 @@
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 './DICTADD'; import DICTADD from './DICTADD';
describe('DICTADD', () => { describe('DICTADD', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('string', () => { it('string', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('dictionary', 'term'), DICTADD.transformArguments('dictionary', 'term'),
['FT.DICTADD', 'dictionary', 'term'] ['FT.DICTADD', 'dictionary', 'term']
); );
});
it('Array', () => {
assert.deepEqual(
transformArguments('dictionary', ['1', '2']),
['FT.DICTADD', 'dictionary', '1', '2']
);
});
}); });
testUtils.testWithClient('client.ft.dictAdd', async client => { it('Array', () => {
assert.equal( assert.deepEqual(
await client.ft.dictAdd('dictionary', 'term'), DICTADD.transformArguments('dictionary', ['1', '2']),
1 ['FT.DICTADD', 'dictionary', '1', '2']
); );
}, GLOBAL.SERVERS.OPEN); });
});
testUtils.testWithClient('client.ft.dictAdd', async client => {
assert.equal(
await client.ft.dictAdd('dictionary', 'term'),
1
);
}, GLOBAL.SERVERS.OPEN);
}); });

15
packages/search/lib/commands/DICTADD.ts
View File

@@ -1,8 +1,11 @@
import { RedisCommandArguments } from '@redis/client/dist/lib/commands'; import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
import { pushVariadicArguments } from '@redis/client/dist/lib/commands/generic-transformers'; import { pushVariadicArguments, RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
export function transformArguments(dictionary: string, term: string | Array<string>): RedisCommandArguments { export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: false,
transformArguments(dictionary: RedisArgument, term: RedisVariadicArgument) {
return pushVariadicArguments(['FT.DICTADD', dictionary], term); return pushVariadicArguments(['FT.DICTADD', dictionary], term);
} },
transformReply: undefined as unknown as () => NumberReply
export declare function transformReply(): number; } as const satisfies Command;

42
packages/search/lib/commands/DICTDEL.spec.ts
View File

@@ -1,28 +1,28 @@
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 './DICTDEL'; import DICTDEL from './DICTDEL';
describe('DICTDEL', () => { describe('DICTDEL', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('string', () => { it('string', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('dictionary', 'term'), DICTDEL.transformArguments('dictionary', 'term'),
['FT.DICTDEL', 'dictionary', 'term'] ['FT.DICTDEL', 'dictionary', 'term']
); );
});
it('Array', () => {
assert.deepEqual(
transformArguments('dictionary', ['1', '2']),
['FT.DICTDEL', 'dictionary', '1', '2']
);
});
}); });
testUtils.testWithClient('client.ft.dictDel', async client => { it('Array', () => {
assert.equal( assert.deepEqual(
await client.ft.dictDel('dictionary', 'term'), DICTDEL.transformArguments('dictionary', ['1', '2']),
0 ['FT.DICTDEL', 'dictionary', '1', '2']
); );
}, GLOBAL.SERVERS.OPEN); });
});
testUtils.testWithClient('client.ft.dictDel', async client => {
assert.equal(
await client.ft.dictDel('dictionary', 'term'),
0
);
}, GLOBAL.SERVERS.OPEN);
}); });

15
packages/search/lib/commands/DICTDEL.ts
View File

@@ -1,8 +1,11 @@
import { RedisCommandArguments } from '@redis/client/dist/lib/commands'; import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
import { pushVariadicArguments } from '@redis/client/dist/lib/commands/generic-transformers'; import { pushVariadicArguments, RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
export function transformArguments(dictionary: string, term: string | Array<string>): RedisCommandArguments { export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: false,
transformArguments(dictionary: RedisArgument, term: RedisVariadicArgument) {
return pushVariadicArguments(['FT.DICTDEL', dictionary], term); return pushVariadicArguments(['FT.DICTDEL', dictionary], term);
} },
transformReply: undefined as unknown as () => NumberReply
export declare function transformReply(): number; } as const satisfies Command;

56
packages/search/lib/commands/EXPLAIN.spec.ts
View File

@@ -1,33 +1,33 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import { transformArguments } from './EXPLAIN'; import EXPLAIN from './EXPLAIN';
describe('EXPLAIN', () => { describe('EXPLAIN', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('simple', () => { it('simple', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('index', '*'), EXPLAIN.transformArguments('index', '*'),
['FT.EXPLAIN', 'index', '*'] ['FT.EXPLAIN', 'index', '*']
); );
});
it('with PARAMS', () => {
assert.deepEqual(
transformArguments('index', '*', {
PARAMS: {
param: 'value'
}
}),
['FT.EXPLAIN', 'index', '*', 'PARAMS', '2', 'param', 'value']
);
});
it('with DIALECT', () => {
assert.deepEqual(
transformArguments('index', '*', {
DIALECT: 1
}),
['FT.EXPLAIN', 'index', '*', 'DIALECT', '1']
);
});
}); });
it('with PARAMS', () => {
assert.deepEqual(
EXPLAIN.transformArguments('index', '*', {
PARAMS: {
param: 'value'
}
}),
['FT.EXPLAIN', 'index', '*', 'PARAMS', '2', 'param', 'value']
);
});
it('with DIALECT', () => {
assert.deepEqual(
EXPLAIN.transformArguments('index', '*', {
DIALECT: 1
}),
['FT.EXPLAIN', 'index', '*', 'DIALECT', '1']
);
});
});
}); });

30
packages/search/lib/commands/EXPLAIN.ts
View File

@@ -1,26 +1,28 @@
import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';
import { Params, pushParamsArgs } from "."; import { Params, pushParamsArgs } from ".";
export const IS_READ_ONLY = true; export interface FtExplainOptions {
PARAMS?: Params;
interface ExplainOptions { DIALECT?: number;
PARAMS?: Params;
DIALECT?: number;
} }
export function transformArguments( export default {
index: string, FIRST_KEY_INDEX: undefined,
query: string, IS_READ_ONLY: true,
options?: ExplainOptions transformArguments(
): Array<string> { index: RedisArgument,
query: RedisArgument,
options?: FtExplainOptions
) {
const args = ['FT.EXPLAIN', index, query]; const args = ['FT.EXPLAIN', index, query];
pushParamsArgs(args, options?.PARAMS); pushParamsArgs(args, options?.PARAMS);
if (options?.DIALECT) { if (options?.DIALECT) {
args.push('DIALECT', options.DIALECT.toString()); args.push('DIALECT', options.DIALECT.toString());
} }
return args; return args;
} },
transformReply: undefined as unknown as () => SimpleStringReply
export declare function transformReply(): string; } as const satisfies Command;

14
packages/search/lib/commands/EXPLAINCLI.spec.ts
View File

@@ -1,11 +1,11 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import { transformArguments } from './EXPLAINCLI'; import EXPLAINCLI from './EXPLAINCLI';
describe('EXPLAINCLI', () => { describe('EXPLAINCLI', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('index', '*'), EXPLAINCLI.transformArguments('index', '*'),
['FT.EXPLAINCLI', 'index', '*'] ['FT.EXPLAINCLI', 'index', '*']
); );
}); });
}); });

13
packages/search/lib/commands/EXPLAINCLI.ts
View File

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

56
packages/search/lib/commands/SUGADD.spec.ts
View File

@@ -1,35 +1,35 @@
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 './SUGADD'; import SUGADD from './SUGADD';
describe('SUGADD', () => { describe('SUGADD', () => {
describe('transformArguments', () => { describe('transformArguments', () => {
it('without options', () => { it('without options', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key', 'string', 1), SUGADD.transformArguments('key', 'string', 1),
['FT.SUGADD', 'key', 'string', '1'] ['FT.SUGADD', 'key', 'string', '1']
); );
});
it('with INCR', () => {
assert.deepEqual(
transformArguments('key', 'string', 1, { INCR: true }),
['FT.SUGADD', 'key', 'string', '1', 'INCR']
);
});
it('with PAYLOAD', () => {
assert.deepEqual(
transformArguments('key', 'string', 1, { PAYLOAD: 'payload' }),
['FT.SUGADD', 'key', 'string', '1', 'PAYLOAD', 'payload']
);
});
}); });
testUtils.testWithClient('client.ft.sugAdd', async client => { it('with INCR', () => {
assert.equal( assert.deepEqual(
await client.ft.sugAdd('key', 'string', 1), SUGADD.transformArguments('key', 'string', 1, { INCR: true }),
1 ['FT.SUGADD', 'key', 'string', '1', 'INCR']
); );
}, GLOBAL.SERVERS.OPEN); });
it('with PAYLOAD', () => {
assert.deepEqual(
SUGADD.transformArguments('key', 'string', 1, { PAYLOAD: 'payload' }),
['FT.SUGADD', 'key', 'string', '1', 'PAYLOAD', 'payload']
);
});
});
testUtils.testWithClient('client.ft.sugAdd', async client => {
assert.equal(
await client.ft.sugAdd('key', 'string', 1),
1
);
}, GLOBAL.SERVERS.OPEN);
}); });

23
packages/search/lib/commands/SUGADD.ts
View File

@@ -1,20 +1,25 @@
interface SugAddOptions { import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
INCR?: true;
PAYLOAD?: string; export interface FtSugAddOptions {
INCR?: boolean;
PAYLOAD?: RedisArgument;
} }
export function transformArguments(key: string, string: string, score: number, options?: SugAddOptions): Array<string> { export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, string: RedisArgument, score: number, options?: FtSugAddOptions) {
const args = ['FT.SUGADD', key, string, score.toString()]; const args = ['FT.SUGADD', key, string, score.toString()];
if (options?.INCR) { if (options?.INCR) {
args.push('INCR'); args.push('INCR');
} }
if (options?.PAYLOAD) { if (options?.PAYLOAD) {
args.push('PAYLOAD', options.PAYLOAD); args.push('PAYLOAD', options.PAYLOAD);
} }
return args; return args;
} },
transformReply: undefined as unknown as () => NumberReply
export declare function transformReply(): number; } as const satisfies Command;

26
packages/search/lib/commands/SUGDEL.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 './SUGDEL'; import SUGDEL from './SUGDEL';
describe('SUGDEL', () => { describe('SUGDEL', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key', 'string'), SUGDEL.transformArguments('key', 'string'),
['FT.SUGDEL', 'key', 'string'] ['FT.SUGDEL', 'key', 'string']
); );
}); });
testUtils.testWithClient('client.ft.sugDel', async client => { testUtils.testWithClient('client.ft.sugDel', async client => {
assert.equal( assert.equal(
await client.ft.sugDel('key', 'string'), await client.ft.sugDel('key', 'string'),
false false
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

13
packages/search/lib/commands/SUGDEL.ts
View File

@@ -1,5 +1,10 @@
export function transformArguments(key: string, string: string): Array<string> { import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
return ['FT.SUGDEL', key, string];
}
export { transformBooleanReply as transformReply } from '@redis/client/dist/lib/commands/generic-transformers'; export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, string: RedisArgument) {
return ['FT.SUGDEL', key, string];
},
transformReply: undefined as unknown as () => NumberReply<0 | 1>
} as const satisfies Command;

26
packages/search/lib/commands/SUGLEN.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 './SUGLEN'; import SUGLEN from './SUGLEN';
describe('SUGLEN', () => { describe('SUGLEN', () => {
it('transformArguments', () => { it('transformArguments', () => {
assert.deepEqual( assert.deepEqual(
transformArguments('key'), SUGLEN.transformArguments('key'),
['FT.SUGLEN', 'key'] ['FT.SUGLEN', 'key']
); );
}); });
testUtils.testWithClient('client.ft.sugLen', async client => { testUtils.testWithClient('client.ft.sugLen', async client => {
assert.equal( assert.equal(
await client.ft.sugLen('key'), await client.ft.sugLen('key'),
0 0
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
}); });

13
packages/search/lib/commands/SUGLEN.ts
View File

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