@morphql/server 0.1.3

package/.dockerignore

@@ -0,0 +1,15 @@
+node_modules
+dist
+.git
+.gitignore
+*.md
+.env*
+.docker
+Dockerfile*
+docker-compose*
+.eslintrc*
+.prettier*
+jest.config*
+tsconfig*.json
+test
+coverage

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/Dockerfile

@@ -0,0 +1,63 @@
+# Stage 1: Builder
+FROM node:24-alpine AS builder
+
+WORKDIR /app
+
+# Copy root package files
+COPY package*.json ./
+
+# Copy workspace package files (maintaining structure)
+COPY packages/core/package*.json ./packages/core/
+COPY packages/server/package*.json ./packages/server/
+
+# Install ALL dependencies (including devDeps for building)
+RUN npm ci
+
+# Copy TypeScript configs
+COPY tsconfig*.json ./
+COPY packages/core/tsconfig*.json ./packages/core/
+COPY packages/server/tsconfig*.json ./packages/server/
+COPY packages/server/nest-cli.json ./packages/server/
+
+# Copy source code for both packages
+COPY packages/core/src ./packages/core/src
+COPY packages/server/src ./packages/server/src
+COPY packages/server/test ./packages/server/test
+
+# Build core first (server depends on it)
+RUN npm run build --workspace=@morphql/core
+
+# Build server
+RUN npm run build --workspace=server
+
+# Prune dev dependencies
+RUN npm prune --omit=dev
+
+# Stage 2: Production
+FROM node:24-alpine AS production
+
+WORKDIR /app
+
+# Copy root metadata
+COPY package*.json ./
+
+# Copy the entire built workspace from builder
+# This includes the pruned node_modules which already has the correct links structure
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/packages ./packages
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nestjs -u 1001
+
+USER nestjs
+
+ENV NODE_ENV=production
+EXPOSE 3000
+
+# Set WORKDIR to server for correct execution context
+WORKDIR /app/packages/server
+
+# Execute using local package script
+CMD ["npm", "run", "start:prod"]
+#CMD ["tail", "-f", "/dev/null"]

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniele Traverso
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# MorphQL Server
+
+A high-performance, stateless NestJS API for the MorphQL transformation engine.
+
+## Overview
+
+This server provides a RESTful interface to compile and execute Morph Query Language (MorphQL) transformations. Built with NestJS, it's designed to be a lightweight, scalable microservice that can be deployed in containerized environments.
+
+### Features
+
+- 🚀 **Stateless Execution**: Designed for horizontal scaling
+- 🔄 **Isomorphic Engine**: Run the exact same transformations as the client-side library
+- ⚡ **Redis Caching**: Built-in compiled query caching for high-throughput scenarios
+- 🐳 **Docker Ready**: Production-optimized multi-stage container images
+- 🔐 **API Key Authentication**: Optional security via `X-API-KEY` header
+- 📊 **Swagger Documentation**: Interactive API docs at `/api`
+- 🏥 **Health Checks**: Liveness and readiness endpoints for orchestration
+
+## Quick Start
+
+### Docker Compose (Recommended)
+
+```bash
+# Start server + Redis
+docker compose up -d
+
+# View logs
+docker compose logs -f server
+
+# Stop services
+docker compose down
+```
+
+The server will be available at `http://localhost:3000` with Swagger docs at `http://localhost:3000/api`.
+
+### Development Mode
+
+```bash
+# From monorepo root
+npm run server
+
+# Or from packages/server
+npm run start:dev
+```
+
+## API Reference
+
+All endpoints are prefixed with `/v1`. Full interactive documentation is available at `/api` when the server is running.
+
+### 1. Execute Transformation
+
+Compile and execute a query against data in a single request.
+
+**Endpoint**: `POST /v1/execute`
+
+**Request**:
+
+```json
+{
+  "query": "from json to json transform set firstName = split(fullName, ' ')[0]",
+  "data": { "fullName": "John Doe" }
+}
+```
+
+**Response**:
+
+```json
+{
+  "success": true,
+  "result": { "firstName": "John" },
+  "executionTime": 2.5
+}
+```
+
+**Example with curl**:
+
+```bash
+curl -X POST http://localhost:3000/v1/execute \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "from json to json transform set name = fullName",
+    "data": { "fullName": "Jane Smith" }
+  }'
+```
+
+### 2. Compile Query
+
+Get the generated JavaScript code for a query without executing it.
+
+**Endpoint**: `POST /v1/compile`
+
+**Request**:
+
+```json
+{
+  "query": "from json to xml transform set name = fullName"
+}
+```
+
+**Response**:
+
+```json
+{
+  "success": true,
+  "code": "function(source) { /* generated code */ }"
+}
+```
+
+### 3. Health Checks
+
+**Liveness**: `GET /v1/health`
+
+```json
+{ "status": "ok", "timestamp": "2026-01-20T00:00:00.000Z" }
+```
+
+**Readiness**: `GET /v1/health/ready`
+
+- Returns `200` if service and Redis (if configured) are ready
+- Returns `503` if Redis is configured but unavailable
+
+## Configuration
+
+Configure the server via environment variables:
+
+| Variable       | Description                          | Default | Required |
+| -------------- | ------------------------------------ | ------- | -------- |
+| `PORT`         | Server port                          | `3000`  | No       |
+| `NODE_ENV`     | Environment mode                     | -       | No       |
+| `REDIS_HOST`   | Redis hostname for caching           | -       | No       |
+| `REDIS_PORT`   | Redis port                           | `6379`  | No       |
+| `REDIS_PREFIX` | Cache key prefix                     | `morphql:`  | No       |
+| `API_KEY`      | Optional API key for auth            | -       | No       |
+| `API_KEY_FILE` | Optional API key file (for secrets)  | -       | No       |
+
+**Note**: If `REDIS_HOST` is not set, the server runs without caching (queries are compiled on every request).
+
+## Authentication
+
+The server supports optional API key authentication via the `X-API-KEY` header.
+
+**Enable authentication**:
+
+```bash
+# Set API_KEY environment variable
+export API_KEY=your-secret-key
+
+# Or in docker-compose.yml
+environment:
+  - API_KEY=your-secret-key
+```
+
+**Making authenticated requests**:
+
+```bash
+curl -X POST http://localhost:3000/v1/execute \
+  -H "X-API-KEY: your-secret-key" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "...", "data": {...}}'
+```
+
+If `API_KEY` is not set, all requests are allowed (useful for development).
+
+## Docker Deployment
+
+### Building the Image
+
+```bash
+# From monorepo root
+docker build -f packages/server/Dockerfile -t morphql-server .
+```
+
+### Running with Docker
+
+```bash
+# Without Redis
+docker run -p 3000:3000 morphql-server
+
+# With Redis
+docker run -p 3000:3000 \
+  -e REDIS_HOST=redis.example.com \
+  -e REDIS_PORT=6379 \
+  morphql-server
+```
+
+### Docker Compose Production
+
+The included `docker-compose.yml` provides a production-ready setup with:
+
+- NestJS server with health checks
+- Redis for query caching
+- Persistent Redis data volume
+- Automatic restart policies
+
+## Development
+
+### Available Scripts
+
+| Command               | Description              |
+| --------------------- | ------------------------ |
+| `npm run start`       | Start in production mode |
+| `npm run start:dev`   | Start with hot-reload    |
+| `npm run start:debug` | Start with debugger      |
+| `npm run build`       | Build for production     |
+| `npm run test`        | Run unit tests           |
+| `npm run test:e2e`    | Run end-to-end tests     |
+| `npm run lint`        | Lint and fix code        |
+
+### Project Structure
+
+```
+packages/server/
+├── src/
+│   ├── main.ts              # Application entry point
+│   ├── app.module.ts        # Root module
+│   ├── morph.controller.ts  # API endpoints
+│   └── auth.guard.ts        # API key authentication
+├── test/                    # E2E tests
+├── Dockerfile               # Multi-stage production build
+├── docker-compose.yml       # Local deployment stack
+└── package.json
+```
+
+## Performance
+
+- **Caching**: When Redis is enabled, compiled queries are cached indefinitely (queries are deterministic)
+- **Stateless**: Each request is independent, enabling horizontal scaling
+- **Async**: All endpoints use async/await for non-blocking I/O
+
+## Monitoring
+
+The server provides structured logging via NestJS:
+
+- Request routing and mapping on startup
+- Error logging with stack traces
+- Performance metrics in `executionTime` field
+
+For production monitoring, consider:
+
+- Health check endpoints for Kubernetes/Docker Swarm
+- Redis monitoring for cache hit rates
+- Application Performance Monitoring (APM) tools
+
+## License
+
+MIT

