Merge commit '245e5df38574af2499f223799404bc65e06ae174' into v3.x

CHANGELOG.md

@@ -1,3 +1,44 @@
+#### v3.5.2 (2023-11-29)
+
+##### Chores
+
+*  up composer (49013f81)
+*  incrementing version number - v3.5.1 (4c543488)
+*  update changelog for v3.5.1 (48f7ae99)
+*  incrementing version number - v3.5.0 (d06fb4f0)
+*  incrementing version number - v3.4.3 (5c984250)
+*  incrementing version number - v3.4.2 (3f0dac38)
+*  incrementing version number - v3.4.1 (01e69574)
+*  incrementing version number - v3.4.0 (fd9247c5)
+*  incrementing version number - v3.3.9 (5805e770)
+*  incrementing version number - v3.3.8 (a5603565)
+*  incrementing version number - v3.3.7 (b26f1744)
+*  incrementing version number - v3.3.6 (7fb38792)
+*  incrementing version number - v3.3.4 (a67f84ea)
+*  incrementing version number - v3.3.3 (f94d239b)
+*  incrementing version number - v3.3.2 (ec9dac97)
+*  incrementing version number - v3.3.1 (151cc68f)
+*  incrementing version number - v3.3.0 (fc1ad70f)
+*  incrementing version number - v3.2.3 (b06d3e63)
+*  incrementing version number - v3.2.2 (758ecfcd)
+*  incrementing version number - v3.2.1 (20145074)
+*  incrementing version number - v3.2.0 (9ecac38e)
+*  incrementing version number - v3.1.7 (0b4e81ab)
+*  incrementing version number - v3.1.6 (b3a3b130)
+*  incrementing version number - v3.1.5 (ec19343a)
+*  incrementing version number - v3.1.4 (2452783c)
+*  incrementing version number - v3.1.3 (3b4e9d3f)
+*  incrementing version number - v3.1.2 (40fa3489)
+*  incrementing version number - v3.1.1 (40250733)
+*  incrementing version number - v3.1.0 (0cb386bd)
+*  incrementing version number - v3.0.1 (26f6ea49)
+*  incrementing version number - v3.0.0 (224e08cd)
+
+##### Bug Fixes
+
+*  closes #12185, fix cli user password reset (6790000d)
+*  thumb width (a9ef58a5)
+
 #### v3.5.1 (2023-11-14)
 
 ##### Chores

install/package.json

@@ -93,7 +93,7 @@
         "multiparty": "4.2.3",
         "nconf": "0.12.1",
         "nodebb-plugin-2factor": "7.4.0",
-        "nodebb-plugin-composer-default": "10.2.27",
+        "nodebb-plugin-composer-default": "10.2.29",
         "nodebb-plugin-dbsearch": "6.2.2",
         "nodebb-plugin-emoji": "5.1.13",
         "nodebb-plugin-emoji-android": "4.0.0",

public/src/modules/translator.common.js

