@entur/function-tools 0.0.1

package/README.md

@@ -0,0 +1,2 @@
+# firebase-tools
+Ekstra verktøy for firebase

package/bin/enturFunctions.js

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { registerBuild } from '../lib/commands/build.js';
+import { registerDeploy } from '../lib/commands/deploy.js';
+import { registerStart } from '../lib/commands/start.js';
+import { registerUnusedExports } from '../lib/commands/unusedExports.js';
+
+const program = new Command();
+program.name("entur-firebase").description("A multi-command CLI built with commander").version("0.0.1").option("-v, --verbose", "Enable verbose output");
+registerBuild(program);
+registerDeploy(program);
+registerStart(program);
+registerUnusedExports(program);
+// Show help when no subcommand is passed
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+    process.exit(0);
+}
+program.parseAsync(process.argv).catch((error)=>{
+    console.error(error?.message || error);
+    process.exit(1);
+});

package/lib/commands/build.js

@@ -0,0 +1,38 @@
+import { bundle } from '../utils/bundle.js';
+import { flattenDependencies, harmonizeDependencies, calculateDependencies } from '../utils/dependencies.js';
+import { cleanDir } from '../utils/fs.js';
+import { readPackageJSON } from '../utils/packageJSON.js';
+import { getWorkspacePackageNames } from '../utils/workspace.js';
+import { createContext } 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 createContext(options);
+            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);
+        } 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, {
+        packagesToInline
+    });
+    const dependencies = await flattenDependencies(harmonizeDependencies(await calculateDependencies(output)));
+    // const { contentHash } = await pack(functionGroupDir, distDir)
+    return {
+        main: `./lib/${output[0].fileName}`,
+        dependencies
+    };
+}
+
+export { registerBuild };

package/lib/commands/deploy.js

@@ -0,0 +1,91 @@
+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 { getFirebaseJSON, writeFirebaseJSON } from '../utils/firebase.js';
+import { cleanDir, writeJSON } from '../utils/fs.js';
+import { readPackageJSON, getPackageName, writePackageJSON } from '../utils/packageJSON.js';
+import { getWorkspacePackageNames } from '../utils/workspace.js';
+import { createContext } 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)=>{
+        try {
+            const context = await createContext(options);
+            await deploy(context);
+        } catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}
+async function deploy({ projectAlias, projectId, packageJSON, packageRoot, pnpmWorkspaceYAML, projectRoot, outputDir }) {
+    const { name, version, 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);
+    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,
+    console.log(`🚢 Deploying to ${projectAlias} (${projectId})`);
+    await deployToFirebase(outputDir, projectId);
+}
+async function build(entryFile, outputDir, packagesToInline) {
+    const bundleOutputDir = new URL("lib", outputDir);
+    const { output } = await bundle(entryFile, bundleOutputDir, {
+        packagesToInline
+    });
+    const dependencies = await flattenDependencies(harmonizeDependencies(await calculateDependencies(output)));
+    // const { contentHash } = await pack(functionGroupDir, distDir)
+    return {
+        main: `./lib/${output[0].fileName}`,
+        dependencies
+    };
+}
+async function prepareDeploy(codebase, projectAlias, projectId, packageJSON, firebaseJSON, outputDir) {
+    await Promise.all([
+        writeFirebaseJSON(codebase, firebaseJSON, outputDir),
+        createFirebaseRC(projectAlias, projectId, outputDir),
+        writePackageJSON(new URL("./package.json", outputDir), packageJSON),
+        createDotenv(codebase, projectAlias, outputDir)
+    ]);
+    await linkDependencies(outputDir);
+}
+async function createFirebaseRC(projectAlias, projectId, outputDir) {
+    await writeJSON(new URL("./.firebaserc", outputDir), {
+        projects: {
+            [projectAlias]: projectId
+        }
+    });
+}
+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

