Merge tag '13.11.2' into merge-upstream

packages/backend/src/core/AntennaService.ts

@@ -95,7 +95,7 @@ export class AntennaService implements OnApplicationShutdown {
 		this.redisClient.xadd(
 			`antennaTimeline:${antenna.id}`,
 			'MAXLEN', '~', '200',
-			`${this.idService.parse(note.id).date.getTime()}-*`,
+			'*',
 			'note', note.id);
 		
 		this.globalEventService.publishAntennaStream(antenna.id, 'note', note);

packages/backend/src/core/CustomEmojiService.ts

@@ -43,12 +43,8 @@ export class CustomEmojiService {
 			lifetime: 1000 * 60 * 30, // 30m
 			memoryCacheLifetime: 1000 * 60 * 3, // 3m
 			fetcher: () => this.emojisRepository.find({ where: { host: IsNull() } }).then(emojis => new Map(emojis.map(emoji => [emoji.name, emoji]))),
-			toRedisConverter: (value) => JSON.stringify(value.values()),
-			fromRedisConverter: (value) => {
-				// 原因不明だが配列以外が入ってくることがあるため
-				if (!Array.isArray(JSON.parse(value))) return undefined;
-				return new Map(JSON.parse(value).map((x: Emoji) => [x.name, x]));
-			}, // TODO: Date型の変換
+			toRedisConverter: (value) => JSON.stringify(Array.from(value.values())),
+			fromRedisConverter: (value) => new Map(JSON.parse(value).map((x: Emoji) => [x.name, x])), // TODO: Date型の変換
 		});
 	}
 

packages/backend/src/core/NoteCreateService.ts

@@ -329,7 +329,7 @@ export class NoteCreateService implements OnApplicationShutdown {
 			this.redisClient.xadd(
 				`channelTimeline:${data.channel.id}`,
 				'MAXLEN', '~', '1000',
-				`${this.idService.parse(note.id).date.getTime()}-*`,
+				'*',
 				'note', note.id);
 		}
 

packages/backend/src/core/NotificationService.ts

