@equinor/fusion-framework-dev-server 2.1.0 → 2.1.1

package/src/create-dev-server-config.ts

@@ -1,124 +0,0 @@
-import { defineConfig, mergeConfig, type UserConfig } from 'vite';
-
-import reactPlugin from '@vitejs/plugin-react';
-
-import apiServicePlugin, {
-  createProxyHandler,
-} from '@equinor/fusion-framework-vite-plugin-api-service';
-
-import fusionSpaPlugin from '@equinor/fusion-framework-vite-plugin-spa';
-import { ConsoleLogger, LogLevel } from '@equinor/fusion-log';
-
-import { processServices as defaultProcessServices } from './process-services.js';
-
-import type { DevServerOptions, TemplateEnv, TemplateEnvFn } from './types.js';
-
-/**
- * Create a default {@link ConsoleLogger} instance for the dev server.
- *
- * @param lvl - Log verbosity level; defaults to {@link LogLevel.Info}.
- * @param title - Logger title printed as a prefix in console output; defaults to `'dev-server'`.
- * @returns A configured {@link ConsoleLogger} instance.
- */
-const createDefaultLogger = (lvl: LogLevel = LogLevel.Info, title = 'dev-server') => {
-  const logger = new ConsoleLogger(title);
-  logger.level = lvl;
-  return logger;
-};
-
-/**
- * Build a Vite {@link import('vite').UserConfig | UserConfig} for a Fusion Framework dev server
- * without starting the server.
- *
- * Use this function when you need control over the server lifecycle (e.g. to pass the config
- * to another Vite tool). For a simpler create-and-listen workflow, use {@link createDevServer}.
- *
- * The generated config includes:
- * - `@vitejs/plugin-react` for React Fast Refresh / HMR
- * - `@equinor/fusion-framework-vite-plugin-api-service` for service discovery proxying
- * - `@equinor/fusion-framework-vite-plugin-spa` for template environment injection
- * - CORS disabled so backend services handle OPTIONS with proper headers
- *
- * @template TEnv - Environment variable shape extending `Partial<TemplateEnv>`, used to type-check
- *                  the SPA template environment object or factory function.
- * @param options - Development server options containing SPA, API, and logging settings.
- * @param overrides - Optional Vite config merged on top of the generated base config via
- *                    {@link import('vite').mergeConfig | mergeConfig}.
- * @returns A fully resolved Vite `UserConfig` ready for {@link import('vite').createServer | createServer}.
- *
- * @remarks
- * - `spa.templateEnv` accepts either a static object or a factory function returning the environment.
- * - `api.processServices` defaults to the built-in {@link processServices} when omitted.
- * - The default log level is `Info`; set `log.level` to `4` for debug output.
- *
- * @example
- * ```typescript
- * import { createDevServerConfig } from '@equinor/fusion-framework-dev-server';
- * import { createServer } from 'vite';
- *
- * const config = createDevServerConfig({
- *   spa: {
- *     templateEnv: {
- *       portal: { id: 'my-portal' },
- *       title: 'My App',
- *       serviceDiscovery: { url: 'https://discovery.example.com', scopes: [] },
- *       msal: { clientId: 'cid', tenantId: 'tid', redirectUri: '/auth/cb', requiresAuth: 'true' },
- *     },
- *   },
- *   api: { serviceDiscoveryUrl: 'https://discovery.example.com' },
- * });
- *
- * const server = await createServer(config);
- * await server.listen();
- * ```
- */
-export const createDevServerConfig = <TEnv extends Partial<TemplateEnv>>(
-  options: DevServerOptions<TEnv>,
-  overrides?: UserConfig,
-): UserConfig => {
-  const { spa, api, log } = options;
-  const processServices = api.processServices ?? defaultProcessServices;
-  const generateTemplateEnv: TemplateEnvFn<TEnv> =
-    // ensure that the templateEnv is a function
-    typeof spa?.templateEnv === 'function'
-      ? spa.templateEnv
-      : () => spa?.templateEnv as Partial<TEnv>;
-
-  // setup log instance
-  const logger = log?.logger ?? createDefaultLogger(log?.level);
-
-  const apiServiceLogger = logger.createSubLogger('api-service');
-  const spaLogger = logger.createSubLogger('spa');
-
-  const baseConfig = defineConfig({
-    appType: 'custom',
-    define: {
-      'process.env': JSON.stringify({
-        FUSION_LOG_LEVEL: String(logger.level),
-      }),
-    },
-    server: {
-      // Disable Vite's internal CORS handling to allow backend to handle OPTIONS requests properly
-      // This ensures that OPTIONS requests are forwarded to the backend with proper headers
-      cors: false,
-    },
-    plugins: [
-      reactPlugin(),
-      apiServicePlugin(
-        {
-          proxyHandler: createProxyHandler(api.serviceDiscoveryUrl, processServices, {
-            logger: apiServiceLogger,
-          }),
-          routes: api.routes,
-        },
-        {
-          logger: apiServiceLogger,
-        },
-      ),
-      fusionSpaPlugin({ generateTemplateEnv, logger: spaLogger }),
-    ],
-  });
-  return mergeConfig(baseConfig, overrides ?? {});
-};
-
-export default createDevServerConfig;