@@ -463,7 +463,9 @@ module.exports = function (utils, load, warn) {
 		 * @returns {string}
 		 */
 		Translator.escape = function escape(text) {
-			return typeof text === 'string' ? text.replace(/\[\[/g, '[[').replace(/\]\]/g, ']]') : text;
+			return typeof text === 'string' ?
+				text.replace(/\[\[/g, '[[').replace(/\]\]/g, ']]') :
+				text;
 		};
 
 		/**
@@ -473,8 +475,7 @@ module.exports = function (utils, load, warn) {
 		 */
 		Translator.unescape = function unescape(text) {
 			return typeof text === 'string' ?
-				text.replace(/[/g, '[').replace(/\\\[/g, '[')
-					.replace(/]/g, ']').replace(/\\\]/g, ']') :
+				text.replace(/]]/g, ']]').replace(/[[/g, '[[') :
 				text;
 		};
 

test/translator.js

@@ -308,10 +308,6 @@ describe('Translator static methods', () => {
 
 	describe('.unescape', () => {
 		it('should unescape escaped translation patterns within text', (done) => {
-			assert.strictEqual(
-				Translator.unescape('some nice text \\[\\[global:home\\]\\] here'),
-				'some nice text [[global:home]] here'
-			);
 			assert.strictEqual(
 				Translator.unescape('some nice text [[global:home]] here'),
 				'some nice text [[global:home]] here'

types/database/hash.d.ts

@@ -0,0 +1,56 @@
+export interface Hash {
+  decrObjectField(
+    key: string | string[],
+    field: string,
+  ): Promise<number | number[]>
+
+  deleteObjectField(key: string, field: string): Promise<void>
+
+  deleteObjectFields(key: string, fields: string[]): Promise<void>
+
+  getObject(key: string, fields: string[]): Promise<object>
+
+  getObjectField(key: string, field: string): Promise<any>
+
+  getObjectFields(key: string, fields: string[]): Promise<Record<string, any>>
+
+  getObjectKeys(key: string): Promise<string[]>
+
+  getObjectValues(key: string): Promise<any[]>
+
+  getObjects(keys: string[], fields: string[]): Promise<any[]>
+
+  getObjectsFields(
+    keys: string[],
+    fields: string[],
+  ): Promise<Record<string, any>[]>
+
+  incrObjectField(
+    key: string | string[],
+    field: string,
+  ): Promise<number | number[]>
+
+  incrObjectFieldBy(
+    key: string | string[],
+    field: string,
+    value: number,
+  ): Promise<number | number[]>
+
+  incrObjectFieldByBulk(
+    data: [key: string, batch: Record<string, number>][],
+  ): Promise<void>
+
+  isObjectField(key: string, field: string): Promise<boolean>
+
+  isObjectFields(key: string, fields: string[]): Promise<boolean[]>
+
+  setObject(key: string | string[], data: Record<string, any>): Promise<void>
+
+  setObjectBulk(args: [key: string, data: Record<string, any>][]): Promise<void>
+
+  setObjectField(
+    key: string | string[],
+    field: string,
+    value: any,
+  ): Promise<void>
+}

types/database/index.d.ts

@@ -0,0 +1,54 @@
+import { Store } from 'express-session'
+
+export { Hash } from './hash'
+export { List } from './list'
+export { Set } from './set'
+export { Item } from './string'
+export {
+  SortedSet,
+  SortedSetTheoryOperation,
+  SortedSetScanBaseParameters,
+} from './zset'
+
+export interface Database {
+  checkCompatibility(callback: () => void): Promise<void>
+
+  checkCompatibilityVersion(
+    version: string,
+    callback: () => void,
+  ): Promise<void>
+
+  close(): Promise<void>
+
+  createIndices(callback: () => void): Promise<void>
+
+  createSessionStore(options: any): Promise<Store>
+
+  emptydb(): Promise<void>
+
+  flushdb(): Promise<void>
+
+  info(db: any): Promise<any>
+
+  init(): Promise<void>
+}
+
+export type RedisStyleMatchString =
+  | string
+  | `*${string}`
+  | `${string}*`
+  | `*${string}*`
+export type RedisStyleRangeString = `${'(' | '['}${string}` | `${string}`
+
+export enum ObjectType {
+  HASH = 'hash',
+  LIST = 'list',
+  SET = 'set',
+  STRING = 'string',
+  SORTED_SET = 'zset',
+}
+
+export type ValueAndScore = { value: string; score: number }
+export type RedisStyleAggregate = 'SUM' | 'MIN' | 'MAX'
+export type NumberTowardsMinima = number | '-inf'
+export type NumberTowardsMaxima = number | '+inf'

types/database/list.d.ts

@@ -0,0 +1,15 @@
+export interface List {
+  listPrepend(key: string, value: string): Promise<void>
+
+  listAppend(key: string, value: string): Promise<void>
+
+  listRemoveLast(key: string): Promise<string | null>
+
+  listRemoveAll(key: string, value: string | string[]): Promise<void>
+
+  listTrim(key: string, start: number, stop: number): Promise<void>
+
+  getListRange(key: string, start: number, stop: number): Promise<string[]>
+
+  listLength(key: string): Promise<number>
+}

types/database/set.d.ts

@@ -0,0 +1,25 @@
+export interface Set {
+  getSetMembers(key: string): Promise<string[]>
+
+  getSetsMembers(keys: string[]): Promise<string[][]>
+
+  isMemberOfSets(sets: string[], value: string): Promise<boolean[]>
+
+  isSetMember(key: string, value: string): Promise<boolean>
+
+  isSetMembers(key: string, values: string[]): Promise<boolean[]>
+
+  setAdd(key: string, value: string | string[]): Promise<void>
+
+  setCount(key: string): Promise<number>
+
+  setRemove(key: string | string[], value: string | string[]): Promise<void>
+
+  setRemoveRandom(key: string): Promise<string>
+
+  setsAdd(keys: string[], value: string | string[]): Promise<void>
+
+  setsCount(keys: string[]): Promise<number[]>
+
+  setsRemove(keys: string[], value: string): Promise<void>
+}

types/database/string.d.ts

@@ -0,0 +1,35 @@
+import { ObjectType, RedisStyleMatchString } from './index'
+
+export interface Item {
+  delete(key: string): Promise<void>
+
+  deleteAll(keys: string[]): Promise<void>
+
+  exists(key: string): Promise<boolean>
+
+  exists(key: string[]): Promise<boolean[]>
+
+  expire(key: string, seconds: number): Promise<void>
+
+  expireAt(key: string, timestampInSeconds: number): Promise<void>
+
+  get(key: string): Promise<string | null>
+
+  increment(key: string): Promise<number>
+
+  pexpire(key: string, ms: number): Promise<void>
+
+  pexpireAt(key: string, timestampInMs: number): Promise<void>
+
+  pttl(key: string): Promise<number>
+
+  rename(oldkey: string, newkey: string): Promise<void>
+
+  scan(params: { match: RedisStyleMatchString }): Promise<string[]>
+
+  set(key: string, value: string): Promise<void>
+
+  ttl(key: string): Promise<number>
+
+  type(key: string): Promise<ObjectType | null>
+}

types/database/zset.d.ts

@@ -0,0 +1,245 @@
+import {
+  NumberTowardsMaxima,
+  NumberTowardsMinima,
+  RedisStyleAggregate,
+  RedisStyleMatchString,
+  RedisStyleRangeString,
+  ValueAndScore,
+} from './index'
+
+export type SortedSetTheoryOperation = {
+  sets: string[]
+  sort?: 'ASC' | 'DESC'
+  start?: number
+  stop?: number
+  weights?: number[]
+  aggregate?: RedisStyleAggregate
+}
+
+export type SortedSetScanBaseParameters = {
+  key: string
+  match: RedisStyleMatchString
+  limit?: number
+}
+
+export interface SortedSet {
+  getSortedSetIntersect(
+    params: SortedSetTheoryOperation & { withScores: true },
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetIntersect(
+    params: SortedSetTheoryOperation & { withScores?: false },
+  ): Promise<string[]>
+
+  getSortedSetMembers(key: string): Promise<string[]>
+  
+  getSortedSetMembersWithScores(key: string): Promise<ValueAndScore[]>
+
+  getSortedSetRange(
+    key: string | string[],
+    start: number,
+    stop: number,
+  ): Promise<string[]>
+
+  getSortedSetRangeByLex(
+    key: string | string[],
+    min: RedisStyleRangeString | '-',
+    max: RedisStyleRangeString | '+',
+    start?: number,
+    count?: number,
+  ): Promise<string[]>
+
+  getSortedSetRangeByScore(
+    key: string | string[],
+    start: number,
+    count: number,
+    min: NumberTowardsMinima,
+    max: NumberTowardsMaxima,
+  ): Promise<string[]>
+
+  getSortedSetRangeByScoreWithScores(
+    key: string | string[],
+    start: number,
+    count: number,
+    min: NumberTowardsMinima,
+    max: NumberTowardsMaxima,
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetRangeWithScores(
+    key: string | string[],
+    start: number,
+    stop: number,
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetRevIntersect(
+    params: SortedSetTheoryOperation & { withScores: true },
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetRevIntersect(
+    params: SortedSetTheoryOperation & { withScores?: false },
+  ): Promise<string[]>
+
+  getSortedSetRevRange(
+    key: string | string[],
+    start: number,
+    stop: number,
+  ): Promise<string[]>
+
+  getSortedSetRevRangeByLex(
+    key: string,
+    max: RedisStyleRangeString | '+',
+    min: RedisStyleRangeString | '-',
+    start?: number,
+    count?: number,
+  ): Promise<string[]>
+
+  getSortedSetRevRangeByScore(
+    key: string,
+    start: number,
+    count: number,
+    max: NumberTowardsMaxima | '+',
+    min: NumberTowardsMinima | '-',
+  ): Promise<string[]>
+
+  getSortedSetRevRangeByScoreWithScores(
+    key: string,
+    start: number,
+    count: number,
+    max: NumberTowardsMaxima,
+    min: NumberTowardsMinima,
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetRevRangeWithScores(
+    key: string,
+    start: number,
+    stop: number,
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetRevUnion(
+    params: SortedSetTheoryOperation & { withScores?: false },
+  ): Promise<string[]>
+
+  getSortedSetRevUnion(
+    params: SortedSetTheoryOperation & { withScores: true },
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetScan(
+    params: SortedSetScanBaseParameters & { withScores: true },
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetScan(
+    params: SortedSetScanBaseParameters & { withScores?: false },
+  ): Promise<string[]>
+
+  getSortedSetUnion(
+    params: SortedSetTheoryOperation & { withScores: true },
+  ): Promise<ValueAndScore[]>
+
+  getSortedSetUnion(
+    params: SortedSetTheoryOperation & { withScores?: false },
+  ): Promise<string[]>
+
+  getSortedSetsMembers(keys: string[]): Promise<string[][]>
+
+  getSortedSetsMembersWithScores(keys: string[]): Promise<ValueAndScore[][]>
+
+  isMemberOfSortedSets(keys: string[], value: string): Promise<boolean[]>
+
+  isSortedSetMember(key: string, value: string): Promise<boolean>
+
+  isSortedSetMembers(key: string, values: string[]): Promise<boolean[]>
+
+  processSortedSet(
+    setKey: string,
+    processFn: (ids: number[]) => Promise<void> | void,
+    options: { withScores?: boolean; batch?: number; interval?: number, reverse?: boolean; },
+  ): Promise<any>
+
+  sortedSetAdd(key: string, score: number, value: string): Promise<void>
+
+  sortedSetAdd(key: string, score: number[], value: string[]): Promise<void>
+
+  sortedSetAddBulk(
+    args: [key: string, score: number[], value: string[]][],
+  ): Promise<void>
+
+  sortedSetCard(key: string): Promise<number>
+
+  sortedSetCount(
+    key: string,
+    min: NumberTowardsMinima,
+    max: NumberTowardsMaxima,
+  ): Promise<number>
+
+  sortedSetIncrBy(
+    key: string,
+    increment: number,
+    value: string,
+  ): Promise<number>
+
+  sortedSetIncrByBulk(
+    data: [key: string, increment: number, value: string][],
+  ): Promise<number[]>
+
+  sortedSetIntersectCard(keys: string[]): Promise<number>
+
+  sortedSetLexCount(
+    key: string,
+    min: RedisStyleRangeString,
+    max: RedisStyleRangeString,
+  ): Promise<number>
+
+  sortedSetRank(key: string, value: string): Promise<number | null>
+
+  sortedSetRanks(key: string, values: string[]): Promise<(number | null)[]>
+
+  sortedSetRemove(
+    key: string | string[],
+    value: string | string[],
+  ): Promise<void>
+
+  sortedSetRemoveBulk(data: [key: string, member: string][]): Promise<void>
+
+  sortedSetRemoveRangeByLex(
+    key: string,
+    min: RedisStyleRangeString | '-',
+    max: RedisStyleRangeString | '+',
+  ): Promise<void>
+
+  sortedSetRevRank(key: string, value: string): Promise<number>
+
+  sortedSetRevRanks(key: string, values: string[]): Promise<number[]>
+
+  sortedSetScore(key: string, value: string): Promise<number | null>
+
+  sortedSetScores(key: string, values: string[]): Promise<number[]>
+
+  sortedSetUnionCard(keys: string[]): Promise<number>
+
+  sortedSetsAdd(
+    keys: string[],
+    scores: number | number[],
+    value: string,
+  ): Promise<void>
+
+  sortedSetsCard(keys: string[]): Promise<number[]>
+
+  sortedSetsCardSum(keys: string[]): Promise<number>
+
+  sortedSetsRanks<T extends readonly [] | readonly string[]>(
+    keys: T,
+    values: { [K in keyof T]: string },
+  ): Promise<number[]>
+
+  sortedSetsRemove(keys: string[], value: string): Promise<void>
+
+  sortedSetsRemoveRangeByScore(
+    keys: string[],
+    min: NumberTowardsMinima,
+    max: NumberTowardsMaxima,
+  ): Promise<void>
+
+  sortedSetsRevRanks(keys: string[], values: string[]): Promise<number[]>
+
+  sortedSetsScore(keys: string[], value: string): Promise<number[]>
+}