export async function scan()

in ide/deploy/scan.js [39:170]
107 lines of code
21 McCabe index (conditional complexity)

export async function scan() {
    const deployments = new Set();
    const packages = new Set();

    console.log("> Scan:");

    // => REQUIREMENTS
    const defaultReqsGlobs = [
        "packages/*/*/requirements.txt",
        "packages/*/*/package.json",
        "packages/*/*/composer.json",
        "packages/*/*/go.mod"
    ];
    // load user defined requirements or use `defaultReqsGlobs`
    const packageGlobs = getOpenServerlessConfig("requirements", defaultReqsGlobs);
    // requirements
    const reqs = [];

    // Check for additional packages from each package
    // and add them to the requirements array
    for (const pkgGlob of packageGlobs) {
        const items = await glob(pkgGlob);
        for (const item of items) {
            if (!reqs.includes(item)) {
                reqs.push(item);
            }
        }
    }

    // let's package the functions that have requirements
    for (const req of reqs) {
        console.log(">> Requirements:", req);
        const sp = req.split("/");
        const act = buildZip(sp[1], sp[2]);
        deployments.add(act);
        packages.add(sp[1]);
    }

    // => MAINS
    const defaultMainsGlobs = [
        "packages/*/*/index.js",
        "packages/*/*/__main__.py",
        "packages/*/*/index.php",
        "packages/*/*/main.go"
    ];
    // load user defined main functions or use `defaultMainsGlobs`
    const mainsGlobs = getOpenServerlessConfig("mains", defaultMainsGlobs);
    const mains = [];

    for (const mainGlob of mainsGlobs) {
        const items = await glob(mainGlob);
        for (const item of items) {
            if (!mains.includes(item)) {
                mains.push(item);
            }
        }
    }

    for (const main of mains) {
        console.log(">> Main:", main);
        const sp = main.split("/");
        const act = buildAction(sp[1], sp[2]);
        deployments.add(act);
        packages.add(sp[1]);
    }

    // => SINGLES
    const defaultSinglesGlobs = [
        "packages/*/*.py",
        "packages/*/*.js",
        "packages/*/*.php",
        "packages/*/*.go"
    ];
    const singlesGlobs = getOpenServerlessConfig("singles", defaultSinglesGlobs);
    const singles = [];

    for (const singleGlob of singlesGlobs) {
        const items = await glob(singleGlob);
        for (const item of items) {
            if (!singles.includes(item)) {
                singles.push(item);
            }
        }
    }

    for (const single of singles) {
        console.log(">> Action:", single);
        const sp = single.split("/");
        deployments.add(single);
        packages.add(sp[1]);
    }

    console.log("> Deploying:");
    for (const pkg of packages) {
        console.log(">> Package:", pkg);
        deployPackage(pkg);
    }

    for (const action of deployments) {
        console.log(">>> Action:", action);
        deployAction(action);
    }


    // => MANIFESTS
    const defaultProjectGlobs = [
        "packages/*.yaml",
        "packages/*/*.yaml",
    ];
    const manifestsGlobs = getOpenServerlessConfig("manifests", defaultProjectGlobs);
    const manifests = [];

    for (const manifestGlobs of manifestsGlobs) {
        const items = await glob(manifestGlobs);
        for (const item of items) {
            if (!manifests.includes(item)) {
                manifests.push(item);
            }
        }
        manifests.sort((a, b) => a.localeCompare(b));
    }
    if (manifests.length >0 ) {
        if (Bun.file('packeges/.env')) {
            console.log("Found packages .env file. Reading it");
            config({ path: "./package/.env" });
        }
        for (const manifest of manifests) {
            console.log(">>> Manifest:", manifest);
            deployProject(manifest);
        }
    }
}