package/src/create-dev-server.ts

@@ -1,48 +0,0 @@
-import { createServer, type UserConfig } from 'vite';
-import { createDevServerConfig } from './create-dev-server-config.js';
-
-import type { DevServerOptions } from './types.js';
-
-/**
- * Create and return a fully configured Vite development server for a Fusion Framework application.
- *
- * Combines SPA template environment injection, service discovery proxying, and React HMR into
- * a single ready-to-listen server instance. Use this function when you want the default
- * development workflow; use {@link createDevServerConfig} instead if you only need the Vite
- * configuration object without starting the server.
- *
- * @param options - Development server configuration including SPA template environment,
- *                  API proxy settings, and optional logging overrides.
- * @param overrides - Optional Vite {@link import('vite').UserConfig | UserConfig} merged on top
- *                    of the generated configuration (e.g. custom port, extra plugins).
- * @returns A promise that resolves to a Vite {@link import('vite').ViteDevServer | ViteDevServer}
- *          ready for {@link import('vite').ViteDevServer.listen | listen()} and
- *          {@link import('vite').ViteDevServer.printUrls | printUrls()}.
- *
- * @example
- * ```typescript
- * import { createDevServer } from '@equinor/fusion-framework-dev-server';
- *
- * const server = await createDevServer({
- *   spa: {
- *     templateEnv: {
- *       portal: { id: 'my-portal' },
- *       title: 'My App',
- *       serviceDiscovery: { url: 'https://discovery.example.com', scopes: [] },
- *       msal: { clientId: 'id', tenantId: 'tid', redirectUri: '/auth/callback', requiresAuth: 'true' },
- *     },
- *   },
- *   api: { serviceDiscoveryUrl: 'https://discovery.example.com' },
- * });
- *
- * await server.listen();
- * server.printUrls();
- * ```
- */
-export const createDevServer = async (options: DevServerOptions, overrides?: UserConfig) => {
-  const config = createDevServerConfig(options, overrides);
-  const server = await createServer(config);
-  return server;
-};
-
-export default createDevServer;

package/src/index.ts

@@ -1,40 +0,0 @@
-/**
- * @packageDocumentation
- *
- * Development server for Fusion Framework applications.
- *
- * Provides a pre-configured Vite dev server with integrated service discovery proxying,
- * SPA template environment injection, and React HMR support. Use this package when you
- * need a local development environment that mirrors production Fusion portal behaviour.
- *
- * @remarks
- * Main entry points:
- * - {@link createDevServer} — create and start a fully configured Vite dev server
- * - {@link createDevServerConfig} — build a Vite `UserConfig` without starting the server
- * - {@link processServices} — remap Fusion service URIs to local proxy routes
- *
- * @example
- * ```typescript
- * import { createDevServer } from '@equinor/fusion-framework-dev-server';
- *
- * const server = await createDevServer({
- *   api: { serviceDiscoveryUrl: 'https://discovery.example.com' },
- * });
- * await server.listen();
- * server.printUrls();
- * ```
- */
-
-/** Re-export of Vite's {@link import('vite').UserConfig | UserConfig} for consumer convenience when passing overrides. */
-export type { UserConfig } from 'vite';
-
-export { processServices } from './process-services.js';
-
-export { default, createDevServer } from './create-dev-server.js';
-
-export { createDevServerConfig } from './create-dev-server-config.js';
-
-/** Re-export of the SPA template environment type used to configure portal, MSAL, and service discovery settings. */
-export type { FusionTemplateEnv } from '@equinor/fusion-framework-vite-plugin-spa';
-
-export * from './types.js';

package/src/process-services.test.ts

