@entur/function-tools 0.0.4 → 0.0.6

package/bin/enturFunctions.js

@@ -5,7 +5,7 @@ import { registerStart } from '../lib/commands/start.js';
 import { registerUnusedExports } from '../lib/commands/unusedExports.js';
 
 const program = new Command();
-program.name("entur-functions").description("A multi-tool for Firebase functions at Entur").version("0.0.4").option("-v, --verbose", "Enable verbose output");
+program.name("entur-functions").description("A multi-tool for Firebase functions at Entur").version("0.0.6").option("-v, --verbose", "Enable verbose output");
 registerBuild(program);
 registerDeploy(program);
 registerStart(program);

package/lib/bundle/dependencies.js

@@ -0,0 +1,88 @@
+import { writeFile } from 'node:fs/promises';
+import { builtinModules } from 'node:module';
+import { dirname } from 'node:path';
+import { stringify } from 'yaml';
+import { groupByAsync, asyncMap } from '../utils/async.js';
+import { spawnAsync } from '../utils/exec.js';
+import { writePackageJSON, readPackageJSON, packageUp } from '../utils/packageJSON.js';
+
+const alwaysIncludePackageNames = [
+    "@google-cloud/functions-framework",
+    "firebase-functions",
+    "firebase-admin"
+];
+async function writeDependencies(outputs, getOutputFilePath, outputDir) {
+    const packages = [];
+    for (const [packageJSONPath, packageJSON] of (await calculateDependencies(outputs))){
+        const newPackageJSONPath = getOutputFilePath(packageJSONPath);
+        const directory = dirname(newPackageJSONPath);
+        if (directory === ".") {
+            await writePackageJSON(new URL(`./${newPackageJSONPath}`, outputDir), {
+                ...packageJSON,
+                main: `./${outputs[0].fileName}`
+            });
+        } else {
+            await writePackageJSON(new URL(`./${newPackageJSONPath}`, outputDir), packageJSON);
+            packages.push(directory);
+        }
+    }
+    await writeFile(new URL("./pnpm-workspace.yaml", outputDir), stringify({
+        packages
+    }));
+}
+async function calculateDependencies(outputs) {
+    const outputGroupedByPackage = await groupByAsync(outputs.filter((it)=>Boolean(it.type === "chunk" && it.facadeModuleId && it.imports.length > 0)), async (output)=>{
+        const key = output.facadeModuleId && await packageUp({
+            cwd: output.facadeModuleId
+        });
+        if (!key) {
+            throw new Error(`No package.json found for ${output.facadeModuleId}`);
+        }
+        return key;
+    });
+    const filterDependencies = (lookup, dependencies)=>{
+        if (!dependencies) return;
+        const entries = Object.entries(dependencies).filter(([key])=>lookup.has(key));
+        return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+    };
+    const entries = await asyncMap([
+        ...outputGroupedByPackage
+    ], async ([packageJSONPath, outputs])=>{
+        const { name, type, version, ...packageJSON } = await readPackageJSON(packageJSONPath);
+        const importedPackageNames = new Set(outputs.flatMap((it)=>it.imports).filter((it)=>!isBuiltinImport(it)).map(specifierToPackageName));
+        alwaysIncludePackageNames?.forEach((it)=>{
+            importedPackageNames.add(it);
+        });
+        return [
+            packageJSONPath,
+            {
+                name,
+                type,
+                version,
+                dependencies: filterDependencies(importedPackageNames, packageJSON.dependencies),
+                devDependencies: filterDependencies(importedPackageNames, packageJSON.devDependencies),
+                optionalDependencies: filterDependencies(importedPackageNames, packageJSON.optionalDependencies)
+            }
+        ];
+    });
+    return new Map(entries);
+}
+function specifierToPackageName(specifier) {
+    if (specifier.startsWith("@")) {
+        return specifier.split("/", 2).join("/");
+    }
+    return specifier.split("/", 1).join("/");
+}
+function isBuiltinImport(specifier) {
+    return specifier.startsWith("node:") || builtinModules.includes(specifier);
+}
+async function linkDependencies(workingDir) {
+    await spawnAsync("pnpm", [
+        "install",
+        "--prefer-offline"
+    ], {
+        cwd: workingDir
+    });
+}
+
+export { linkDependencies, writeDependencies };

package/lib/{utils/bundle.js → bundle/index.js}

@@ -2,29 +2,35 @@ import { fileURLToPath } from 'node:url';
 import { nodeResolve } from '@rollup/plugin-node-resolve';
 import swc from '@rollup/plugin-swc';
 import { rollup, watch } from 'rollup';
+import { createOutputFileName } from './utils.js';
 
