@entur/function-tools 0.0.1

package/lib/importExports/proxy.js

@@ -0,0 +1,56 @@
+import { filterMap } from '../utils/array.js';
+
+// import type { ExportAllDeclaration, ExportNamedDeclaration, SourceLocation } from "@babel/types"
+// import {
+//     isExportAllDeclaration,
+//     isExportNamedDeclaration,
+//     isExportSpecifier,
+//     isIdentifier,
+// } from "@babel/types"
+function getProxyExports(module) {
+    return module.body.flatMap((node)=>{
+        switch(node.type){
+            case "ExportNamedDeclaration":
+                return getProxyDetails(node);
+            case "ExportAllDeclaration":
+                return getPassthroughProxyDetails(node);
+            default:
+                return [];
+        }
+    });
+}
+function getProxyDetails(node) {
+    if (!node.source?.value) return [];
+    const specifier = node.source.value;
+    // Case: export { default as sampleFile, firstName as givenName } from './sample-file';
+    return filterMap(node.specifiers, (specifierItem)=>{
+        switch(specifierItem.type){
+            case "ExportSpecifier":
+                {
+                    const name = specifierItem.orig.value;
+                    const alias = specifierItem.exported?.value;
+                    return alias && name !== alias ? {
+                        name,
+                        alias,
+                        specifier,
+                        node
+                    } : {
+                        name,
+                        specifier,
+                        node
+                    };
+                }
+        }
+    });
+}
+function getPassthroughProxyDetails(node) {
+    const specifier = node.source.value;
+    // Case: export * from './sample-file';
+    return {
+        specifier,
+        passthrough: true,
+        node
+    };
+}
+
+export { getProxyExports };

package/lib/importExports/resolve.js

@@ -0,0 +1,31 @@
+import { ResolverFactory } from 'oxc-resolver';
+import { uniq } from '../utils/array.js';
+import { asyncFilterMap } from '../utils/async.js';
+import { createCache, isBuiltinImport } from './utils.js';
+
+function createResolver({ extensions, ...options } = {}) {
+    const resolvers = extensions?.length ? extensions.map((it)=>new ResolverFactory({
+            ...options,
+            extensions: [
+                it
+            ]
+        })) : [
+        new ResolverFactory(options)
+    ];
+    return createCache(async (basedir, importValue)=>{
+        if (isBuiltinImport(importValue)) {
+            return [];
+        }
+        const resolutions = await asyncFilterMap(resolvers, async (resolver)=>{
+            const { error, path } = await resolver.async(basedir, importValue);
+            if (error) return;
+            return path;
+        });
+        if (resolutions.length === 0) {
+            throw new Error("Module not found");
+        }
+        return uniq(resolutions);
+    });
+}
+
+export { createResolver };

package/lib/importExports/resolveImports.js

@@ -0,0 +1,53 @@
+import { dirname } from 'node:path';
+import { partition } from '../utils/array.js';
+import { asyncFlatMap } from '../utils/async.js';
+import { isBuiltinImport } from './utils.js';
+
+function createResolveImport(resolver, getExports, getProxyExports) {
+    const walk = async (directory, specifier, currentName)=>{
+        const resolved = await resolver(directory, specifier);
+        return asyncFlatMap(resolved, async (resolvedPath)=>{
+            if (resolvedPath.includes("/node_modules/")) {
+                return {
+                    name: currentName,
+                    resolvedPath
+                };
+            }
+            const exports$1 = await getExports(resolvedPath);
+            const matchingExport = exports$1.find(({ name })=>name === currentName);
+            if (matchingExport) {
+                return {
+                    name: matchingExport.name,
+                    resolvedPath
+                };
+            }
+            const proxyExports = await getProxyExports(resolvedPath);
+            const [namedProxyExports, passthroughProxyExports] = partition(proxyExports, (proxyExport)=>"name" in proxyExport);
+            const foundNamedProxyExport = namedProxyExports.find(({ name, alias })=>(alias ?? name) === currentName);
+            if (foundNamedProxyExport) {
+                return walk(dirname(resolvedPath), foundNamedProxyExport.specifier, foundNamedProxyExport.name);
+            }
+            return asyncFlatMap(passthroughProxyExports, (it)=>walk(dirname(resolvedPath), it.specifier, currentName));
+        });
+    };
+    return async ({ name, specifier, node }, initialDirectory)=>{
+        if (!name || isBuiltinImport(specifier)) return [];
+        const found = await walk(initialDirectory, specifier, name);
+        if (found.length === 0) {
+            throw new Error(`No corresponding exports found of ${name}`);
+        }
+        return found.map((it)=>it.name !== name ? {
+                ...it,
+                alias: name,
+                specifier,
+                node
+            } : {
+                ...it,
+                name,
+                specifier,
+                node
+            });
+    };
+}
+
+export { createResolveImport };

