@module-federation/treeshake-server 0.0.1-alpha.0

package/README.md

@@ -0,0 +1,71 @@
+# Treeshake Server
+
+An adapter-driven build service for shared treeshaking. The CLI runs in **local filesystem mode only** and embeds the treeshake UI automatically. When importing the package, you can register your own adapters, middlewares, and optional frontend UI.
+
+## CLI (embedded UI, local-only)
+
+```bash
+pnpm --filter @module-federation/treeshake-server dev
+# or
+pnpm --filter @module-federation/treeshake-server start
+```
+
+Defaults:
+
+- API: `http://localhost:3000/tree-shaking-shared`
+- UI: `http://localhost:3000/tree-shaking`
+- Storage: local filesystem (`LOCAL_STORE_DIR`, default `./log/static`)
+
+The CLI **ignores** `ADAPTER_ID` and always uses the local filesystem adapter.
+
+### Frontend env overrides (CLI)
+
+The CLI always embeds the UI. You can only override where it is served from:
+
+- `TREESHAKE_FRONTEND_DIST=/path/to/dist`
+- `TREESHAKE_FRONTEND_BASE_PATH=/tree-shaking`
+- `TREESHAKE_FRONTEND_SPA_FALLBACK=0`
+
+## Library usage (custom adapters + middlewares)
+
+```ts
+import {
+  createAdapterRegistry,
+  createAdapterDeps,
+  createApp,
+  createServer,
+  LocalAdapter,
+} from "@module-federation/treeshake-server";
+import { createTreeshakeFrontendAdapter } from "@module-federation/treeshake-frontend/adapter";
+
+const registry = createAdapterRegistry([
+  new LocalAdapter(),
+  // new MyCustomAdapter(),
+]);
+
+const deps = await createAdapterDeps({
+  registry,
+  adapterId: "local", // or your custom adapter id
+});
+
+const app = createApp(deps, {
+  appExtensions: [
+    (appInstance) => {
+      appInstance.use("*", async (c, next) => {
+        c.res.headers.set("x-treeshake", "true");
+        await next();
+      });
+    },
+  ],
+  frontendAdapters: [
+    createTreeshakeFrontendAdapter({
+      basePath: "/tree-shaking",
+      distDir: "/path/to/treeshake-frontend/dist",
+    }),
+  ],
+});
+
+createServer({ app, port: 3000, hostname: "0.0.0.0" });
+```
+
+In library mode you control the adapter registry, middleware, and frontend embedding.

package/bin/treeshake-server.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * Wrapper entry for the CLI.
+ *
+ * pnpm creates workspace bins during install. If the target is a build artifact
+ * (e.g. dist/server.js) and the package hasn't been built yet, install fails
+ * with ENOENT. This wrapper keeps installs clean, and still runs the built
+ * server when it's available.
+ */
+
+const path = require('path');
+
+const entry = path.join(__dirname, '..', 'dist', 'server.js');
+
+try {
+  // eslint-disable-next-line import/no-dynamic-require, global-require
+  require(entry);
+} catch (err) {
+  // If dist hasn't been built yet, show a helpful message and exit.
+  if (err && (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT')) {
+    // eslint-disable-next-line no-console
+    console.error(
+      [
+        'treeshake-server: missing build output at dist/server.js.',
+        '',
+        'Run:',
+        '  pnpm --filter @module-federation/treeshake-server build',
+        '',
+      ].join('\n'),
+    );
+    process.exit(1);
+  }
+
+  throw err;
+}

package/dist/adapters/createAdapterDeps.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterConfig, AdapterCreateResult, AdapterLogger } from './types';
+import type { AdapterRegistry } from './registry';
+export type AdapterDeps = AdapterCreateResult;
+export declare function createAdapterDeps(params: {
+    registry: AdapterRegistry;
+    adapterId: string;
+    adapterConfig?: AdapterConfig;
+    logger?: AdapterLogger;
+    uploadedDir?: string;
+}): Promise<AdapterDeps>;