-async function bundle(entryFile, outputDir, { packagesToInline } = {}) {
-    const bundle1 = await rollup({
+async function bundle(entryFile, { outputDir, packageRoot, projectRoot, packagesToInline }) {
+    const bundle = await rollup({
         input: fileURLToPath(entryFile),
         plugins: plugins(packagesToInline),
         treeshake: "smallest"
     });
-    return bundle1.write({
-        ...outputOptions(),
-        sourcemap: true,
-        dir: fileURLToPath(outputDir)
+    const outputFileName = createOutputFileName(packageRoot, projectRoot);
+    return bundle.write({
+        preserveModules: true,
+        format: "esm",
+        dir: fileURLToPath(outputDir),
+        entryFileNames: ({ facadeModuleId })=>outputFileName(facadeModuleId)
     });
 }
-async function bundleAndWatch(entryFile, outputDir, { packagesToInline, onBundleEnd }) {
+async function bundleAndWatch(entryFile, { outputDir, packageRoot, projectRoot, packagesToInline, onBundleEnd }) {
+    const outputFileName = createOutputFileName(packageRoot, projectRoot);
+    const output = {
+        preserveModules: true,
+        format: "esm",
+        dir: fileURLToPath(outputDir),
+        entryFileNames: ({ facadeModuleId })=>outputFileName(facadeModuleId)
+    };
     const watchOptions = {
         plugins: plugins(packagesToInline),
         input: fileURLToPath(entryFile),
         treeshake: "smallest",
-        output: {
-            ...outputOptions(),
-            sourcemap: true,
-            dir: fileURLToPath(outputDir)
-        },
+        output,
         watch: {
             exclude: [
                 fileURLToPath(outputDir)
@@ -41,9 +47,9 @@ async function bundleAndWatch(entryFile, outputDir, { packagesToInline, onBundle
                 }
             case "BUNDLE_END":
                 {
-                    const output = await event.result.generate(outputOptions());
+                    const bundledOutput = await event.result.generate(output);
                     console.log(`🏠 Finished build in ${event.duration}ms`);
-                    await onBundleEnd?.(output);
+                    await onBundleEnd?.(bundledOutput);
                     return event.result.close();
                 }
             case "ERROR":
@@ -67,11 +73,5 @@ const plugins = (workspacePackages)=>[
             resolveOnly: (moduleId)=>moduleId.startsWith(".") || workspacePackages?.some((it)=>moduleId.startsWith(it)) || moduleId.startsWith("@entur-private/") || false
         })
     ];
-const outputOptions = ()=>({
-        preserveModules: true,
-        dir: "lib",
-        format: "esm",
-        entryFileNames: ({ isEntry })=>isEntry ? "index.js" : "[hash].js"
-    });
 
 export { bundle, bundleAndWatch };

package/lib/bundle/utils.js

@@ -0,0 +1,23 @@
+import { fileURLToPath } from 'node:url';
+
+const nodeModulesPartPath = "/node_modules/";
+function createOutputFileName(packageRootURL, projectRootURL) {
+    const projectRoot = fileURLToPath(projectRootURL);
+    const packageRoot = fileURLToPath(packageRootURL);
+    return (facadeModuleId)=>{
+        const index = facadeModuleId?.lastIndexOf(nodeModulesPartPath);
+        if (facadeModuleId && index && index > -1) {
+            return `bundled_modules/${facadeModuleId.slice(index + nodeModulesPartPath.length)}`;
+        }
+        const filePath = facadeModuleId?.replace(".ts", ".js").replaceAll("/src/", "/lib/");
+        if (filePath?.startsWith(packageRoot)) {
+            return filePath.slice(packageRoot.length);
+        }
+        if (filePath?.startsWith(projectRoot)) {
+            return `local_modules/${filePath.slice(projectRoot.length)}`;
+        }
+        throw new Error(`Unable to determine correct placement for file ${facadeModuleId}`);
+    };
+}
+
+export { createOutputFileName };

package/lib/commands/build.js

@@ -1,5 +1,6 @@
-import { bundle } from '../utils/bundle.js';
-import { flattenDependencies, harmonizeDependencies, calculateDependencies } from '../utils/dependencies.js';
+import { writeDependencies } from '../bundle/dependencies.js';
+import { bundle } from '../bundle/index.js';
+import { createOutputFileName } from '../bundle/utils.js';
 import { cleanDir } from '../utils/fs.js';
 import { readPackageJSON } from '../utils/packageJSON.js';
 import { getWorkspacePackageNames } from '../utils/workspace.js';
@@ -8,31 +9,29 @@ import { resolveProjectConfig } from './utils.js';
 function registerBuild(program) {
     program.command("build").description("Build the project").option("-o, --output-dir <dir>", "Output directory").action(async (options)=>{
         try {
-            const { packageRoot, packageJSON, outputDir, pnpmWorkspaceYAML } = await resolveProjectConfig(options);
+            const projectConfig = await resolveProjectConfig(options);
+            const { packageRoot, packageJSON, outputDir, pnpmWorkspaceYAML } = projectConfig;
             const { name, exports: exports$1 } = await readPackageJSON(packageJSON);
             console.log("🧹 Cleaning dist folder");
             await cleanDir(outputDir);
             console.log(`🔨 Building ${name}`);
             const workspacePackages = await getWorkspacePackageNames(pnpmWorkspaceYAML);
             const entryFile = new URL(exports$1?.["."] ?? "./index.js", packageRoot);
-            await build(entryFile, outputDir, workspacePackages);
+            await build(entryFile, workspacePackages, projectConfig);
         } catch (error) {
             console.error(error);
             process.exit(1);
         }
     });
 }
-async function build(entryFile, outputDir, packagesToInline) {
-    const bundleOutputDir = new URL("lib", outputDir);
-    const { output } = await bundle(entryFile, bundleOutputDir, {
+async function build(entryFile, packagesToInline, { outputDir, packageRoot, projectRoot }) {
+    const { output } = await bundle(entryFile, {
+        outputDir,
+        packageRoot,
+        projectRoot,
         packagesToInline
     });
-    const dependencies = await flattenDependencies(harmonizeDependencies(await calculateDependencies(output)));
-    // const { contentHash } = await pack(functionGroupDir, distDir)
-    return {
-        main: `./lib/${output[0].fileName}`,
-        dependencies
-    };
+    await writeDependencies(output, createOutputFileName(packageRoot, projectRoot), outputDir);
 }
 
 export { registerBuild };

package/lib/commands/deploy.js

@@ -1,12 +1,12 @@
-import { writeFile } from 'node:fs/promises';
-import { bundle } from '../utils/bundle.js';
-import { flattenDependencies, harmonizeDependencies, calculateDependencies, linkDependencies } from '../utils/dependencies.js';
-import { spawnAsync } from '../utils/exec.js';
+import { writeDependencies, linkDependencies } from '../bundle/dependencies.js';
+import { bundle } from '../bundle/index.js';
+import { createOutputFileName } from '../bundle/utils.js';
+import { deploy as deploy$1 } from '../firebase/index.js';
 import { getFirebaseJSON, writeFirebaseJSON } from '../utils/firebase.js';
 import { cleanDir, writeJSON } from '../utils/fs.js';
-import { readPackageJSON, getPackageName, writePackageJSON } from '../utils/packageJSON.js';
+import { readPackageJSON, getPackageName } from '../utils/packageJSON.js';
 import { getWorkspacePackageNames } from '../utils/workspace.js';
-import { resolveProjectConfig } from './utils.js';
+import { resolveProjectConfig, copyEnvFiles } from './utils.js';
 
 function registerDeploy(program) {
     program.command("deploy").description("Deploy the project").option("-o, --output-dir <dir>", "Output directory").option("-P, --project <project id or alias>", "Project id or alias").action(async (options)=>{
@@ -19,45 +19,39 @@ function registerDeploy(program) {
         }
     });
 }
-async function deploy({ projectAlias, projectId, packageJSON, packageRoot, pnpmWorkspaceYAML, projectRoot, outputDir }) {
-    const { name, version, exports: exports$1 } = await readPackageJSON(packageJSON);
+async function deploy(projectConfig) {
+    const { projectAlias, projectId, packageJSON, packageRoot, pnpmWorkspaceYAML, projectRoot, outputDir } = projectConfig;
+    const { name, exports: exports$1 } = await readPackageJSON(packageJSON);
     const workspacePackages = await getWorkspacePackageNames(pnpmWorkspaceYAML);
     const entryFile = new URL(exports$1?.["."] ?? "./index.js", packageRoot);
     console.log("🧹 Cleaning dist folder");
     await cleanDir(outputDir);
     console.log(`🔨 Building ${name}`);
-    const { main, dependencies } = await build(entryFile, outputDir, workspacePackages);
+    await build(entryFile, workspacePackages, projectConfig);
     console.log("⛷️ Prepare deploy");
     const firebaseJSON = await getFirebaseJSON(new URL("firebase.json", projectRoot));
-    await prepareDeploy(getPackageName(name), projectAlias, projectId, {
-        name,
-        type: "module",
-        version,
-        main,
-        ...dependencies
-    }, firebaseJSON, outputDir);
-    // contentHash,
+    await prepareDeploy(getPackageName(name), firebaseJSON, projectConfig);
     console.log(`🚢 Deploying to ${projectAlias} (${projectId})`);
-    await deployToFirebase(outputDir, projectId);
+    await deploy$1({
+        projectId,
+        cwd: outputDir
+    });
 }
-async function build(entryFile, outputDir, packagesToInline) {
-    const bundleOutputDir = new URL("lib", outputDir);
-    const { output } = await bundle(entryFile, bundleOutputDir, {
+async function build(entryFile, packagesToInline, { outputDir, packageRoot, projectRoot }) {
+    const { output } = await bundle(entryFile, {
+        packageRoot,
+        projectRoot,
+        outputDir,
         packagesToInline
     });
-    const dependencies = await flattenDependencies(harmonizeDependencies(await calculateDependencies(output)));
-    // const { contentHash } = await pack(functionGroupDir, distDir)
-    return {
-        main: `./lib/${output[0].fileName}`,
-        dependencies
-    };
+    await writeDependencies(output, createOutputFileName(packageRoot, projectRoot), outputDir);
 }
-async function prepareDeploy(codebase, projectAlias, projectId, packageJSON, firebaseJSON, outputDir) {
+async function prepareDeploy(codebase, firebaseJSON, { projectAlias, projectId, outputDir, envFiles }) {
+    const envPrefix = `FUNCTION_CODEBASE='${codebase}'\nENTUR_PROJECT_ALIAS='${projectAlias}'`;
     await Promise.all([
         writeFirebaseJSON(codebase, firebaseJSON, outputDir),
         createFirebaseRC(projectAlias, projectId, outputDir),
-        writePackageJSON(new URL("./package.json", outputDir), packageJSON),
-        createDotenv(codebase, projectAlias, outputDir)
+        copyEnvFiles(envFiles, envPrefix, outputDir)
     ]);
     await linkDependencies(outputDir);
 }
@@ -68,24 +62,5 @@ async function createFirebaseRC(projectAlias, projectId, outputDir) {
         }
     });
 }
-function deployToFirebase(workingDir, projectId, extraArgs = []) {
-    return spawnAsync("firebase", [
-        "deploy",
-        "--only",
-        "functions,firestore",
-        "-P",
-        projectId,
-        ...extraArgs
-    ], {
-        cwd: workingDir
-    });
-}
-async function createDotenv(codebase, projectAlias, outputDir) {
-    const envFile = `
-NODE_OPTIONS='--enable-source-maps'
-FUNCTION_CODEBASE='${codebase}'
-ENTUR_PROJECT_ALIAS='${projectAlias}'`;
-    await writeFile(new URL("./.env", outputDir), envFile.trim());
-}
 
 export { registerDeploy };

package/lib/commands/start.js

@@ -1,63 +1,66 @@
-import { bundleAndWatch } from '../utils/bundle.js';
-import { flattenDependencies, harmonizeDependencies, calculateDependencies, linkDependencies } from '../utils/dependencies.js';
-import { spawnAsync } from '../utils/exec.js';
+import { writeDependencies, linkDependencies } from '../bundle/dependencies.js';
+import { bundleAndWatch } from '../bundle/index.js';
+import { createOutputFileName } from '../bundle/utils.js';
+import { startEmulator } from '../firebase/index.js';
 import { getFirebaseJSON, writeFirebaseJSON } from '../utils/firebase.js';
 import { cleanDir, writeJSON } from '../utils/fs.js';
-import { readPackageJSON, getPackageName, writePackageJSON } from '../utils/packageJSON.js';
+import { readPackageJSON, getPackageName } from '../utils/packageJSON.js';
 import { getWorkspacePackageNames } from '../utils/workspace.js';
-import { resolveProjectConfig } from './utils.js';
+import { resolveProjectConfig, copyEnvFiles } from './utils.js';
 
 function registerStart(program) {
-    program.command("start").description("Start function emulator").option("-o, --output-dir <dir>", "Output directory").option("-P, --project <project id or alias>", "Project id or alias").action(async (options)=>{
+    program.command("start").description("Start function emulator").option("-o, --output-dir <dir>", "Output directory").option("-P, --project <project id or alias>", "Project id or alias").option("--inspect-functions [port]", "emulate Cloud Functions in debug mode with the node inspector on the given port (9229 if not specified)").action(async (options)=>{
         try {
-            const projectConfig = await resolveProjectConfig(options);
-            await start(projectConfig);
+            const projectConfig = await resolveProjectConfig({
+                ...options,
+                isEmulator: true
+            });
+            await start(options.inspectFunctions ?? false, projectConfig);
         } catch (error) {
             console.error(error);
             process.exit(1);
         }
     });
 }
-async function start({ packageRoot, packageJSON, projectAlias, projectId, projectRoot, pnpmWorkspaceYAML, outputDir }) {
-    const { name, version, exports: exports$1 } = await readPackageJSON(packageJSON);
+async function start(inspectFunctions, projectConfig) {
+    const { packageRoot, packageJSON, projectId, projectRoot, pnpmWorkspaceYAML, outputDir } = projectConfig;
+    const { name, exports: exports$1 } = await readPackageJSON(packageJSON);
     const codebase = getPackageName(name);
     const packagesToInline = await getWorkspacePackageNames(pnpmWorkspaceYAML);
     const entryFile = new URL(exports$1?.["."] ?? "./index.js", packageRoot);
     console.log("🧹 Cleaning dist folder");
     await cleanDir(outputDir);
     console.log(`🔨 Building ${name}`);
-    const bundleOutputDir = new URL("lib", outputDir);
     let firstRun = true;
     const onBundleEnd = async ({ output })=>{
-        const main = `./lib/${output[0].fileName}`;
-        const dependencies = await flattenDependencies(harmonizeDependencies(await calculateDependencies(output)));
-        // const { contentHash } = await pack(functionGroupDir, distDir)
+        await writeDependencies(output, createOutputFileName(packageRoot, projectRoot), outputDir);
         const firebaseJSON = await getFirebaseJSON(new URL("firebase.json", projectRoot));
-        await prepareStart(codebase, projectAlias, projectId, {
-            name,
-            type: "module",
-            version,
-            main,
-            ...dependencies
-        }, firebaseJSON, outputDir);
+        await prepareStart(codebase, firebaseJSON, projectConfig);
         if (firstRun) {
             firstRun = false;
-            runEmulator(codebase, projectAlias, projectId, outputDir, []).catch((error)=>{
+            startEmulator({
+                projectId,
+                cwd: outputDir,
+                inspectFunctions
+            }).catch((error)=>{
                 console.error(error);
-                process.exit(1);
             });
         }
     };
-    await bundleAndWatch(entryFile, bundleOutputDir, {
+    await bundleAndWatch(entryFile, {
+        outputDir,
+        projectRoot,
+        packageRoot,
         packagesToInline,
         onBundleEnd
     });
 }
-async function prepareStart(codebase, projectAlias, projectId, packageJSON, firebaseJSON, outputDir) {
+async function prepareStart(codebase, firebaseJSON, { projectAlias, projectId, outputDir, envFiles }) {
+    const envPrefix = `FUNCTION_CODEBASE='${codebase}'\nENTUR_PROJECT_ALIAS='${projectAlias}'`;
     await Promise.all([
         writeFirebaseJSON(codebase, firebaseJSON, outputDir),
         createFirebaseRC(projectAlias, projectId, outputDir),
-        writePackageJSON(new URL("./package.json", outputDir), packageJSON)
+        copyEnvFiles(envFiles, envPrefix, outputDir)
     ]);
     await linkDependencies(outputDir);
 }
@@ -68,23 +71,5 @@ async function createFirebaseRC(projectAlias, projectId, outputDir) {
         }
     });
 }
-function runEmulator(codebase, projectAlias, projectId, workingDir, extraArgs) {
-    return spawnAsync("firebase", [
-        "emulators:start",
-        "--only",
-        "functions",
-        "-P",
-        projectId,
-        ...extraArgs
-    ], {
-        cwd: workingDir,
-        env: {
-            ...process.env,
-            FUNCTION_CODEBASE: codebase,
-            ENTUR_PROJECT_ALIAS: projectAlias,
-            NODE_OPTIONS: process.env.NODE_OPTIONS ? `${process.env.NODE_OPTIONS} --enable-source-maps` : "--enable-source-maps"
-        }
-    });
-}
 
 export { registerStart };

package/lib/commands/utils.d.ts

@@ -2,6 +2,7 @@ type Options = {
     outputDir?: string;
     project?: string;
     cwd?: string;
+    isEmulator?: boolean;
 };
 type ProjectConfig = {
     pnpmWorkspaceYAML: URL;
@@ -11,8 +12,10 @@ type ProjectConfig = {
     projectRoot: URL;
     projectAlias: string;
     projectId: string;
+    envFiles: URL[];
 };
-declare function resolveProjectConfig({ outputDir, project, cwd, }?: Options): Promise<ProjectConfig>;
+declare function resolveProjectConfig({ outputDir, project, isEmulator, cwd, }?: Options): Promise<ProjectConfig>;
+declare function copyEnvFiles([envFile, ...envFiles]: URL[], prefix: string, outputDir: URL): Promise<void>;
 
-export { resolveProjectConfig };
+export { copyEnvFiles, resolveProjectConfig };
 export type { ProjectConfig };

package/lib/commands/utils.js

@@ -1,8 +1,12 @@
-import { pathToFileURL } from 'node:url';
+import { readFile, writeFile, cp } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
 import { findUp } from 'find-up-simple';
-import { readJSON } from '../utils/fs.js';
+import { asyncFilterMap } from '../utils/async.js';
+import { readJSON, exists } from '../utils/fs.js';
 
-async function resolveProjectConfig({ outputDir = "dist", project, cwd = process.cwd() } = {}) {
+const FUNCTIONS_EMULATOR_DOTENV = ".env.local";
+async function resolveProjectConfig({ outputDir = "dist", project, isEmulator, cwd = process.cwd() } = {}) {
     const [pnpmWorkspacePath, packageJSONPath, firebaseRCPath] = await Promise.all([
         findUp("pnpm-workspace.yaml", {
             cwd
@@ -28,14 +32,18 @@ async function resolveProjectConfig({ outputDir = "dist", project, cwd = process
     const outputDirUrl = new URL(`./${outputDir}/`, `${pathToFileURL(cwd)}/`);
     const pnpmWorkspaceYAML = pathToFileURL(pnpmWorkspacePath);
     const packageJSONUrl = pathToFileURL(packageJSONPath);
+    const packageRoot = new URL("./", packageJSONUrl);
+    const projectRoot = new URL("./", pnpmWorkspaceYAML);
+    const envFiles = await findEnvFiles(packageRoot, projectId, projectAlias, isEmulator);
     return {
         pnpmWorkspaceYAML,
         packageJSON: packageJSONUrl,
         outputDir: outputDirUrl,
-        packageRoot: new URL("./", packageJSONUrl),
-        projectRoot: new URL("./", pnpmWorkspaceYAML),
+        packageRoot,
+        projectRoot,
         projectAlias,
-        projectId
+        projectId,
+        envFiles
     };
 }
 function getProjectAliasAndId({ default: defaultProjectId, ...projects }, project) {
@@ -67,5 +75,34 @@ function getProjectAliasAndId({ default: defaultProjectId, ...projects }, projec
     }
     throw new Error(`No project with alias or id ${project} found in .firebaserc`);
 }
+function findEnvFiles(packageRoot, projectId, projectAlias, isEmulator) {
+    const files = [
+        ".env"
+    ];
+    files.push(`.env.${projectId}`);
+    if (projectAlias) {
+        files.push(`.env.${projectAlias}`);
+    }
+    if (isEmulator) {
+        files.push(FUNCTIONS_EMULATOR_DOTENV);
+    }
+    return asyncFilterMap(files, async (fileName)=>{
+        const fileUrl = new URL(`./${fileName}`, packageRoot);
+        return await exists(fileUrl) ? fileUrl : undefined;
+    });
+}
+async function copyEnvFiles([envFile, ...envFiles], prefix, outputDir) {
+    if (envFile) {
+        const fileContent = await readFile(envFile, "utf8");
+        const fileName = basename(fileURLToPath(envFile));
+        await writeFile(new URL(`./${fileName}`, outputDir), `${prefix}\n${fileContent}`);
+    } else {
+        await writeFile(new URL("./.env", outputDir), prefix);
+    }
+    for (const envFile of envFiles){
+        const fileName = basename(fileURLToPath(envFile));
+        await cp(envFile, new URL(`./${fileName}`, outputDir));
+    }
+}
 
-export { resolveProjectConfig };
+export { copyEnvFiles, resolveProjectConfig };

package/lib/firebase/index.js

@@ -0,0 +1,47 @@
+import { spawnAsync } from '../utils/exec.js';
+
+const FUNCTIONS_DISCOVERY_TIMEOUT = "30";
+function deploy({ projectId, cwd }) {
+    return spawnAsync("firebase", [
+        "deploy",
+        "--only",
+        "functions,firestore",
+        "-P",
+        projectId
+    ], {
+        cwd,
+        env: {
+            ...process.env,
+            FUNCTIONS_DISCOVERY_TIMEOUT
+        }
+    });
+}
+function startEmulator({ projectId, cwd, inspectFunctions }) {
+    let extraArgs = [];
+    if (typeof inspectFunctions === "string") {
+        extraArgs = [
+            "--inspect-functions",
+            inspectFunctions
+        ];
+    } else if (inspectFunctions) {
+        extraArgs = [
+            "--inspect-functions"
+        ];
+    }
+    return spawnAsync("firebase", [
+        "emulators:start",
+        "--only",
+        "functions",
+        "-P",
+        projectId,
+        ...extraArgs
+    ], {
+        cwd,
+        env: {
+            ...process.env,
+            FUNCTIONS_DISCOVERY_TIMEOUT
+        }
+    });
+}
+
+export { deploy, startEmulator };

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export { ProjectConfig, resolveProjectConfig } from './commands/utils.js';
+export { ProjectConfig, copyEnvFiles, resolveProjectConfig } from './commands/utils.js';
 export { Export, getExports } from './importExports/exports.js';
 export { Import, getImports } from './importExports/imports.js';

package/lib/index.js

@@ -1,3 +1,3 @@
-export { resolveProjectConfig } from './commands/utils.js';
+export { copyEnvFiles, resolveProjectConfig } from './commands/utils.js';
 export { getExports } from './importExports/exports.js';
 export { getImports } from './importExports/imports.js';

package/lib/utils/array.js

@@ -12,20 +12,6 @@ function filterMap(arr, mapper) {
         return acc;
     }, []);
 }
-function groupBy(array, iteratee) {
-    return array.reduce((map, item, index, array_)=>{
-        const key = iteratee(item, index, array_);
-        const existingGroup = map.get(key);
-        if (existingGroup) {
-            existingGroup.push(item);
-        } else {
-            map.set(key, [
-                item
-            ]);
-        }
-        return map;
-    }, new Map());
-}
 function partition(array, predicate) {
     return array.reduce((result, value, index, arr)=>{
         const [include, exclude] = result;
@@ -41,4 +27,4 @@ function partition(array, predicate) {
     ]);
 }
 
-export { filterMap, groupBy, partition, uniq };
+export { filterMap, partition, uniq };

package/lib/utils/fs.js

@@ -1,4 +1,4 @@
-import { rm, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { rm, mkdir, readFile, writeFile, access } from 'node:fs/promises';
 
 async function cleanDir(dir) {
     await rm(dir, {
@@ -9,6 +9,14 @@ async function cleanDir(dir) {
         recursive: true
     });
 }
+async function exists(fileOrDirectory) {
+    try {
+        await access(fileOrDirectory);
+        return true;
+    } catch  {
+        return false;
+    }
+}
 async function readJSON(file) {
     const fileContent = await readFile(file, "utf-8");
     return JSON.parse(fileContent);
@@ -17,4 +25,4 @@ async function writeJSON(file, data) {
     await writeFile(file, JSON.stringify(data, undefined, 4));
 }
 
-export { cleanDir, readJSON, writeJSON };
+export { cleanDir, exists, readJSON, writeJSON };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@entur/function-tools",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "publishConfig": {
     "access": "public"
   },
@@ -21,7 +21,6 @@
     "oxc-resolver": "^11.16.2",
     "rollup": "^4.54.0",
     "rollup-plugin-dts": "^6.3.0",
-    "semver": "^7.7.3",
     "yaml": "^2.8.2"
   },
   "peerDependencies": {

package/lib/utils/dependencies.js

@@ -1,159 +0,0 @@
-import { builtinModules } from 'node:module';
-import { dirname } from 'node:path';
-import { coerce, satisfies } from 'semver';
-import { groupBy } from './array.js';
-import { groupByAsync, asyncMap } from './async.js';
-import { spawnAsync } from './exec.js';
-import { readPackageJSON, packageUp } from './packageJSON.js';
-
-const alwaysIncludePackageNames = [
-    "@google-cloud/functions-framework"
-];
-async function calculateDependencies(outputs) {
-    const outputGroupedByPackage = await groupByAsync(outputs.filter((it)=>Boolean(it.type === "chunk" && it.facadeModuleId && it.imports.length > 0)), async (output)=>{
-        const key = output.facadeModuleId && await packageUp({
-            cwd: output.facadeModuleId
-        });
-        if (!key) {
-            throw new Error(`No package.json found for ${output.facadeModuleId}`);
-        }
-        return key;
-    });
-    const filterDependencies = (lookup, dependencies)=>{
-        if (!dependencies) return;
-        const entries = Object.entries(dependencies).filter(([key])=>lookup.has(key));
-        return Object.fromEntries(entries);
-    };
-    const entries = await asyncMap([
-        ...outputGroupedByPackage
-    ], async ([packageJSONPath, outputs])=>{
-        const packageJSON = await readPackageJSON(packageJSONPath);
-        const importedPackageNames = new Set(outputs.flatMap((it)=>it.imports).filter((it)=>!isBuiltinImport(it)).map(specifierToPackageName));
-        if (alwaysIncludePackageNames?.length) {
-            alwaysIncludePackageNames.forEach((it)=>{
-                importedPackageNames.add(it);
-            });
-        }
-        return [
-            dirname(packageJSONPath),
-            {
-                ...packageJSON,
-                dependencies: filterDependencies(importedPackageNames, packageJSON.dependencies),
-                devDependencies: filterDependencies(importedPackageNames, packageJSON.devDependencies),
-                optionalDependencies: filterDependencies(importedPackageNames, packageJSON.optionalDependencies)
-            }
-        ];
-    });
-    return new Map(entries);
-}
-function specifierToPackageName(specifier) {
-    if (specifier.startsWith("@")) {
-        return specifier.split("/", 2).join("/");
-    }
-    return specifier.split("/", 1).join("/");
-}
-function isBuiltinImport(specifier) {
-    return builtinModules.includes(specifier) || specifier.startsWith("node:");
-}
-function harmonizeDependencies(initialDependecies) {
-    const entries = [
-        ...initialDependecies.values()
-    ].flatMap((it)=>[
-            ...Object.entries(it.dependencies ?? {}),
-            ...Object.entries(it.devDependencies ?? {}),
-            ...Object.entries(it.peerDependencies ?? {}),
-            ...Object.entries(it.optionalDependencies ?? {})
-        ]);
-    const harmonizedSemvers = new Map([
-        ...groupBy(entries, ([packageName])=>packageName)
-    ].map(([packageName, entriesForPackageName])=>{
-        const firstVersion = entriesForPackageName[0][1];
-        if (entriesForPackageName.length === 1) {
-            return [
-                packageName,
-                firstVersion
-            ];
-        }
-        if (entriesForPackageName.every(([, semver])=>semver === firstVersion)) {
-            return [
-                packageName,
-                firstVersion
-            ];
-        }
-        const satisfiedVersion = entriesForPackageName.reduce((acc, [, semver])=>{
-            if (acc === semver) {
-                return acc;
-            }
-            const semVerOrNull = coerce(semver);
-            if (semVerOrNull !== null && satisfies(semVerOrNull, acc)) {
-                console.log(`${packageName} ${semver} over ${acc}`);
-                return semver;
-            }
-            if (semVerOrNull !== null && satisfies(semVerOrNull, semver)) {
-                console.log(`${packageName} ${acc} over ${semver}`);
-                return acc;
-            }
-            throw new Error(`Unable to find determine correct version of ${packageName} between ${semver} and ${acc}`);
-        }, firstVersion);
-        return [
-            packageName,
-            satisfiedVersion
-        ];
-    }));
-    const harmonizeSemver = (dependencies)=>{
-        if (!dependencies) return;
-        const entries = Object.entries(dependencies).map(([packageName, initialSemver])=>{
-            const semver = harmonizedSemvers.get(packageName);
-            return [
-                packageName,
-                semver ?? initialSemver
-            ];
-        });
-        return Object.fromEntries(entries);
-    };
-    return new Map([
-        ...initialDependecies
-    ].map(([packageName, packageJSON])=>{
-        return [
-            packageName,
-            {
-                ...packageJSON,
-                dependencies: harmonizeSemver(packageJSON.dependencies),
-                devDependencies: harmonizeSemver(packageJSON.devDependencies),
-                peerDependencies: harmonizeSemver(packageJSON.peerDependencies)
-            }
-        ];
-    }));
-}
-// optionalDependencies: harmonizeSemver(packageJSON.optionalDependencies),
-async function flattenDependencies(dependencies) {
-    const listOfDependencies = [
-        ...dependencies.values()
-    ].map((it)=>it.dependencies);
-    const listOfDevDependencies = [
-        ...dependencies.values()
-    ].map((it)=>it.devDependencies);
-    const listOfPeerDependencies = [
-        ...dependencies.values()
-    ].map((it)=>it.peerDependencies);
-    const listOfOptionalDependencies = [
-        ...dependencies.values()
-    ].map((it)=>it.optionalDependencies);
-    return {
-        dependencies: Object.assign({}, ...listOfDependencies),
-        devDependencies: Object.assign({}, ...listOfDevDependencies),
-        peerDependencies: Object.assign({}, ...listOfPeerDependencies),
-        optionalDependencies: Object.assign({}, ...listOfOptionalDependencies)
-    };
-}
-async function linkDependencies(workingDir) {
-    await spawnAsync("pnpm", [
-        "install",
-        "--ignore-workspace",
-        "--prefer-offline"
-    ], {
-        cwd: workingDir
-    });
-}
-
-export { calculateDependencies, flattenDependencies, harmonizeDependencies, linkDependencies };