package/lib/importExports/traverse.js

@@ -0,0 +1,41 @@
+function traverse(node, visitors) {
+    const traverseNode = (currentNode)=>{
+        if (isMemberExpression(currentNode)) {
+            visitors.visitMemberExpression?.(currentNode);
+        } else if (isTsQualifiedName(currentNode)) {
+            visitors.visitTsQualifiedName?.(currentNode);
+        }
+        for (const value of Object.values(currentNode)){
+            if (isNode(value)) {
+                traverseNode(value);
+            }
+            if (Array.isArray(value)) {
+                for (const item of value){
+                    if (isNode(item)) {
+                        traverseNode(item);
+                    } else if (isArgument(item)) {
+                        traverseNode(item.expression);
+                    }
+                }
+            }
+        }
+    };
+    traverseNode(node);
+}
+function isMemberExpression(node) {
+    return node.type === "MemberExpression";
+}
+function isTsQualifiedName(node) {
+    return node.type === "TsQualifiedName";
+}
+function isNode(value) {
+    return isObject(value) && "type" in value && typeof value.type === "string";
+}
+function isArgument(value) {
+    return isObject(value) && "expression" in value && isObject(value.expression);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+
+export { traverse };

package/lib/importExports/unused.js

@@ -0,0 +1,76 @@
+import { dirname } from 'node:path';
+import { minimatch } from 'minimatch';
+import { filterMap } from '../utils/array.js';
+import { asyncReduce } from '../utils/async.js';
+
+function createReadFileDependencies(getImports, getExports, resolveImport) {
+    return async (filePath)=>{
+        const exports$1 = await getExports(filePath);
+        const { imports, missing } = await asyncReduce(await getImports(filePath), async (acc, it)=>{
+            try {
+                const resolvedImports = await resolveImport(it, dirname(filePath));
+                acc.imports.push(...resolvedImports);
+            } catch (error) {
+                acc.missing.push({
+                    ...it,
+                    message: error instanceof Error ? error.message : `Unknown error`
+                });
+            }
+            return acc;
+        }, {
+            imports: [],
+            missing: []
+        });
+        return {
+            filePath,
+            imports,
+            exports: exports$1,
+            missing
+        };
+    };
+}
+function createIsImported(fileDependecies) {
+    const table = new Set();
+    const getKey = (filePath, name)=>`${filePath}:${name}`;
+    const getAliasKey = (filePath, name)=>`${filePath}:alias:${name}`;
+    // Build a set for quick lookup, where key is combined using path and name
+    fileDependecies.forEach(({ imports })=>{
+        imports.forEach(({ resolvedPath, name, alias })=>{
+            table.add(getKey(resolvedPath, name));
+            if (alias) {
+                table.add(getAliasKey(resolvedPath, alias));
+            }
+        });
+    });
+    return (filePath, name)=>table.has(getKey(filePath, name)) || table.has(getAliasKey(filePath, name));
+}
+function extractUnusedExports(fileDependencies, ignorePatterns) {
+    const isImported = createIsImported(fileDependencies);
+    const unusedExportEntries = filterMap(fileDependencies, ({ filePath, exports: exports$1 })=>{
+        const filteredExports = exports$1.filter(({ name })=>!isImported(filePath, name));
+        if (filteredExports.length === 0) return;
+        return [
+            filePath,
+            filteredExports
+        ];
+    });
+    const missingImportsEntries = filterMap(fileDependencies, ({ filePath, missing })=>{
+        if (missing.length === 0) return;
+        return [
+            filePath,
+            missing
+        ];
+    });
+    if (!ignorePatterns?.length) {
+        return {
+            missingImports: new Map(missingImportsEntries),
+            unusedExports: new Map(unusedExportEntries)
+        };
+    }
+    return {
+        missingImports: new Map(missingImportsEntries),
+        unusedExports: new Map(unusedExportEntries.filter(([filePath])=>ignorePatterns.every((ignorePattern)=>!minimatch(filePath, ignorePattern))))
+    };
+}
+
+export { createReadFileDependencies, extractUnusedExports };

package/lib/importExports/utils.js

@@ -0,0 +1,18 @@
+import { builtinModules } from 'node:module';
+
+function isBuiltinImport(specifier) {
+    return specifier.startsWith("node:") || builtinModules.includes(specifier);
+}
+function createCache(fn) {
+    const cache = new Map();
+    return (...args)=>{
+        const key = args.map((it)=>String(it)).join(":");
+        const cached = cache.get(key);
+        if (cached !== undefined) return cached;
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+}
+
+export { createCache, isBuiltinImport };

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { Export, getExports } from './importExports/exports.js';
+export { Import, getImports } from './importExports/imports.js';

package/lib/index.js

@@ -0,0 +1,2 @@
+export { getExports } from './importExports/exports.js';
+export { getImports } from './importExports/imports.js';

package/lib/utils/array.js

@@ -0,0 +1,44 @@
+function uniq(array) {
+    return [
+        ...new Set(array)
+    ];
+}
+function filterMap(arr, mapper) {
+    return arr.reduce((acc, item, index, array)=>{
+        const b = mapper(item, index, array);
+        if (b !== undefined) {
+            acc.push(b);
+        }
+        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;
+        if (predicate(value, index, arr)) {
+            include.push(value);
+        } else {
+            exclude.push(value);
+        }
+        return result;
+    }, [
+        [],
+        []
+    ]);
+}
+
+export { filterMap, groupBy, partition, uniq };

package/lib/utils/async.js

@@ -0,0 +1,34 @@
+function asyncMap(array, iteratee) {
+    return Promise.all(array.map(iteratee));
+}
+async function asyncFilterMap(arr, mapper) {
+    const mapped = await asyncMap(arr, mapper);
+    return mapped.filter((it)=>it !== undefined);
+}
+async function asyncFlatMap(array, iteratee) {
+    const result = await Promise.all(array.map(iteratee));
+    return result.flat();
+}
+async function asyncReduce(array, iteratee, initialValue) {
+    return array.reduce(async (queue, item, index)=>{
+        const accumulator = await queue;
+        return iteratee(accumulator, item, index, array);
+    }, Promise.resolve(initialValue));
+}
+function groupByAsync(array, iteratee) {
+    return array.reduce(async (queue, item, index, array_)=>{
+        const map = await queue;
+        const key = await iteratee(item, index, array_);
+        const existingGroup = map.get(key);
+        if (existingGroup) {
+            existingGroup.push(item);
+        } else {
+            map.set(key, [
+                item
+            ]);
+        }
+        return map;
+    }, Promise.resolve(new Map()));
+}
+
+export { asyncFilterMap, asyncFlatMap, asyncMap, asyncReduce, groupByAsync };

package/lib/utils/bundle.js

@@ -0,0 +1,77 @@
+import { fileURLToPath } from 'node:url';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import swc from '@rollup/plugin-swc';
+import { rollup, watch } from 'rollup';
+
+async function bundle(entryFile, outputDir, { packagesToInline } = {}) {
+    const bundle1 = await rollup({
+        input: fileURLToPath(entryFile),
+        plugins: plugins(packagesToInline),
+        treeshake: "smallest"
+    });
+    return bundle1.write({
+        ...outputOptions(),
+        sourcemap: true,
+        dir: fileURLToPath(outputDir)
+    });
+}
+async function bundleAndWatch(entryFile, outputDir, { packagesToInline, onBundleEnd }) {
+    const watchOptions = {
+        plugins: plugins(packagesToInline),
+        input: fileURLToPath(entryFile),
+        treeshake: "smallest",
+        output: {
+            ...outputOptions(),
+            sourcemap: true,
+            dir: fileURLToPath(outputDir)
+        },
+        watch: {
+            exclude: [
+                fileURLToPath(outputDir)
+            ]
+        }
+    };
+    const watcher = watch(watchOptions);
+    watcher.on("event", async (event)=>{
+        switch(event.code){
+            case "BUNDLE_START":
+                {
+                    console.log("🏗️  Start building...");
+                    return;
+                }
+            case "BUNDLE_END":
+                {
+                    const output = await event.result.generate(outputOptions());
+                    console.log(`🏠 Finished build in ${event.duration}ms`);
+                    await onBundleEnd?.(output);
+                    return event.result.close();
+                }
+            case "ERROR":
+                {
+                    console.log("🛑 Encountered an error while bundling");
+                    console.error(event.error);
+                    return event.result?.close();
+                }
+        }
+    });
+}
+const plugins = (workspacePackages)=>[
+        swc({
+            swc: {
+                jsc: {
+                    preserveAllComments: true
+                }
+            }
+        }),
+        nodeResolve({
+            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/utils/dependencies.js

@@ -0,0 +1,159 @@
+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 };

package/lib/utils/exec.js

@@ -0,0 +1,20 @@
+import { spawn } from 'node:child_process';
+
+function spawnAsync(command, args, options) {
+    return new Promise((resolve, reject)=>{
+        const run = spawn(command, args, {
+            ...options,
+            stdio: "inherit"
+        });
+        run.on("exit", (exitCode)=>{
+            if (exitCode === 0) {
+                resolve();
+            } else {
+                const commandWithArguments = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+                reject(new Error(`an error occurred while executing "${commandWithArguments}" in folder ${options?.cwd}`));
+            }
+        });
+    });
+}
+
+export { spawnAsync };

package/lib/utils/firebase.js

@@ -0,0 +1,18 @@
+import { writeFile } from 'node:fs/promises';
+import { readJSON } from './fs.js';
+
+function getFirebaseJSON(file) {
+    return readJSON(file);
+}
+async function writeFirebaseJSON(codebase, { functions }, outputDir) {
+    const newFirebaseJSON = {
+        functions: {
+            ...functions,
+            codebase,
+            source: "."
+        }
+    };
+    await writeFile(new URL("firebase.json", outputDir), JSON.stringify(newFirebaseJSON, undefined, 4));
+}
+
+export { getFirebaseJSON, writeFirebaseJSON };

package/lib/utils/fs.js

@@ -0,0 +1,20 @@
+import { rm, mkdir, readFile, writeFile } from 'node:fs/promises';
+
+async function cleanDir(dir) {
+    await rm(dir, {
+        recursive: true,
+        force: true
+    });
+    await mkdir(dir, {
+        recursive: true
+    });
+}
+async function readJSON(file) {
+    const fileContent = await readFile(file, "utf-8");
+    return JSON.parse(fileContent);
+}
+async function writeJSON(file, data) {
+    await writeFile(file, JSON.stringify(data, undefined, 4));
+}
+
+export { cleanDir, readJSON, writeJSON };

package/lib/utils/packageJSON.js

@@ -0,0 +1,21 @@
+import process from 'node:process';
+import { findUp } from 'find-up-simple';
+import { readJSON, writeJSON } from './fs.js';
+
+function readPackageJSON(file) {
+    return readJSON(file);
+}
+async function writePackageJSON(file, packageJSON) {
+    await writeJSON(file, packageJSON);
+}
+function getPackageName(name) {
+    const match = name.match(/@[a-z-]+\/([a-z-]+)$/);
+    return match?.[1] ?? name;
+}
+async function packageUp({ cwd = process.cwd() } = {}) {
+    return findUp("package.json", {
+        cwd
+    });
+}
+
+export { getPackageName, packageUp, readPackageJSON, writePackageJSON };