@nu-art/build-and-install 0.203.117

package/phases/phases.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Phase_DeployBackend = exports.Phase_DeployFrontend = exports.Phase_Launch = exports.Phase_CompileWatch = exports.Phase_Compile = exports.Phase_Debug = exports.Phase_Lint = exports.Phase_Clean = exports.Phase_InstallPackages = exports.Phase_InstallPnpm = exports.Phase_InstallGlobals = exports.Phase_PackagePurge = exports.Phase_PrintEnv = exports.Phase_CheckCyclicImports = exports.Phase_PrintDependencyTree = exports.Phase_InstallNvm = exports.Phase_ResolvePackages = exports.Phase_ResolveEnv = exports.Phase_ResolveTemplate = exports.Phase_SetupProject = exports.Phase_SetWithThunderstorm = exports.Phase_PrintHelp = exports.projectPackages = void 0;
+const ProjectManager_1 = require("../logic/ProjectManager");
+const map_project_packages_1 = require("../logic/map-project-packages");
+const fs = require("fs");
+const fs_1 = require("fs");
+const consts_1 = require("../core/consts");
+const tools_1 = require("@nu-art/commando/core/tools");
+const ts_common_1 = require("@nu-art/ts-common");
+const types_1 = require("../core/types");
+const generate_1 = require("../core/package/generate");
+const consts_2 = require("../core/package/consts");
+const nvm_1 = require("@nu-art/commando/cli/nvm");
+const params_1 = require("../core/params/params");
+const basic_1 = require("@nu-art/commando/cli/basic");
+const pnpm_1 = require("@nu-art/commando/cli/pnpm");
+const chokidar = require("chokidar");
+const pathToConfig = (0, tools_1.convertToFullPath)('./.config/project-config.ts');
+if (!fs.existsSync(pathToConfig))
+    throw new ts_common_1.ImplementationMissingException(`Missing ./.config/project-config.ts file, could not find in path: ${pathToConfig}`);
+const projectConfig = require(pathToConfig).default;
+const CONST_ThunderstormVersionKey = 'THUNDERSTORM_SDK_VERSION';
+const CONST_ThunderstormDependencyKey = 'THUNDERSTORM_SDK_VERSION_DEPENDENCY';
+const CONST_ProjectVersionKey = 'APP_VERSION';
+const CONST_ProjectDependencyKey = 'APP_VERSION_DEPENDENCY';
+const CONST_TS_Config = `tsconfig.json`;
+const CONST_RunningRoot = process.cwd();
+const pathToProjectTS_Config = (0, tools_1.convertToFullPath)(`./.config/${CONST_TS_Config}`);
+const pathToProjectEslint = (0, tools_1.convertToFullPath)('./.config/.eslintrc.js');
+exports.projectPackages = (0, map_project_packages_1.mapProjectPackages)(projectConfig);
+const runInDebug = false;
+let runningWithInfra = false;
+exports.Phase_PrintHelp = {
+    type: 'project',
+    name: 'printHelp',
+    terminatingPhase: true,
+    filter: async () => params_1.RuntimeParams.help,
+    action: async () => {
+        const commando = nvm_1.NVM.createCommando(basic_1.Cli_Basic);
+        commando.append('echo "Build and install parameters:"');
+        //Resolve all params by group
+        const paramsByGroup = (0, ts_common_1.reduceToMap)(params_1.AllBaiParams, param => { var _a; return (_a = param.group) !== null && _a !== void 0 ? _a : 'No Group'; }, (item, index, mapper) => {
+            var _a, _b, _c, _d;
+            mapper[(_a = item.group) !== null && _a !== void 0 ? _a : 'No Group'] = [...(_c = mapper[(_b = item.group) !== null && _b !== void 0 ? _b : 'No Group']) !== null && _c !== void 0 ? _c : [], item];
+            return mapper[(_d = item.group) !== null && _d !== void 0 ? _d : 'No Group'];
+        });
+        (0, ts_common_1._keys)(paramsByGroup).map(paramGroup => {
+            commando.append(`echo "${paramGroup}:" \n`);
+            paramsByGroup[paramGroup].map(param => {
+                commando.append(`echo "\n	${param.keys.join(' | ')} \n \t\t${param.description.trim().split('\n').join('\n\t\t')} \n"`);
+            });
+        });
+        return commando.execute();
+    }
+};
+exports.Phase_SetWithThunderstorm = {
+    type: 'project',
+    name: 'with-ts-home',
+    action: async () => {
+        var _a;
+        // set value of the running with infra flag
+        if (params_1.RuntimeParams.thunderstormHome)
+            return runningWithInfra = true;
+        // Remove all the infra packages from the runtime project
+        exports.projectPackages.packagesDependency = (_a = exports.projectPackages.packagesDependency) === null || _a === void 0 ? void 0 : _a.map(_packageArray => _packageArray.filter(_package => _package.type !== types_1.PackageType_InfraLib));
+        return runningWithInfra = false;
+    }
+};
+exports.Phase_SetupProject = {
+    type: 'project',
+    name: 'setup-project',
+    action: async () => {
+        const thunderstormVersionJson = require((0, tools_1.convertToFullPath)('./version-thunderstorm.json'));
+        exports.projectPackages.params[CONST_ThunderstormVersionKey] = thunderstormVersionJson.version;
+        exports.projectPackages.params[CONST_ThunderstormDependencyKey] = thunderstormVersionJson.version;
+        const projectVersionJson = require((0, tools_1.convertToFullPath)('./version-app.json'));
+        exports.projectPackages.params[CONST_ProjectVersionKey] = projectVersionJson.version;
+        exports.projectPackages.params[CONST_ProjectDependencyKey] = projectVersionJson.version;
+    }
+};
+exports.Phase_ResolveTemplate = {
+    type: 'package',
+    name: 'resolve-template',
+    mandatoryPhases: [exports.Phase_SetupProject, exports.Phase_SetWithThunderstorm],
+    action: async (pkg) => {
+        // with workspace: *
+        pkg.packageJsonWorkspace = (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(pkg.packageJsonTemplate, (value, key) => {
+            const toRet = projectConfig.params[key] ? 'workspace:*' : projectConfig.params[value];
+            return toRet;
+        });
+        // placed package name to version
+        projectConfig.params[pkg.packageJsonWorkspace.name] = pkg.packageJsonWorkspace.version;
+        projectConfig.params[`${pkg.packageJsonWorkspace.name}_path`] = `file:.dependencies/${pkg.name}`;
+        // with versions for all packages, for be output: file:.dependencies/${pkg.name}
+        pkg.packageJsonOutput = (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(pkg.packageJsonTemplate, (value, key) => {
+            var _a;
+            const toRet = (_a = projectConfig.params[key]) !== null && _a !== void 0 ? _a : projectConfig.params[value];
+            return toRet;
+        });
+        pkg.packageJsonRuntime = (0, map_project_packages_1.convertPackageJSONTemplateToPackJSON_Value)(pkg.packageJsonTemplate, (value, key) => {
+            var _a, _b;
+            const toRet = (_b = (_a = projectConfig.params[`${key}_path`]) !== null && _a !== void 0 ? _a : projectConfig.params[key]) !== null && _b !== void 0 ? _b : projectConfig.params[value];
+            return toRet;
+        });
+        // write final package.json to package root folder
+        await fs_1.promises.writeFile(`${pkg.path}/${consts_1.CONST_PackageJSON}`, JSON.stringify(pkg.packageJsonWorkspace, null, 2), { encoding: 'utf-8' });
+        // write final package.json to package output folder
+        if (pkg.type === 'sourceless')
+            return;
+        if (!fs.existsSync(pkg.output))
+            await fs_1.promises.mkdir(pkg.output);
+    }
+};
+exports.Phase_ResolveEnv = {
+    type: 'package',
+    name: 'resolve-env',
+    mandatoryPhases: [exports.Phase_ResolveTemplate, exports.Phase_SetupProject, exports.Phase_SetWithThunderstorm],
+    filter: async (pkg) => pkg.type === 'firebase-functions-app' || pkg.type === 'firebase-hosting-app',
+    action: async (pkg) => {
+        var _a, _b;
+        const firebasePkg = pkg;
+        await fs_1.promises.writeFile(`${firebasePkg.path}/${consts_1.CONST_FirebaseRC}`, JSON.stringify((0, generate_1.createFirebaseRC)(firebasePkg, params_1.RuntimeParams.setEnv), null, 2), { encoding: 'utf-8' });
+        let fileContent;
+        if (pkg.type === 'firebase-hosting-app')
+            fileContent = (0, generate_1.createFirebaseHostingJSON)(firebasePkg, params_1.RuntimeParams.setEnv);
+        if (pkg.type === 'firebase-functions-app') {
+            const firebaseFunctionPkg = firebasePkg;
+            const pathToFirebaseConfigFolder = `${firebaseFunctionPkg.path}/${firebaseFunctionPkg.envConfig.pathToFirebaseConfig}`;
+            try {
+                await fs_1.promises.access(pathToFirebaseConfigFolder);
+            }
+            catch (e) {
+                await fs_1.promises.mkdir(pathToFirebaseConfigFolder, { recursive: true });
+            }
+            if (firebasePkg.envConfig.ssl) {
+                const pathToProxyFile = `${firebaseFunctionPkg.path}/src/main/proxy.ts`;
+                try {
+                    await fs_1.promises.access(pathToProxyFile);
+                }
+                catch (e) {
+                    let defaultFileContent = await fs_1.promises.readFile(`${__dirname}/defaults/backend-proxy/proxy._ts`, { encoding: 'utf-8' });
+                    defaultFileContent = defaultFileContent.replace(/SERVER_PORT/g, `${firebasePkg.envConfig.basePort}`);
+                    defaultFileContent = defaultFileContent.replace(/PATH_TO_SSL_KEY/g, `${(_a = firebasePkg.envConfig.ssl) === null || _a === void 0 ? void 0 : _a.pathToKey}`);
+                    defaultFileContent = defaultFileContent.replace(/PATH_TO_SSL_CERTIFICATE/g, `${(_b = firebasePkg.envConfig.ssl) === null || _b === void 0 ? void 0 : _b.pathToCertificate}`);
+                    await fs_1.promises.writeFile(pathToProxyFile, defaultFileContent, { encoding: 'utf-8' });
+                }
+            }
+            await Promise.all(consts_2.Default_ListOfFirebaseConfigFiles.map(async (firebaseConfigFile) => {
+                const pathToConfigFile = `${pathToFirebaseConfigFolder}/${firebaseConfigFile}`;
+                try {
+                    await fs_1.promises.access(pathToConfigFile);
+                }
+                catch (e) {
+                    const defaultFileContent = await fs_1.promises.readFile(`${__dirname}/defaults/.firebase_config/${firebaseConfigFile}`, { encoding: 'utf-8' });
+                    await fs_1.promises.writeFile(pathToConfigFile, defaultFileContent, { encoding: 'utf-8' });
+                }
+            }));
+            fileContent = (0, generate_1.createFirebaseFunctionsJSON)(firebaseFunctionPkg, params_1.RuntimeParams.setEnv);
+        }
+        await fs_1.promises.writeFile(`${firebasePkg.path}/${consts_1.CONST_FirebaseJSON}`, JSON.stringify(fileContent, null, 2), { encoding: 'utf-8' });
+    }
+};
+exports.Phase_ResolvePackages = {
+    type: 'project',
+    name: 'setup-packages',
+    action: async () => {
+    }
+};
+exports.Phase_InstallNvm = {
+    type: 'project',
+    name: 'install-nvm',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    action: async () => {
+        const installed = await nvm_1.NVM.installRequiredVersionIfNeeded();
+        if (!installed)
+            return;
+    }
+};
+exports.Phase_PrintDependencyTree = {
+    type: ProjectManager_1.PackageBuildPhaseType_Package,
+    name: 'print-dependency-tree',
+    terminatingPhase: true,
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => {
+        return params_1.RuntimeParams.dependencyTree && (0, ts_common_1.exists)(pkg.packageJsonWorkspace);
+    },
+    action: async (pkg) => {
+        return nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(pkg.path)
+            .append(`mkdir -p ${CONST_RunningRoot}/.trash/dependencies`)
+            .append(`pnpm list --depth 1000 > "${CONST_RunningRoot}/.trash/dependencies/${pkg.name}.txt"`)
+            .execute();
+    }
+};
+exports.Phase_CheckCyclicImports = {
+    type: ProjectManager_1.PackageBuildPhaseType_PackageWithOutput,
+    name: 'check-cyclic-imports',
+    terminatingPhase: true,
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => params_1.RuntimeParams.checkCyclicImports,
+    action: async (pkg) => {
+        if (!pkg.output)
+            return;
+        return nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(pkg.path)
+            .append(`npx madge --image "./imports-${pkg.name}.svg" --circular ${pkg.output}`)
+            .execute();
+    }
+};
+exports.Phase_PrintEnv = {
+    type: 'project',
+    name: 'print-env',
+    terminatingPhase: true,
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async () => params_1.RuntimeParams.printEnv,
+    action: async () => {
+        return nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .append('npm -g list typescript eslint firebase-tools sort-package-json --depth=0')
+            .append('echo "npm version:"; npm -v')
+            .append('echo "node version:"; node -v')
+            .append('echo "base version:"; bash --version')
+            .execute();
+    }
+};
+exports.Phase_PackagePurge = {
+    type: ProjectManager_1.PackageBuildPhaseType_PackageWithOutput,
+    name: 'package-purge',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => fs.existsSync(pkg.output) && params_1.RuntimeParams.purge,
+    action: async (pkg) => {
+        await fs_1.promises.rm(pkg.output, { recursive: true, force: true });
+    }
+};
+exports.Phase_InstallGlobals = {
+    type: 'project',
+    name: 'install-globals',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async () => params_1.RuntimeParams.installGlobals,
+    action: async () => {
+        const globalPackages = 'firebase-tools@latest ts-node@latest typescript@latest eslint@^8.0.0';
+        await nvm_1.NVM.createCommando().append(`npm i -g ${globalPackages}`).execute();
+    }
+};
+exports.Phase_InstallPnpm = {
+    type: 'project',
+    name: 'install-pnpm',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    action: async () => {
+        await pnpm_1.PNPM.install(nvm_1.NVM.createCommando());
+    }
+};
+exports.Phase_InstallPackages = {
+    type: 'project',
+    name: 'install-packages',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async () => params_1.RuntimeParams.installPackages,
+    action: async () => {
+        const listOfLibs = exports.projectPackages.packages
+            .filter(pkg => runningWithInfra || ['project-lib', 'app', 'sourceless'].includes(pkg.type))
+            .map(pkg => pkg.path.replace(`${process.cwd()}/`, '').replace(process.cwd(), '.'));
+        await pnpm_1.PNPM.createWorkspace(listOfLibs);
+        await pnpm_1.PNPM.installPackages(nvm_1.NVM.createCommando());
+    }
+};
+exports.Phase_Clean = {
+    type: ProjectManager_1.PackageBuildPhaseType_PackageWithOutput,
+    name: 'clean',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => params_1.RuntimeParams.clean,
+    action: async (pkg) => {
+        if (!fs.existsSync(pkg.output))
+            return;
+        await fs_1.promises.rm(pkg.output, { recursive: true, force: true });
+    }
+};
+exports.Phase_Lint = {
+    type: 'package',
+    name: 'lint',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => params_1.RuntimeParams.lint && pkg.type !== 'sourceless',
+    action: async (pkg) => {
+        const folder = 'main';
+        const sourceFolder = `${pkg.path}/src/${folder}`;
+        return nvm_1.NVM.createCommando().append(`eslint --config ${pathToProjectEslint} --ext .ts --ext .tsx "${sourceFolder}"`).execute();
+    }
+};
+exports.Phase_Debug = {
+    type: 'project',
+    name: 'debug',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async () => params_1.RuntimeParams.debug,
+    action: async () => {
+        console.log(JSON.stringify(exports.projectPackages, null, 2));
+    }
+};
+const sourcesPaths = [];
+const suffixes = [
+    'ts',
+    'tsx',
+    'scss',
+    'json',
+    'svg',
+];
+const compileActions = {};
+exports.Phase_Compile = {
+    type: 'package',
+    name: 'compile',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => pkg.type !== 'sourceless' && !params_1.RuntimeParams.noBuild,
+    action: async (pkg) => {
+        var _a;
+        if (pkg.type === 'sourceless')
+            return;
+        const folder = 'main';
+        const sourceFolder = `${pkg.path}/src/${folder}`;
+        suffixes.forEach(suffix => {
+            sourcesPaths.push(`${sourceFolder}/**/*.${suffix}`);
+        });
+        const pathToLocalTsConfig = `${sourceFolder}/${CONST_TS_Config}`;
+        const commando = nvm_1.NVM.createCommando();
+        if (!pkg.customTsConfig)
+            await fs_1.promises.copyFile(pathToProjectTS_Config, pathToLocalTsConfig);
+        // --- HERE ---
+        await fs_1.promises.writeFile(`${pkg.output}/${consts_1.CONST_PackageJSON}`, JSON.stringify(pkg.packageJsonOutput, null, 2), { encoding: 'utf-8' });
+        if (pkg.type == 'firebase-functions-app') {
+            await fs_1.promises.writeFile(`${pkg.output}/${consts_1.CONST_PackageJSON}`, JSON.stringify(pkg.packageJsonRuntime, null, 2), { encoding: 'utf-8' });
+            const runTimePackages = (0, ts_common_1.filterDuplicates)((_a = exports.projectPackages.packagesDependency) === null || _a === void 0 ? void 0 : _a.flat().filter(_pkg => {
+                var _a, _b;
+                if (_pkg.name === pkg.name)
+                    return false;
+                if (((_a = pkg.packageJsonOutput) === null || _a === void 0 ? void 0 : _a.dependencies) && !(0, ts_common_1._keys)((_b = pkg.packageJsonOutput) === null || _b === void 0 ? void 0 : _b.dependencies).includes(_pkg.packageJsonTemplate.name))
+                    return false;
+                return _pkg.type !== 'sourceless';
+            }), __pkg => __pkg.name);
+            if (runTimePackages) {
+                for (const rtPack of runTimePackages) {
+                    if (!rtPack.output)
+                        continue;
+                    const pkgOutputFolderAsDependency = `${pkg.output}/.dependencies/${rtPack.name}/`;
+                    await nvm_1.NVM.createCommando()
+                        .append(`mkdir -p ${pkgOutputFolderAsDependency}`)
+                        .append(`rsync -a --delete ${rtPack.output}/ ${pkg.output}/.dependencies/${rtPack.name}/`)
+                        .execute();
+                    await fs_1.promises.writeFile(`${pkgOutputFolderAsDependency}/${consts_1.CONST_PackageJSON}`, JSON.stringify(rtPack.packageJsonRuntime, null, 2), { encoding: 'utf-8' });
+                }
+            }
+        }
+        compileActions[sourceFolder] = async (deleteDist) => {
+            if (deleteDist)
+                await fs_1.promises.rmdir(pkg.output);
+            await commando
+                .append(`tsc -p "${pathToLocalTsConfig}" --rootDir "${sourceFolder}" --outDir "${pkg.output}"`)
+                .execute();
+        };
+        return compileActions[sourceFolder]();
+    }
+};
+exports.Phase_CompileWatch = {
+    type: 'project',
+    name: 'compile-watch',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async () => params_1.RuntimeParams.watch,
+    action: async () => {
+        const watcher = chokidar.watch(sourcesPaths);
+        const watchListener = (path, deleteDist) => {
+            const libPath = (0, ts_common_1._keys)(compileActions).find(libPath => path.startsWith(libPath));
+            if (!libPath)
+                return console.error(`couldn't find lib to run for path: ${libPath}...\nListening on: ${(0, ts_common_1.__stringify)(sourcesPaths, true)}`);
+            return compileActions[libPath](deleteDist);
+        };
+        watcher
+            .on('add', (path) => {
+            console.log(`New File added: ${path}`);
+            watchListener(path);
+        })
+            .on('change', (path) => {
+            console.log(`Detected changes in file: ${path}`);
+            watchListener(path);
+        })
+            .on('unlinkDir', (path) => {
+            console.log(`Deleted Directory: ${path}`);
+            watchListener(path, true);
+        })
+            .on('error', (error) => {
+            console.log(`error`, error);
+        })
+            .on('unlink', (path) => {
+            console.log(`File Deleted: ${path}`);
+            watchListener(path, true);
+        })
+            .on('ready', () => {
+            console.log('Watching: ', sourcesPaths);
+        });
+    }
+};
+let counter = 0;
+exports.Phase_Launch = {
+    type: 'package',
+    name: 'launch',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => { var _a; return !!((_a = pkg.name.match(new RegExp(params_1.RuntimeParams.launch))) === null || _a === void 0 ? void 0 : _a[0]) && (pkg.type === 'firebase-functions-app' || pkg.type === 'firebase-hosting-app'); },
+    action: async (pkg) => {
+        if (pkg.type === 'firebase-functions-app') {
+            await (0, ts_common_1.sleep)(1000 * counter++);
+            const allPorts = Array.from({ length: 10 }, (_, i) => `${pkg.envConfig.basePort + i}`);
+            const command = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
+                .cd(pkg.path).debug()
+                .append(`nvm use`)
+                .append(`echo RUNNING PACKAGE1 ${pkg.name}`)
+                .append(`array=($(lsof -ti:${allPorts.join(',')}))`)
+                .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
+                .append(`echo RUNNING PACKAGE2 ${pkg.name}`);
+            command.append(`firebase emulators:start --export-on-exit --import=.trash/data ${runInDebug ? `--inspect-functions ${pkg.envConfig.ssl}` : ''}`);
+            return command
+                .execute();
+        }
+        if (pkg.type === 'firebase-hosting-app')
+            return nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
+                .cd(pkg.path)
+                .append(`nvm use`)
+                .append(`pwd`)
+                .append(`npm run start`)
+                .execute();
+    }
+};
+exports.Phase_DeployFrontend = {
+    type: 'package',
+    name: 'deploy-frontend',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => {
+        var _a;
+        console.log(`deploy flag(${pkg.name}): ${params_1.RuntimeParams.deploy}`);
+        return !!((_a = pkg.name.match(new RegExp(params_1.RuntimeParams.deploy))) === null || _a === void 0 ? void 0 : _a[0]) && pkg.type === 'firebase-hosting-app';
+    },
+    action: async (pkg) => {
+        if (pkg.type !== 'firebase-hosting-app')
+            throw new ts_common_1.BadImplementationException(`Somehow got a non firebase hosting package here: ${(0, ts_common_1.__stringify)(pkg)}`);
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(pkg.path)
+            .append(`firebase deploy --only hosting`)
+            .execute();
+    }
+};
+exports.Phase_DeployBackend = {
+    type: 'package',
+    name: 'deploy-functions',
+    mandatoryPhases: [exports.Phase_ResolveEnv],
+    filter: async (pkg) => { var _a; return !!((_a = pkg.name.match(new RegExp(params_1.RuntimeParams.deploy))) === null || _a === void 0 ? void 0 : _a[0]) && pkg.type === 'firebase-functions-app'; },
+    action: async (pkg) => {
+        if (pkg.type !== 'firebase-functions-app')
+            throw new ts_common_1.BadImplementationException(`Somehow got a non firebase functions package here: ${(0, ts_common_1.__stringify)(pkg)}`);
+        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+            .cd(pkg.path)
+            .append(`firebase --debug deploy --only functions --force`)
+            .execute();
+    }
+};