bitwarden-estensione-browser/libs/common/src/services/search.service.ts

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

309 lines
10 KiB
TypeScript
Raw Normal View History

import * as lunr from "lunr";
import { CipherService } from "../abstractions/cipher.service";
import { I18nService } from "../abstractions/i18n.service";
import { LogService } from "../abstractions/log.service";
import { SearchService as SearchServiceAbstraction } from "../abstractions/search.service";
2018-09-12 16:22:46 +02:00
import { CipherType } from "../enums/cipherType";
import { FieldType } from "../enums/fieldType";
import { UriMatchType } from "../enums/uriMatchType";
2022-02-22 15:39:11 +01:00
import { CipherView } from "../models/view/cipherView";
2021-01-23 02:54:22 +01:00
import { SendView } from "../models/view/sendView";
2018-08-20 14:41:12 +02:00
export class SearchService implements SearchServiceAbstraction {
indexedEntityId?: string = null;
private indexing = false;
private index: lunr.Index = null;
private searchableMinLength = 2;
constructor(
private cipherService: CipherService,
private logService: LogService,
private i18nService: I18nService
) {
if (["zh-CN", "zh-TW"].indexOf(i18nService.locale) !== -1) {
this.searchableMinLength = 1;
}
//register lunr pipeline function
lunr.Pipeline.registerFunction(this.normalizeAccentsPipelineFunction, "normalizeAccents");
2021-12-16 13:36:21 +01:00
}
clearIndex(): void {
this.indexedEntityId = null;
this.index = null;
2021-12-16 13:36:21 +01:00
}
2018-08-13 17:52:55 +02:00
isSearchable(query: string): boolean {
query = SearchService.normalizeSearchQuery(query);
const notSearchable =
query == null ||
(this.index == null && query.length < this.searchableMinLength) ||
(this.index != null && query.length < this.searchableMinLength && query.indexOf(">") !== 0);
2018-08-13 17:52:55 +02:00
return !notSearchable;
}
async indexCiphers(indexedEntityId?: string, ciphers?: CipherView[]): Promise<void> {
if (this.indexing) {
2018-08-13 17:52:55 +02:00
return;
}
this.logService.time("search indexing");
this.indexing = true;
this.indexedEntityId = indexedEntityId;
this.index = null;
const builder = new lunr.Builder();
builder.pipeline.add(this.normalizeAccentsPipelineFunction);
builder.ref("id");
builder.field("shortid", { boost: 100, extractor: (c: CipherView) => c.id.substr(0, 8) });
builder.field("name", {
boost: 10,
});
2020-04-14 21:16:18 +02:00
builder.field("subtitle", {
2018-09-12 16:22:46 +02:00
boost: 5,
extractor: (c: CipherView) => {
if (c.subTitle != null && c.type === CipherType.Card) {
return c.subTitle.replace(/\*/g, "");
}
2018-09-12 16:22:46 +02:00
return c.subTitle;
2021-12-16 13:36:21 +01:00
},
});
builder.field("notes");
2020-04-14 21:16:18 +02:00
builder.field("login.username", {
extractor: (c: CipherView) =>
2019-01-25 15:30:21 +01:00
c.type === CipherType.Login && c.login != null ? c.login.username : null,
2021-12-16 13:36:21 +01:00
});
2020-04-14 21:16:18 +02:00
builder.field("login.uris", { boost: 2, extractor: (c: CipherView) => this.uriExtractor(c) });
builder.field("fields", { extractor: (c: CipherView) => this.fieldExtractor(c, false) });
builder.field("fields_joined", { extractor: (c: CipherView) => this.fieldExtractor(c, true) });
builder.field("attachments", {
extractor: (c: CipherView) => this.attachmentExtractor(c, false),
2021-12-16 13:36:21 +01:00
});
2020-04-14 21:16:18 +02:00
builder.field("attachments_joined", {
2018-08-13 22:00:21 +02:00
extractor: (c: CipherView) => this.attachmentExtractor(c, true),
2021-12-16 13:36:21 +01:00
});
2020-04-14 21:16:18 +02:00
builder.field("organizationid", { extractor: (c: CipherView) => c.organizationId });
ciphers = ciphers || (await this.cipherService.getAllDecrypted());
ciphers.forEach((c) => builder.add(c));
this.index = builder.build();
2020-04-14 21:16:18 +02:00
this.indexing = false;
this.logService.timeEnd("search indexing");
2021-12-16 13:36:21 +01:00
}
async searchCiphers(
query: string,
filter: ((cipher: CipherView) => boolean) | ((cipher: CipherView) => boolean)[] = null,
ciphers: CipherView[] = null
): Promise<CipherView[]> {
const results: CipherView[] = [];
if (query != null) {
query = SearchService.normalizeSearchQuery(query.trim().toLowerCase());
2021-12-16 13:36:21 +01:00
}
if (query === "") {
query = null;
}
if (ciphers == null) {
ciphers = await this.cipherService.getAllDecrypted();
}
if (filter != null && Array.isArray(filter) && filter.length > 0) {
ciphers = ciphers.filter((c) => filter.every((f) => f == null || f(c)));
} else if (filter != null) {
ciphers = ciphers.filter(filter as (cipher: CipherView) => boolean);
}
2018-08-13 17:52:55 +02:00
if (!this.isSearchable(query)) {
return ciphers;
}
2019-07-23 14:28:53 +02:00
if (this.indexing) {
await new Promise((r) => setTimeout(r, 250));
2019-07-23 14:28:53 +02:00
if (this.indexing) {
await new Promise((r) => setTimeout(r, 500));
2019-07-23 14:28:53 +02:00
}
}
const index = this.getIndexForSearch();
if (index == null) {
// Fall back to basic search if index is not available
2018-08-13 20:28:10 +02:00
return this.searchCiphersBasic(ciphers, query);
}
const ciphersMap = new Map<string, CipherView>();
ciphers.forEach((c) => ciphersMap.set(c.id, c));
let searchResults: lunr.Index.Result[] = null;
const isQueryString = query != null && query.length > 1 && query.indexOf(">") === 0;
if (isQueryString) {
try {
2018-08-17 17:07:50 +02:00
searchResults = index.search(query.substr(1).trim());
} catch (e) {
this.logService.error(e);
}
} else {
const soWild = lunr.Query.wildcard.LEADING | lunr.Query.wildcard.TRAILING;
searchResults = index.query((q) => {
lunr.tokenizer(query).forEach((token) => {
2019-01-28 17:06:28 +01:00
const t = token.toString();
q.term(t, { fields: ["name"], wildcard: soWild });
q.term(t, { fields: ["subtitle"], wildcard: soWild });
q.term(t, { fields: ["login.uris"], wildcard: soWild });
q.term(t, {});
});
});
}
if (searchResults != null) {
searchResults.forEach((r) => {
if (ciphersMap.has(r.ref)) {
results.push(ciphersMap.get(r.ref));
}
});
}
return results;
2021-12-16 13:36:21 +01:00
}
2018-08-13 20:28:10 +02:00
2022-02-22 15:39:11 +01:00
searchCiphersBasic(ciphers: CipherView[], query: string, deleted = false) {
query = SearchService.normalizeSearchQuery(query.trim().toLowerCase());
return ciphers.filter((c) => {
if (deleted !== c.isDeleted) {
return false;
}
2018-08-13 20:28:10 +02:00
if (c.name != null && c.name.toLowerCase().indexOf(query) > -1) {
return true;
}
if (query.length >= 8 && c.id.startsWith(query)) {
return true;
}
if (c.subTitle != null && c.subTitle.toLowerCase().indexOf(query) > -1) {
return true;
}
if (c.login && c.login.uri != null && c.login.uri.toLowerCase().indexOf(query) > -1) {
return true;
}
return false;
});
}
2018-08-13 22:00:21 +02:00
2021-01-23 02:54:22 +01:00
searchSends(sends: SendView[], query: string) {
query = SearchService.normalizeSearchQuery(query.trim().toLocaleLowerCase());
if (query === null) {
return sends;
}
const sendsMatched: SendView[] = [];
const lowPriorityMatched: SendView[] = [];
sends.forEach((s) => {
2021-01-23 02:54:22 +01:00
if (s.name != null && s.name.toLowerCase().indexOf(query) > -1) {
sendsMatched.push(s);
} else if (
query.length >= 8 &&
(s.id.startsWith(query) ||
s.accessId.toLocaleLowerCase().startsWith(query) ||
(s.file?.id != null && s.file.id.startsWith(query)))
) {
lowPriorityMatched.push(s);
} else if (s.notes != null && s.notes.toLowerCase().indexOf(query) > -1) {
lowPriorityMatched.push(s);
} else if (s.text?.text != null && s.text.text.toLowerCase().indexOf(query) > -1) {
lowPriorityMatched.push(s);
} else if (s.file?.fileName != null && s.file.fileName.toLowerCase().indexOf(query) > -1) {
lowPriorityMatched.push(s);
2021-01-23 02:54:22 +01:00
}
});
return sendsMatched.concat(lowPriorityMatched);
2021-01-23 02:54:22 +01:00
}
getIndexForSearch(): lunr.Index {
return this.index;
}
2018-08-13 22:00:21 +02:00
private fieldExtractor(c: CipherView, joined: boolean) {
if (!c.hasFields) {
return null;
}
let fields: string[] = [];
c.fields.forEach((f) => {
2018-08-13 22:00:21 +02:00
if (f.name != null) {
fields.push(f.name);
}
if (f.type === FieldType.Text && f.value != null) {
fields.push(f.value);
}
});
fields = fields.filter((f) => f.trim() !== "");
2018-08-13 22:00:21 +02:00
if (fields.length === 0) {
return null;
}
return joined ? fields.join(" ") : fields;
2021-12-16 13:36:21 +01:00
}
2018-08-13 22:00:21 +02:00
private attachmentExtractor(c: CipherView, joined: boolean) {
if (!c.hasAttachments) {
return null;
}
let attachments: string[] = [];
c.attachments.forEach((a) => {
2018-08-13 22:00:21 +02:00
if (a != null && a.fileName != null) {
if (joined && a.fileName.indexOf(".") > -1) {
attachments.push(a.fileName.substr(0, a.fileName.lastIndexOf(".")));
} else {
attachments.push(a.fileName);
}
2021-12-16 13:36:21 +01:00
}
});
2018-08-13 22:00:21 +02:00
attachments = attachments.filter((f) => f.trim() !== "");
if (attachments.length === 0) {
return null;
}
return joined ? attachments.join(" ") : attachments;
2021-12-16 13:36:21 +01:00
}
private uriExtractor(c: CipherView) {
if (c.type !== CipherType.Login || c.login == null || !c.login.hasUris) {
return null;
}
const uris: string[] = [];
c.login.uris.forEach((u) => {
2019-01-25 15:30:21 +01:00
if (u.uri == null || u.uri === "") {
2021-12-16 13:36:21 +01:00
return;
}
if (u.hostname != null) {
uris.push(u.hostname);
2021-12-16 13:36:21 +01:00
return;
}
let uri = u.uri;
if (u.match !== UriMatchType.RegularExpression) {
const protocolIndex = uri.indexOf("://");
if (protocolIndex > -1) {
uri = uri.substr(protocolIndex + 3);
2021-12-16 13:36:21 +01:00
}
const queryIndex = uri.search(/\?|&|#/);
if (queryIndex > -1) {
uri = uri.substring(0, queryIndex);
2021-12-16 13:36:21 +01:00
}
}
uris.push(uri);
2021-12-16 13:36:21 +01:00
});
return uris.length > 0 ? uris : null;
2021-12-16 13:36:21 +01:00
}
private normalizeAccentsPipelineFunction(token: lunr.Token): any {
const searchableFields = ["name", "login.username", "subtitle", "notes"];
const fields = (token as any).metadata["fields"];
const checkFields = fields.every((i: any) => searchableFields.includes(i));
if (checkFields) {
return SearchService.normalizeSearchQuery(token.toString());
}
return token;
}
// Remove accents/diacritics characters from text. This regex is equivalent to the Diacritic unicode property escape, i.e. it will match all diacritic characters.
static normalizeSearchQuery(query: string): string {
return query?.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
}
}