package/dist/adapters/local/adapter.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterContext, AdapterCreateResult, AdapterEnv, TreeShakeAdapter } from '../types';
+export type LocalAdapterConfig = {
+    rootDir?: string;
+    publicBaseUrl?: string;
+};
+export declare class LocalAdapter implements TreeShakeAdapter<LocalAdapterConfig> {
+    readonly id = "local";
+    fromEnv(env: AdapterEnv): LocalAdapterConfig;
+    create(config: LocalAdapterConfig, _context?: AdapterContext): Promise<AdapterCreateResult>;
+}

package/dist/adapters/local/index.d.ts

@@ -0,0 +1,3 @@
+export { LocalAdapter } from './adapter';
+export type { LocalAdapterConfig } from './adapter';
+export { LocalObjectStore } from './localObjectStore';

package/dist/adapters/local/localObjectStore.d.ts

@@ -0,0 +1,13 @@
+import type { ObjectStore } from '../types';
+export declare class LocalObjectStore implements ObjectStore {
+    private readonly rootDir;
+    private readonly publicBaseUrl;
+    constructor(opts?: {
+        rootDir?: string;
+        publicBaseUrl?: string;
+    });
+    exists(key: string): Promise<boolean>;
+    uploadFile(localPath: string, key: string): Promise<void>;
+    downloadFile(key: string, localPath: string): Promise<void>;
+    publicUrl(key: string): string;
+}

package/dist/adapters/registry.d.ts

@@ -0,0 +1,7 @@
+import type { TreeShakeAdapter } from './types';
+export type AdapterRegistry = {
+    adapters: TreeShakeAdapter[];
+    getAdapterById: (id: string) => TreeShakeAdapter;
+};
+export declare function createAdapterRegistry(adapters: TreeShakeAdapter[]): AdapterRegistry;
+export declare function createOssAdapterRegistry(): AdapterRegistry;

package/dist/adapters/types.d.ts

@@ -0,0 +1,74 @@
+export type AdapterLogger = {
+    info: (...args: unknown[]) => void;
+    warn?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+};
+export type AdapterContext = {
+    logger?: AdapterLogger;
+    uploadedDir?: string;
+};
+export type AdapterConfig = Record<string, unknown>;
+export interface ObjectStore {
+    /**
+     * Return true if an object exists for the given key.
+     *
+     * "key" is the object-store path/key (not a full URL).
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Upload a local file to the object store under the given key.
+     */
+    uploadFile(localPath: string, key: string): Promise<void>;
+    /**
+     * Download a file from the object store to a local path.
+     */
+    downloadFile(key: string, localPath: string): Promise<void>;
+    /**
+     * Convert a key to a publicly reachable URL.
+     */
+    publicUrl(key: string): string;
+}
+export type UploadOptions = {
+    scmName: string;
+    bucketName: string;
+    publicFilePath: string;
+    publicPath: string;
+    cdnRegion: string;
+};
+export interface ProjectPublisher {
+    /**
+     * Return true if a public URL is already reachable (cache hit).
+     */
+    exists(publicUrl: string): Promise<boolean>;
+    /**
+     * Compute the public URL for a would-be published file.
+     *
+     * This lets the caller do an existence check before uploading.
+     */
+    publicUrl(params: {
+        sharedName: string;
+        hash: string;
+        fileName: string;
+        options: UploadOptions;
+    }): string;
+    /**
+     * Publish a file to a project-owned CDN/bucket and return its public URL.
+     */
+    publishFile(params: {
+        localPath: string;
+        sharedName: string;
+        hash: string;
+        options: UploadOptions;
+    }): Promise<string>;
+}
+export type AdapterCreateResult = {
+    objectStore: ObjectStore;
+    projectPublisher?: ProjectPublisher;
+    shutdown?: () => Promise<void>;
+};
+export type AdapterEnv = Record<string, string | undefined>;
+export interface TreeShakeAdapter<TConfig = AdapterConfig> {
+    readonly id: string;
+    create(config: TConfig, context?: AdapterContext): Promise<AdapterCreateResult>;
+    fromEnv?: (env: AdapterEnv) => TConfig;
+}

package/dist/app.d.ts