@@ -66,6 +66,7 @@ export class NotificationService implements OnApplicationShutdown {
 	@bindThis
 	private postReadAllNotifications(userId: User['id']) {
 		this.globalEventService.publishMainStream(userId, 'readAllNotifications');
+		this.pushNotificationService.pushNotification(userId, 'readAllNotifications', undefined);
 	}
 
 	@bindThis
@@ -99,7 +100,7 @@ export class NotificationService implements OnApplicationShutdown {
 		const redisIdPromise = this.redisClient.xadd(
 			`notificationTimeline:${notifieeId}`,
 			'MAXLEN', '~', '300',
-			`${this.idService.parse(notification.id).date.getTime()}-*`,
+			'*',
 			'data', JSON.stringify(notification));
 
 		const packed = await this.notificationEntityService.pack(notification, notifieeId, {});

packages/backend/src/core/PushNotificationService.ts

@@ -1,12 +1,14 @@
 import { Inject, Injectable } from '@nestjs/common';
 import push from 'web-push';
+import Redis from 'ioredis';
 import { DI } from '@/di-symbols.js';
 import type { Config } from '@/config.js';
 import type { Packed } from '@/misc/json-schema';
 import { getNoteSummary } from '@/misc/get-note-summary.js';
-import type { SwSubscriptionsRepository } from '@/models/index.js';
+import type { SwSubscription, SwSubscriptionsRepository } from '@/models/index.js';
 import { MetaService } from '@/core/MetaService.js';
 import { bindThis } from '@/decorators.js';
+import { RedisKVCache } from '@/misc/cache.js';
 
 // Defined also packages/sw/types.ts#L13
 type PushNotificationsTypes = {
@@ -15,6 +17,7 @@ type PushNotificationsTypes = {
 		antenna: { id: string, name: string };
 		note: Packed<'Note'>;
 	};
+	'readAllNotifications': undefined;
 };
 
 // Reduce length because push message servers have character limits
@@ -40,15 +43,27 @@ function truncateBody<T extends keyof PushNotificationsTypes>(type: T, body: Pus
 
 @Injectable()
 export class PushNotificationService {
+	private subscriptionsCache: RedisKVCache<SwSubscription[]>;
+
 	constructor(
 		@Inject(DI.config)
 		private config: Config,
 
+		@Inject(DI.redis)
+		private redisClient: Redis.Redis,
+
 		@Inject(DI.swSubscriptionsRepository)
 		private swSubscriptionsRepository: SwSubscriptionsRepository,
 
 		private metaService: MetaService,
 	) {
+		this.subscriptionsCache = new RedisKVCache<SwSubscription[]>(this.redisClient, 'userSwSubscriptions', {
+			lifetime: 1000 * 60 * 60 * 1, // 1h
+			memoryCacheLifetime: 1000 * 60 * 3, // 3m
+			fetcher: (key) => this.swSubscriptionsRepository.findBy({ userId: key }),
+			toRedisConverter: (value) => JSON.stringify(value),
+			fromRedisConverter: (value) => JSON.parse(value),
+		});
 	}
 
 	@bindThis
@@ -62,12 +77,13 @@ export class PushNotificationService {
 			meta.swPublicKey,
 			meta.swPrivateKey);
 	
-		// Fetch
-		const subscriptions = await this.swSubscriptionsRepository.findBy({
-			userId: userId,
-		});
+		const subscriptions = await this.subscriptionsCache.fetch(userId);
 	
 		for (const subscription of subscriptions) {
+			if ([
+				'readAllNotifications',
+			].includes(type) && !subscription.sendReadMessage) continue;
+
 			const pushSubscription = {
 				endpoint: subscription.endpoint,
 				keys: {

packages/backend/src/misc/cache.ts

@@ -8,7 +8,7 @@ export class RedisKVCache<T> {
 	private memoryCache: MemoryKVCache<T>;
 	private fetcher: (key: string) => Promise<T>;
 	private toRedisConverter: (value: T) => string;
-	private fromRedisConverter: (value: string) => T | undefined; // undefined means no cache
+	private fromRedisConverter: (value: string) => T;
 
 	constructor(redisClient: RedisKVCache<T>['redisClient'], name: RedisKVCache<T>['name'], opts: {
 		lifetime: RedisKVCache<T>['lifetime'];
@@ -92,7 +92,7 @@ export class RedisSingleCache<T> {
 	private memoryCache: MemorySingleCache<T>;
 	private fetcher: () => Promise<T>;
 	private toRedisConverter: (value: T) => string;
-	private fromRedisConverter: (value: string) => T | undefined; // undefined means no cache
+	private fromRedisConverter: (value: string) => T;
 
 	constructor(redisClient: RedisSingleCache<T>['redisClient'], name: RedisSingleCache<T>['name'], opts: {
 		lifetime: RedisSingleCache<T>['lifetime'];

packages/backend/src/server/api/ApiServerService.ts

@@ -89,7 +89,7 @@ export class ApiServerService {
 					Params: { endpoint: string; },
 					Body: Record<string, unknown>,
 					Querystring: Record<string, unknown>,
-				}>('/' + endpoint.name, { bodyLimit: 1024 * 32 }, async (request, reply) => {
+				}>('/' + endpoint.name, { bodyLimit: 1024 * 1024 }, async (request, reply) => {
 					if (request.method === 'GET' && !endpoint.meta.allowGet) {
 						reply.code(405);
 						reply.send();

packages/backend/src/server/api/EndpointsModule.ts

@@ -98,6 +98,7 @@ import * as ep___channels_update from './endpoints/channels/update.js';
 import * as ep___channels_favorite from './endpoints/channels/favorite.js';
 import * as ep___channels_unfavorite from './endpoints/channels/unfavorite.js';
 import * as ep___channels_myFavorites from './endpoints/channels/my-favorites.js';
+import * as ep___channels_search from './endpoints/channels/search.js';
 import * as ep___charts_activeUsers from './endpoints/charts/active-users.js';
 import * as ep___charts_apRequest from './endpoints/charts/ap-request.js';
 import * as ep___charts_drive from './endpoints/charts/drive.js';
@@ -431,6 +432,7 @@ const $channels_update: Provider = { provide: 'ep:channels/update', useClass: ep
 const $channels_favorite: Provider = { provide: 'ep:channels/favorite', useClass: ep___channels_favorite.default };
 const $channels_unfavorite: Provider = { provide: 'ep:channels/unfavorite', useClass: ep___channels_unfavorite.default };
 const $channels_myFavorites: Provider = { provide: 'ep:channels/my-favorites', useClass: ep___channels_myFavorites.default };
+const $channels_search: Provider = { provide: 'ep:channels/search', useClass: ep___channels_search.default };
 const $charts_activeUsers: Provider = { provide: 'ep:charts/active-users', useClass: ep___charts_activeUsers.default };
 const $charts_apRequest: Provider = { provide: 'ep:charts/ap-request', useClass: ep___charts_apRequest.default };
 const $charts_drive: Provider = { provide: 'ep:charts/drive', useClass: ep___charts_drive.default };
@@ -768,6 +770,7 @@ const $retention: Provider = { provide: 'ep:retention', useClass: ep___retention
 		$channels_favorite,
 		$channels_unfavorite,
 		$channels_myFavorites,
+		$channels_search,
 		$charts_activeUsers,
 		$charts_apRequest,
 		$charts_drive,
@@ -1099,6 +1102,7 @@ const $retention: Provider = { provide: 'ep:retention', useClass: ep___retention
 		$channels_favorite,
 		$channels_unfavorite,
 		$channels_myFavorites,
+		$channels_search,
 		$charts_activeUsers,
 		$charts_apRequest,
 		$charts_drive,

packages/backend/src/server/api/endpoints.ts

@@ -98,6 +98,7 @@ import * as ep___channels_update from './endpoints/channels/update.js';
 import * as ep___channels_favorite from './endpoints/channels/favorite.js';
 import * as ep___channels_unfavorite from './endpoints/channels/unfavorite.js';
 import * as ep___channels_myFavorites from './endpoints/channels/my-favorites.js';
+import * as ep___channels_search from './endpoints/channels/search.js';
 import * as ep___charts_activeUsers from './endpoints/charts/active-users.js';
 import * as ep___charts_apRequest from './endpoints/charts/ap-request.js';
 import * as ep___charts_drive from './endpoints/charts/drive.js';
@@ -429,6 +430,7 @@ const eps = [
 	['channels/favorite', ep___channels_favorite],
 	['channels/unfavorite', ep___channels_unfavorite],
 	['channels/my-favorites', ep___channels_myFavorites],
+	['channels/search', ep___channels_search],
 	['charts/active-users', ep___charts_activeUsers],
 	['charts/ap-request', ep___charts_apRequest],
 	['charts/drive', ep___charts_drive],

packages/backend/src/server/api/endpoints/channels/search.ts

@@ -0,0 +1,67 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Brackets } from 'typeorm';
+import { Endpoint } from '@/server/api/endpoint-base.js';
+import { QueryService } from '@/core/QueryService.js';
+import type { ChannelsRepository } from '@/models/index.js';
+import { ChannelEntityService } from '@/core/entities/ChannelEntityService.js';
+import { DI } from '@/di-symbols.js';
+import { sqlLikeEscape } from '@/misc/sql-like-escape.js';
+
+export const meta = {
+	tags: ['channels'],
+
+	requireCredential: false,
+
+	res: {
+		type: 'array',
+		optional: false, nullable: false,
+		items: {
+			type: 'object',
+			optional: false, nullable: false,
+			ref: 'Channel',
+		},
+	},
+} as const;
+
+export const paramDef = {
+	type: 'object',
+	properties: {
+		query: { type: 'string' },
+		type: { type: 'string', enum: ['nameAndDescription', 'nameOnly'], default: 'nameAndDescription' },
+		sinceId: { type: 'string', format: 'misskey:id' },
+		untilId: { type: 'string', format: 'misskey:id' },
+		limit: { type: 'integer', minimum: 1, maximum: 100, default: 5 },
+	},
+	required: ['query'],
+} as const;
+
+// eslint-disable-next-line import/no-default-export
+@Injectable()
+export default class extends Endpoint<typeof meta, typeof paramDef> {
+	constructor(
+		@Inject(DI.channelsRepository)
+		private channelsRepository: ChannelsRepository,
+
+		private channelEntityService: ChannelEntityService,
+		private queryService: QueryService,
+	) {
+		super(meta, paramDef, async (ps, me) => {
+			const query = this.queryService.makePaginationQuery(this.channelsRepository.createQueryBuilder('channel'), ps.sinceId, ps.untilId);
+
+			if (ps.type === 'nameAndDescription') {
+				query.andWhere(new Brackets(qb => { qb
+					.where('channel.name ILIKE :q', { q: `%${ sqlLikeEscape(ps.query) }%` })
+					.orWhere('channel.description ILIKE :q', { q: `%${ sqlLikeEscape(ps.query) }%` });
+				}));
+			} else {
+				query.andWhere('channel.name ILIKE :q', { q: `%${ sqlLikeEscape(ps.query) }%` });
+			}
+
+			const channels = await query
+				.take(ps.limit)
+				.getMany();
+
+			return await Promise.all(channels.map(x => this.channelEntityService.pack(x, me)));
+		});
+	}
+}

packages/backend/src/server/api/stream/channels/local-timeline.ts

@@ -54,10 +54,10 @@ class LocalTimelineChannel extends Channel {
 		}
 
 		// 関係ない返信は除外
-		if (note.reply && !this.user!.showTimelineReplies) {
+		if (note.reply && this.user && !this.user.showTimelineReplies) {
 			const reply = note.reply;
 			// 「チャンネル接続主への返信」でもなければ、「チャンネル接続主が行った返信」でもなければ、「投稿者の投稿者自身への返信」でもない場合
-			if (reply.userId !== this.user!.id && note.userId !== this.user!.id && reply.userId !== note.userId) return;
+			if (reply.userId !== this.user.id && note.userId !== this.user.id && reply.userId !== note.userId) return;
 		}
 
 		// 流れてきたNoteがミュートしているユーザーが関わるものだったら無視する