async getChildren()

in src/entityExplorer.ts [53:125]
72 lines of code
10 McCabe index (conditional complexity)

    async getChildren(element?: WskEntity): Promise<WskEntity[]> {
        const listOptions = { limit: 0 };
        const compareName = (a: openwhisk.Desc, b: openwhisk.Desc) =>
            a.name?.localeCompare(b.name as string) as number;

        if (element) {
            if (element instanceof WskEndpoint) {
                const namespaces = this.storageManager.getNamespaces(element.apihost);
                if (namespaces) {
                    return Promise.resolve(
                        namespaces.map(
                            (ns) =>
                                new WskNamespace(
                                    ns.name,
                                    openwhisk({ apihost: element.apihost, api_key: ns.api_key }),
                                    element
                                )
                        )
                    );
                }
            } else if (element instanceof WskNamespace) {
                const packages = element.client.packages
                    .list(listOptions)
                    .then((ps) =>
                        ps.sort(compareName).map((p) => createWskPackage(p, element.client))
                    );
                const triggers = element.client.triggers
                    .list(listOptions)
                    .then((ts) =>
                        ts.sort(compareName).map((t) => createWskTrigger(t, element.client))
                    );
                const actions = element.client.actions.list(listOptions).then((as) =>
                    as
                        .filter((a) => !a.namespace?.includes('/'))
                        .sort(compareName)
                        .map((a) => createWskAction(a, element.client))
                );
                return Promise.all<WskEntity[], WskEntity[], WskEntity[]>([
                    packages,
                    actions,
                    triggers,
                ]).then((arrs) => Promise.resolve<WskEntity[]>(arrs[0].concat(...arrs.slice(1))));
            } else if (element instanceof WskPackage) {
                if (element.packageDesc.name) {
                    const actionsInPackage = (
                        await element.client.packages.get(element.packageDesc.name)
                    ).actions;
                    if (actionsInPackage) {
                        return Promise.resolve(
                            actionsInPackage.map((a) =>
                                createWskAction(a, element.client, element.packageDesc)
                            )
                        );
                    }
                }
            }
        } else {
            try {
                await updateStatesByLocalWskPropFile(this.storageManager);
            } catch (e) {
                vscode.window.showErrorMessage(`Failed to load .wskprops (${e.message})`);
            }
            const endpoints = this.storageManager.getEndpoints();
            if (endpoints) {
                return Promise.resolve(
                    Object.entries(endpoints).map(
                        ([host, value]) => new WskEndpoint(value.alias, host)
                    )
                );
            }
        }
        return [];
    }