package/docker-compose.yml

@@ -0,0 +1,32 @@
+services:
+  server:
+    build:
+      context: ../..
+      dockerfile: packages/server/Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - REDIS_HOST=redis
+      - REDIS_PORT=6379
+    depends_on:
+      redis:
+        condition: service_healthy
+    restart: unless-stopped
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    command: redis-server --appendonly yes
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    restart: unless-stopped
+
+volumes:
+  redis-data:

package/eslint.config.mjs

@@ -0,0 +1,35 @@
+// @ts-check
+import eslint from '@eslint/js';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  {
+    ignores: ['eslint.config.mjs'],
+  },
+  eslint.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  eslintPluginPrettierRecommended,
+  {
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.jest,
+      },
+      sourceType: 'commonjs',
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-floating-promises': 'warn',
+      '@typescript-eslint/no-unsafe-argument': 'warn',
+      "prettier/prettier": ["error", { endOfLine: "auto" }],
+    },
+  },
+);

package/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@morphql/server",
+  "version": "0.1.3",
+  "description": "Stateless Transformation Engine API for MorphQL",
+  "author": "Hyperwindmill",
+  "private": false,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main.js",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:cov": "vitest run --coverage",
+    "test:e2e": "vitest run --config ./vitest.config.ts"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/core": "^11.0.1",
+    "@nestjs/platform-express": "^11.0.1",
+    "@nestjs/swagger": "^11.2.5",
+    "@morphql/core": "^0.1.3",
+    "ioredis": "^5.9.2",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.18.0",
+    "@nestjs/cli": "^11.0.0",
+    "@nestjs/schematics": "^11.0.0",
+    "@nestjs/testing": "^11.0.1",
+    "@swc/core": "^1.10.9",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.7",
+    "@types/supertest": "^6.0.2",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.2.2",
+    "globals": "^16.0.0",
+    "prettier": "^3.4.2",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-loader": "^9.5.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.20.0",
+    "unplugin-swc": "^1.5.1",
+    "vitest": "^3.0.3"
+  }
+}

