@inertianest/core 0.0.1-alpha.1

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@inertianest/core",
+  "version": "0.0.1-alpha.1",
+  "description": "Core module for Inertia.js in NestJS",
+  "main": "index.js",
+  "type": "module",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@inertianest/node": "0.0.1-alpha.1"
+  },
+  "peerDependencies": {
+    "vite": "^7.1.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const INERTIA_OPTIONS = Symbol('INERTIA_OPTIONS');
+export const VITE_DEV_SERVER = Symbol('VITE_DEV_SERVER');

package/src/decorators/index.ts

@@ -0,0 +1 @@
+export * from './inertia.decorator.js';

package/src/decorators/inertia.decorator.ts

@@ -0,0 +1,45 @@
+import { SetMetadata, createParamDecorator, type ExecutionContext } from '@nestjs/common';
+import type { Request, Response } from 'express';
+
+export const INERTIA_COMPONENT = Symbol('INERTIA_COMPONENT');
+
+export interface InertiaRenderOptions {
+  component: string;
+  props?: Record<string, unknown>;
+}
+
+/**
+ * Decorator to mark a controller method as an Inertia render endpoint
+ *
+ * @param component The React component name to render (e.g., 'Dashboard', 'Users/Index')
+ * @param defaultProps Optional default props to pass to the component
+ *
+ * @example
+ * ```typescript
+ * @Get()
+ * @Inertia('Dashboard')
+ * async index() {
+ *   return { stats: await this.dashboardService.getStats() };
+ * }
+ * ```
+ */
+export const Inertia = (component: string, defaultProps?: Record<string, unknown>) =>
+  SetMetadata(INERTIA_COMPONENT, { component, props: defaultProps ?? {} } as InertiaRenderOptions);
+
+/**
+ * Parameter decorator to get the Express Request object
+ */
+export const InertiaRequest = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext): Request => {
+    return ctx.switchToHttp().getRequest<Request>();
+  },
+);
+
+/**
+ * Parameter decorator to get the Express Response object
+ */
+export const InertiaResponse = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext): Response => {
+    return ctx.switchToHttp().getResponse<Response>();
+  },
+);

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './constants.js';
+export * from './inertia.module.js';
+export * from './inertia.service.js';
+export * from './inertia.interceptor.js';
+export * from './nest-adapter.js';
+export * from './decorators/index.js';

package/src/inertia.interceptor.ts

