Misskey の一元化された Note 取得フローと重複防止メカニズム#

const unlock = await acquireApObjectLock(this.redisForTimelines, uri);

// このサーバーに既に登録されていたらそれを返す
const exist = await this.fetchNote(uri);
if (exist) return exist;

} catch (e) {
    // duplicate key error
    if (isDuplicateKeyValueError(e)) {
        const err = new Error('Duplicated note');
        err.name = 'duplicated';
        throw err;
    }

} catch (err: any) {
    if (err.name !== 'duplicated') {
        throw err;
    }
    this.logger.info('The note is already inserted while creating itself, reading again');
    const duplicate = await this.fetchNote(value);
    if (!duplicate) {
        throw new Error(`The note creation failed with duplication error even when there is no duplication: ${entryUri}`);
    }
    return duplicate;
}

const pendingNoteFetches = new Map<string, Promise<void>>();

const scheduleMinimizedNoteRetry = (data: { id: string }) => {
    if (pendingNoteFetches.has(data.id)) return; // 重複をガード

    const retryPromise = retryWithFibonacciBackoff(() => fetchNoteJson(data.id), {
        maxAttempts: 3,
        initialDelayMs: 100,
    }).finally(() => {
        pendingNoteFetches.delete(data.id);
    });

    pendingNoteFetches.set(data.id, retryPromise);
};

export async function retryWithFibonacciBackoff<T>(
    task: () => Promise<T>,
    options: RetryOptions,
): Promise<T> {
    let nextDelayMultiplier = 1;
    let followingDelayMultiplier = 2;

    for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
        try {
            return await task();
        } catch (error) {
            if (attempt >= options.maxAttempts) {
                throw error;
            }

            const delay = nextDelayMultiplier * options.initialDelayMs;
            await sleep(delay);
            [nextDelayMultiplier, followingDelayMultiplier] = [
                followingDelayMultiplier,
                nextDelayMultiplier + followingDelayMultiplier,
            ];
        }
    }

    throw new Error('Retry attempts exhausted.');
}

export function misskeyApi<...>(endpoint, data, token?, signal?): Promise<_ResT> {
    pendingApiRequestsCount.value++;

    const promise = new Promise<_ResT>((resolve, reject) => {
        window.fetch(`${apiUrl}/${endpoint}`, {
            method: 'POST',
            body: JSON.stringify(data),
            credentials: 'include',
            signal,
        }).then(handleResponse(resolve, reject)).catch(reject);
    });

    return promise;
}

const observer = new IntersectionObserver((entries) => {
    if (entries.some((entry) => entry.isIntersecting)) {
        showing.value = true;
    }
});

.root {
    content-visibility: auto;
    contain-intrinsic-size: none auto 128px;
}

<MkLoading v-if="fetching"/>
<MkError v-else-if="error" @retry="init()"/>
<div v-else-if="empty"><!-- empty state --></div>
<div v-else>
    <slot :items="items" :fetching="fetching || moreFetching"></slot>
    <MkButton v-if="!moreFetching" @click="fetchMore">Load More</MkButton>
</div>

const queue = ref<MisskeyEntity[]>([]);

function prepend(item: MisskeyEntity): void {
    if (isHead() && !isPausingUpdate) unshiftItems([item]);
    else prependQueue(item);
}

function executeQueue() {
    if (queue.value.length === 0) return;
    unshiftItems(queue.value);
    queue.value = [];
}

watch(visibility, () => {
    if (visibility.value === 'hidden') {
        timerForSetPause = window.setTimeout(() => {
            isPausingUpdate = true;
        }, BACKGROUND_PAUSE_WAIT_SEC * 1000);
    }
});

async function loadUnloadedNotes() {
    const items = [...notVisibleNoteData];
    notVisibleNoteData.length = 0;

    const notes = await Promise.allSettled(items.map(fulfillNoteData));
    const fulfilledNotes = notes
        .filter((i): i is PromiseFulfilledResult<object> => 
            i.status === 'fulfilled' && i.value != null)
        .map(i => i.value);
}

public publishNoteStream(note: MiNote, type: K, value?: NoteEventTypes[K]): void {
    this.publish(`noteStream:${note.id}`, type, {
        id: note.id,
        userId: note.userId,
        visibility: note.visibility,
        visibleUserIds: note.visibleUserIds,
        mentions: note.mentions,
        replyUserId: note.replyUserId,
        body: value,
    });
}