@@ -1,36 +0,0 @@
-import { IncomingMessage } from 'node:http';
-import { Socket } from 'node:net';
-
-import { describe, expect, it } from 'vitest';
-
-import { processServices } from './process-services.js';
-
-const request = new IncomingMessage(new Socket());
-request.headers.referer = 'http://localhost:3000';
-
-describe('processServices', () => {
-  it('proxies localhost subdomains through the portable shared-host route', () => {
-    const result = processServices(
-      [{ key: 'people', name: 'People', uri: 'http://people.localhost:4010' }],
-      { route: '/@fusion-api', request },
-    );
-
-    expect(result.routes).toEqual([
-      {
-        match: '/people/*sub',
-        proxy: { target: 'http://localhost:4010' },
-      },
-    ]);
-  });
-
-  it('preserves normal upstream proxy targets and path rewriting', () => {
-    const result = processServices(
-      [{ key: 'people', name: 'People', uri: 'https://people.example/api' }],
-      { route: '/@fusion-api', request },
-    );
-    const [route] = result.routes ?? [];
-
-    expect(route?.proxy?.target).toBe('https://people.example');
-    expect(route?.proxy?.rewrite?.('/people/api/persons')).toBe('/api/persons');
-  });
-});

package/src/process-services.ts

@@ -1,99 +0,0 @@
-import type { ApiDataProcessor, ApiRoute } from '@equinor/fusion-framework-vite-plugin-api-service';
-import type { FusionService } from './types.js';
-
-/**
- * Remap Fusion service discovery entries so their URIs point through the local dev server proxy,
- * and generate matching Vite proxy routes for each service.
- *
- * Use this as the default `api.processServices` handler in {@link DevServerOptions}, or call it
- * inside a custom handler to get the base mapping before applying additional transformations
- * (e.g. adding mock services or filtering environments).
- *
- * @param data - Array of {@link FusionService} entries returned by the service discovery endpoint.
- * @param args - Context provided by the API service plugin.
- * @param args.route - Base route path used to construct local proxy URLs (e.g. `'/services-proxy'`).
- * @param args.request - Incoming HTTP request; the `referer` header is used to resolve the local origin.
- * @returns An object with `data` (services with rewritten URIs) and `routes` (Vite proxy route configs).
- * @throws {Error} When `data` is not an array, indicating an unexpected service discovery response.
- *
- * @example
- * ```typescript
- * const services = [
- *   { key: 'service1', uri: 'http://example.com/api', name: 'Service 1' },
- *   { key: 'service2', uri: 'http://example.org/api', name: 'Service 2' },
- * ];
- * const args = {
- *   route: '/proxy',
- *   request: { headers: { referer: 'http://localhost:3000' } },
- * };
- * const result = processServices(services, args);
- * console.log(result.data); // Processed services with updated URIs
- *
- * // Expected output:
- * // result.data:
- * // [
- * //   { key: 'service1', uri: 'http://localhost:3000/proxy/service1', name: 'Service 1' },
- * //   { key: 'service2', uri: 'http://localhost:3000/proxy/service2', name: 'Service 2' },
- * // ]
- *
- * console.log(result.routes); // Generated proxy routes
- *
- * // result.routes:
- * // [
- * //   {
- * //     match: '/service1/api*sub',
- * //     proxy: {
- * //       target: 'http://example.com',
- * //       rewrite: (path) => path.replace('/service1', ''),
- * //     },
- * //   },
- * //   {
- * //     match: '/service2/api*sub',
- * //     proxy: {
- * //       target: 'http://example.org',
- * //       rewrite: (path) => path.replace('/service2', ''),
- * //     },
- * //   },
- * // ]
- * ```
- */
-export const processServices: ApiDataProcessor<FusionService[]> = (data, args) => {
-  const { route, request } = args;
-  const apiRoutes = [] as ApiRoute[];
-  const apiServices = [] as FusionService[];
-
-  // Fail fast when the upstream response isn't the expected service-list shape
-  if (!Array.isArray(data)) {
-    throw new Error('Invalid data format');
-  }
-
-  // remap all services to proxy though the dev server
-  // and generate the proxy routes
-  for (const service of data as FusionService[]) {
-    // append host, port and protocol to the service uri
-    // and replace the path with the local proxy path
-    const serviceUrl = new URL(`${route}/${service.key}`, request.headers.referer);
-    apiServices.push({ ...service, uri: String(serviceUrl) });
-
-    // Add the proxy route for this service.
-    const url = new URL(service.uri);
-    const usesLocalhostSubdomain = url.hostname.endsWith('.localhost');
-    // Node does not resolve localhost subdomains consistently across operating systems. The mock
-    // server also accepts /<service>/* on plain localhost, so proxy through that portable address.
-    if (usesLocalhostSubdomain) {
-      url.hostname = 'localhost';
-    }
-    apiRoutes.push({
-      match: `/${service.key}${url.pathname}*sub`,
-      proxy: usesLocalhostSubdomain
-        ? { target: url.origin }
-        : {
-            target: url.origin,
-            rewrite: (path) => path.replace(`/${service.key}`, ''),
-          },
-    });
-  }
-  return { data: apiServices, routes: apiRoutes };
-};
-
-export default processServices;

package/src/types.ts

