backendium 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -50,3 +50,5 @@ export default class Backendium<GlobalAuthType = any> extends BackendiumRouter<G
     start(callback?: (server: Server) => void): Server;
     startAsync(): Promise<Server>;
 }
+export * from "./ws";
+export * from "./router";

package/dist/index.js

@@ -85,3 +85,5 @@ export default class Backendium extends BackendiumRouter {
         });
     }
 }
+export * from "./ws";
+export * from "./router";

package/dist/logger.js

@@ -137,7 +137,7 @@ export default class Logger {
     }
     wsInit(url) {
         let prefix = this.getPrefix("wsInit");
-        this.logSeparately([chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.red("done")], [prefix, "Websocket init on url", url, "done"]);
+        this.logSeparately([chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.green("done")], [prefix, "Websocket init on url", url, "done"]);
     }
     wsInitFailed(url) {
         let prefix = this.getPrefix("wsInitFailed");

package/dist/router.d.ts

@@ -52,7 +52,7 @@ export declare class BackendiumRouter<GlobalAuthType = undefined> {
     unlock<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
     link<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
     unlink<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    ws<InitDataType>(route: string): WebSocketRouteConstructor<InitDataType>;
+    ws<InitDataType>(route: string, constructor: WebSocketRouteConstructor<InitDataType>): void;
     protected static addPrefix([method, route, handler]: [MethodType, string | undefined, Array<(app: Backendium) => RequestHandler>], prefix: string): [MethodType, string, Array<(app: Backendium) => RequestHandler>];
     protected static addPrefix([method, route, handler]: ["ws", string, Array<(app: Backendium) => WSRequestHandler>], prefix: string): ["ws", string, Array<(app: Backendium) => WSRequestHandler>];
     router<AuthType>(router: BackendiumRouter<AuthType>, routePrefix?: string): void;

package/dist/router.js

@@ -1,5 +1,4 @@
 import backendiumHandler from "./handler.js";
-import { WebSocketRouteConstructor } from "./ws.js";
 export class BackendiumRouter {
     constructor() {
         this._handlers = [];
@@ -115,12 +114,10 @@ export class BackendiumRouter {
     unlink(...args) {
         this.addHandler("unlink", ...args);
     }
-    ws(route) {
-        const constructor = new WebSocketRouteConstructor();
+    ws(route, constructor) {
         this._handlers.push(["ws", route, [(app) => (request, response, next) => {
                     constructor._handle(request, response, next, app);
                 }]]);
-        return constructor;
     }
     static addPrefix([method, route, handler], prefix) {
         return [method, route || !(route === null || route === void 0 ? void 0 : route.startsWith("/")) ? prefix + (route !== null && route !== void 0 ? route : "") : prefix + (route !== null && route !== void 0 ? route : ""), handler];

package/dist/ws.d.ts

@@ -96,6 +96,7 @@ export declare class WebSocketRouteConstructor<InitDataType> {
     on<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): WebSocketRouteConstructor<InitDataType>;
     once<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): WebSocketRouteConstructor<InitDataType>;
     off<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): WebSocketRouteConstructor<InitDataType>;
-    requireInit<Type>(callback: (connection: WebSocket & WebSocketExtension, data: Type, app: Backendium) => null | InitDataType | Promise<null | InitDataType>, validator: Validator<Type>): void;
+    requireInit<Type>(callback: (connection: WebSocket & WebSocketExtension, data: Type, app: Backendium) => null | InitDataType | Promise<null | InitDataType>, validator: Validator<Type>): WebSocketRouteConstructor<InitDataType>;
 }
+export declare function websocketConstructor<InitDataType = undefined>(): WebSocketRouteConstructor<InitDataType>;
 export {};

package/dist/ws.js

@@ -333,6 +333,10 @@ export class WebSocketRouteConstructor {
                     app.logger.wsInitFailed(url);
             }
         }));
+        return this;
     }
 }
+export function websocketConstructor() {
+    return new WebSocketRouteConstructor;
+}
 // @TODO error handling +termination logging

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backendium",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Express-based javascript backend framework with websocket support and type-safe checkeasy validators",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -114,30 +114,38 @@ curl http://localhost:8080/validated/headers -H "n:2"
 ```
 # Authorization
 ```typescript
+const USERS: {[key: number]: string} = {
+    54: "sizoff"
+}
+
 router.post<Buffer, {}, {}, string>("/auth", (request, response) => {
     console.log(request.auth); // type of request.auth is string
     response.end();
 }, {
     authChecker(request, response) {
-        if (typeof request.headers.auth !== "string" || request.headers.auth !== "backendium") return null; // auth failed
-        return request.headers.auth; // return auth data
+        if (typeof request.headers.auth !== "string" || !(Number(request.headers.auth) in USERS)) return null; // auth failed
+        return USERS[Number(request.headers.auth)]; // return auth data
     }
 });
 ```
 ```bash
-curl http://localhost:8080/auth -H "auth:backendium" -d ""
+curl http://localhost:8080/auth -H "auth:54" -d ""
 ```
 ## Global (for router)
 ```typescript
 const router = new BackendiumRouter<string>;
 
