redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-09 00:22:08 +03:00
Code Activity

get ready for beta release

Browse Source
This commit is contained in:
Leibale
2023-11-09 21:08:53 -05:00
parent 7247777a6f
commit 5b086ba358
12 changed files with 4563 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
.npmignore
View File

@@ -1,12 +0,0 @@
.github/
.vscode/
docs/
examples/
packages/
.deepsource.toml
.release-it.json
CONTRIBUTING.md
SECURITY.md
index.ts
tsconfig.base.json
tsconfig.json

4212
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

1
package.json
View File

@@ -19,6 +19,7 @@
"gh-pages": "^6.0.0", "gh-pages": "^6.0.0",
"mocha": "^10.2.0", "mocha": "^10.2.0",
"nyc": "^15.1.0", "nyc": "^15.1.0",
"release-it": "^16.2.1",
"tsx": "^3.14.0", "tsx": "^3.14.0",
"typedoc": "^0.25.3", "typedoc": "^0.25.3",
"typescript": "^5.2.2" "typescript": "^5.2.2"

6
packages/bloom/.npmignore
View File

@@ -1,6 +0,0 @@
.nyc_output/
coverage/
lib/
.nycrc.json
.release-it.json
tsconfig.json

6
packages/json/.npmignore
View File

@@ -1,6 +0,0 @@
.nyc_output/
coverage/
lib/
.nycrc.json
.release-it.json
tsconfig.json

6
packages/search/.npmignore
View File

@@ -1,6 +0,0 @@
.nyc_output/
coverage/
lib/
.nycrc.json
.release-it.json
tsconfig.json

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

