tspace-spear 1.0.0-rc

package/License

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Thanathip Srisawatpattana
+
+ 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,320 @@
+# tspace-spear
+
+[![NPM version](https://img.shields.io/npm/v/tspace-spear.svg)](https://www.npmjs.com)
+[![NPM downloads](https://img.shields.io/npm/dm/tspace-spear.svg)](https://www.npmjs.com)
+
+tspace-spear is an api framework for node.js fast and highly focused on providing the best developer experience.
+the tspace-spear using native http server
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+npm install tspace-spear --save
+
+```
+## Basic Usage
+- [StartServer](#start-server)
+- [Middleware](#middleware)
+- [Controller](#controller)
+- [Router](#router)
+- [Handlers](#handlers)
+
+## StartServer
+```js
+import Spear from "tspace-spear";
+
+new Spear()
+.get('/' , () => 'Hello world!')
+.get('/json' , () => {
+  return {
+    message : 'Hello world!'
+  }
+})
+.listen(3000 , ({ server, port }) => console.log(`server listening on : http://localhost:${port}`))
+
+```
+
+## Middleware
+```js
+// file cat-middleware.ts
+export default (ctx : TContext, next: TNextFunction) =>{
+  console.log('cat middleware globals');
+  return next();
+}
+
+import  Spear { Router, TContext, TNextFunction } from "tspace-spear";
+import CatMiddleware from './cat-middleware.ts'
+
+(async () => {
+  const port = Number(process.env.PORT ?? 3000)
+  const app = new Spear({
+    middlewares: [ CatMiddleware ]
+    // if you want to import a middleware with a directory can you follow the example
+    // middlewares : {
+    //   folder : `${__dirname}/middlewares`,
+    //   name :  /middleware\.(ts|js)$/i
+    // }
+  })
+
+  // or add a middleware
+  app.use((ctx : TContext , next : TNextFunction) => {
+    console.log('global middlewares')
+    return next()
+  })
+
+  app.get('/' , ({ res } : TContext) => {
+    return res.json({
+      message : 'hello world!'
+    });
+  })
+
+  app.listen(port , () => console.log(`Server is now listening port: ${port}`))
+
+  // localhost:3000
+
+})()
+```
+
+## Controller
+```js
+import { 
+  Controller , 
+  Middleware , 
+  Get , 
+  Post,
+  Patch,
+  Put,
+  Delete,  
+  WriteHeader, 
+  Query, 
+  Body,
+  Params,
+  Cookies,
+  Files, 
+  StatusCode 
+} from 'tspace-spear';
+
+import type { 
+  TCookies, TParams, 
+  TRequest, TResponse ,  
+  TQuery, TFiles, 
+  TContext, TNextFunction
+} from 'tspace-spear';
+import CatMiddleware from './cat-middleware.ts'
+
+// file cat-controller.ts
+@Controller('/cats')
+class CatController {
+  @Get('/')
+  @Middleware(CatMiddleware)
+  @Query('test','id')
+  @Cookies('name')
+  public async index({ query , cookies , req } : { 
+    query : TQuery<{ id : string }>
+    cookies : TCookies<{ name : string}>
+    req : TRequest
+  }) {
+
+    return {
+      query,
+      cookies
+    }
+  }
+
+  @Get('/:id')
+  @Middleware(CatMiddleware)
+  @Params('id')
+  public async show({ params} : TContext) {
+    return {
+      params
+    }
+  }
+
+  @Post('/')
+  @Middleware(CatMiddleware)
+  public async store({ body } : TContext) {
+    return {
+      body
+    }
+  }
+
+  @Put('/:id')
+  @Middleware(CatMiddleware)
+  public async update({ files } : TContext) {
+    return {
+     files
+    }
+  }
+
+  @Post('/upload')
+  @Middleware(CatMiddleware)
+  public async upload({ files } : TContext) {
+    return {
+     files
+    }
+  }
+
+  @Delete('/:id')
+  @Middleware(CatMiddleware)
+  public async destroy({ params } : TContext) {
+    return {
+     params
+    }
+  }
+}
+
+import Spear , { Router, TContext, TNextFunction } from "tspace-spear";
+import CatController from './cat-controller.ts'
+
+(async () => {
+
+  const app = new Spear({
+    controllers: [ CatController ]
+    // if you want to import a controller with a directory can you follow the example
+    // controllers : {
+    //   folder : `${__dirname}/controllers`,
+    //   name :  /controller\.(ts|js)$/i
+    // }
+  })
+
+  app.get('/' , ( { res } : TContext) => {
+    return res.json({
+      message : 'hello world!'
+    });
+  })
+
+  let port = 3000
+
+  app.listen(port , () => console.log(`Server is now listening port: ${port}`))
+
+  // localhost:3000/cats 
+  // localhost:3000/cats/41
+
+})()
+```
+
+## Router
+
+```js
+import Spear , { Router, TContext, TNextFunction } from "tspace-spear";
+
+const app = new Spear()
+
+const router = new Router()
+    
+router.groups('/my',(r) => {
+
+  r.get('/cats' , ({ req , res }) => {
+
+      return res.json({
+          message : 'Hello, World!'
+      })
+  })
+
+  return r
+})
+    
+router.get('/cats' , ({ req , res }) => {
+  return res.json({
+      message : 'Hello, World!'
+  })
+})
+
+app.useRouter(router)
+
+app.get('/' , ({ res } : TContext) => {
+  return res.json({
+    message : 'hello world!'
+  });
+})
+
+let port = 3000
+
+app.listen(port , () => console.log(`Server is now listening port: ${port}`))
+
+// localhost:3000/my/cats
+// localhost:3000/cats
+
+```
+
+## Handlers
+```js
+
+const app = new Spear({
+  logger : true, // logging
+  globalPrefix : '/api' // prefix all routes
+})
+
+app.enableCors({
+    origins: [
+      /^http:\/\/localhost:\d+$/
+    ],
+    credentials: true
+})
+
+app.useFileUpload({
+    limits : 1000 * 1000, // limits for file upload 1_000_000 bytes
+    useTempFiles : true, // whether to use temporary files
+    tempFileDir : 'tmp', // temporary directory
+    removeTempFile : {
+      remove : true, // remove temporary files
+      ms : 1000 * 60 // remove temporary after 60 seconds
+    }
+  })
+
+app.useBodyParser()
+
+app.useCookiesParser()
+
+app.get('/' , ({ res } : TContext) => {
+  return res.json({
+    message : 'hello world!'
+  });
+})
+
+app.get('/errors', () => {
+  throw new Error('testing Error handler')
+})
+    
+// every response should returns following this format response
+app.formatResponse((results : unknown , statusCode : number) => {
+
+  if(typeof results === 'string') return results
+  
+  /// ...
+
+  return {
+      success : statusCode < 400,
+      ...results,
+      code : statusCode
+  }
+})
+  
+// every notfound page should returns following this format response
+app.notFoundHandler(({ res } : TContext) => {
+  return res.notFound();
+})
+    
+// every errors page should returns following this format response
+app.errorHandler((err : Error , { res } : TContext) => {
+
+  return res
+    .status(500)
+    .json({
+      success : false,
+      message : err?.message,
+      code    : 500
+  });
+}) 
+    
+let port = 3000
+
+app.listen(port , () => console.log(`Server is now listening port: ${port}`))
+
+// localhost:3000/*********** // not found
+// localhost:3000/errors // errors
+// localhost:3000 // format response
+
+```

package/build/lib/core/decorators/context.d.ts

@@ -0,0 +1,5 @@
+export declare const Body: (...bodyParms: string[]) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Files: (...filesParms: string[]) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Params: (...paramsData: string[]) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Query: (...queryParms: string[]) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Cookies: (...cookiesParms: string[]) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/build/lib/core/decorators/context.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cookies = exports.Query = exports.Params = exports.Files = exports.Body = void 0;
+const Body = (...bodyParms) => {
+    return function (target, key, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.body) !== null && _a !== void 0 ? _a : {};
+                const body = bodyParms.reduce((acc, key) => (q[key] != null ? Object.assign(Object.assign({}, acc), { [key]: q[key] }) : acc), {});
+                ctx.body = Object.keys(body).length ? body : null;
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.Body = Body;
+const Files = (...filesParms) => {
+    return function (target, key, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.files) !== null && _a !== void 0 ? _a : {};
+                const files = filesParms.reduce((acc, key) => (q[key] != null ? Object.assign(Object.assign({}, acc), { [key]: q[key] }) : acc), {});
+                ctx.files = Object.keys(files).length ? files : null;
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.Files = Files;
+const Params = (...paramsData) => {
+    return function (target, key, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.params) !== null && _a !== void 0 ? _a : {};
+                const params = paramsData.reduce((acc, key) => (q[key] != null ? Object.assign(Object.assign({}, acc), { [key]: q[key] }) : acc), {});
+                ctx.params = Object.keys(params).length ? params : null;
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.Params = Params;
+const Query = (...queryParms) => {
+    return function (target, key, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.query) !== null && _a !== void 0 ? _a : {};
+                const query = queryParms.reduce((acc, key) => (q[key] != null ? Object.assign(Object.assign({}, acc), { [key]: q[key] }) : acc), {});
+                ctx.query = Object.keys(query).length ? query : null;
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.Query = Query;
+const Cookies = (...cookiesParms) => {
+    return function (target, key, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.cookies) !== null && _a !== void 0 ? _a : {};
+                const cookies = cookiesParms.reduce((acc, key) => (q[key] != null ? Object.assign(Object.assign({}, acc), { [key]: q[key] }) : acc), {});
+                ctx.cookies = Object.keys(cookies).length ? cookies : null;
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.Cookies = Cookies;

package/build/lib/core/decorators/controller.d.ts

@@ -0,0 +1 @@
+export declare const Controller: (path: `/${string}`) => ClassDecorator;

package/build/lib/core/decorators/controller.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const Controller = (path) => {
+    return (target) => {
+        Reflect.defineMetadata("controllers", path, target);
+    };
+};
+exports.Controller = Controller;

package/build/lib/core/decorators/headers.d.ts

@@ -0,0 +1,2 @@
+import { OutgoingHttpHeaders } from 'http';
+export declare const WriteHeader: (statusCode: number, contentType: OutgoingHttpHeaders) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/build/lib/core/decorators/headers.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteHeader = void 0;
+const WriteHeader = (statusCode, contentType) => {
+    return (target, key, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            return __awaiter(this, void 0, void 0, function* () {
+                ctx.res.writeHead(...[statusCode, contentType]);
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.WriteHeader = WriteHeader;

package/build/lib/core/decorators/index.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+export * from './methods';
+export * from './headers';
+export * from './middleware';
+export * from './controller';
+export * from './headers';
+export * from './statusCode';
+export * from './context';

package/build/lib/core/decorators/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+__exportStar(require("./methods"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./controller"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./statusCode"), exports);
+__exportStar(require("./context"), exports);

package/build/lib/core/decorators/methods.d.ts

@@ -0,0 +1,5 @@
+export declare const Get: (path: `/${string}`) => MethodDecorator;
+export declare const Post: (path: `/${string}`) => MethodDecorator;
+export declare const Put: (path: `/${string}`) => MethodDecorator;
+export declare const Patch: (path: `/${string}`) => MethodDecorator;
+export declare const Delete: (path: `/${string}`) => MethodDecorator;

package/build/lib/core/decorators/methods.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = void 0;
+const methodDecorator = (method) => {
+    return (path) => {
+        return (target, propertyKey) => {
+            const controller = target.constructor;
+            const routers = Reflect.hasMetadata("routers", controller)
+                ? Reflect.getMetadata("routers", controller)
+                : [];
+            routers.push({
+                method,
+                path,
+                handler: propertyKey,
+            });
+            Reflect.defineMetadata("routers", routers, controller);
+        };
+    };
+};
+exports.Get = methodDecorator('get');
+exports.Post = methodDecorator('post');
+exports.Put = methodDecorator('put');
+exports.Patch = methodDecorator('patch');
+exports.Delete = methodDecorator('delete');

package/build/lib/core/decorators/middleware.d.ts

@@ -0,0 +1,2 @@
+import { TRequestFunction } from '../../types';
+export declare const Middleware: (middleware: TRequestFunction) => (target: any, key: string, descriptor: PropertyDescriptor) => void;

package/build/lib/core/decorators/middleware.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = void 0;
+const Middleware = (middleware) => {
+    return (target, key, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (ctx, next) {
+            try {
+                Reflect.defineMetadata("middlewares", descriptor, target);
+                return middleware(ctx, (err) => {
+                    if (err != null) {
+                        return next(err);
+                    }
+                    return originalMethod.call(this, ctx, next);
+                });
+            }
+            catch (error) {
+                return next(error);
+            }
+        };
+    };
+};
+exports.Middleware = Middleware;

package/build/lib/core/decorators/statusCode.d.ts

@@ -0,0 +1 @@
+export declare const StatusCode: (statusCode: number) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/build/lib/core/decorators/statusCode.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCode = void 0;
+const StatusCode = (statusCode) => {
+    return (target, key, descriptor) => {
+        const originalMethod = descriptor.value;
+        statusCode = statusCode < 100 ? 100 : statusCode > 599 ? 599 : statusCode;
+        descriptor.value = function (ctx, next) {
+            return __awaiter(this, void 0, void 0, function* () {
+                ctx.res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                return yield originalMethod.call(this, ctx, next);
+            });
+        };
+        return descriptor;
+    };
+};
+exports.StatusCode = StatusCode;