@entur/function-tools 0.0.7 → 0.0.9

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.7").option("-v, --verbose", "Enable verbose output");
+program.name("entur-functions").description("A multi-tool for Firebase functions at Entur").version("0.0.9").option("-v, --verbose", "Enable verbose output");
 registerBuild(program);
 registerDeploy(program);
 registerStart(program);

package/lib/bundle/dependencies.js

@@ -1,34 +1,121 @@
-import { writeFile } from 'node:fs/promises';
+import { copyFile } from 'node:fs/promises';
 import { builtinModules } from 'node:module';
-import { dirname } from 'node:path';
-import { stringify } from 'yaml';
+import { dirname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { writePackageJSON, readPackageJSON, packageUp } from '../packageJSON/index.js';
+import { filterMap } from '../utils/array.js';
 import { groupByAsync, asyncMap } from '../utils/async.js';
 import { spawnAsync } from '../utils/exec.js';
-import { writePackageJSON, readPackageJSON, packageUp } from '../utils/packageJSON.js';
+import { readYAML, writeYAML } from '../utils/fs.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))){
+async function writeDependencies(outputs, getOutputFilePath, projectRoot, outputDir) {
+    const pnpmLockSourceURL = new URL("./pnpm-lock.yaml", projectRoot);
+    const pnpmLockOutputURL = new URL("./pnpm-lock.yaml", outputDir);
+    const pnpmWorkspaceSourceURL = new URL("./pnpm-workspace.yaml", projectRoot);
+    const pnpmWorkspaceOutputURL = new URL("./pnpm-workspace.yaml", outputDir);
+    await Promise.all([
+        copyFile(pnpmLockSourceURL, pnpmLockOutputURL),
+        copyFile(pnpmWorkspaceSourceURL, pnpmWorkspaceOutputURL)
+    ]);
+    const dependencies = await calculateDependencies(outputs);
+    await Promise.all([
+        writePackageJSONs(dependencies, getOutputFilePath, outputDir),
+        updateWorkspace(dependencies, getOutputFilePath, pnpmWorkspaceOutputURL),
+        updatePNPMLock(dependencies, getOutputFilePath, pnpmLockOutputURL, projectRoot)
+    ]);
+}
+async function writePackageJSONs(packageJSONMap, getOutputFilePath, outputDir) {
+    for (const [packageJSONPath, packageJSON] of packageJSONMap){
         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 writePackageJSON(new URL(`./${newPackageJSONPath}`, outputDir), packageJSON);
     }
-    await writeFile(new URL("./pnpm-workspace.yaml", outputDir), stringify({
+}
+async function updateWorkspace(packageJSONMap, getOutputFilePath, pnpmWorkspaceURL) {
+    const packages = filterMap([
+        ...packageJSONMap.keys()
+    ], (filePath)=>{
+        const outputFileName = dirname(getOutputFilePath(filePath));
+        return outputFileName !== "." ? outputFileName : undefined;
+    });
+    const workspace = await readYAML(pnpmWorkspaceURL);
+    await writeYAML(pnpmWorkspaceURL, {
+        ...workspace,
         packages
-    }));
+    });
+}
+async function updatePNPMLock(packageJSONMap, getOutputFilePath, pnpmLockURL, projectRoot) {
+    const projectRootPath = fileURLToPath(projectRoot);
+    const lockfile = await readYAML(pnpmLockURL);
+    const updateDependencies = (dependencies, packageJSONDependencies)=>{
+        if (!dependencies || !packageJSONDependencies) {
+            return;
+        }
+        const entries = filterMap(Object.entries(dependencies), ([packageName, versionOrDependency])=>{
+            const specifier = packageJSONDependencies[packageName];
+            if (!specifier) return;
+            return typeof versionOrDependency === "string" ? [
+                packageName,
+                {
+                    specifier,
+                    version: versionOrDependency
+                }
+            ] : [
+                packageName,
+                versionOrDependency
+            ];
+        });
+        if (entries.length === 0) {
+            return;
+        }
+        return Object.fromEntries(entries);
+    };
+    const findSnapshot = (packageName)=>{
+        for (const { dependencies, devDependencies } of Object.values(lockfile.importers)){
+            const found = dependencies?.[packageName] || devDependencies?.[packageName];
+            if (found) {
+                const key = `${packageName}@${found.version}`;
+                const snapshot = lockfile.snapshots[key];
+                if (snapshot) return snapshot;
+            }
+        }
+    };
+    const entries = [
+        ...packageJSONMap
+    ].map(([packageJSONPath, packageJSON])=>{
+        const packageRootPath = dirname(packageJSONPath);
+        const key = relative(projectRootPath, packageRootPath);
+        const importer = lockfile.importers[key];
+        const updatedKey = getOutputFilePath(packageRootPath) || ".";
+        if (importer) {
+            return [
+                updatedKey,
+                {
+                    dependencies: updateDependencies(importer.dependencies, packageJSON.dependencies),
+                    devDependencies: updateDependencies(importer.devDependencies, packageJSON.devDependencies)
+                }
+            ];
+        }
+        const snapshot = findSnapshot(packageJSON.name);
+        if (snapshot) {
+            return [
+                updatedKey,
+                {
+                    dependencies: updateDependencies(snapshot.dependencies, packageJSON.dependencies),
+                    devDependencies: updateDependencies(snapshot.devDependencies, packageJSON.devDependencies)
+                }
+            ];
+        }
+        throw new Error(`Unable to create importer for ${packageJSON.name}`);
+    });
+    await writeYAML(pnpmLockURL, {
+        ...lockfile,
+        importers: Object.fromEntries(entries)
+    });
 }
 async function calculateDependencies(outputs) {
     const outputGroupedByPackage = await groupByAsync(outputs.filter((it)=>Boolean(it.type === "chunk" && it.facadeModuleId && it.imports.length > 0)), async (output)=>{
@@ -45,6 +132,7 @@ async function calculateDependencies(outputs) {
         const entries = Object.entries(dependencies).filter(([key])=>lookup.has(key));
         return entries.length > 0 ? Object.fromEntries(entries) : undefined;
     };
+    const entryFile = outputs[0];
     const entries = await asyncMap([
         ...outputGroupedByPackage
     ], async ([packageJSONPath, outputs])=>{
@@ -59,6 +147,7 @@ async function calculateDependencies(outputs) {
                 name,
                 type,
                 version,
+                main: outputs.includes(entryFile) ? `./${entryFile.fileName}` : undefined,
                 dependencies: filterDependencies(importedPackageNames, packageJSON.dependencies),
                 devDependencies: filterDependencies(importedPackageNames, packageJSON.devDependencies),
                 optionalDependencies: filterDependencies(importedPackageNames, packageJSON.optionalDependencies)
@@ -79,7 +168,7 @@ function isBuiltinImport(specifier) {
 async function linkDependencies(workingDir) {
     await spawnAsync("pnpm", [
         "install",
-        "--prefer-offline"
+        "--fix-lockfile"
     ], {
         cwd: workingDir
     });

package/lib/bundle/index.js

@@ -2,15 +2,13 @@ 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, packageRoot, projectRoot, packagesToInline }) {
+async function bundle(entryFile, { outputDir, outputFileName, shouldInlinePackage }) {
     const bundle = await rollup({
         input: fileURLToPath(entryFile),
-        plugins: plugins(packagesToInline),
+        plugins: plugins(shouldInlinePackage),
         treeshake: "smallest"
     });
-    const outputFileName = createOutputFileName(packageRoot, projectRoot);
     return bundle.write({
         preserveModules: true,
         format: "esm",
@@ -18,8 +16,7 @@ async function bundle(entryFile, { outputDir, packageRoot, projectRoot, packages
         entryFileNames: ({ facadeModuleId })=>outputFileName(facadeModuleId)
     });
 }
-async function bundleAndWatch(entryFile, { outputDir, packageRoot, projectRoot, packagesToInline, onBundleEnd }) {
-    const outputFileName = createOutputFileName(packageRoot, projectRoot);
+async function bundleAndWatch(entryFile, { outputDir, outputFileName, shouldInlinePackage, onBundleEnd }) {
     const output = {
         preserveModules: true,
         format: "esm",
@@ -27,7 +24,7 @@ async function bundleAndWatch(entryFile, { outputDir, packageRoot, projectRoot,
         entryFileNames: ({ facadeModuleId })=>outputFileName(facadeModuleId)
     };
     const watchOptions = {
-        plugins: plugins(packagesToInline),
+        plugins: plugins(shouldInlinePackage),
         input: fileURLToPath(entryFile),
         treeshake: "smallest",
         output,
@@ -61,7 +58,7 @@ async function bundleAndWatch(entryFile, { outputDir, packageRoot, projectRoot,
         }
     });
 }
-const plugins = (workspacePackages)=>[
+const plugins = (resolveOnly)=>[
         swc({
             swc: {
                 jsc: {
@@ -70,7 +67,7 @@ const plugins = (workspacePackages)=>[
             }
         }),
         nodeResolve({
-            resolveOnly: (moduleId)=>moduleId.startsWith(".") || workspacePackages?.some((it)=>moduleId.startsWith(it)) || moduleId.startsWith("@entur-private/") || false
+            resolveOnly
         })
     ];
 

package/lib/bundle/utils.js

@@ -5,19 +5,25 @@ function createOutputFileName(packageRootURL, projectRootURL) {
     const projectRoot = fileURLToPath(projectRootURL);
     const packageRoot = fileURLToPath(packageRootURL);
     return (facadeModuleId)=>{
-        const index = facadeModuleId?.lastIndexOf(nodeModulesPartPath);
-        if (facadeModuleId && index && index > -1) {
+        if (!facadeModuleId) {
+            throw new Error(`file path is null`);
+        }
+        const index = facadeModuleId.lastIndexOf(nodeModulesPartPath);
+        if (facadeModuleId && index > -1) {
             return `bundled_modules/${facadeModuleId.slice(index + nodeModulesPartPath.length)}`;
         }
-        const filePath = facadeModuleId?.replace(".ts", ".js").replaceAll("/src/", "/lib/");
-        if (filePath?.startsWith(packageRoot)) {
+        const filePath = facadeModuleId.replace(".ts", ".js").replaceAll("/src/", "/lib/");
+        if (filePath.startsWith(packageRoot) || packageRoot.slice(0, -1) === filePath) {
             return filePath.slice(packageRoot.length);
         }
-        if (filePath?.startsWith(projectRoot)) {
+        if (filePath.startsWith(projectRoot)) {
             return `local_modules/${filePath.slice(projectRoot.length)}`;
         }
         throw new Error(`Unable to determine correct placement for file ${facadeModuleId}`);
     };
 }
+function createShouldInlinePackage(packagesToInline) {
+    return (moduleId)=>moduleId.startsWith(".") || packagesToInline?.some((it)=>moduleId.startsWith(it)) || moduleId.startsWith("@entur-private/") || false;
+}
 
-export { createOutputFileName };
+export { createOutputFileName, createShouldInlinePackage };

package/lib/commands/build.js

@@ -1,37 +1,40 @@
-import { writeDependencies } from '../bundle/dependencies.js';
+import { writeDependencies, linkDependencies } from '../bundle/dependencies.js';
 import { bundle } from '../bundle/index.js';
-import { createOutputFileName } from '../bundle/utils.js';
+import { createOutputFileName, createShouldInlinePackage } from '../bundle/utils.js';
+import { readPackageJSON } from '../packageJSON/index.js';
 import { cleanDir } from '../utils/fs.js';
-import { readPackageJSON } from '../utils/packageJSON.js';
 import { getWorkspacePackageNames } from '../utils/workspace.js';
 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)=>{
+    program.command("build").description("Build the project").option("-o, --output-dir <dir>", "Output directory").action(async ({ outputDir })=>{
         try {
-            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, workspacePackages, projectConfig);
+            const projectConfig = await resolveProjectConfig({
+                outputDir
+            });
+            await build(projectConfig);
         } catch (error) {
             console.error(error);
             process.exit(1);
         }
     });
 }
-async function build(entryFile, packagesToInline, { outputDir, packageRoot, projectRoot }) {
+async function build(projectConfig) {
+    const { packageRoot, projectRoot, 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 entryFile = new URL(exports$1?.["."] ?? "./index.js", packageRoot);
+    const outputFileName = createOutputFileName(packageRoot, projectRoot);
+    const shouldInlinePackage = createShouldInlinePackage(await getWorkspacePackageNames(pnpmWorkspaceYAML));
     const { output } = await bundle(entryFile, {
         outputDir,
-        packageRoot,
-        projectRoot,
-        packagesToInline
+        outputFileName,
+        shouldInlinePackage
     });
-    await writeDependencies(output, createOutputFileName(packageRoot, projectRoot), outputDir);
+    await writeDependencies(output, outputFileName, projectRoot, outputDir);
+    await linkDependencies(outputDir);
 }
 
 export { registerBuild };

package/lib/commands/deploy.js

@@ -1,33 +1,35 @@
 import { writeDependencies, linkDependencies } from '../bundle/dependencies.js';
 import { bundle } from '../bundle/index.js';
-import { createOutputFileName } from '../bundle/utils.js';
+import { createOutputFileName, createShouldInlinePackage } from '../bundle/utils.js';
 import { deploy as deploy$1 } from '../firebase/index.js';
-import { getFirebaseJSON, writeFirebaseJSON } from '../utils/firebase.js';
+import { getFirebaseJSON, writeFirebaseJSON } from '../firebase/utils.js';
+import { readPackageJSON, getPackageName } from '../packageJSON/index.js';
 import { cleanDir, writeJSON } from '../utils/fs.js';
-import { readPackageJSON, getPackageName } from '../utils/packageJSON.js';
 import { getWorkspacePackageNames } from '../utils/workspace.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").option("--debug", "print verbose debug output and keep a debug log file", false).action(async (options)=>{
+    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").option("--debug", "print verbose debug output and keep a debug log file", false).option("--force", "delete missing Cloud Functions and bypass interactive prompts", false).action(async ({ outputDir, project, ...options })=>{
         try {
-            const projectConfig = await resolveProjectConfig(options);
-            await deploy(options.debug, projectConfig);
+            const projectConfig = await resolveProjectConfig({
+                outputDir,
+                project
+            });
+            await deploy(options, projectConfig);
         } catch (error) {
             console.error(error);
             process.exit(1);
         }
     });
 }
-async function deploy(debug, projectConfig) {
-    const { projectAlias, projectId, packageJSON, packageRoot, pnpmWorkspaceYAML, projectRoot, outputDir } = projectConfig;
+async function deploy(options, projectConfig) {
+    const { projectAlias, projectId, packageJSON, packageRoot, 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}`);
-    await build(entryFile, workspacePackages, projectConfig);
+    await build(entryFile, projectConfig);
     console.log("⛷️ Prepare deploy");
     const firebaseJSON = await getFirebaseJSON(new URL("firebase.json", projectRoot));
     await prepareDeploy(getPackageName(name), firebaseJSON, projectConfig);
@@ -35,17 +37,19 @@ async function deploy(debug, projectConfig) {
     await deploy$1({
         projectId,
         cwd: outputDir,
-        debug
+        ...options
     });
 }
-async function build(entryFile, packagesToInline, { outputDir, packageRoot, projectRoot }) {
+async function build(entryFile, { outputDir, packageRoot, projectRoot, pnpmWorkspaceYAML }) {
+    const outputFileName = createOutputFileName(packageRoot, projectRoot);
+    const shouldInlinePackage = createShouldInlinePackage(await getWorkspacePackageNames(pnpmWorkspaceYAML));
     const { output } = await bundle(entryFile, {
-        packageRoot,
-        projectRoot,
         outputDir,
-        packagesToInline
+        outputFileName,
+        shouldInlinePackage
     });
-    await writeDependencies(output, createOutputFileName(packageRoot, projectRoot), outputDir);
+    await writeDependencies(output, outputFileName, projectRoot, outputDir);
+    await linkDependencies(outputDir);
 }
 async function prepareDeploy(codebase, firebaseJSON, { projectAlias, projectId, outputDir, envFiles }) {
     const envPrefix = `FUNCTION_CODEBASE='${codebase}'\nENTUR_PROJECT_ALIAS='${projectAlias}'`;

package/lib/commands/start.js

@@ -1,39 +1,42 @@
 import { writeDependencies, linkDependencies } from '../bundle/dependencies.js';
 import { bundleAndWatch } from '../bundle/index.js';
-import { createOutputFileName } from '../bundle/utils.js';
+import { createOutputFileName, createShouldInlinePackage } from '../bundle/utils.js';
 import { startEmulator } from '../firebase/index.js';
-import { getFirebaseJSON, writeFirebaseJSON } from '../utils/firebase.js';
+import { getFirebaseJSON, writeFirebaseJSON } from '../firebase/utils.js';
+import { readPackageJSON, getPackageName } from '../packageJSON/index.js';
 import { cleanDir, writeJSON } from '../utils/fs.js';
-import { readPackageJSON, getPackageName } from '../utils/packageJSON.js';
 import { getWorkspacePackageNames } from '../utils/workspace.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").option("--inspect-functions [port]", "emulate Cloud Functions in debug mode with the node inspector on the given port (9229 if not specified)", false).option("--debug", "print verbose debug output and keep a debug log file", false).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)", false).option("--debug", "print verbose debug output and keep a debug log file", false).action(async ({ outputDir, project, ...options })=>{
         try {
             const projectConfig = await resolveProjectConfig({
-                ...options,
+                outputDir,
+                project,
                 isEmulator: true
             });
-            await start(options.debug, options.inspectFunctions, projectConfig);
+            await start(options, projectConfig);
         } catch (error) {
             console.error(error);
             process.exit(1);
         }
     });
 }
-async function start(debug, inspectFunctions, projectConfig) {
+async function start(options, 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 outputFileName = createOutputFileName(packageRoot, projectRoot);
+    const shouldInlinePackage = createShouldInlinePackage(await getWorkspacePackageNames(pnpmWorkspaceYAML));
     let firstRun = true;
     const onBundleEnd = async ({ output })=>{
-        await writeDependencies(output, createOutputFileName(packageRoot, projectRoot), outputDir);
+        await writeDependencies(output, outputFileName, projectRoot, outputDir);
+        await linkDependencies(outputDir);
         const firebaseJSON = await getFirebaseJSON(new URL("firebase.json", projectRoot));
         await prepareStart(codebase, firebaseJSON, projectConfig);
         if (firstRun) {
@@ -41,8 +44,7 @@ async function start(debug, inspectFunctions, projectConfig) {
             startEmulator({
                 projectId,
                 cwd: outputDir,
-                debug,
-                inspectFunctions
+                ...options
             }).catch((error)=>{
                 console.error(error);
             });
@@ -50,9 +52,8 @@ async function start(debug, inspectFunctions, projectConfig) {
     };
     await bundleAndWatch(entryFile, {
         outputDir,
-        projectRoot,
-        packageRoot,
-        packagesToInline,
+        outputFileName,
+        shouldInlinePackage,
         onBundleEnd
     });
 }

package/lib/firebase/index.js

@@ -1,12 +1,14 @@
 import { spawnAsync } from '../utils/exec.js';
 
 const FUNCTIONS_DISCOVERY_TIMEOUT = "30";
-function deploy({ projectId, cwd, debug }) {
+function deploy({ projectId, cwd, debug, force }) {
     const extraArgs = [];
     if (debug) {
-        console.log("Environment variables:", process.env);
         extraArgs.push("--debug");
     }
+    if (force) {
+        extraArgs.push("--force");
+    }
     return spawnAsync("firebase", [
         "deploy",
         "--only",

package/lib/{utils/firebase.js → firebase/utils.js}

@@ -1,5 +1,5 @@
 import { writeFile } from 'node:fs/promises';
-import { readJSON } from './fs.js';
+import { readJSON } from '../utils/fs.js';
 
 function getFirebaseJSON(file) {
     return readJSON(file);

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

@@ -1,6 +1,6 @@
 import process from 'node:process';
 import { findUp } from 'find-up-simple';
-import { readJSON, writeJSON } from './fs.js';
+import { readJSON, writeJSON } from '../utils/fs.js';
 
 function readPackageJSON(file) {
     return readJSON(file);

package/lib/utils/fs.js

@@ -1,4 +1,5 @@
-import { rm, mkdir, readFile, writeFile, access } from 'node:fs/promises';
+import { readFile, rm, mkdir, writeFile, access } from 'node:fs/promises';
+import { parse, stringify } from 'yaml';
 
 async function cleanDir(dir) {
     await rm(dir, {
@@ -24,5 +25,12 @@ async function readJSON(file) {
 async function writeJSON(file, data) {
     await writeFile(file, JSON.stringify(data, undefined, 4));
 }
+async function readYAML(file) {
+    const fileContent = await readFile(file, "utf-8");
+    return parse(fileContent);
+}
+async function writeYAML(file, data) {
+    await writeFile(file, stringify(data, undefined, 4));
+}
 
-export { cleanDir, exists, readJSON, writeJSON };
+export { cleanDir, exists, readJSON, readYAML, writeJSON, writeYAML };

package/lib/utils/workspace.js

@@ -1,6 +1,6 @@
 import { readFile, glob } from 'node:fs/promises';
 import { parse } from 'yaml';
-import { readPackageJSON } from './packageJSON.js';
+import { readPackageJSON } from '../packageJSON/index.js';
 
 async function getWorkspacePackageNames(pnpmWorkspaceYAML) {
     const pnpmWorkspaceContent = await readFile(pnpmWorkspaceYAML, "utf-8");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@entur/function-tools",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "publishConfig": {
     "access": "public"
   },