@@ -0,0 +1,90 @@
+import { bundleAndWatch } from '../utils/bundle.js';
+import { flattenDependencies, harmonizeDependencies, calculateDependencies, linkDependencies } from '../utils/dependencies.js';
+import { spawnAsync } from '../utils/exec.js';
+import { getFirebaseJSON, writeFirebaseJSON } from '../utils/firebase.js';
+import { cleanDir, writeJSON } from '../utils/fs.js';
+import { readPackageJSON, getPackageName, writePackageJSON } from '../utils/packageJSON.js';
+import { getWorkspacePackageNames } from '../utils/workspace.js';
+import { createContext } 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)=>{
+        try {
+            const context = await createContext(options);
+            await start(context);
+        } 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);
+    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)
+        const firebaseJSON = await getFirebaseJSON(new URL("firebase.json", projectRoot));
+        await prepareStart(codebase, projectAlias, projectId, {
+            name,
+            type: "module",
+            version,
+            main,
+            ...dependencies
+        }, firebaseJSON, outputDir);
+        if (firstRun) {
+            firstRun = false;
+            runEmulator(codebase, projectAlias, projectId, outputDir, []).catch((error)=>{
+                console.error(error);
+                process.exit(1);
+            });
+        }
+    };
+    await bundleAndWatch(entryFile, bundleOutputDir, {
+        packagesToInline,
+        onBundleEnd
+    });
+}
+async function prepareStart(codebase, projectAlias, projectId, packageJSON, firebaseJSON, outputDir) {
+    await Promise.all([
+        writeFirebaseJSON(codebase, firebaseJSON, outputDir),
+        createFirebaseRC(projectAlias, projectId, outputDir),
+        writePackageJSON(new URL("./package.json", outputDir), packageJSON)
+    ]);
+    await linkDependencies(outputDir);
+}
+async function createFirebaseRC(projectAlias, projectId, outputDir) {
+    await writeJSON(new URL("./.firebaserc", outputDir), {
+        projects: {
+            [projectAlias]: projectId
+        }
+    });
+}
+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/unusedExports.js