@@ -1,28 +1,28 @@
import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types'; // import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';
import { Params, pushParamsArgs } from "."; // import { Params, pushParamsArgs } from ".";
export interface FtExplainOptions { // export interface FtExplainOptions {
PARAMS?: Params; // PARAMS?: Params;
DIALECT?: number; // DIALECT?: number;
} // }
export default { // export default {
FIRST_KEY_INDEX: undefined, // FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: true, // IS_READ_ONLY: true,
transformArguments( // transformArguments(
index: RedisArgument, // index: RedisArgument,
query: RedisArgument, // query: RedisArgument,
options?: FtExplainOptions // 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 // transformReply: undefined as unknown as () => SimpleStringReply
} as const satisfies Command; // } as const satisfies Command;

326
packages/search/lib/commands/INFO.ts
View File

@@ -1,167 +1,167 @@
import { RedisCommandArgument } from '@redis/client/dist/lib/commands'; // import { RedisCommandArgument } from '@redis/client/dist/lib/commands';
import { transformTuplesReply } from '@redis/client/dist/lib/commands/generic-transformers'; // import { transformTuplesReply } from '@redis/client/dist/lib/commands/generic-transformers';
export function transformArguments(index: string): Array<string> { // export function transformArguments(index: string): Array<string> {
return ['FT.INFO', index]; // return ['FT.INFO', index];
} // }
type InfoRawReply = [ // type InfoRawReply = [
'index_name', // 'index_name',
RedisCommandArgument, // RedisCommandArgument,
'index_options', // 'index_options',
Array<RedisCommandArgument>, // Array<RedisCommandArgument>,
'index_definition', // 'index_definition',
Array<RedisCommandArgument>, // Array<RedisCommandArgument>,
'attributes', // 'attributes',
Array<Array<RedisCommandArgument>>, // Array<Array<RedisCommandArgument>>,
'num_docs', // 'num_docs',
RedisCommandArgument, // RedisCommandArgument,
'max_doc_id', // 'max_doc_id',
RedisCommandArgument, // RedisCommandArgument,
'num_terms', // 'num_terms',
RedisCommandArgument, // RedisCommandArgument,
'num_records', // 'num_records',
RedisCommandArgument, // RedisCommandArgument,
'inverted_sz_mb', // 'inverted_sz_mb',
RedisCommandArgument, // RedisCommandArgument,
'vector_index_sz_mb', // 'vector_index_sz_mb',
RedisCommandArgument, // RedisCommandArgument,
'total_inverted_index_blocks', // 'total_inverted_index_blocks',
RedisCommandArgument, // RedisCommandArgument,
'offset_vectors_sz_mb', // 'offset_vectors_sz_mb',
RedisCommandArgument, // RedisCommandArgument,
'doc_table_size_mb', // 'doc_table_size_mb',
RedisCommandArgument, // RedisCommandArgument,
'sortable_values_size_mb', // 'sortable_values_size_mb',
RedisCommandArgument, // RedisCommandArgument,
'key_table_size_mb', // 'key_table_size_mb',
RedisCommandArgument, // RedisCommandArgument,
'records_per_doc_avg', // 'records_per_doc_avg',
RedisCommandArgument, // RedisCommandArgument,
'bytes_per_record_avg', // 'bytes_per_record_avg',
RedisCommandArgument, // RedisCommandArgument,
'offsets_per_term_avg', // 'offsets_per_term_avg',
RedisCommandArgument, // RedisCommandArgument,
'offset_bits_per_record_avg', // 'offset_bits_per_record_avg',
RedisCommandArgument, // RedisCommandArgument,
'hash_indexing_failures', // 'hash_indexing_failures',
RedisCommandArgument, // RedisCommandArgument,
'indexing', // 'indexing',
RedisCommandArgument, // RedisCommandArgument,
'percent_indexed', // 'percent_indexed',
RedisCommandArgument, // RedisCommandArgument,
'gc_stats', // 'gc_stats',
[ // [
'bytes_collected', // 'bytes_collected',
RedisCommandArgument, // RedisCommandArgument,
'total_ms_run', // 'total_ms_run',
RedisCommandArgument, // RedisCommandArgument,
'total_cycles', // 'total_cycles',
RedisCommandArgument, // RedisCommandArgument,
'average_cycle_time_ms', // 'average_cycle_time_ms',
RedisCommandArgument, // RedisCommandArgument,
'last_run_time_ms', // 'last_run_time_ms',
RedisCommandArgument, // RedisCommandArgument,
'gc_numeric_trees_missed', // 'gc_numeric_trees_missed',
RedisCommandArgument, // RedisCommandArgument,
'gc_blocks_denied', // 'gc_blocks_denied',
RedisCommandArgument // RedisCommandArgument
], // ],
'cursor_stats', // 'cursor_stats',
[ // [
'global_idle', // 'global_idle',
number, // number,
'global_total', // 'global_total',
number, // number,
'index_capacity', // 'index_capacity',
number, // number,
'index_total', // 'index_total',
number // number
], // ],
'stopwords_list'?, // 'stopwords_list'?,
Array<RedisCommandArgument>? // Array<RedisCommandArgument>?
]; // ];
interface InfoReply { // interface InfoReply {
indexName: RedisCommandArgument; // indexName: RedisCommandArgument;
indexOptions: Array<RedisCommandArgument>; // indexOptions: Array<RedisCommandArgument>;
indexDefinition: Record<string, RedisCommandArgument>; // indexDefinition: Record<string, RedisCommandArgument>;
attributes: Array<Record<string, RedisCommandArgument>>; // attributes: Array<Record<string, RedisCommandArgument>>;
numDocs: RedisCommandArgument; // numDocs: RedisCommandArgument;
maxDocId: RedisCommandArgument; // maxDocId: RedisCommandArgument;
numTerms: RedisCommandArgument; // numTerms: RedisCommandArgument;
numRecords: RedisCommandArgument; // numRecords: RedisCommandArgument;
invertedSzMb: RedisCommandArgument; // invertedSzMb: RedisCommandArgument;
vectorIndexSzMb: RedisCommandArgument; // vectorIndexSzMb: RedisCommandArgument;
totalInvertedIndexBlocks: RedisCommandArgument; // totalInvertedIndexBlocks: RedisCommandArgument;
offsetVectorsSzMb: RedisCommandArgument; // offsetVectorsSzMb: RedisCommandArgument;
docTableSizeMb: RedisCommandArgument; // docTableSizeMb: RedisCommandArgument;
sortableValuesSizeMb: RedisCommandArgument; // sortableValuesSizeMb: RedisCommandArgument;
keyTableSizeMb: RedisCommandArgument; // keyTableSizeMb: RedisCommandArgument;
recordsPerDocAvg: RedisCommandArgument; // recordsPerDocAvg: RedisCommandArgument;
bytesPerRecordAvg: RedisCommandArgument; // bytesPerRecordAvg: RedisCommandArgument;
offsetsPerTermAvg: RedisCommandArgument; // offsetsPerTermAvg: RedisCommandArgument;
offsetBitsPerRecordAvg: RedisCommandArgument; // offsetBitsPerRecordAvg: RedisCommandArgument;
hashIndexingFailures: RedisCommandArgument; // hashIndexingFailures: RedisCommandArgument;
indexing: RedisCommandArgument; // indexing: RedisCommandArgument;
percentIndexed: RedisCommandArgument; // percentIndexed: RedisCommandArgument;
gcStats: { // gcStats: {
bytesCollected: RedisCommandArgument; // bytesCollected: RedisCommandArgument;
totalMsRun: RedisCommandArgument; // totalMsRun: RedisCommandArgument;
totalCycles: RedisCommandArgument; // totalCycles: RedisCommandArgument;
averageCycleTimeMs: RedisCommandArgument; // averageCycleTimeMs: RedisCommandArgument;
lastRunTimeMs: RedisCommandArgument; // lastRunTimeMs: RedisCommandArgument;
gcNumericTreesMissed: RedisCommandArgument; // gcNumericTreesMissed: RedisCommandArgument;
gcBlocksDenied: RedisCommandArgument; // gcBlocksDenied: RedisCommandArgument;
}; // };
cursorStats: { // cursorStats: {
globalIdle: number; // globalIdle: number;
globalTotal: number; // globalTotal: number;
indexCapacity: number; // indexCapacity: number;
idnexTotal: number; // idnexTotal: number;
}; // };
stopWords: Array<RedisCommandArgument> | undefined; // stopWords: Array<RedisCommandArgument> | undefined;
} // }
export function transformReply(rawReply: InfoRawReply): InfoReply { // export function transformReply(rawReply: InfoRawReply): InfoReply {
return { // return {
indexName: rawReply[1], // indexName: rawReply[1],
indexOptions: rawReply[3], // indexOptions: rawReply[3],
indexDefinition: transformTuplesReply(rawReply[5]), // indexDefinition: transformTuplesReply(rawReply[5]),
attributes: rawReply[7].map(attribute => transformTuplesReply(attribute)), // attributes: rawReply[7].map(attribute => transformTuplesReply(attribute)),
numDocs: rawReply[9], // numDocs: rawReply[9],
maxDocId: rawReply[11], // maxDocId: rawReply[11],
numTerms: rawReply[13], // numTerms: rawReply[13],
numRecords: rawReply[15], // numRecords: rawReply[15],
invertedSzMb: rawReply[17], // invertedSzMb: rawReply[17],
vectorIndexSzMb: rawReply[19], // vectorIndexSzMb: rawReply[19],
totalInvertedIndexBlocks: rawReply[21], // totalInvertedIndexBlocks: rawReply[21],
offsetVectorsSzMb: rawReply[23], // offsetVectorsSzMb: rawReply[23],
docTableSizeMb: rawReply[25], // docTableSizeMb: rawReply[25],
sortableValuesSizeMb: rawReply[27], // sortableValuesSizeMb: rawReply[27],
keyTableSizeMb: rawReply[29], // keyTableSizeMb: rawReply[29],
recordsPerDocAvg: rawReply[31], // recordsPerDocAvg: rawReply[31],
bytesPerRecordAvg: rawReply[33], // bytesPerRecordAvg: rawReply[33],
offsetsPerTermAvg: rawReply[35], // offsetsPerTermAvg: rawReply[35],
offsetBitsPerRecordAvg: rawReply[37], // offsetBitsPerRecordAvg: rawReply[37],
hashIndexingFailures: rawReply[39], // hashIndexingFailures: rawReply[39],
indexing: rawReply[41], // indexing: rawReply[41],
percentIndexed: rawReply[43], // percentIndexed: rawReply[43],
gcStats: { // gcStats: {
bytesCollected: rawReply[45][1], // bytesCollected: rawReply[45][1],
totalMsRun: rawReply[45][3], // totalMsRun: rawReply[45][3],
totalCycles: rawReply[45][5], // totalCycles: rawReply[45][5],
averageCycleTimeMs: rawReply[45][7], // averageCycleTimeMs: rawReply[45][7],
lastRunTimeMs: rawReply[45][9], // lastRunTimeMs: rawReply[45][9],
gcNumericTreesMissed: rawReply[45][11], // gcNumericTreesMissed: rawReply[45][11],
gcBlocksDenied: rawReply[45][13] // gcBlocksDenied: rawReply[45][13]
}, // },
cursorStats: { // cursorStats: {
globalIdle: rawReply[47][1], // globalIdle: rawReply[47][1],
globalTotal: rawReply[47][3], // globalTotal: rawReply[47][3],
indexCapacity: rawReply[47][5], // indexCapacity: rawReply[47][5],
idnexTotal: rawReply[47][7] // idnexTotal: rawReply[47][7]
}, // },
stopWords: rawReply[49] // stopWords: rawReply[49]
}; // };
} // }

46
packages/search/lib/commands/PROFILE_AGGREGATE.ts
View File

@@ -1,29 +1,29 @@
import { pushAggregatehOptions, AggregateOptions, transformReply as transformAggregateReply, AggregateRawReply } from './AGGREGATE'; // import { pushAggregatehOptions, AggregateOptions, transformReply as transformAggregateReply, AggregateRawReply } from './AGGREGATE';
import { ProfileOptions, ProfileRawReply, ProfileReply, transformProfile } from '.'; // import { ProfileOptions, ProfileRawReply, ProfileReply, transformProfile } from '.';
export const IS_READ_ONLY = true; // export const IS_READ_ONLY = true;
export function transformArguments( // export function transformArguments(
index: string, // index: string,
query: string, // query: string,
options?: ProfileOptions & AggregateOptions // options?: ProfileOptions & AggregateOptions
): Array<string> { // ): Array<string> {
const args = ['FT.PROFILE', index, 'AGGREGATE']; // const args = ['FT.PROFILE', index, 'AGGREGATE'];
if (options?.LIMITED) { // if (options?.LIMITED) {
args.push('LIMITED'); // args.push('LIMITED');
} // }
args.push('QUERY', query); // args.push('QUERY', query);
pushAggregatehOptions(args, options) // pushAggregatehOptions(args, options)
return args; // return args;
} // }
type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>; // type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>;
export function transformReply(reply: ProfileAggeregateRawReply): ProfileReply { // export function transformReply(reply: ProfileAggeregateRawReply): ProfileReply {
return { // return {
results: transformAggregateReply(reply[0]), // results: transformAggregateReply(reply[0]),
profile: transformProfile(reply[1]) // profile: transformProfile(reply[1])
}; // };
} // }

46
packages/search/lib/commands/PROFILE_SEARCH.ts
View File

@@ -1,29 +1,29 @@
import { SearchOptions, SearchRawReply, transformReply as transformSearchReply } from './SEARCH'; // import { SearchOptions, SearchRawReply, transformReply as transformSearchReply } from './SEARCH';
import { pushSearchOptions, ProfileOptions, ProfileRawReply, ProfileReply, transformProfile } from '.'; // import { pushSearchOptions, ProfileOptions, ProfileRawReply, ProfileReply, transformProfile } from '.';
import { RedisCommandArguments } from '@redis/client/dist/lib/commands'; // import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
export const IS_READ_ONLY = true; // export const IS_READ_ONLY = true;
export function transformArguments( // export function transformArguments(
index: string, // index: string,
query: string, // query: string,
options?: ProfileOptions & SearchOptions // options?: ProfileOptions & SearchOptions
): RedisCommandArguments { // ): RedisCommandArguments {
let args: RedisCommandArguments = ['FT.PROFILE', index, 'SEARCH']; // let args: RedisCommandArguments = ['FT.PROFILE', index, 'SEARCH'];
if (options?.LIMITED) { // if (options?.LIMITED) {
args.push('LIMITED'); // args.push('LIMITED');
} // }
args.push('QUERY', query); // args.push('QUERY', query);
return pushSearchOptions(args, options); // return pushSearchOptions(args, options);
} // }
type ProfileSearchRawReply = ProfileRawReply<SearchRawReply>; // type ProfileSearchRawReply = ProfileRawReply<SearchRawReply>;
export function transformReply(reply: ProfileSearchRawReply, withoutDocuments: boolean): ProfileReply { // export function transformReply(reply: ProfileSearchRawReply, withoutDocuments: boolean): ProfileReply {
return { // return {
results: transformSearchReply(reply[0], withoutDocuments), // results: transformSearchReply(reply[0], withoutDocuments),
profile: transformProfile(reply[1]) // profile: transformProfile(reply[1])
}; // };
} // }

152
packages/time-series/lib/commands/INFO.ts
View File

@@ -1,82 +1,82 @@
import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.'; // import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.';
export const FIRST_KEY_INDEX = 1; // export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; // export const IS_READ_ONLY = true;
export function transformArguments(key: string): Array<string> { // export function transformArguments(key: string): Array<string> {
return ['TS.INFO', key]; // return ['TS.INFO', key];
} // }
export type InfoRawReply = [ // export type InfoRawReply = [
'totalSamples', // 'totalSamples',
number, // number,
'memoryUsage', // 'memoryUsage',
number, // number,
'firstTimestamp', // 'firstTimestamp',
number, // number,
'lastTimestamp', // 'lastTimestamp',
number, // number,
'retentionTime', // 'retentionTime',
number, // number,
'chunkCount', // 'chunkCount',
number, // number,
'chunkSize', // 'chunkSize',
number, // number,
'chunkType', // 'chunkType',
string, // string,
'duplicatePolicy', // 'duplicatePolicy',
TimeSeriesDuplicatePolicies | null, // TimeSeriesDuplicatePolicies | null,
'labels', // 'labels',
Array<[name: string, value: string]>, // Array<[name: string, value: string]>,
'sourceKey', // 'sourceKey',
string | null, // string | null,
'rules', // 'rules',
Array<[key: string, timeBucket: number, aggregationType: TimeSeriesAggregationType]> // Array<[key: string, timeBucket: number, aggregationType: TimeSeriesAggregationType]>
]; // ];
export interface InfoReply { // export interface InfoReply {
totalSamples: number; // totalSamples: number;
memoryUsage: number; // memoryUsage: number;
firstTimestamp: number; // firstTimestamp: number;
lastTimestamp: number; // lastTimestamp: number;
retentionTime: number; // retentionTime: number;
chunkCount: number; // chunkCount: number;
chunkSize: number; // chunkSize: number;
chunkType: string; // chunkType: string;
duplicatePolicy: TimeSeriesDuplicatePolicies | null; // duplicatePolicy: TimeSeriesDuplicatePolicies | null;
labels: Array<{ // labels: Array<{
name: string; // name: string;
value: string; // value: string;
}>; // }>;
sourceKey: string | null; // sourceKey: string | null;
rules: Array<{ // rules: Array<{
key: string; // key: string;
timeBucket: number; // timeBucket: number;
aggregationType: TimeSeriesAggregationType // aggregationType: TimeSeriesAggregationType
}>; // }>;
} // }
export function transformReply(reply: InfoRawReply): InfoReply { // export function transformReply(reply: InfoRawReply): InfoReply {
return { // return {
totalSamples: reply[1], // totalSamples: reply[1],
memoryUsage: reply[3], // memoryUsage: reply[3],
firstTimestamp: reply[5], // firstTimestamp: reply[5],
lastTimestamp: reply[7], // lastTimestamp: reply[7],
retentionTime: reply[9], // retentionTime: reply[9],
chunkCount: reply[11], // chunkCount: reply[11],
chunkSize: reply[13], // chunkSize: reply[13],
chunkType: reply[15], // chunkType: reply[15],
duplicatePolicy: reply[17], // duplicatePolicy: reply[17],
labels: reply[19].map(([name, value]) => ({ // labels: reply[19].map(([name, value]) => ({
name, // name,
value // value
})), // })),
sourceKey: reply[21], // sourceKey: reply[21],
rules: reply[23].map(([key, timeBucket, aggregationType]) => ({ // rules: reply[23].map(([key, timeBucket, aggregationType]) => ({
key, // key,
timeBucket, // timeBucket,
aggregationType // aggregationType
})) // }))
}; // };
} // }

104
packages/time-series/lib/commands/INFO_DEBUG.ts
View File

@@ -1,57 +1,57 @@
import { // import {
transformArguments as transformInfoArguments, // transformArguments as transformInfoArguments,
InfoRawReply, // InfoRawReply,
InfoReply, // InfoReply,
transformReply as transformInfoReply // transformReply as transformInfoReply
} from './INFO'; // } from './INFO';
export { IS_READ_ONLY, FIRST_KEY_INDEX } from './INFO'; // export { IS_READ_ONLY, FIRST_KEY_INDEX } from './INFO';
export function transformArguments(key: string): Array<string> { // export function transformArguments(key: string): Array<string> {
const args = transformInfoArguments(key); // const args = transformInfoArguments(key);
args.push('DEBUG'); // args.push('DEBUG');
return args; // return args;
} // }
type InfoDebugRawReply = [ // type InfoDebugRawReply = [
...InfoRawReply, // ...InfoRawReply,
'keySelfName', // 'keySelfName',
string, // string,
'chunks', // 'chunks',
Array<[ // Array<[
'startTimestamp', // 'startTimestamp',
number, // number,
'endTimestamp', // 'endTimestamp',
number, // number,
'samples', // 'samples',
number, // number,
'size', // 'size',
number, // number,
'bytesPerSample', // 'bytesPerSample',
string // string
]> // ]>
]; // ];
interface InfoDebugReply extends InfoReply { // interface InfoDebugReply extends InfoReply {
keySelfName: string; // keySelfName: string;
chunks: Array<{ // chunks: Array<{
startTimestamp: number; // startTimestamp: number;
endTimestamp: number; // endTimestamp: number;
samples: number; // samples: number;
size: number; // size: number;
bytesPerSample: string; // bytesPerSample: string;
}>; // }>;
} // }
export function transformReply(rawReply: InfoDebugRawReply): InfoDebugReply { // export function transformReply(rawReply: InfoDebugRawReply): InfoDebugReply {
const reply = transformInfoReply(rawReply as unknown as InfoRawReply); // const reply = transformInfoReply(rawReply as unknown as InfoRawReply);
(reply as InfoDebugReply).keySelfName = rawReply[25]; // (reply as InfoDebugReply).keySelfName = rawReply[25];
(reply as InfoDebugReply).chunks = rawReply[27].map(chunk => ({ // (reply as InfoDebugReply).chunks = rawReply[27].map(chunk => ({
startTimestamp: chunk[1], // startTimestamp: chunk[1],
endTimestamp: chunk[3], // endTimestamp: chunk[3],
samples: chunk[5], // samples: chunk[5],
size: chunk[7], // size: chunk[7],
bytesPerSample: chunk[9] // bytesPerSample: chunk[9]
})); // }));
return reply as InfoDebugReply; // return reply as InfoDebugReply;
} // }