+const USERS: {[key: number]: string} = {
+    54: "sizoff"
+}
+
 router.setAuth((request, response) => {
-    if (typeof request.headers.auth !== "string" || request.headers.auth !== "backendium") return null; // auth failed
-    return request.headers.auth; // return auth data
+    if (typeof request.headers.auth !== "string" || !(Number(request.headers.auth) in USERS)) return null; // auth failed
+    return USERS[Number(request.headers.auth)]; // return auth data
 });
 
 router.post("/auth", (request, response) => {
-    console.log(request.globalAuth); // type of request.globalAuth is string
+    console.log(request.globalAuth); // type of request.auth is string
     response.end();
 }, {
     auth: true
@@ -166,11 +174,62 @@ router.ws("/ws")
         socket.send(data);
     });
 ```
-request:
+### js build-in websockets:
 ```javascript
 const connection = new WebSocket("ws://localhost:8080/ws");
 connection.send("test");
 connection.onmessage = (message) => {
     console.log(message.data);
 };
+```
+### [Backendium connect](https://github.com/vssizoff/backendiumConnect)
+```typescript
+import {websocketRequest} from "backendium-connect";
+
+websocketRequest()
+    .on("message", (data, socket) => {
+        console.log(data); // data is Buffer
+    })
+    .send("ws://localhost:8080/ws")
+    .then(socket => {
+        socket.send("test");
+    });
+```
+## Events
+```typescript
+router.ws("/ws")
+    .event<number>("sqrt", (data, socket) => {
+        console.log(data);
+        socket.emit("response", Math.sqrt(data));
+    }, int());
+```
+only Backendium connect
+```typescript
+websocketRequest()
+    .event<number>("response", data => console.log(data), float())
+    .send("ws://localhost:8080/ws")
+    .then(socket => {
+        socket.emit("sqrt", 2);
+    });
+```
+## Init
+```typescript
+router.ws<string>("/ws/init")
+    .event("test", (data, socket) => {
+        socket.send(socket.initData);
+    })
+    .requireInit<number>((socket, data) => {
+        if (!(data in USERS)) return null; // auth failed
+        return USERS[data]; // return auth data
+    }, int());
+```
+```typescript
+websocketRequest<number>()
+    .on("message", data => {
+        console.log(data.toString());
+    })
+    .send("ws://localhost:8080/ws/init", 54)
+    .then(socket => {
+        socket.emit("test");
+    });
 ```

package/src/index.ts

@@ -106,4 +106,7 @@ export default class Backendium<GlobalAuthType = any> extends BackendiumRouter<G
             this.start(resolve);
         });
     }
-}
+}
+
+export * from "./ws";
+export * from "./router";

package/src/logger.ts

@@ -164,7 +164,7 @@ export default class Logger {
 
     wsInit(url: string) {
         let prefix = this.getPrefix("wsInit");
-        this.logSeparately([chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.red("done")],
+        this.logSeparately([chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.green("done")],
             [prefix, "Websocket init on url", url, "done"]);
     }
 

package/src/router.ts

@@ -200,12 +200,10 @@ export class BackendiumRouter<GlobalAuthType = undefined> {
         this.addHandler("unlink", ...args);
     }
 
-    ws<InitDataType>(route: string): WebSocketRouteConstructor<InitDataType> {
-        const constructor = new WebSocketRouteConstructor<InitDataType>();
+    ws<InitDataType>(route: string, constructor: WebSocketRouteConstructor<InitDataType>) {
         this._handlers.push(["ws", route, [(app: Backendium) => (request: Request, response: WSResponse, next: NextFunction) => {
             constructor._handle(request, response, next, app);
         }]]);
-        return constructor;
     }
 
     protected static addPrefix([method, route, handler]: [MethodType, string | undefined, Array<(app: Backendium) => RequestHandler>], prefix: string): [MethodType, string, Array<(app: Backendium) => RequestHandler>];

package/src/ws.ts

@@ -341,7 +341,7 @@ export class WebSocketRouteConstructor<InitDataType> {
         return this;
     }
     
-    public requireInit<Type>(callback: (connection: WebSocket & WebSocketExtension, data: Type, app: Backendium) => null | InitDataType | Promise<null | InitDataType>, validator: Validator<Type>) {
+    public requireInit<Type>(callback: (connection: WebSocket & WebSocketExtension, data: Type, app: Backendium) => null | InitDataType | Promise<null | InitDataType>, validator: Validator<Type>): WebSocketRouteConstructor<InitDataType> {
         this.initRequired = true;
         this.on("init", async (socket, data, app, url) => {
             let [mainData, parsed] = validator ? parse(data, validator) : [data, true];
@@ -365,7 +365,12 @@ export class WebSocketRouteConstructor<InitDataType> {
                 else app.logger.wsInitFailed(url);
             }
         });
+        return this;
     }
 }
 
+export function websocketConstructor<InitDataType = undefined>() {
+    return new WebSocketRouteConstructor<InitDataType>;
+}
+
 // @TODO error handling +termination logging