# kwix

> Backend framework for node enthusiasts

Latest version **0.0.7** (published 2022-08-24) · MIT license · 0 weekly downloads

## Install

```sh
npm install kwix
pnpm add kwix
yarn add kwix
bun add kwix
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.0.7 |
| Published | 2022-08-24 |
| First published | 2021-04-07 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 53.6 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | k-koehler |
| Maintainers | kevin-koehler |

## Links

- npm: https://www.npmjs.com/package/kwix
- Homepage: https://github.com/k-koehler/kwix#readme
- npm.io page: https://npm.io/package/kwix

## Recent versions

- 0.0.7 (latest) — 2022-08-24
- 0.0.6 — 2022-08-16
- 0.0.5 — 2022-08-16
- 0.0.4 — 2021-10-20
- 0.0.3 — 2021-09-02
- 0.0.2 — 2021-08-20
- 0.0.1 — 2021-04-07

## README

# `kwix`

## Description

`kwix` is a framework-agnostic library for building scalable, object-oriented, typescript nodejs applications. `kwix` uses a controller/middleware pattern allowing you to build extensible controllers and middlewares.

## Getting started

`kwix` ships with fastify/express support. To get started simply create a router and go wild with controllers!

```typescript
// app.ts
import fastify from "fastify";
import { FastifyRouter, FastifyServer } from "kwix/fastify";

const app = fastify();

export const { Get, Post, Patch, Delete } = new FastifyRouter(
  new FastifyServer(app)
).methods();

export default app;
```

```typescript
// controller.ts
import { FastifyController } from "kwix/fastify";

@Get("/hello-world")
export default class HelloWorldController extends FastifyController {
  protected handle(){
    return this.success()
  }
}
```

## Using custom frameworks

Firstly, select an http framework of your choice, i.e. express/fastify.

Next, implement response/request objects using said framework:

```typescript
// io.ts
import { Request, Response } from "kwix";

export class MyAwesomeFrameworkRequest extends Request {
  // implement body, query, headers, and params abstract methods here
}

export class MyAwesomeFrameworkResponse extends Response {
  // expose any framework specific methods you might need on the response here
}
```

Next, implement a server, so that `kwix` knows how to bind to your framework.

```typescript
//server.ts 
import { ConcreteController, Controller, RouteMethod, Server } from "kwix";
import { MyAwesomeFrameworkRequest, MyAwesomeFrameworkResponse } from "./io";

export default class MyAwesomeFrameworkServer extends Server<
  MyAwesomeFrameworkRequest,
  MyAwesomeFrameworkResponse
> {
  // implement handle abstract method here
}
```

Next, implement a router and bind the router to your framework server instance.

```typescript
// router.ts
import { Router } from "kwix";
import { MyAwesomeFrameworkRequest, MyAwesomeFrameworkResponse } from "./io";
import MyAwesomeFrameworkServer from "./server";

export default class MyAwesomeFrameworkRouter extends Router<
  MyAwesomeFrameworkRequest,
  MyAwesomeFrameworkResponse
> {
  protected server: MyAwesomeFrameworkServer;

  public constructor(server: MyAwesomeFrameworkServer) {
    super();
    this.server = server;
  }
}
```

```typescript
// app.ts
import instance from "my-awesome-framework";
import MyAwesomeFrameworkServer from "./server";
import MyAwesomeFrameworkRouter from "./router";

const app = instance();

export const { Get, Post, Patch, Delete } = new MyAwesomeFrameworkRouter(
  new MyAwesomeFrameworkServer(app)
).methods();

export default app;
```

Next, implement a base controller:

```typescript
// base-controller.ts
import { MyAwesomeFrameworkRequest, MyAwesomeFrameworkResponse } from "./io";
export default abstract class BaseController extends MiddlewareController<
  MyAwesomeFrameworkRequest,
  MyAwesomeFrameworkResponse
> {
  // implement success, bad request, etc. abstract methods here
}
```

LASTLY, create controllers at will!

```typescript
// hello-world-controller.ts
import BaseController from "./base-controller";

@Get("/hello-world")
export default class HelloWorldController extends BaseController {
  protected handle(){
    return this.success();
  }
}
```

---
_Source: https://npm.io/package/kwix · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._