@@ -0,0 +1,48 @@
+import {
+  Injectable,
+  type NestInterceptor,
+  type ExecutionContext,
+  type CallHandler,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import { Reflector } from '@nestjs/core';
+import type { Request, Response } from 'express';
+import { InertiaService } from './inertia.service.js';
+import { INERTIA_COMPONENT, type InertiaRenderOptions } from './decorators/inertia.decorator.js';
+
+@Injectable()
+export class InertiaInterceptor implements NestInterceptor {
+  constructor(
+    private readonly reflector: Reflector,
+    private readonly inertiaService: InertiaService,
+  ) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<void> {
+    const renderOptions = this.reflector.get<InertiaRenderOptions>(
+      INERTIA_COMPONENT,
+      context.getHandler(),
+    );
+
+    // If no @Inertia decorator is present, pass through normally
+    if (!renderOptions) {
+      return next.handle();
+    }
+
+    const ctx = context.switchToHttp();
+    const request = ctx.getRequest<Request>();
+    const response = ctx.getResponse<Response>();
+
+    return next.handle().pipe(
+      mergeMap(async (data) => {
+        const props = { ...renderOptions.props, ...(data || {}) };
+        await this.inertiaService.render(
+          request,
+          response,
+          renderOptions.component,
+          props,
+        );
+      }),
+    );
+  }
+}

package/src/inertia.module.ts

@@ -0,0 +1,135 @@
+import { type DynamicModule, Global, Module, type OnModuleInit } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { InertiaService } from './inertia.service.js';
+import { defineConfig, type SharedData } from '@inertianest/node';
+import type { ViteDevServer } from 'vite';
+import { resolve } from 'path';
+import { INERTIA_OPTIONS, VITE_DEV_SERVER } from './constants.js';
+import { InertiaInterceptor } from './inertia.interceptor.js';
+
+export { INERTIA_OPTIONS, VITE_DEV_SERVER };
+
+export interface InertiaModuleOptions<T extends SharedData = SharedData> {
+  /**
+   * The ID of the root element where Inertia renders
+   */
+  rootElementId?: string;
+
+  /**
+   * Asset version for cache busting
+   */
+  assetsVersion?: string;
+
+  /**
+   * Enable history encryption
+   */
+  encryptHistory?: boolean;
+
+  /**
+   * Shared data available on all pages
+   */
+  sharedData?: T;
+
+  /**
+   * Path to the HTML entrypoint for development
+   */
+  indexEntrypoint?: string;
+
+  /**
+   * Path to the HTML entrypoint for production
+   */
+  indexBuildEntrypoint?: string;
+
+  /**
+   * Enable SSR mode
+   */
+  ssrEnabled?: boolean;
+
+  /**
+   * Path to the SSR entrypoint for development
+   */
+  ssrEntrypoint?: string;
+
+  /**
+   * Path to the SSR entrypoint for production
+   */
+  ssrBuildEntrypoint?: string;
+}
+
+@Global()
+@Module({})
+export class InertiaModule implements OnModuleInit {
+  private static viteDevServer: ViteDevServer | undefined;
+
+
+  async onModuleInit() {
+    // Vite middleware is set up in forRoot
+  }
+
+  static async forRoot<T extends SharedData = SharedData>(
+    options: InertiaModuleOptions<T> = {},
+  ): Promise<DynamicModule> {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    let viteDevServer: ViteDevServer | undefined;
+
+    // Create Vite dev server in development mode
+    // Use dynamic import to avoid bundling vite in production
+    if (isDevelopment) {
+      const { createServer: createViteServer } = await import('vite');
+      viteDevServer = await createViteServer({
+        configFile: resolve(process.cwd(), 'vite.config.ts'),
+        server: { middlewareMode: true },
+      });
+      this.viteDevServer = viteDevServer;
+    }
+
+    // Build the config for node-inertiajs
+    const ssrEnabled = options.ssrEnabled ?? false;
+    const baseConfig = {
+      rootElementId: options.rootElementId ?? 'app',
+      assetsVersion: options.assetsVersion ?? '1',
+      encryptHistory: options.encryptHistory ?? false,
+      ...(options.sharedData !== undefined && { sharedData: options.sharedData }),
+      indexEntrypoint: options.indexEntrypoint ?? resolve(process.cwd(), 'client/index.html'),
+      indexBuildEntrypoint:
+        options.indexBuildEntrypoint ?? resolve(process.cwd(), 'dist/client/index.html'),
+    };
+
+    // Use defineConfig to resolve the configuration
+    const resolvedConfig = ssrEnabled
+      ? defineConfig({
+          ...baseConfig,
+          ssrEnabled: true,
+          ssrEntrypoint: options.ssrEntrypoint!,
+          ssrBuildEntrypoint: options.ssrBuildEntrypoint!,
+        })
+      : defineConfig({
+          ...baseConfig,
+          ssrEnabled: false,
+        });
+
+    return {
+      module: InertiaModule,
+      providers: [
+        {
+          provide: INERTIA_OPTIONS,
+          useValue: resolvedConfig,
+        },
+        {
+          provide: VITE_DEV_SERVER,
+          useValue: viteDevServer,
+        },
+        InertiaService,
+        {
+          provide: APP_INTERCEPTOR,
+          useClass: InertiaInterceptor,
+        },
+      ],
+      exports: [InertiaService, INERTIA_OPTIONS, VITE_DEV_SERVER],
+    };
+  }
+
+  static getViteDevServer(): ViteDevServer | undefined {
+    return this.viteDevServer;
+  }
+}

package/src/inertia.service.ts

@@ -0,0 +1,59 @@
+import { Inject, Injectable } from '@nestjs/common';
+import type { Request, Response } from 'express';
+import { Inertia, type ResolvedConfig, type Data } from '@inertianest/node';
+import type { ViteDevServer } from 'vite';
+import { NestAdapter } from './nest-adapter.js';
+import { INERTIA_OPTIONS, VITE_DEV_SERVER } from './constants.js';
+
+@Injectable()
+export class InertiaService {
+  constructor(
+    @Inject(INERTIA_OPTIONS) private readonly config: ResolvedConfig,
+    @Inject(VITE_DEV_SERVER) private readonly viteDevServer: ViteDevServer | undefined,
+  ) {}
+
+  /**
+   * Create an Inertia instance for the current request
+   */
+  createInertia(req: Request, res: Response): Inertia {
+    const adapter = new NestAdapter(req, res);
+    // Cast to any to handle Vite version differences
+    return new Inertia(adapter, this.config, this.viteDevServer as any);
+  }
+
+  /**
+   * Render an Inertia response
+   */
+  async render<T extends Record<string, unknown>>(
+    req: Request,
+    res: Response,
+    component: string,
+    props?: T,
+  ): Promise<void> {
+    const inertia = this.createInertia(req, res);
+    await inertia.render(component, props);
+  }
+
+  /**
+   * Share data for the current request
+   */
+  share(req: Request, res: Response, data: Record<string, Data>): Inertia {
+    const inertia = this.createInertia(req, res);
+    inertia.share(data);
+    return inertia;
+  }
+
+  /**
+   * Get the Vite dev server for middleware setup
+   */
+  getViteDevServer(): ViteDevServer | undefined {
+    return this.viteDevServer;
+  }
+
+  /**
+   * Get the resolved config
+   */
+  getConfig(): ResolvedConfig {
+    return this.config;
+  }
+}

package/src/nest-adapter.ts

@@ -0,0 +1,89 @@
+import { Adapter } from '@inertianest/node';
+import type { Request, Response } from 'express';
+
+/**
+ * NestJS/Express adapter for node-inertiajs
+ */
+export class NestAdapter extends Adapter {
+  constructor(
+    private readonly req: Request,
+    private readonly res: Response,
+  ) {
+    super();
+  }
+
+  get url(): string {
+    return this.req.originalUrl || this.req.url || '/';
+  }
+
+  get method(): string {
+    return this.req.method || 'GET';
+  }
+
+  get statusCode(): number {
+    return this.res.statusCode || 200;
+  }
+
+  set statusCode(code: number) {
+    this.res.statusCode = code;
+  }
+
+  get request(): Request {
+    return this.req;
+  }
+
+  get response(): Response {
+    return this.res;
+  }
+
+  getHeader(name: string): string | string[] | undefined {
+    return this.req.headers[name.toLowerCase()] as string | string[] | undefined;
+  }
+
+  setHeader(name: string, value: string): void {
+    this.res.setHeader(name.toLowerCase(), value);
+  }
+
+  send(content: string): void {
+    this.res.setHeader('Content-Type', 'text/html');
+    this.res.end(content);
+  }
+
+  json(data: unknown): void {
+    try {
+      this.res.setHeader('Content-Type', 'application/json');
+      this.res.end(JSON.stringify(data));
+    } catch {
+      this.res.statusCode = 500;
+      this.res.end(JSON.stringify({ error: 'Failed to serialize JSON' }));
+    }
+  }
+
+  redirect(statusOrUrl: number | string, url?: string): void {
+    let status = 302;
+    let location = '';
+
+    if (typeof statusOrUrl === 'number' && typeof url === 'string') {
+      status = statusOrUrl;
+      location = url;
+    } else if (typeof statusOrUrl === 'string') {
+      location = statusOrUrl;
+    }
+
+    const encodedLocation = encodeURI(location);
+    this.statusCode = status;
+    this.setHeader('Location', encodedLocation);
+
+    const body = this.req?.headers?.accept?.includes('html')
+      ? `<p>${status}. Redirecting to <a href="${encodedLocation}">${encodedLocation}</a></p>`
+      : `${status}. Redirecting to ${encodedLocation}`;
+
+    this.setHeader('Content-Length', Buffer.byteLength(body).toString());
+
+    if (this.method === 'HEAD') {
+      this.res.end();
+    } else {
+      this.res.end(body);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,50 @@
+{
+    // Visit https://aka.ms/tsconfig to read more about this file
+    "compilerOptions": {
+      // File Layout
+      // "rootDir": "./src",
+      "outDir": "./dist",
+  
+      // Environment Settings
+      // See also https://aka.ms/tsconfig/module
+      "module": "nodenext",
+      "target": "esnext",
+
+      // Decorator support (required for NestJS)
+      "experimentalDecorators": true,
+      "emitDecoratorMetadata": true,
+      // For nodejs:
+      // "lib": ["esnext"],
+      "types": ["node"],
+      // and npm install -D @types/node
+  
+      // Other Outputs
+      "sourceMap": true,
+      "declaration": true,
+      "declarationMap": true,
+  
+      // Stricter Typechecking Options
+      "noUncheckedIndexedAccess": true,
+      "exactOptionalPropertyTypes": true,
+  
+      // Style Options
+      // "noImplicitReturns": true,
+      // "noImplicitOverride": true,
+      // "noUnusedLocals": true,
+      // "noUnusedParameters": true,
+      // "noFallthroughCasesInSwitch": true,
+      // "noPropertyAccessFromIndexSignature": true,
+  
+      // Recommended Options
+      "strict": true,
+      "jsx": "react-jsx",
+      "verbatimModuleSyntax": true,
+      "isolatedModules": true,
+      "noUncheckedSideEffectImports": true,
+      "moduleDetection": "force",
+      "skipLibCheck": true
+    },
+    "include": ["src"],
+    "exclude": ["node_modules"]
+  }
+