package/src/app.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { MorphController } from './morph.controller.js';
+
+@Module({
+  imports: [],
+  controllers: [MorphController],
+  providers: [],
+})
+export class AppModule {}

package/src/auth.guard.ts

@@ -0,0 +1,56 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Request } from 'express';
+import * as fs from 'fs';
+
+@Injectable()
+export class ApiKeyGuard implements CanActivate {
+  private apiKey: string | null = null;
+
+  constructor() {
+    this.loadApiKey();
+  }
+
+  private loadApiKey() {
+    // 1. Try env var
+    if (process.env.API_KEY) {
+      this.apiKey = process.env.API_KEY;
+      return;
+    }
+
+    // 2. Try file (Docker Swarm Secret)
+    if (process.env.API_KEY_FILE) {
+      try {
+        if (fs.existsSync(process.env.API_KEY_FILE)) {
+          this.apiKey = fs
+            .readFileSync(process.env.API_KEY_FILE, 'utf8')
+            .trim();
+        }
+      } catch (e) {
+        console.error(
+          `Failed to load API key from file ${process.env.API_KEY_FILE}`,
+          e,
+        );
+      }
+    }
+  }
+
+  canActivate(context: ExecutionContext): boolean {
+    if (!this.apiKey) {
+      return true; // No API Key configured, allow all
+    }
+
+    const request = context.switchToHttp().getRequest<Request>();
+    const requestKey = request.headers['x-api-key'];
+
+    if (requestKey === this.apiKey) {
+      return true;
+    }
+
+    throw new UnauthorizedException('Invalid or missing API Key');
+  }
+}