@@ -0,0 +1,18 @@
+import { Hono } from 'hono';
+import type { AppEnv } from './http/env';
+import type { ObjectStore } from './ports/objectStore';
+import type { ProjectPublisher } from './ports/projectPublisher';
+import type { FrontendAdapter } from './frontend/types';
+import { setLogger } from './infra/logger';
+export declare function createApp(deps: {
+    objectStore: ObjectStore;
+    projectPublisher?: ProjectPublisher;
+}, opts?: {
+    corsOrigin?: string;
+    staticRootDir?: string;
+    pruneIntervalMs?: number;
+    logger?: Parameters<typeof setLogger>[0];
+    runtimeEnv?: Record<string, string | undefined>;
+    frontendAdapters?: FrontendAdapter[];
+    appExtensions?: Array<(app: Hono<AppEnv>) => void>;
+}): Hono<AppEnv, import("hono/types").BlankSchema, "/">;

package/dist/cli/ossEnv.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterEnv, AdapterConfig } from '../adapters/types';
+import type { AdapterRegistry } from '../adapters/registry';
+export type ResolvedOssEnv = {
+    adapterId: string;
+    adapterConfig: AdapterConfig;
+    corsOrigin: string;
+    staticRootDir: string;
+    logLevel: string;
+    port: number;
+    hostname: string;
+    pruneIntervalMs: number;
+    runtimeEnv: AdapterEnv;
+};
+export declare function resolveOssEnv(params: {
+    env: AdapterEnv;
+    registry: AdapterRegistry;
+    defaultAdapterId?: string;
+}): ResolvedOssEnv;

package/dist/domain/build/constant.d.ts

@@ -0,0 +1 @@
+export declare const STATS_NAME = "mf-stats.json";

package/dist/domain/build/normalize-config.d.ts

@@ -0,0 +1,22 @@
+import type { CheckTreeShaking, Config } from './schema';
+export type NormalizedConfig = {
+    [sharedName: string]: (Config | CheckTreeShaking) & {
+        usedExports: string[];
+    };
+};
+export type BuildType = 're-shake' | 'full';
+export declare const parseNormalizedKey: (key: string) => {
+    name: string;
+    version: string;
+};
+export declare const normalizedKey: (name: string, v: string) => string;
+export declare function normalizeConfig(config: Config | CheckTreeShaking): NormalizedConfig;
+export declare function extractBuildConfig(config: NormalizedConfig[string], type: BuildType): {
+    shared: [string, string, string[]][];
+    plugins: [string, (string | undefined)?][] | undefined;
+    target: string | string[];
+    libraryType: string;
+    usedExports: string[];
+    type: BuildType;
+    hostName: string;
+};

package/dist/domain/build/retrieve-global-name.d.ts

@@ -0,0 +1 @@
+export declare function retrieveGlobalName(mfName: string, sharedName: string, version: string): string;