@@ -0,0 +1,168 @@
+import { glob, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { parse } from '@swc/core';
+import { EnforceExtension } from 'oxc-resolver';
+import { getExports } from '../importExports/exports.js';
+import { getImports } from '../importExports/imports.js';
+import { getProxyExports } from '../importExports/proxy.js';
+import { createResolver } from '../importExports/resolve.js';
+import { createResolveImport } from '../importExports/resolveImports.js';
+import { createReadFileDependencies, extractUnusedExports } from '../importExports/unused.js';
+import { createCache } from '../importExports/utils.js';
+import { createContext } from './utils.js';
+
+function registerUnusedExports(program) {
+    program.command("unused-exports").description("Check for unused exports").action(async ()=>{
+        try {
+            const context = await createContext();
+            await unusedExports([
+                "**/*.+(ts|tsx)"
+            ], [], {
+                extensions: [
+                    ".ts"
+                ]
+            }, context);
+        } catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}
+async function unusedExports(patterns, ignorePatterns, resolverOptions, { cwd }) {
+    const resolver = createResolver({
+        conditionNames: [
+            "import",
+            "node",
+            "default"
+        ],
+        enforceExtension: EnforceExtension.Auto,
+        ...resolverOptions
+    });
+    const resolveImport = createResolveImport(resolver, getFileExports, getFileProxyExports);
+    const readFileDependencies = createReadFileDependencies(getFileImports, getFileExports, resolveImport);
+    const exclude = [
+        "**/node_modules",
+        "tools/createPackage/template",
+        "tools/dependency/mocks"
+    ];
+    const fileDependencies = [];
+    for await (const filePath of glob(patterns, {
+        cwd,
+        exclude
+    })){
+        fileDependencies.push(await readFileDependencies(join(cwd, filePath)));
+    }
+    const { unusedExports, missingImports } = extractUnusedExports(fileDependencies, ignorePatterns.map((it)=>join(cwd, it)));
+    if (unusedExports.size > 0) {
+        console.log("Exports not used in any files:\n");
+        await print(unusedExports, {
+            cwd
+        });
+    }
+    if (unusedExports.size > 0 && missingImports.size > 0) {
+        console.log();
+    }
+    if (missingImports.size > 0) {
+        console.log("Unresolvable import paths:\n");
+        await print(missingImports, {
+            cwd
+        });
+    }
+    if (unusedExports.size > 0 || missingImports.size > 0) {
+        process.exitCode = 1;
+    }
+}
+const parseFile = createCache(async (filePath)=>{
+    let options;
+    if (filePath.endsWith(".ts")) {
+        options = {
+            syntax: "typescript"
+        };
+    } else if (filePath.endsWith(".tsx")) {
+        options = {
+            syntax: "typescript",
+            tsx: true
+        };
+    } else if (filePath.endsWith(".js")) {
+        options = {
+            syntax: "ecmascript"
+        };
+    } else if (filePath.endsWith(".jsx")) {
+        options = {
+            syntax: "ecmascript",
+            jsx: true
+        };
+    } else {
+        return {
+            type: "Module",
+            span: {
+                start: 0,
+                end: 17,
+                ctxt: 2
+            },
+            interpreter: "",
+            body: [
+                {
+                    type: "ExportDefaultExpression",
+                    span: {
+                        start: 0,
+                        end: 17,
+                        ctxt: 2
+                    },
+                    expression: {
+                        type: "ObjectExpression",
+                        span: {
+                            start: 15,
+                            end: 17,
+                            ctxt: 2
+                        },
+                        properties: []
+                    }
+                }
+            ]
+        };
+    }
+    const content = await readFile(filePath, "utf-8");
+    return parse(content, options);
+});
+const getFileImports = createCache(async (filePath)=>{
+    const module = await parseFile(filePath);
+    return getImports(module);
+});
+const getFileExports = createCache(async (filePath)=>{
+    const module = await parseFile(filePath);
+    return getExports(module);
+});
+const getFileProxyExports = createCache(async (filePath)=>{
+    const module = await parseFile(filePath);
+    return getProxyExports(module);
+});
+async function print(printMap, { limit = 50, cwd = process.cwd() } = {}) {
+    let count = 0;
+    for (const [filePath, items] of printMap){
+        count++;
+        if (count > limit) {
+            break;
+        }
+        const relativePath = relative(cwd, filePath);
+        console.log(highlight(relativePath));
+        for (const item of items){
+            if ("specifier" in item) {
+                console.log(` - ${item.specifier}`);
+            } else {
+                console.log(` - ${item.name}`);
+            }
+        }
+        console.log("");
+    }
+    if (printMap.size > limit) {
+        console.log("");
+        console.log(`Showing ${limit} of ${printMap.size} affected files`);
+        console.log("");
+    }
+}
+function highlight(message) {
+    return `\u001B[33m${message}\u001B[0m`;
+}
+
+export { registerUnusedExports };

package/lib/commands/utils.js

@@ -0,0 +1,73 @@
+import { pathToFileURL } from 'node:url';
+import { findUp } from 'find-up-simple';
+import { readJSON } from '../utils/fs.js';
+
+async function createContext({ outputDir = "dist", project } = {}) {
+    const cwd = process.cwd();
+    const [pnpmWorkspacePath, packageJSONPath, firebaseRCPath] = await Promise.all([
+        findUp("pnpm-workspace.yaml", {
+            cwd
+        }),
+        findUp("package.json", {
+            cwd
+        }),
+        findUp(".firebaserc", {
+            cwd
+        })
+    ]);
+    if (!pnpmWorkspacePath) {
+        throw new Error("Unable to find pnpm-workspace.yaml");
+    }
+    if (!packageJSONPath) {
+        throw new Error("Unable to find package.json");
+    }
+    if (!firebaseRCPath) {
+        throw new Error("Unable to find .firebaserc");
+    }
+    const { projects } = await readJSON(firebaseRCPath);
+    const { projectAlias, projectId } = getProjectAliasAndId(projects, project);
+    const outputDirUrl = new URL(`./${outputDir}/`, `${pathToFileURL(cwd)}/`);
+    const pnpmWorkspaceYAML = pathToFileURL(pnpmWorkspacePath);
+    const packageJSONUrl = pathToFileURL(packageJSONPath);
+    return {
+        pnpmWorkspaceYAML,
+        packageJSON: packageJSONUrl,
+        outputDir: outputDirUrl,
+        packageRoot: new URL("./", packageJSONUrl),
+        projectRoot: new URL("./", pnpmWorkspaceYAML),
+        projectAlias,
+        projectId,
+        cwd
+    };
+}
+function getProjectAliasAndId({ default: defaultProjectId, ...projects }, project) {
+    if (!project) {
+        const defaultProjectEntry = Object.entries(projects).find(([, value])=>value === defaultProjectId);
+        if (!defaultProjectEntry) {
+            throw new Error("No default project found in .firebaserc");
+        }
+        const [projectAlias, projectId] = defaultProjectEntry;
+        return {
+            projectAlias,
+            projectId
+        };
+    }
+    if (projects[project]) {
+        return {
+            projectAlias: project,
+            projectId: projects[project]
+        };
+    }
+    const projectEntries = Object.entries(projects);
+    const matchingProjectEntry = projectEntries.find(([, value])=>value === project);
+    if (matchingProjectEntry) {
+        const [projectAlias, projectId] = matchingProjectEntry;
+        return {
+            projectAlias,
+            projectId
+        };
+    }
+    throw new Error(`No project with alias or id ${project} found in .firebaserc`);
+}
+
+export { createContext };

package/lib/importExports/exports.d.ts

@@ -0,0 +1,10 @@
+import { Node, Module } from '@swc/core';
+
+type Export = {
+    name: string;
+    node: Node;
+};
+declare function getExports(module: Module): Export[];
+
+export { getExports };
+export type { Export };

package/lib/importExports/exports.js

@@ -0,0 +1,88 @@
+import { filterMap } from '../utils/array.js';
+
+function getExports(module) {
+    return module.body.flatMap((node)=>{
+        switch(node.type){
+            case "ExportDeclaration":
+                return getExportDetails(node);
+            case "ExportNamedDeclaration":
+                return getNamedExportDetails(node);
+            case "ExportDefaultDeclaration":
+            case "ExportDefaultExpression":
+                return getExportDefaultDetails(node);
+            default:
+                return [];
+        }
+    });
+}
+function getExportDetails(node) {
+    switch(node.declaration.type){
+        case "VariableDeclaration":
+            {
+                return node.declaration.declarations.flatMap((declaration)=>{
+                    switch(declaration.id.type){
+                        case "Identifier":
+                            return {
+                                name: declaration.id.value,
+                                node
+                            };
+                        case "ObjectPattern":
+                            {
+                                return filterMap(declaration.id.properties, (property)=>{
+                                    if (property.type !== "AssignmentPatternProperty") return;
+                                    return {
+                                        name: property.key.value,
+                                        node
+                                    };
+                                });
+                            }
+                        default:
+                            {
+                                return [];
+                            }
+                    }
+                });
+            }
+        case "ClassDeclaration":
+        case "FunctionDeclaration":
+            {
+                return {
+                    name: node.declaration.identifier.value,
+                    node
+                };
+            }
+        case "TsEnumDeclaration":
+        case "TsInterfaceDeclaration":
+        case "TsTypeAliasDeclaration":
+            {
+                return {
+                    name: node.declaration.id.value,
+                    node
+                };
+            }
+        default:
+            {
+                return [];
+            }
+    }
+}
+function getNamedExportDetails(node) {
+    if (node.source) return [];
+    return filterMap(node.specifiers, (specifier)=>{
+        if (specifier.type !== "ExportSpecifier") return;
+        return {
+            name: specifier.orig.value,
+            node: node
+        };
+    });
+}
+function getExportDefaultDetails(node) {
+    return [
+        {
+            name: "default",
+            node
+        }
+    ];
+}
+
+export { getExports };

package/lib/importExports/imports.d.ts

@@ -0,0 +1,11 @@
+import { Node, Module } from '@swc/core';
+
+type Import = {
+    specifier: string;
+    name?: string;
+    node: Node;
+};
+declare function getImports(module: Module): Import[];
+
+export { getImports };
+export type { Import };

package/lib/importExports/imports.js

@@ -0,0 +1,74 @@
+import { filterMap } from '../utils/array.js';
+import { traverse } from './traverse.js';
+
+function getImports(module) {
+    return module.body.flatMap((node)=>{
+        switch(node.type){
+            case "ImportDeclaration":
+                {
+                    return getImportDetails(node, module);
+                }
+            default:
+                {
+                    return [];
+                }
+        }
+    });
+}
+function getImportDetails(node, module) {
+    const specifier = node.source.value;
+    if (node.specifiers.length === 0) {
+        return {
+            specifier,
+            node
+        };
+    }
+    return filterMap(node.specifiers, (it)=>{
+        switch(it.type){
+            case "ImportDefaultSpecifier":
+                {
+                    return {
+                        name: "default",
+                        specifier,
+                        node
+                    };
+                }
+            case "ImportSpecifier":
+                {
+                    return {
+                        name: it.imported?.value ?? it.local.value,
+                        specifier,
+                        node
+                    };
+                }
+            case "ImportNamespaceSpecifier":
+                {
+                    const namespace = it.local.value;
+                    const names = new Set();
+                    traverse(module, {
+                        visitMemberExpression (node) {
+                            if (node.object.type === "Identifier" && node.object.value === namespace && node.property.type === "Identifier") {
+                                names.add(node.property.value);
+                            }
+                        },
+                        visitTsQualifiedName (node) {
+                            if (node.left.type === "Identifier" && node.left.value === namespace && node.right.type === "Identifier") {
+                                names.add(node.right.value);
+                            }
+                        }
+                    });
+                    return [
+                        ...names
+                    ].map((name)=>({
+                            name,
+                            specifier,
+                            node
+                        }));
+                }
+            default:
+                console.log(it);
+        }
+    }).flat();
+}
+
+export { getImports };