@stonyx/rest-server 0.2.1-alpha.0 → 0.2.1-alpha.10

package/README.md

@@ -1,3 +1,7 @@
+[![CI](https://github.com/abofs/stonyx-rest-server/actions/workflows/ci.yml/badge.svg)](https://github.com/abofs/stonyx-rest-server/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@stonyx/rest-server.svg)](https://www.npmjs.com/package/@stonyx/rest-server)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
 # @stonyx/rest-server
 
 REST server module for the [Stonyx framework](https://github.com/abofs/stonyx), providing dynamic route registration and built-in request handling with optional authentication hooks.
@@ -41,16 +45,13 @@ export default {
 };
 ```
 
-Then initialize the Stonyx framework, which auto-initializes all of its modules, including `@stonyx/rest-server`:
-
-```js
-import Stonyx from 'stonyx';
-import config from './config/environment.js';
+Then run the application via the Stonyx CLI, which auto-initializes all modules including the REST server:
 
-new Stonyx(config);
+```bash
+stonyx serve
 ```
 
-For further framework initialization instructions, see the [Stonyx repository](https://github.com/abofs/stonyx).
+For further framework instructions, see the [Stonyx repository](https://github.com/abofs/stonyx).
 
 ### Optional Direct Usage
 
@@ -72,12 +73,26 @@ Configuration is read from `stonyx/config` under `restServer`:
 
 |       Option      |         Type        | Default     | Description                                                |
 | :---------------: | :-----------------: | :---------- | :--------------------------------------------------------- |
-|       `dir`       |      **String**     | `undefined` | Directory containing request classes to mount as routes    |
+|       `dir`       |      **String**     | `'./requests'` | Directory containing request classes to mount as routes    |
 | `camelCaseRoutes` |     **Boolean**     | `true`      | Convert filenames to camelCase when generating route paths |
-|       `port`      |      **Number**     | `3000`      | Port to listen on                                          |
+|       `port`      |      **Number**     | `2666`      | Port to listen on                                          |
 |      `origin`     | **String \| Array** | `'*'`       | CORS origin(s) allowed                                     |
+|    `methods`      | **String**          | `'GET,POST,PATCH,PUT,DELETE'` | CORS allowed methods                              |
+| `enableHealthCheck` |   **Boolean**     | `true`      | Register `GET /health` endpoint (disable via `REST_HEALTH_CHECK_DISABLE=true`) |
+|  `trustProxy`   |     **Boolean**     | `false`     | Trust reverse proxy headers (e.g. `X-Forwarded-Proto`). Enable via `REST_TRUST_PROXY=true` when running behind a load balancer such as AWS ALB/ELB to ensure correct protocol detection. |
 |    `statusMap`    |      **Object**     | `{}`        | Optional mapping of HTTP status codes to custom messages   |
-|      `debug`      |     **Boolean**     | `false`     | Enable debug logging during route setup                    |
+
+### Running Behind a Load Balancer
+
+When your application runs behind a reverse proxy or load balancer (e.g. AWS ALB/ELB), the load balancer terminates SSL and forwards requests to your server over HTTP internally. This means Express sees `http` as the protocol even though the original client request used `https`.
+
+To fix this, enable the `trustProxy` option:
+
+```bash
+REST_TRUST_PROXY=true
+```
+
+This tells Express to trust the `X-Forwarded-Proto` header set by the load balancer, so `request.protocol` correctly returns `https`. This is important for any functionality that generates URLs based on the incoming request protocol, such as JSON:API relationship links.
 
 ## Request Class
 
@@ -135,10 +150,6 @@ project-root/
 
 The `RestServer` will automatically mount these routes using the filenames as paths (`/public` and `/private` by default, or camelCased if configured).
 
-Perfect! Here’s a self-contained **“Example Requests”** section with sample `curl` calls:
-
----
-
 ### Example Requests
 
 Assuming you have `public.js` and `private.js` routes mounted, you can test them like this:

package/config/environment.js

@@ -3,8 +3,9 @@ const {
   REST_CORS_METHODS,
   REST_HEALTH_CHECK_DISABLE,
   REST_PORT,
-  REST_REQUEST_PATH
-} = process;
+  REST_REQUEST_PATH,
+  REST_TRUST_PROXY
+} = process.env;
 
 export default {
   enableHealthCheck: REST_HEALTH_CHECK_DISABLE !== 'true',
@@ -12,6 +13,7 @@ export default {
   methods: REST_CORS_METHODS ?? 'GET,POST,PATCH,PUT,DELETE',
   dir: REST_REQUEST_PATH ?? './requests',
   port: REST_PORT ?? 2666,
+  trustProxy: REST_TRUST_PROXY === 'true',
   logColor: 'yellow',
   logMethod: 'api'
 };

package/dist/main.d.ts

@@ -0,0 +1,17 @@
+import { type Express } from 'express';
+import type { Server } from 'http';
+export { default as Request } from './request.js';
+export default class RestServer {
+    static instance: RestServer;
+    api: Express;
+    server: Server;
+    constructor();
+    static close(): void;
+    init(): Promise<void>;
+    setupRouter(): Promise<void>;
+    setupGlobalMiddleware(): void;
+    mountRoute(routeClassUntyped: unknown, { name, options }: {
+        name: string;
+        options?: unknown;
+    }): void;
+}

package/dist/main.js

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2025 Stone Costa
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import cors from 'cors';
+import express from 'express';
+import config from 'stonyx/config';
+import log from 'stonyx/log';
+import { forEachFileImport } from '@stonyx/utils/file';
+export { default as Request } from './request.js';
+export default class RestServer {
+    static instance;
+    api;
+    server;
+    constructor() {
+        if (RestServer.instance)
+            return RestServer.instance;
+        RestServer.instance = this;
+        this.api = express();
+    }
+    static close() {
+        if (!RestServer.instance)
+            throw new Error('RestServer has not been initialized yet');
+        const { server } = RestServer.instance;
+        server.closeAllConnections();
+        server.close();
+    }
+    async init() {
+        await this.setupRouter();
+        const { port } = config.restServer;
+        // start REST server
+        this.server = this.api.listen(port);
+        log.title(`API Server is listening on port ${port}`);
+    }
+    async setupRouter() {
+        const { camelCaseRoutes, dir, enableHealthCheck } = config.restServer;
+        this.setupGlobalMiddleware();
+        try {
+            await forEachFileImport(dir, this.mountRoute.bind(this), { rawName: !camelCaseRoutes, ignoreAccessFailure: true });
+            if (enableHealthCheck)
+                this.api.get('/health', (_req, res) => res.sendStatus(200));
+        }
+        catch (error) {
+            if (config.debug)
+                console.log(error);
+            log.error(`Unable to dynamically configure routes from files in ${dir}`);
+            throw new Error(`Unable to dynamically configure routes from files in ${dir}`);
+        }
+    }
+    setupGlobalMiddleware() {
+        const { origin, methods, trustProxy } = config.restServer;
+        if (trustProxy)
+            this.api.set('trust proxy', true);
+        this.api.use([
+            cors({ origin, methods }),
+            express.json()
+        ]);
+    }
+    mountRoute(routeClassUntyped, { name, options }) {
+        const routeClass = routeClassUntyped;
+        const { api } = this;
+        const classInstance = new routeClass(options);
+        const route = name === 'index' ? '/' : `/${name}`;
+        const { expressInstance } = classInstance;
+        classInstance.registerCalls();
+        expressInstance.mountpath = route;
+        // Mount handler to main api instance
+        api.use(route, expressInstance);
+    }
+}

package/dist/request.d.ts

@@ -0,0 +1,15 @@
+import { type Request as ExpressRequest, type Response as ExpressResponse, type Express } from 'express';
+export type RequestState = Record<string, unknown>;
+export type RequestHandler = (req: ExpressRequest, state: RequestState) => unknown | Promise<unknown>;
+export type AuthHandler = (req: ExpressRequest, state: RequestState) => number | undefined;
+export type RouteHandlers = Record<string, Record<string, RequestHandler | RequestHandler[]>>;
+export default class Request {
+    static stateProp: string;
+    static getState(req: ExpressRequest): RequestState;
+    static sendStatusResponse(res: ExpressResponse, status: number): void;
+    expressInstance: Express;
+    handlers: RouteHandlers;
+    auth?: AuthHandler;
+    constructor();
+    registerCalls(): void;
+}

package/dist/request.js

@@ -0,0 +1,86 @@
+import express from 'express';
+import config from 'stonyx/config';
+import { makeArray } from '@stonyx/utils/object';
+const METHODS = new Set(['get', 'post', 'put', 'delete', 'patch']);
+export default class Request {
+    static stateProp = '__stonyxState';
+    static getState(req) {
+        const { stateProp } = Request;
+        const record = req;
+        if (record[stateProp] !== undefined)
+            return record[stateProp];
+        record[stateProp] = {};
+        return record[stateProp];
+    }
+    static sendStatusResponse(res, status) {
+        const statusMap = config.restServer?.statusMap ?? {};
+        const message = statusMap[status] || '';
+        if (message) {
+            res.status(status).send(message);
+        }
+        else {
+            res.sendStatus(status);
+        }
+    }
+    expressInstance;
+    handlers;
+    constructor() {
+        const api = express();
+        api.disable('x-powered-by');
+        this.expressInstance = api;
+    }
+    registerCalls() {
+        const { expressInstance } = this;
+        const { getState, sendStatusResponse } = Request;
+        for (const [method, handlers] of Object.entries(this.handlers)) {
+            if (!METHODS.has(method)) {
+                console.warn(`Method "${method}" is not a valid HTTP method. Skipping...`);
+                continue;
+            }
+            for (const [route, handler] of Object.entries(handlers)) {
+                expressInstance[method](route, async (req, res) => {
+                    // Run auth after route matching so request.params is populated
+                    if (this.auth) {
+                        const status = this.auth(req, getState(req));
+                        if (status)
+                            return sendStatusResponse(res, status);
+                    }
+                    const callStack = [...makeArray(handler)];
+                    const mainCall = callStack.pop();
+                    let response;
+                    // Run middleware
+                    while (callStack.length) {
+                        response = await callStack.shift().bind(this)(req, getState(req));
+                        if (response !== undefined)
+                            break;
+                    }
+                    if (response === undefined)
+                        response = await mainCall(req, getState(req));
+                    if (Number.isInteger(response))
+                        return sendStatusResponse(res, response);
+                    // Handle redirect if set via call state object
+                    const state = getState(req);
+                    const { redirect } = state;
+                    if (redirect)
+                        return res.redirect(redirect);
+                    // Handle pipe if set via call state object
+                    const { pipe } = state;
+                    if (pipe) {
+                        const { headers, source } = pipe;
+                        if (headers)
+                            for (const [key, value] of Object.entries(headers))
+                                res.set(key, value);
+                        return source.pipe(res);
+                    }
+                    if (response === undefined) {
+                        res.sendStatus(200);
+                        return;
+                    }
+                    if (typeof response !== 'object')
+                        return sendStatusResponse(res, 500);
+                    res.send(response);
+                });
+            }
+        }
+    }
+}

package/package.json

@@ -4,22 +4,31 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.1-alpha.0",
+  "version": "0.2.1-alpha.10",
   "description": "Rest Server Module for Stonyx Framework",
   "repository": {
     "type": "git",
     "url": "https://github.com/abofs/stonyx-rest-server"
   },
-  "main": "src/main.js",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
   "type": "module",
   "exports": {
-    ".": "./src/main.js"
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    }
   },
   "author": "Stone Costa",
   "license": "Apache-2.0",
   "contributors": [
     "Stone Costa <stone.costa@synamicd.com>"
   ],
+  "files": [
+    "dist",
+    "config",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -27,14 +36,22 @@
   "dependencies": {
     "cors": "^2.8.5",
     "express": "^5.1.0",
-    "stonyx": "^0.2.2"
+    "stonyx": "0.2.3-beta.12"
   },
   "devDependencies": {
-    "@stonyx/utils": "^0.2.2",
+    "@stonyx/utils": "0.2.3-beta.7",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.5.2",
+    "@types/qunit": "^2.19.13",
+    "@types/sinon": "^21.0.1",
     "qunit": "^2.24.1",
-    "sinon": "^21.0.0"
+    "sinon": "^21.0.0",
+    "typescript": "^5.8.3"
   },
   "scripts": {
-    "test": "qunit --require ./stonyx-bootstrap.cjs"
+    "build": "tsc",
+    "build:test": "tsc -p tsconfig.test.json",
+    "test": "pnpm build && pnpm build:test && stonyx test 'dist-test/test/**/*-test.js'"
   }
 }

package/.github/workflows/ci.yml

@@ -1,36 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches:
-      - dev
-      - main
-
-concurrency:
-  group: ci-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 24.13.0
-          cache: 'pnpm'
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run tests
-        run: pnpm test

package/.github/workflows/publish.yml

@@ -1,143 +0,0 @@
-name: Publish to NPM
-
-on:
-  # Manual trigger (kept for flexibility)
-  workflow_dispatch:
-    inputs:
-      version-type:
-        description: 'Version type'
-        required: true
-        type: choice
-        options:
-          - alpha
-          - patch
-          - minor
-          - major
-      custom-version:
-        description: 'Custom version (optional, overrides version-type)'
-        required: false
-        type: string
-
-  # Auto-publish alpha on PR
-  pull_request:
-    types: [opened, synchronize, reopened]
-    branches: [main, dev]
-
-  # Auto-publish stable on merge to main
-  push:
-    branches: [main]
-
-permissions:
-  contents: write
-  id-token: write  # Required for npm provenance
-  pull-requests: write  # For PR comments
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          # For PR events, check out the PR branch
-          ref: ${{ github.event_name == 'pull_request' && github.head_ref || github.ref }}
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 24.13.0
-          cache: 'pnpm'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run tests
-        run: pnpm test
-
-      - name: Configure git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      # Determine version type based on trigger
-      - name: Determine version bump type
-        id: version-type
-        run: |
-          if [ "${{ github.event_name }}" = "pull_request" ]; then
-            echo "type=alpha" >> $GITHUB_OUTPUT
-          elif [ "${{ github.event_name }}" = "push" ]; then
-            echo "type=patch" >> $GITHUB_OUTPUT
-          elif [ "${{ github.event.inputs.custom-version }}" != "" ]; then
-            echo "type=custom" >> $GITHUB_OUTPUT
-          else
-            echo "type=${{ github.event.inputs.version-type }}" >> $GITHUB_OUTPUT
-          fi
-
-      # Version bumping
-      - name: Bump version (custom)
-        if: steps.version-type.outputs.type == 'custom'
-        run: pnpm version ${{ github.event.inputs.custom-version }} --no-git-tag-version
-
-      - name: Bump version (alpha)
-        if: steps.version-type.outputs.type == 'alpha'
-        run: pnpm version prerelease --preid=alpha --no-git-tag-version
-
-      - name: Bump version (patch/minor/major)
-        if: steps.version-type.outputs.type == 'patch' || steps.version-type.outputs.type == 'minor' || steps.version-type.outputs.type == 'major'
-        run: pnpm version ${{ steps.version-type.outputs.type }} --no-git-tag-version
-
-      - name: Get package version
-        id: package-version
-        run: echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
-
-      # Publishing
-      - name: Publish to NPM (alpha)
-        if: contains(steps.package-version.outputs.version, 'alpha')
-        run: pnpm publish --tag alpha --access public --no-git-checks
-
-      - name: Publish to NPM (stable)
-        if: "!contains(steps.package-version.outputs.version, 'alpha')"
-        run: pnpm publish --access public
-
-      # Only commit and tag for stable releases (push to main or manual stable)
-      - name: Commit version bump and create tag
-        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && !contains(steps.package-version.outputs.version, 'alpha'))
-        run: |
-          git add package.json
-          git commit -m "chore: release v${{ steps.package-version.outputs.version }}"
-          git tag v${{ steps.package-version.outputs.version }}
-          git push origin main --tags
-
-      - name: Create GitHub Release
-        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && !contains(steps.package-version.outputs.version, 'alpha'))
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: v${{ steps.package-version.outputs.version }}
-          release_name: v${{ steps.package-version.outputs.version }}
-          draft: false
-          prerelease: false
-
-      # Add PR comment with alpha version info
-      - name: Comment on PR with alpha version
-        if: github.event_name == 'pull_request'
-        uses: actions/github-script@v6
-        with:
-          script: |
-            const version = '${{ steps.package-version.outputs.version }}';
-            const packageName = require('./package.json').name;
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: `## 🚀 Alpha Version Published\n\n**Version:** \`${version}\`\n\n**Install:**\n\`\`\`bash\npnpm add ${packageName}@${version}\n# or\npnpm add ${packageName}@alpha  # latest alpha\n\`\`\`\n\nThis alpha version is now available for testing!`
-            });

