export async function findTreeItem()

in src/commands/api/findTreeItem.ts [25:88]


export async function findTreeItem(query: TreeItemQuery): Promise<DatabaseAccountTreeItem | DatabaseTreeItem | undefined> {
    return await callWithTelemetryAndErrorHandling('api.findTreeItem', async (context: IActionContext) => {
        context.errorHandling.suppressDisplay = true;
        context.errorHandling.rethrow = true;

        let parsedCS: ParsedConnectionString;
        if (query.postgresData) {
            const postgresData = query.postgresData;
            const connectionString: string = createPostgresConnectionString(postgresData.hostName, postgresData.port, postgresData.username, postgresData.password, postgresData.databaseName);
            parsedCS = parsePostgresConnectionString(connectionString);
        } else {
            const connectionString = nonNullProp(query, 'connectionString');
            if (/^mongodb[^:]*:\/\//i.test(connectionString)) {
                parsedCS = await parseMongoConnectionString(connectionString);
            } else if (/^postgres:\/\//i.test(connectionString)) {
                parsedCS = parsePostgresConnectionString(connectionString);
            } else {
                parsedCS = parseDocDBConnectionString(connectionString);
            }
        }

        const maxTime = Date.now() + 10 * 1000; // Give up searching subscriptions after 10 seconds and just attach the account

        // 1. Get result from cache if possible
        let result: DatabaseAccountTreeItem | DatabaseTreeItem | undefined = tryGetTreeItemFromCache(parsedCS);

        // 2. Search attached accounts (do this before subscriptions because it's faster)
        if (!result) {
            const attachedDbAccounts = await ext.attachedAccountsNode.getCachedChildren(context);
            result = await searchDbAccounts(attachedDbAccounts, parsedCS, context, maxTime);
        }

        // 3. Search subscriptions
        if (!result) {
            const rootNodes = await ext.tree.getChildren();
            for (const rootNode of rootNodes) {
                if (Date.now() > maxTime) {
                    break;
                }

                if (rootNode instanceof SubscriptionTreeItem) {
                    const dbAccounts = await rootNode.getCachedChildren(context);
                    result = await searchDbAccounts(dbAccounts, parsedCS, context, maxTime);
                    if (result) {
                        break;
                    }
                }
            }
        }

        // 4. If all else fails, just attach a new node
        if (!result) {
            if (parsedCS.databaseName) {
                result = new DatabaseTreeItemInternal(parsedCS, parsedCS.databaseName);
            } else {
                result = new DatabaseAccountTreeItemInternal(parsedCS);
            }
        }

        cacheTreeItem(parsedCS, result);

        return result;
    });
}