package/src/main.ts

@@ -0,0 +1,19 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module.js';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  const config = new DocumentBuilder()
+    .setTitle('MorphQL API')
+    .setDescription('Stateless Transformation Engine')
+    .setVersion('1.0')
+    .addApiKey({ type: 'apiKey', name: 'X-API-KEY', in: 'header' }, 'X-API-KEY')
+    .build();
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('api', app, document);
+
+  await app.listen(process.env.PORT ?? 3000);
+}
+bootstrap();

package/src/morph.controller.ts

@@ -0,0 +1,153 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import {
+  Controller,
+  Post,
+  Get,
+  Body,
+  UseGuards,
+  BadRequestException,
+  InternalServerErrorException,
+  ServiceUnavailableException,
+} from '@nestjs/common';
+import { ApiKeyGuard } from './auth.guard.js';
+import { compile } from '@morphql/core';
+import { RedisCache } from '@morphql/core/cache-services';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiProperty,
+  ApiResponse,
+  ApiHeader,
+} from '@nestjs/swagger';
+
+// Initialize cache if configured
+const redisHost = process.env.REDIS_HOST;
+const cache = redisHost
+  ? new RedisCache({
+      host: redisHost,
+      port: process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT) : 6379,
+      prefix: process.env.REDIS_PREFIX || 'morphql:',
+    })
+  : undefined;
+
+export class ExecuteDto {
+  @ApiProperty({
+    description: 'The MorphQL query string',
+    example: 'from json to json transform set name = split(fullName, " ")',
+  })
+  query!: string;
+
+  @ApiProperty({
+    description: 'The source data to transform',
+    example: { fullName: 'John Doe' },
+  })
+  data!: Record<string, unknown>;
+}
+
+export class CompileDto {
+  @ApiProperty({
+    description: 'The MorphQL query string',
+    example: 'from json to json transform set name = split(fullName, " ")',
+  })
+  query!: string;
+}
+
+export class ExecuteResponseDto {
+  @ApiProperty()
+  success!: boolean;
+
+  @ApiProperty()
+  result!: unknown;
+
+  @ApiProperty()
+  executionTime!: number;
+}
+
+export class CompileResponseDto {
+  @ApiProperty()
+  success!: boolean;
+
+  @ApiProperty()
+  code!: string;
+}
+
+@ApiTags('Morph Engine')
+@ApiHeader({
+  name: 'X-API-KEY',
+  description: 'Optional API Key for authentication',
+  required: false,
+})
+@Controller('v1')
+@UseGuards(ApiKeyGuard)
+export class MorphController {
+  @Post('execute')
+  @ApiOperation({ summary: 'Execute a transformation' })
+  @ApiResponse({ status: 200, type: ExecuteResponseDto })
+  async execute(@Body() body: ExecuteDto): Promise<ExecuteResponseDto> {
+    if (!body.query || !body.data) {
+      throw new BadRequestException('Missing query or data');
+    }
+
+    try {
+      const start = performance.now();
+      const engine = await compile(body.query, { cache });
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const result = await engine(body.data);
+      const end = performance.now();
+
+      return {
+        success: true,
+        result,
+        executionTime: end - start,
+      };
+    } catch (e: unknown) {
+      console.error('Execute Error:', e);
+      const message =
+        e instanceof Error ? e.message : 'Unknown compilation error';
+      throw new InternalServerErrorException(message);
+    }
+  }
+
+  @Post('compile')
+  @ApiOperation({ summary: 'Compile MorphQL to JavaScript' })
+  @ApiResponse({ status: 200, type: CompileResponseDto })
+  async compile(@Body() body: CompileDto): Promise<CompileResponseDto> {
+    if (!body.query) {
+      throw new BadRequestException('Missing query');
+    }
+
+    try {
+      const engine = await compile(body.query, { cache });
+      return {
+        success: true,
+        code: engine.code,
+      };
+    } catch (e: unknown) {
+      const message =
+        e instanceof Error ? e.message : 'Unknown compilation error';
+      throw new InternalServerErrorException(message);
+    }
+  }
+
+  @Get('health')
+  @ApiOperation({ summary: 'Liveness check' })
+  @ApiResponse({ status: 200, description: 'Service is alive' })
+  health() {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+
+  @Get('health/ready')
+  @ApiOperation({ summary: 'Readiness check' })
+  @ApiResponse({ status: 200, description: 'Service is ready' })
+  @ApiResponse({ status: 503, description: 'Service is not ready' })
+  async ready() {
+    if (cache && redisHost) {
+      const isRedisOk = await cache.ping();
+      if (!isRedisOk) {
+        throw new ServiceUnavailableException('Redis cache is unavailable');
+      }
+    }
+    return { status: 'ready', timestamp: new Date().toISOString() };
+  }
+}

package/test/app.e2e-spec.ts

@@ -0,0 +1,83 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { App } from 'supertest/types.js';
+import { AppModule } from './../src/app.module.js';
+import { describe, it, expect, beforeEach } from 'vitest';
+
+describe('MorphController (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  describe('Health', () => {
+    it('/v1/health (GET)', () => {
+      return request(app.getHttpServer())
+        .get('/v1/health')
+        .expect(200)
+        .expect((res) => {
+          expect(res.body.status).toBe('ok');
+        });
+    });
+
+    it('/v1/health/ready (GET)', () => {
+      // Note: Redis might not be running in this test environment,
+      // but the controller handles it gracefully if not configured.
+      return request(app.getHttpServer())
+        .get('/v1/health/ready')
+        .expect(200)
+        .expect((res) => {
+          expect(res.body.status).toBe('ready');
+        });
+    });
+  });
+
+  const validQuery =
+    'from json to json transform set name = "Hello " + fullName';
+  const testData = { fullName: 'John Doe' };
+
+  it('/v1/compile (POST)', () => {
+    return request(app.getHttpServer())
+      .post('/v1/compile')
+      .send({ query: validQuery })
+      .expect(201)
+      .expect((res) => {
+        expect(res.body.success).toBe(true);
+        expect(res.body.code).toBeDefined();
+        expect(res.body.code).toContain('function');
+      });
+  });
+
+  it('/v1/execute (POST)', () => {
+    return request(app.getHttpServer())
+      .post('/v1/execute')
+      .send({ query: validQuery, data: testData })
+      .expect(201)
+      .expect((res) => {
+        expect(res.body.success).toBe(true);
+        const result =
+          typeof res.body.result === 'string'
+            ? JSON.parse(res.body.result)
+            : res.body.result;
+        expect(result).toEqual({ name: 'Hello John Doe' });
+        expect(res.body.executionTime).toBeGreaterThanOrEqual(0);
+      });
+  });
+
+  it('/v1/execute (POST) - Missing Data', () => {
+    return request(app.getHttpServer())
+      .post('/v1/execute')
+      .send({ query: validQuery })
+      .expect(400);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": true,
+    "noFallthroughCasesInSwitch": true,
+    "types": ["vitest/globals", "node"]
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,16 @@
+import swc from 'unplugin-swc';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    root: './',
+    include: ['**/*.e2e-spec.ts', '**/*.spec.ts'],
+  },
+  plugins: [
+    // This is required to build the test files with SWC
+    swc.vite({
+      module: { type: 'es6' },
+    }),
+  ],
+});