@@ -1,105 +0,0 @@
-import type { ApiDataProcessor, ApiRoute } from '@equinor/fusion-framework-vite-plugin-api-service';
-import type { FusionTemplateEnv, TemplateEnvFn } from '@equinor/fusion-framework-vite-plugin-spa';
-import type { ConsoleLogger } from '@equinor/fusion-log';
-
-/**
- * A service entry returned by the Fusion service discovery endpoint.
- *
- * Each entry represents a single backend service that can be proxied
- * through the development server via {@link processServices}.
- */
-export type FusionService = {
-  /** Unique service identifier used as the proxy path segment (e.g. `'context'`, `'people'`). */
-  key: string;
-  /** Absolute URL of the upstream service endpoint. */
-  uri: string;
-  /** Human-readable display name of the service. */
-  name: string;
-  /**
-   * OAuth scopes required when requesting tokens for this service.
-   *
-   * @remarks
-   * When present, these scopes are forwarded through {@link processServices} so the
-   * Fusion Framework HTTP module can acquire a Bearer token for service requests.
-   * If absent (i.e. the service discovery endpoint does not return scopes), the HTTP
-   * client will make unauthenticated requests — use the service worker resource
-   * configuration to inject auth in that case.
-   */
-  scopes?: string[];
-};
-
-/**
- * Re-export of {@link FusionTemplateEnv} under the local alias `TemplateEnv`.
- *
- * Describes the environment variables injected into the SPA HTML template
- * (portal ID, service discovery URL, MSAL settings, telemetry level, etc.).
- */
-export {
-  FusionTemplateEnv as TemplateEnv,
-  TemplateEnvFn,
-} from '@equinor/fusion-framework-vite-plugin-spa';
-
-/**
- * Alias for Vite's `UserConfig`, used as the optional overrides parameter
- * of {@link createDevServer} and {@link createDevServerConfig}.
- */
-export { UserConfig as DevServerOverrides } from 'vite';
-
-/**
- * Configuration options for the Fusion Framework development server.
- *
- * Pass an instance of this type to {@link createDevServer} or {@link createDevServerConfig}
- * to configure SPA template injection, API service discovery proxying, and server-side logging.
- *
- * @template TEnv - Shape of the SPA template environment variables, extending
- *                  `Partial<FusionTemplateEnv>`. Defaults to `Partial<FusionTemplateEnv>`.
- *
- * @example
- * ```typescript
- * const opts: DevServerOptions = {
- *   spa: {
- *     templateEnv: {
- *       portal: { id: 'my-portal' },
- *       title: 'My App',
- *       serviceDiscovery: { url: 'https://discovery.example.com', scopes: [] },
- *       msal: { clientId: 'id', tenantId: 'tid', redirectUri: '/auth/cb', requiresAuth: 'true' },
- *     },
- *   },
- *   api: { serviceDiscoveryUrl: 'https://discovery.example.com' },
- *   log: { level: 3 },
- * };
- * ```
- */
-export interface DevServerOptions<
-  TEnv extends Partial<FusionTemplateEnv> = Partial<FusionTemplateEnv>,
-> {
-  /** SPA template settings. When provided, the dev server injects these values into the HTML template at serve time. */
-  spa?: {
-    /** Static environment object or factory function that produces it on each request. */
-    templateEnv: TEnv | TemplateEnvFn<TEnv>;
-  };
-  api: {
-    /**
-     * The URL of the service discovery proxy endpoint.
-     */
-    serviceDiscoveryUrl: string;
-
-    /**
-     * Route mapper for processing service discovery data.
-     */
-    processServices?: ApiDataProcessor<FusionService[]>;
-
-    /**
-     * Additional routes to be added to the API service proxy.
-     * @remarks used for overriding proxy responses and mocking services.
-     */
-    routes?: ApiRoute[];
-  };
-  /** Server-side (CLI) logging configuration. */
-  log?: {
-    /** Log verbosity: 0 = None, 1 = Error, 2 = Warning, 3 = Info, 4 = Debug. Defaults to Info (3). */
-    level?: number;
-    /** Custom logger instance. When omitted a default {@link ConsoleLogger} is created. */
-    logger?: ConsoleLogger;
-  };
-}

package/src/version.ts

@@ -1,2 +0,0 @@
-// Generated by genversion.
-export const version = '2.1.0';

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist/esm",
-    "declarationDir": "./dist/types",
-    "paths": {
-      "*": ["./*"]
-    }
-  },
-  "references": [
-    {
-      "path": "../vite-plugins/api-service"
-    },
-    {
-      "path": "../vite-plugins/spa"
-    }
-  ],
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "tests"]
-}

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineProject } from 'vitest/config';
-
-import { name, version } from './package.json' with { type: 'json' };
-
-export default defineProject({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-    name: `${name}@${version}`,
-  },
-});