public async shouldHideNote(packedNote: Packed<'Note'>, meId: MiUser['id'] | null): Promise<boolean> {
    if (meId === packedNote.userId) return false;

    if (this.isSigninOrTimeHidden(packedNote, meId)) {
        return true;
    }

    if (packedNote.visibility === 'specified' && !this.isSpecifiedVisibleTo(packedNote, meId)) {
        return true;
    }

    if (packedNote.visibility === 'followers' && !(await this.isFollowerVisibleTo(packedNote, meId))) {
        return true;
    }

    return false;
}

public hideNote(packedNote: Packed<'Note'>): void {
    packedNote.visibleUserIds = undefined;
    packedNote.fileIds = [];
    packedNote.files = [];
    packedNote.text = null;
    packedNote.poll = undefined;
    packedNote.cw = null;
    packedNote.isHidden = true;
}

const followings = await this.cacheService.userFollowingsCache.fetch(meId);
if (Object.hasOwn(followings, packedNote.userId)) {
    return true;
}

replyUserId: note.reply?.userId ?? note.replyUserId,

type HiddenLayer = 'note' | 'renote' | 'renoteRenote';

public async shouldHide(
    note: Packed<'Note'>,
    meId: MiUser['id'] | null,
): Promise<LockdownCheckResult>

public applyHiding(
    note: Packed<'Note'>,
    hiddenLayers: Set<HiddenLayer>,
): void {
    if (hiddenLayers.has('note')) {
        this.noteEntityService.hideNote(note);
    }
    if (hiddenLayers.has('renote') && note.renote) {
        this.noteEntityService.hideNote(note.renote);
    }
    if (hiddenLayers.has('renoteRenote') && note.renote && note.renote.renote) {
        this.noteEntityService.hideNote(note.renote.renote);
    }
}

public async processHiding(
    note: Packed<'Note'>,
    meId: MiUser['id'] | null,
): Promise<{ shouldSkip: boolean }> {
    const result = await this.shouldHide(note, meId);
    if (result.shouldSkip) {
        return { shouldSkip: true };
    }
    this.applyHiding(note, result.hiddenLayers);
    return { shouldSkip: false };
}

public abstract init(params: JsonObject): Awaitable<void | boolean>;

public async connectChannel(id: string, params: JsonObject | undefined, channel: string, pong = false) {
    // ...
    const valid = await ch.init(params ?? {});
    if (typeof valid === 'boolean' && !valid) {
        // 初期化処理の結果、接続拒否されたので切断
        this.disconnectChannel(id);
        return;
    }
    // ...
}

private async onNoteStreamMessage(data: GlobalEvents['note']['payload']) {
    // 自分自身ではないかつ
    if (data.body.userId !== this.user?.id) {
        // 公開範囲が指名で自分が含まれてない
        if (data.body.visibility === 'specified' && 
            (this.user == null || (!data.body.visibleUserIds.includes(this.user.id) && 
            !(data.body.mentions?.includes(this.user.id) ?? false)))) {
            return;
        }

        // 公開範囲がフォロワーで自分がフォロワーでない
        if (data.body.visibility === 'followers' && 
            (this.user == null || (!Object.hasOwn(this.following, data.body.userId) && 
            data.body.replyUserId !== this.user.id && 
            !(data.body.mentions?.includes(this.user.id) ?? false)))) {
            return;
        }
    }
    // ...
}

private channels: Map<string, Channel> = new Map();

const { shouldSkip } = await this.noteStreamingHidingService.processHiding(note, user.id);
if (shouldSkip) return;

protected isNoteVisibleForMe(note: Packed<'Note'>): boolean {
    const meId = this.connection.user?.id ?? null;

    if (note.visibility === 'specified') {
        if (meId == null) {
            return false;
        } else if (meId === note.userId) {
            return true;
        } else {
            return (note.visibleUserIds?.some(id => meId === id) ?? false)
                || (note.mentions?.some(id => meId === id) ?? false);
        }
    }

    if (note.visibility === 'followers') {
        if (meId == null) {
            return false;
        } else if (meId === note.userId) {
            return true;
        } else if (note.reply && (meId === note.reply.userId)) {
            return true;
        } else if (note.mentions && note.mentions.some(id => meId === id)) {
            return true;
        } else {
            return Object.hasOwn(this.following, note.userId);
        }
    }

    return true;
}