@nerest/nerest 0.1.0 → 1.5.1

package/LICENSE.md

@@ -0,0 +1,178 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2025 Nerest team

package/README.md

@@ -1,43 +1,30 @@
-# @nerest/nerest
+# Nerest
 
-React micro frontend framework
+Nerest is an opinionated micro frontend framework/stack for building SSR applications with TypeScript, Fastify, JSON Schema and React. It is available as a single `@nerest/nerest` npm package.
 
-> TODO: purpose, outline, documentation
+[View current documentation](https://nerestjs.github.io/docs/)
 
-## Installation
+## Quick Start
 
-TODO: update package
-
-```
-npm i --save @nerest/nerest react react-dom
-```
-
-## Points of Interest
-
-- SSR server entry:
-  - Development: [server/development.ts](server/development.ts)
-  - Production: [server/production.ts](server/production.ts)
-- Hydrating client entry: [client/index.ts](client/index.ts)
-- CLI entry: [bin/index.ts](bin/index.ts)
-- Production build script: [build/index.ts](build/index.ts)
+[Follow the tutorial](https://nerestjs.github.io/docs/tutorial/) to build your first Nerest micro frontend step-by-step, or clone and run [the complete version](https://github.com/nerestjs/tutorial) of that micro frontend locally.
 
 ## Conventions
 
-The `apps` directory must contain all of the apps provided by the micro frontend. E.g. `/apps/foo/index.tsx` is the entrypoint component of the `foo` app. It becomes available as the `/api/foo` route of the micro frontend server.
+### `/apps`
 
-See [nerest-harness](https://gitlab.tcsbank.ru/tj/nerest-harness) for the minimal example of a nerest micro frontend.
+The `/apps` directory must contain all of the apps provided by the micro frontend. E.g. `/apps/foo/index.tsx` is the entrypoint component of the `foo` app. It becomes available as the `/api/foo` route of the micro frontend server.
 
-### Examples (`/examples/*.json`)
+#### Examples (`/examples/*.json`)
 
 The app directory may contain an `examples` subdirectory with example JSON files which can be used as props for the app entrypoint component. E.g. `/apps/foo/examples/example-1.json` becomes available as the `/api/foo/examples/example-1` route of the micro frontend server.
 
-### Schema (`/schema.json`)
+#### Schema (`/schema.json`)
 
 The app directory should contain a `schema.json` file that describes the schema of a request body for this specific app in the [JSON Schema language](https://json-schema.org/). All requests sent to this app, and app examples from the `examples` subdirectory will be validated against this schema. `ajv` and `ajv-formats` are used for validation, so all JSON Schema features implemented by them are supported.
 
 OpenAPI specification is compiled automatically based on the provided schemas and becomes available at `/api/json`. It can also be explored through Swagger UI that becomes available at `/api`.
 
-### Props Hook (`/props.ts`)
+#### Props Hook (`/props.ts`)
 
 The app directory may contain a `props.ts` module that exports a default function. If it exists, this function will be executed on the server for every incoming request, receiving the body of the request and a logger as parameters. You can use this hook to modify and return a new object, which will be passed down to the `index.tsx` entrypoint component instead. For example:
 
@@ -54,17 +41,27 @@ export default function (props: Props, logger: FastifyBaseLogger) {
 }
 ```
 
-The exported function may be async, in which case nerest will wait for the Promise to resolve, then pass the result object to the entrypoint component.
+The exported function may be async, in which case Nerest will wait for the Promise to resolve, then pass the result object to the entrypoint component.
+
+### `/package.json`
+
+`name`, `description`, `version`, `homepage` and `repository` fields of the root `package.json` file are used to display project info in the header of the generated Swagger page.
+
+`name` is also used to disambiguate multiple apps with the same name from different micro frontends. If you have multiple apps with the same name embeded in a single page, make sure that the `name` field of their micro frontends' `package.json` files is unique.
 
 ## Configuration
 
-Different aspects of Nerest apps can be configured via environment variables, JSON configuration and runtime hooks written in TypeScript. Examples of all kinds of configuration can be viewed in the [nerest-harness](https://gitlab.tcsbank.ru/tj/nerest-harness) repository.
+Different aspects of Nerest apps can be configured via environment variables, JSON configuration and runtime hooks written in TypeScript.
 
 ### Environment Variables
 
 #### Buildtime
 
-- `NEREST_STATIC_PATH` is required for production build and must contain the URL of where the client static assets will be deployed. It lets the server-side renderer return their paths in the assets field of the response.
+##### STATIC_PATH
+
+`STATIC_PATH` is required for production build and should contain the URL where the client static assets will be deployed. It enables the server-side renderer to return their paths in the assets field of the response.
+
+In development, it is optional and can be used to load example previews' assets from a different address than the default `127.0.0.1:$PORT`. This allows debugging of the micro frontend from another device on the same local network. For example, run `STATIC_PATH=<local_ip>:<port> npm run watch` and access previews from another device on the same network by going to `http://<local_ip>:<port>/api/`
 
 #### Runtime
 
@@ -74,17 +71,19 @@ All environment variables prefixed with `NEREST_` will be bundled with your app
 
 ##### Server
 
-Additional environment variables which can be setup for a runtime:
+Environment variables for runtime configuration:
 
-- `ENABLE_K8S_PROBES`: activates additional routes `/livenessProbe` and `/readinessProbe` to check application status
+- `PORT`: Sets the port number for the application. The default port is 3000.
+- `ENABLE_K8S_PROBES`: Enables additional routes `/livenessProbe` and `/readinessProbe` to check the application status, useful for Kubernetes healthchecks.
+- `DISABLE_SCHEMA_VALIDATION`: Disables validation of request body against app schema. Can be used in production to speed up request time.
 
-### JSON Configuration
+### Build
 
-You can configure the output of `nerest build` by placing an optional `nerest-build.json` configuration file in the root of the micro frontend. The full schema of this file is located in [schemas/nerest-build.schema.json](schemas/nerest-build.schema.json).
+Customize the build output by placing an optional `nerest/build.json` configuration file in the micro frontend's root directory. Refer to the [schemas/nerest-build.schema.json](schemas/nerest-build.schema.json) for the full schema of this file.
 
 #### excludes: `string[]`
 
-Excludes modules from the client build and replaces their imports with imports of an empty module instead. You can use this to exclude either JS or CSS modules from the final build.
+Excludes modules from the production client build and replaces their imports with imports of an empty module instead. You can use this to exclude either JS or CSS modules from the final build.
 
 ```
 "excludes": ["@scope/name"]
@@ -92,7 +91,7 @@ Excludes modules from the client build and replaces their imports with imports o
 
 #### externals: `Record<string, string>`
 
-Excludes modules from the client build and maps them to globally available constants instead. You can use this to share common dependencies between different micro frontends by exposing them on the `window` object. For example:
+Excludes modules from the production client build and maps them to globally available constants instead. You can use this to share common dependencies between different micro frontends by exposing them on the `window` object. For example:
 
 ```
 "externals": {
@@ -103,23 +102,50 @@ Excludes modules from the client build and maps them to globally available const
 
 Here `react` and `react-dom` imports will be replaced with accessing the respective `window` constants.
 
-### Runtime Hook
+#### postcss.plugins: `Record<string, PluginOptions>`
+
+Include specified PostCSS plugins in the build by providing their full package names as keys and their options as values. Make sure to install these plugins using `npm install` beforehand. Use an empty object for default options. Example:
+
+```json
+"postcss": {
+  "plugins": {
+    "postcss-extend": {},
+    "postcss-short": {
+      "features": {
+        "position": false
+      }
+    }
+  }
+}
+```
+
+In the above example, `postcss-extend` is added to vite's PostCSS configuration with default options, enabling the use of `@extend` rules in CSS code. `postcss-short` is added with specific options provided.
 
-If the module `nerest-runtime.ts` exists in the root of the micro frontend and exports a default function, this function will be executed when the server starts, and the fastify app instance will be passed to it as its only argument. Example of `nerest-runtime.ts`:
+#### clientSideEffects: `string[]`
+
+List of names of apps that have client side-effects, for example have their own self-initialization code that runs on import. Their entries will be loaded when hydration starts to run side-effect code.
+
+```
+"clientSideEffects": ["foo", "bar"]
+```
+
+### Runtime
+
+If the module `nerest/runtime.ts` exists in the micro frontend's root directory and exports a default function, it will be executed when the server starts. The Fastify app instance will be passed as the function's only argument. Example of `nerest/runtime.ts`:
 
 ```typescript
 import type { FastifyInstance } from 'fastify';
 
 export default function (app: FastifyInstance) {
-  console.log('Hello from nerest-runtime.ts');
+  console.log('Hello from nerest/runtime.ts');
 }
 ```
 
 This runtime hook can be used to adjust fastify settings, register additional plugins or add custom routes.
 
-#### Logger Configuration
+#### Logger
 
-Nerest uses the default server-side [fastify logger](https://fastify.dev/docs/latest/Reference/Logging/#logging), enabled by default. To configure or disable it, export a `logger` function from the `nerest-runtime.ts` module. It will be called on server start, and the return value will be passed to fastify as logger configuration.
+Nerest uses the [default server-side fastify logger](https://fastify.dev/docs/latest/Reference/Logging/#logging), enabled by default. To configure or disable it, export a `logger` function from the `nerest/runtime.ts` module. This function will be called on server start, and its return value will be used as the logger configuration for Fastify.
 
 ```typescript
 import type { FastifyServerOptions } from 'fastify';
@@ -131,7 +157,43 @@ export function logger(): FastifyServerOptions['logger'] {
 
 To disable the logger, return `false` from the function.
 
-You can also supply your own logger instance. Instead of passing configuration options, pass the instance. The logger you supply must conform to the [Pino](https://github.com/pinojs/pino) interface; that is, it must have the following methods: `info`, `error`, `debug`, `fatal`, `warn`, `trace`, `silent`, `child` and a string property `level`.
+### Preview
+
+For customizing micro frontend previews, create a `nerest/preview-head.html` file in the project's root directory. This file allows you to modify the preview rendering by appending your own HTML markup, such as metadata, external stylesheets, or scripts to the end of the `<head>`. Use it to to enhance the appearance and behavior of previews according to your specific needs.
+
+```html
+<!-- Pull in static files served from the internet -->
+<link rel="preload" href="https://example.com/cdn/fonts/my-font.woff2" />
+
+<!-- Or load custom head-tag JavaScript -->
+<script src="https://example.com/sample.js"></script>
+<script>
+  Sample.load();
+</script>
+```
+
+## CLI
+
+### `nerest build`
+
+Creates the production build of the micro frontend, generating the necessary files in the build directory.
+
+- Serverside entry is outputted to the `build/server.mjs` file.
+- Clientside static files are outputted to the `build/client/assets` directory. These files should be made available [at the `STATIC_PATH` URL](#static_path).
+
+### `nerest typegen`
+
+Generates TypeScript type definitions for the micro frontend's app schemas and outputs them to the schema.d.ts file, located next to the corresponding schema file. By default, it searches for schema files in the root directories of app directories.
+
+To override this behavior, provide a list of globs to the nerest typegen command. Remember to quote the globs to ensure they are executed by nerest and not your shell. For example:
+
+```
+nerest typegen 'apps/*/schema.json' 'schemas/*.json'
+```
+
+### `nerest watch`
+
+Starts the development server on the default port 3000. The server will automatically reload when changes are made to the app's source code.
 
 ## Development
 
@@ -142,4 +204,33 @@ npm install
 npm run build
 ```
 
-Use [nerest-harness](https://gitlab.tcsbank.ru/tj/nerest-harness) to test changes locally.
+- SSR server entry:
+  - Development: [server/development.ts](server/development.ts)
+  - Production: [server/production.ts](server/production.ts)
+- Hydrating client entry: [client/index.ts](client/index.ts)
+- CLI entry: [bin/index.ts](bin/index.ts)
+- Production build script: [build/index.ts](build/index.ts)
+
+## Testing
+
+Nerest uses Vitest for both module and integration tests. Run module tests with:
+
+```bash
+npm run test:module
+```
+
+Integration tests verify the framework as a whole using a test harness micro frontend located in [`tests/integration/harness`](tests/integration/harness). There are two modes:
+
+```bash
+# Development mode - includes browser tests
+npm run test:integration:dev
+
+# Production mode - tests production build
+npm run test:integration:prod
+```
+
+Development mode tests include browser-based tests using Playwright to verify client-side hydration and interactivity. Production mode tests verify the production build and server functionality.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

package/bin/index.ts

@@ -3,12 +3,15 @@
 import 'dotenv/config';
 
 import { build } from './build.js';
+import { typegen } from './typegen.js';
 import { watch } from './watch.js';
 
 // TODO: add CLI help and manual, maybe use a CLI framework like oclif
 async function cliEntry(args: string[]) {
   if (args[0] === 'build') {
     await build();
+  } else if (args[0] === 'typegen') {
+    await typegen(args.slice(1));
   } else if (args[0] === 'watch') {
     await watch();
   }

package/bin/typegen.ts

@@ -0,0 +1,35 @@
+import path from 'path';
+import fs from 'fs/promises';
+import fg from 'fast-glob';
+import { compileFromFile } from 'json-schema-to-typescript';
+
+// Comment at the start of every type definition file, alerting
+// developers to not modify the file by hand
+const bannerComment = `
+/**
+ * This file was automatically generated by Nerest.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source schema.json file,
+ * and run "nerest typegen" to regenerate this file.
+ */`.trim();
+
+// Generates a TypeScript type definition for each JSON Schema in the given globs
+export async function typegen(globs: string[]) {
+  // If no globs are provided, default to the schema.json file in each app directory
+  if (globs.length === 0) {
+    globs = ['apps/*/schema.json'];
+  }
+
+  const paths = await fg.glob(globs, { onlyFiles: true });
+  console.log(`Found ${paths.length} schemas, generating types...`);
+
+  for (const schemaPath of paths) {
+    // Turn each schema.json file into schema.d.ts
+    const typePath = schemaPath.replace('.json', '.d.ts');
+    const type = await compileFromFile(schemaPath, {
+      cwd: path.resolve(path.dirname(schemaPath)),
+      bannerComment,
+    });
+    await fs.writeFile(typePath, type, 'utf-8');
+    console.log(`${schemaPath} -> ${typePath}`);
+  }
+}

package/bin/watch.ts

@@ -3,7 +3,8 @@ import { runDevelopmentServer } from '../server/development.js';
 // Start dev server in watch mode, that restarts on file change
 // and rebuilds the client static files
 export async function watch() {
-  // TODO: will be replaced with nerest logger
   console.log('Starting Nerest watch...');
-  await runDevelopmentServer();
+  await runDevelopmentServer(
+    process.env.PORT ? Number(process.env.PORT) : 3000
+  );
 }

package/build/configs/development.ts

@@ -0,0 +1,63 @@
+import type { InlineConfig } from 'vite';
+
+import type { BuildArgs } from './shared.js';
+import { viteConfigShared } from './shared.js';
+import logger from './vite-logger.development.js';
+
+export async function viteConfigDevelopmentClient(
+  args: BuildArgs
+): Promise<InlineConfig> {
+  return {
+    ...(await viteConfigShared(args)),
+    build: {
+      // Manifest is needed to report used assets in SSR handles
+      manifest: true,
+      modulePreload: false,
+      watch: {},
+      rollupOptions: {
+        input: '/node_modules/@nerest/nerest/client/index.ts',
+        output: {
+          dir: 'build/client/assets',
+          entryFileNames: `[name].js`,
+          chunkFileNames: `[name].js`,
+          assetFileNames: `[name].[ext]`,
+        },
+      },
+    },
+    customLogger: logger,
+  };
+}
+
+export async function viteConfigDevelopmentServer(
+  args: BuildArgs
+): Promise<InlineConfig> {
+  return {
+    ...(await viteConfigShared(args)),
+    server: {
+      // Middleware lets vite compile on the fly, providing
+      // hot reload of certain modules
+      middlewareMode: true,
+      // Origin to serve imported assets from (like images)
+      origin: new URL(args.base).origin,
+      // Run HMR WebSocket server on random port to prevent conflicts
+      // between multiple projects running simultaneously
+      hmr: { port: randomPort() },
+      // Allow requests from all hosts in development
+      allowedHosts: true,
+    },
+    // optimizeDeps is only necessary with index.html entrypoint,
+    // which we don't have
+    optimizeDeps: {
+      noDiscovery: true,
+      include: [],
+    },
+    customLogger: logger,
+  };
+}
+
+// Returns a random high-number port to prevent conflicts
+function randomPort() {
+  // 49152-65535 is the ephemeral port range
+  // https://datatracker.ietf.org/doc/html/rfc6335#section-6
+  return 49152 + Math.floor(Math.random() * (65535 - 49152));
+}

package/build/configs/production.ts

@@ -0,0 +1,59 @@
+import type { InlineConfig } from 'vite';
+import { viteExternalsPlugin } from 'vite-plugin-externals';
+
+import type { BuildArgs } from './shared.js';
+import { viteConfigShared } from './shared.js';
+import { excludes } from '../excludes/index.js';
+
+export async function viteConfigProductionClient(
+  args: BuildArgs
+): Promise<InlineConfig> {
+  return {
+    ...(await viteConfigShared(args)),
+    build: {
+      // Manifest is needed to report used assets in SSR handles
+      manifest: true,
+      modulePreload: false,
+      rollupOptions: {
+        input: '/node_modules/@nerest/nerest/client/index.ts',
+        output: {
+          dir: 'build/client/assets',
+          entryFileNames: `[name].js`,
+          chunkFileNames: `[name].js`,
+          assetFileNames: `[name].[ext]`,
+        },
+      },
+    },
+    resolve: {
+      // excludes - map buildConfig.excludes packages to an empty module
+      alias: excludes(args.buildConfig?.excludes),
+    },
+    plugins: [
+      // externals - map buildConfig.externals packages to a global variable on window
+      viteExternalsPlugin(args.buildConfig?.externals, { useWindow: false }),
+    ],
+  };
+}
+
+export async function viteConfigProductionServer(
+  args: BuildArgs
+): Promise<InlineConfig> {
+  return {
+    ...(await viteConfigShared(args)),
+    build: {
+      emptyOutDir: false,
+      modulePreload: false,
+      // This is an important setting for producing a server build
+      ssr: true,
+      rollupOptions: {
+        input: '/node_modules/@nerest/nerest/server/production.ts',
+        output: {
+          dir: 'build',
+          entryFileNames: `server.mjs`,
+          chunkFileNames: `[name].mjs`,
+          assetFileNames: `[name].[ext]`,
+        },
+      },
+    },
+  };
+}