package/src/main.js

@@ -1,89 +0,0 @@
-/*
- * Copyright 2025 Stone Costa
- *
- * Licensed under the Apache License, Version 2.0 (the 'License');
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import cors from 'cors';
-import express from 'express';
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-import { forEachFileImport } from '@stonyx/utils/file';
-
-export { default as Request } from './request.js';
-
-export default class RestServer {
-  constructor() {
-    if (RestServer.instance) return RestServer.instance;
-    RestServer.instance = this;
-
-    this.api = new express();
-  }
-
-  static close() {
-    if (!RestServer.instance) throw new Error('RestServer has not been initialized yet');
-
-    RestServer.instance.server.close();
-  }
-  
-  async init() {
-    await this.setupRouter();
-    
-    const { port } = config.restServer;
-
-    // start REST server
-    this.server = this.api.listen(port);
-    log.title(`API Server is listening on port ${port}`);
-  }
-
-  async setupRouter() {
-    const { camelCaseRoutes, dir, enableHealthCheck } = config.restServer;
-    this.setupGlobalMiddleware();
-
-    try {
-      await forEachFileImport(dir, this.mountRoute.bind(this), { rawName: !camelCaseRoutes, ignoreAccessFailure: true });
-
-      if (enableHealthCheck) this.api.get('/health', (_req, res) => res.sendStatus(200));
-    } catch (error) {
-      if (config.debug) console.log(error);
-      throw log.error(`Unable to dynamically configure routes from files in ${dir}`);
-    }
-  }
-
-  async setupGlobalMiddleware() {
-    const { origin, methods } = config.restServer;
-
-    this.api.use([
-      cors({ origin, methods }),
-      express.json()
-    ]);
-  }
-
-  async mountRoute(routeClass, { name, options }) {
-    const { api } = this;
-    const classInstance = new routeClass(options);
-    const route = name === 'index' ? '/' : `/${name}`;
-    const { expressInstance, authorization } = classInstance;
-    
-    const routeCalls = [ expressInstance ];
-
-    // Assign auth callback if it exists
-    if (authorization) routeCalls.unshift(authorization.bind(classInstance));
-
-    classInstance.registerCalls();
-    expressInstance.mountpath = route;
-    
-    // Mount handler to main api instance
-    api.use(route, ...routeCalls);
-  }
-}

package/src/request.js

@@ -1,85 +0,0 @@
-import express from 'express';
-import config from 'stonyx/config';
-import { makeArray } from '@stonyx/utils/object';
-
-const METHODS = new Set(['get', 'post', 'put', 'delete', 'patch']);
-
-export default class Request {
-  static stateProp = '__stonyxState';
-
-  static getState(req) {
-    const { stateProp } = Request;
-    if (req[stateProp] !== undefined) return req[stateProp];
-    
-    req[stateProp] = {};
-    return req[stateProp];
-  }
-
-  static sendStatusResponse(res, status) {
-    const statusMap = config.restServer?.statusMap || {};
-    const message = statusMap[status] || '';
-  
-    return message ? res.status(status).send(message) : res.sendStatus(status);
-  }
-
-  constructor() {
-    const api = express();
-    api.disable('x-powered-by');
-    
-    this.expressInstance = api;
-  }
-
-  // auth hook wrapper
-  authorization(req, res, next) {
-    if (!this.auth) return next();
-
-    const status = this.auth(req, Request.getState(req));
-    if (status) return Request.sendStatusResponse(res, status);
-
-    next();
-  }
-
-  registerCalls() {
-    const { expressInstance } = this;
-    const { getState } = Request;
-    
-    for (const [method, handlers] of Object.entries(this.handlers)) {
-      if (!METHODS.has(method)) {
-        console.warn(`Method "${method}" is not a valid HTTP method. Skipping...`);
-        continue;
-      }
-
-      for (const [route, handler] of Object.entries(handlers)) {
-        expressInstance[method](route, async (req, res) => {
-          const callStack = [...makeArray(handler)];
-          const mainCall = callStack.pop();
-          const { sendStatusResponse } = Request;
-          let response;
-
-          // Run middleware
-          while(callStack.length) {
-            response = await callStack.shift().bind(this)(req, getState(req));
-            if (response !== undefined) break;
-          }
-
-          if (response === undefined) response = await mainCall(req, getState(req));
-          if (Number.isInteger(response)) return sendStatusResponse(res, response);
-          
-          // Handle pipe if set via call state object
-          const { pipe } = getState(req);
-          if (pipe) {
-            const { headers, source } = pipe;
-
-            if (headers) for (const [key, value] of Object.entries(headers)) res.set(key, value);
-            return source.pipe(res);
-          }
-
-          if (response === undefined) return res.sendStatus(200);
-          if (typeof response !== 'object') return sendStatusResponse(res, 500);
-
-          res.send(response);
-        });
-      }
-    }
-  }
-}

package/stonyx-bootstrap.cjs

@@ -1,12 +0,0 @@
-/**
- * commonJS Bootstrap loading - Stonyx must be loaded first, prior to the rest of the application
- */
-const { default:Stonyx } = require('stonyx');
-const { default:config } = require('./config/environment.js');
-
-// Override dir for tests
-config.dir = './test/sample/requests';
-
-new Stonyx(config, __dirname);
-
-module.exports = Stonyx;