package/dist/domain/build/schema.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const ConfigSchema: z.ZodObject<{
+    shared: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString, z.ZodArray<z.ZodString>], null>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>], null>>>;
+    target: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    libraryType: z.ZodString;
+    hostName: z.ZodString;
+    uploadOptions: z.ZodOptional<z.ZodObject<{
+        scmName: z.ZodString;
+        bucketName: z.ZodString;
+        publicFilePath: z.ZodString;
+        publicPath: z.ZodString;
+        cdnRegion: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare const CheckTreeShakingSchema: z.ZodObject<{
+    shared: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString, z.ZodArray<z.ZodString>], null>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>], null>>>;
+    target: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    libraryType: z.ZodString;
+    hostName: z.ZodString;
+    uploadOptions: z.ZodOptional<z.ZodObject<{
+        scmName: z.ZodString;
+        bucketName: z.ZodString;
+        publicFilePath: z.ZodString;
+        publicPath: z.ZodString;
+        cdnRegion: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CheckTreeShaking = z.infer<typeof CheckTreeShakingSchema>;

package/dist/domain/upload/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const SERVER_VERSION = "v0-011501";
+export declare const UPLOADED_DIR = "_shared-tree-shaking";

package/dist/domain/upload/retrieve-cdn-path.d.ts

@@ -0,0 +1,4 @@
+export declare function retrieveCDNPath({ configHash, sharedKey, }: {
+    configHash: string;
+    sharedKey: string;
+}): string;

package/dist/frontend/adapter/index.d.ts

@@ -0,0 +1,13 @@
+export type FrontendAdapter = {
+    id: string;
+    register: (app: {
+        get: (path: string, handler: any) => void;
+    }) => void;
+};
+export type TreeshakeFrontendAdapterOptions = {
+    basePath?: string;
+    distDir?: string;
+    indexFile?: string;
+    spaFallback?: boolean;
+};
+export declare function createTreeshakeFrontendAdapter(opts?: TreeshakeFrontendAdapterOptions): FrontendAdapter;

package/dist/frontend/adapter/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createTreeshakeFrontendAdapter: ()=>createTreeshakeFrontendAdapter
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const defaultBasePath = '/tree-shaking';
+const contentTypeByExt = (filePath)=>{
+    if (filePath.endsWith('.html')) return 'text/html; charset=utf-8';
+    if (filePath.endsWith('.js')) return "application/javascript";
+    if (filePath.endsWith('.css')) return 'text/css';
+    if (filePath.endsWith('.json')) return 'application/json';
+    if (filePath.endsWith('.svg')) return 'image/svg+xml';
+    if (filePath.endsWith('.png')) return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg')) return 'image/jpeg';
+    if (filePath.endsWith('.webp')) return 'image/webp';
+    if (filePath.endsWith('.ico')) return 'image/x-icon';
+    return 'application/octet-stream';
+};
+const resolveDistDir = (override)=>{
+    if (override) return override;
+    const candidate = external_node_path_default().resolve(__dirname, '..');
+    const candidateIndex = external_node_path_default().join(candidate, 'index.html');
+    if (external_node_fs_default().existsSync(candidateIndex)) return candidate;
+    return external_node_path_default().resolve(__dirname, '..', '..', 'dist');
+};
+const safeResolve = (rootDir, requestPath)=>{
+    const rootResolved = external_node_path_default().resolve(rootDir);
+    const rel = requestPath.replace(/^\/+/, '');
+    const filePath = external_node_path_default().resolve(rootResolved, rel);
+    if (filePath !== rootResolved && !filePath.startsWith(`${rootResolved}${external_node_path_default().sep}`)) return null;
+    return filePath;
+};
+function createTreeshakeFrontendAdapter(opts = {}) {
+    const basePath = opts.basePath ?? defaultBasePath;
+    const normalizedBase = '/' === basePath ? '' : basePath.replace(/\/$/, '');
+    const distDir = resolveDistDir(opts.distDir);
+    const indexFile = opts.indexFile ?? 'index.html';
+    const spaFallback = opts.spaFallback ?? true;
+    const handler = async (c)=>{
+        let requestPath = c.req.path;
+        try {
+            requestPath = decodeURIComponent(requestPath);
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+        let relPath = requestPath;
+        if (normalizedBase && requestPath.startsWith(normalizedBase)) relPath = requestPath.slice(normalizedBase.length);
+        if (!relPath || '/' === relPath) relPath = `/${indexFile}`;
+        const filePath = safeResolve(distDir, relPath);
+        if (filePath) try {
+            const stat = await external_node_fs_default().promises.stat(filePath);
+            if (stat.isFile()) {
+                const buf = await external_node_fs_default().promises.readFile(filePath);
+                return new Response(buf, {
+                    status: 200,
+                    headers: {
+                        'Content-Type': contentTypeByExt(filePath)
+                    }
+                });
+            }
+        } catch  {}
+        if (!spaFallback) return c.text('Not Found', 404);
+        const fallbackPath = safeResolve(distDir, `/${indexFile}`);
+        if (!fallbackPath) return c.text('Not Found', 404);
+        try {
+            const buf = await external_node_fs_default().promises.readFile(fallbackPath);
+            return new Response(buf, {
+                status: 200,
+                headers: {
+                    'Content-Type': contentTypeByExt(fallbackPath)
+                }
+            });
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+    };
+    return {
+        id: 'treeshake-frontend',
+        register (app) {
+            const base = normalizedBase || '/';
+            app.get(base, handler);
+            app.get(`${base}/*`, handler);
+        }
+    };
+}
+exports.createTreeshakeFrontendAdapter = __webpack_exports__.createTreeshakeFrontendAdapter;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createTreeshakeFrontendAdapter"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/frontend/adapter/index.mjs

@@ -0,0 +1,83 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+const defaultBasePath = '/tree-shaking';
+const contentTypeByExt = (filePath)=>{
+    if (filePath.endsWith('.html')) return 'text/html; charset=utf-8';
+    if (filePath.endsWith('.js')) return "application/javascript";
+    if (filePath.endsWith('.css')) return 'text/css';
+    if (filePath.endsWith('.json')) return 'application/json';
+    if (filePath.endsWith('.svg')) return 'image/svg+xml';
+    if (filePath.endsWith('.png')) return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg')) return 'image/jpeg';
+    if (filePath.endsWith('.webp')) return 'image/webp';
+    if (filePath.endsWith('.ico')) return 'image/x-icon';
+    return 'application/octet-stream';
+};
+const resolveDistDir = (override)=>{
+    if (override) return override;
+    const candidate = node_path.resolve(__dirname, '..');
+    const candidateIndex = node_path.join(candidate, 'index.html');
+    if (node_fs.existsSync(candidateIndex)) return candidate;
+    return node_path.resolve(__dirname, '..', '..', 'dist');
+};
+const safeResolve = (rootDir, requestPath)=>{
+    const rootResolved = node_path.resolve(rootDir);
+    const rel = requestPath.replace(/^\/+/, '');
+    const filePath = node_path.resolve(rootResolved, rel);
+    if (filePath !== rootResolved && !filePath.startsWith(`${rootResolved}${node_path.sep}`)) return null;
+    return filePath;
+};
+function createTreeshakeFrontendAdapter(opts = {}) {
+    const basePath = opts.basePath ?? defaultBasePath;
+    const normalizedBase = '/' === basePath ? '' : basePath.replace(/\/$/, '');
+    const distDir = resolveDistDir(opts.distDir);
+    const indexFile = opts.indexFile ?? 'index.html';
+    const spaFallback = opts.spaFallback ?? true;
+    const handler = async (c)=>{
+        let requestPath = c.req.path;
+        try {
+            requestPath = decodeURIComponent(requestPath);
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+        let relPath = requestPath;
+        if (normalizedBase && requestPath.startsWith(normalizedBase)) relPath = requestPath.slice(normalizedBase.length);
+        if (!relPath || '/' === relPath) relPath = `/${indexFile}`;
+        const filePath = safeResolve(distDir, relPath);
+        if (filePath) try {
+            const stat = await node_fs.promises.stat(filePath);
+            if (stat.isFile()) {
+                const buf = await node_fs.promises.readFile(filePath);
+                return new Response(buf, {
+                    status: 200,
+                    headers: {
+                        'Content-Type': contentTypeByExt(filePath)
+                    }
+                });
+            }
+        } catch  {}
+        if (!spaFallback) return c.text('Not Found', 404);
+        const fallbackPath = safeResolve(distDir, `/${indexFile}`);
+        if (!fallbackPath) return c.text('Not Found', 404);
+        try {
+            const buf = await node_fs.promises.readFile(fallbackPath);
+            return new Response(buf, {
+                status: 200,
+                headers: {
+                    'Content-Type': contentTypeByExt(fallbackPath)
+                }
+            });
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+    };
+    return {
+        id: 'treeshake-frontend',
+        register (app) {
+            const base = normalizedBase || '/';
+            app.get(base, handler);
+            app.get(`${base}/*`, handler);
+        }
+    };
+}
+export { createTreeshakeFrontendAdapter };

package/dist/frontend/index.html

@@ -0,0 +1 @@
+<!DOCTYPE html><html><head><link rel="icon" href="/tree-shaking/favicon.ico"><title>Tree Shaking Visualizer</title><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><script defer src="/tree-shaking/static/js/lib-react.c59642e3.js"></script><script defer src="/tree-shaking/static/js/lib-router.75e1e689.js"></script><script defer src="/tree-shaking/static/js/296.084d1b43.js"></script><script defer src="/tree-shaking/static/js/index.5488f626.js"></script><link href="/tree-shaking/static/css/index.16175e0f.css" rel="stylesheet"></head><body><div id="root"></div></body></html>