alado 1.0.0

package/LICENSE

@@ -0,0 +1,18 @@
+(The MIT License)
+Copyright (c) 2024 Pavlo Lazunko <pavlo@databikers.com>
+
+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,515 @@
+Alado is an extremely fast, simple, robust, and lightweight framework 
+for creating server applications written in Node.js and running over the HTTP protocol.
+
+Its main difference from most similar well-known frameworks is that with a minimum of external dependencies 
+it provides out-of-the-box such fully-functioning features as routing, CORS, automatic API documentation (Open API 3.0), 
+parsing query and path parameters, and the request body, file uploading, request authentication, etc.
+
+The basis of use is a combination of interface simplicity and separation of the “routine” part of writing API 
+from business logic implementation - due to a declarative approach to describing all request parameters 
+in the form of static reusable structures.
+
+1. Installation
+
+```shell
+npm i -s alado
+```
+
+2. Instancing
+
+```typescript
+
+import { AladoServer } from 'alado';
+
+const app: AladoServer = new AladoServer({
+  port: 3000,
+  cors: {
+    enable: true,
+    allowedOrigin: '*',
+    allowedHeaders: [ 'Authorization' ],
+    exposeHeaders: [ 'x-total-count' ],
+  },
+  openApiDoc: {
+    enable: true,
+    route: '/open-api',
+    info: {
+      title: 'My API title',
+      description: 'My API description',
+      version: '1.0.0'
+    }
+  }
+})
+
+```
+
+In case you want to run an HTTPs server (even though normally a Node.js app runs behind nginx/ingress etc.) 
+You can do it using the ssl parameter (look at SecureContextOptions in the "tls" module - 
+[Node.js TLS module](https://nodejs.org/api/tls.html#tlscreateserveroptions-secureconnectionlistener):
+
+
+```typescript
+
+import { readFileSync } from 'fs';
+import { AladoServer } from 'alado';
+
+const app = new AladoServer({
+  port: 3000,
+  ssl: {
+    cert: readFileSync('/path/to/cert'),
+    key: readFileSync('/path/to/key'),
+  },
+  cors: {
+    enable: true,
+    allowedOrigin: '*',
+    allowedHeaders: [ 'Authorization' ],
+    exposeHeaders: [ 'x-total-count' ],
+  },
+  openApiDoc: {
+    enable: true,
+    route: '/',
+    info: {
+      title: 'My API title',
+      description: 'My API description',
+      version: '1.0.0'
+    }
+  }
+})
+
+```
+3. Defining routes
+
+Here is how you define routes in Alado:
+
+```typescript
+
+app.get('/user/:id', context, (request: Request): Response<UserDto> => {
+  const user = {
+    name: 'John Doe',
+    id: request.path.id
+  }
+  return {
+    statusCode: 200,
+    headers: { 
+      'Content-Type': 'application/json',
+    },
+    body: user
+  }
+});
+
+
+app.start(() => console.log(`[API]: application has been launched successfully`))
+
+```
+The application provides "get", "post", "delete", "patch", "put" and "head" methods for defining routes. 
+These methods accept three required arguments:
+
+* route or path: A string that may contain variables to specify the route.
+* context: An aggregating object that fully describes the request.
+* handler: A function that handles the request.
+
+3.1 Route or path.
+
+Path variables defining works in the same way as it works in other frameworks:  You just define a part of your route (means part separated by slashes)
+as ":id" and receive the passed value as request.path.id).
+
+3.2 Context
+
+Here's the contract of the request context:
+
+```typescript
+
+interface Context <T> {
+  title: string;
+  auth?: RequestAuthentication;
+  options: ContextOptions;
+  request: ContextRequest;
+  response: Response<T>;
+}
+
+```
+Unlike context.title, which is simply a unique string, the other properties may not be immediately clear. 
+However, once explained, they become quite obvious and extremely logical. 
+
+**Note that all parts of the context and its nested properties can be reused**
+
+3.2.1 Context.auth
+
+```typescript
+
+import { RequestAuthentication } from 'alado';
+
+const bearerAuth: RequestAuthentication =  {
+  inputProperty: 'headers.authorization',
+  outputProperty: 'auth.user',
+  handler: async (bearer: string) => {
+   // validate header, return user 
+    return {
+      name: 'John Doe',
+      id: 1
+    }
+  },
+  required: true, // false You want "soft" checking
+  error: {
+    statusCode: 401,
+    message: 'Unauthorized'
+  }
+}
+
+```
+This means that the application takes an "Authorization" header
+(or "api_token" query parameter if you provide "query.api_token" as an inputProperty,
+"body.someThing" and "path.token" work also)
+use the provided handler to get the user and set the received user to request.auth.user, 
+(and the mentioned "request" here is the request argument in your route handler)
+Or just returns 401 Unauthorized.
+This means that the application can authenticate using an "Authorization" header, or alternatively, 
+using an "api_token" query parameter (if specified as "query.api_token" in the inputProperty). 
+It can also authenticate using values like "body.someThing" or "path.token". 
+In the example the provided handler retrieves the user and assigns it to request.auth.user 
+(where request is the argument in your route handler). 
+If authentication fails, it returns a 401 Unauthorized response.
+
+This also works:
+
+```typescript
+import { RequestAuthentication } from 'alado';
+
+const bearerAuth: RequestAuthentication =  {
+  inputProperty: 'header.x-api-token',
+  outputProperty: 'auth',
+  handler: async (xApiToken: string) => {
+   // You will receive user and company as nested properties in request auth 
+    return {
+      user: {
+        name: 'John Doe',
+        id: 1
+      },
+      company: {
+        name: 'Databikers Limited',
+        id: 2
+      }
+    }
+  },
+  //optional property if You want to specify execution context for the auth handler
+  handlerContext: {}, 
+  required: true, // false You want "soft" checking
+  error: {
+    statusCode: 401,
+    message: 'Unauthorized'
+  }
+}
+```
+
+3.2.2 Context.options
+
+```typescript
+interface ContextOptions {
+  allowUnknownFields?: boolean;
+  openApiDoc?: {
+    description?: string;
+    operationId: string;
+    tags?: string[];
+  }
+}
+```
+Setting "allowUnknownFields" to false protects your application from receiving unexpected properties in the request body, query, and files. It does not affect request.path, as path variables are defined at the routing level, nor does it affect request headers. Conversely, you can receive { name: 'John Doe', role: 'Admin' } when only expecting name.
+
+The "openApiDoc" property is part of the Open API route definition and is optional.
+
+3.2.3 Context.request
+
+Context.request is aggregating object that describes all HTTP request properties You expect
+
+```typescript
+
+interface ContextRequest {
+  headers?: Record<string, PropertyDefinition>;
+  query?: Record<string, PropertyDefinition>;
+  path?: Record<string, PropertyDefinition>;
+  body?: Record<string, PropertyDefinition>;
+  files?: Record<string, FilePropertyDefinition>;
+  auth?: Record<string, any>;
+}
+```
+There's an example for request with path property only:
+
+```typescript
+const request: ContextRequest = {
+    path: {
+      id: {
+        openApiDoc: {
+          schema: {
+            type: 'string',
+          },
+          example: '123456',
+          description: 'User id'
+        },
+        validation: {
+          required: true,
+          handler (value) {
+            return /^\d+$/.test(value);
+          },
+          transform (value) {
+            return parseInt(value, 10);
+          },
+          error: {
+            statusCode: 400,
+            message: '400.1.0'
+          }
+        }
+      }
+    }
+  };
+```
+Validation.handler returns boolean (any => boolean | any => Promise<boolean>) if received value fits to provided requirements,
+and in falsy case it throws an error and app returns 400 Bad Request with a json body contains specified message
+Handler can be async and can use complex logic under the hood; it allows to use 
+Avoid using an arrow functions as handlers - in this case You can lose execution context, 
+The execution context of validation.handler (and validation transform) is the request 
+(aggregating object - the argument used at the route handler)
+
+```typescript
+
+const request: ContextRequest = {
+    body: {
+      role: {
+        openApiDoc: {
+          schema: {
+            type: 'string',
+          },
+          example: 'admin',
+          description: 'User role'
+        },
+        validation: {
+          required: true,
+          async handler (value) {
+            if (this.auth.user.role === 'admin') {
+              return true;
+            }
+            await userService.makeSomeChecking(this.query.scope);
+            return value === 'customer'
+          },
+          error: {
+            statusCode: 400,
+            message: '400.1.0'
+          }
+        }
+      }
+    }
+  };
+
+```
+In the same way You can describe the request headers, query, body. Remember, if context.options.allowUnknownFields
+is set to false, all non-described request properties (or non-described nested properties in the described request properties) never be accessible.
+
+```typescript
+
+const request: ContextRequest = {
+    query: {
+      sortBy: {
+        openApiDoc: {
+          schema: {
+            type: 'string',
+          },
+          example: 'createdAt',
+          description: 'Sort by field'
+        },
+        validation: {
+          required: true,
+          handler (value) {
+            return ['createdAt','updatedAt'].includes(value);
+          },
+          error: {
+            statusCode: 400,
+            message: 'sortBy should be createdAt or updatedAt'
+          }
+        }
+      },
+      sortOrder: {
+        openApiDoc: {
+          schema: {
+            type: 'string',
+          },
+          example: 'asc',
+          description: 'Sort order'
+        },
+        validation: {
+          required: true,
+          handler (value) {
+            return ['asc','desc'].includes(value);
+          },
+          error: {
+            statusCode: 400,
+            message: 'sortOrder should be asc or desc'
+          }
+        }
+      }
+    }
+  };
+
+```
+Now, if you send GET /user?sortBy=updateAt&sortOrder=desc&limit=10, the limit parameter will be ignored since it wasn't described:
+```typescript
+
+app.post('/user', context, (request: Request) => {
+
+  console.log(request.query);
+  
+  // {
+  //   sortBy: 'updatedAt',
+  //   sortOrder: 'desc'
+  // }
+  
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: []
+  }
+})
+
+
+```
+
+Regarding the request body even it described properly it will be available only for POST, PUT and PATCH HTTP requests.
+If You want dealing with uploaded files You just should to describe it in the request:
+
+```typescript
+const request: ContextRequest = {
+  files: {
+    avatar: {
+      mimetypes: [
+        'image/png'
+      ],
+      maxSize: 1048576,
+      required: true,
+      maxSizeError: {
+        statusCode: 413,
+        message: 'The avatar should not be larger than 1MB'
+      },
+      mimetypeError: {
+        statusCode: 415,
+        message: 'The avatar should be a PNG image'
+      },
+      requiredError: {
+        statusCode: 400,
+        message: 'The avatar file is required'
+      }
+    }
+  }
+};
+
+```
+and uploaded file will be acceptable in the request:
+
+```typescript
+import { createWriteStream } from 'fs';
+
+app.post('/user/:id/avatar', context, (request: Request) => {
+
+  console.log(request.files);
+  // {
+  //   avatar: { 
+  //     stream: PassThrough, 
+  //     size: 65025, 
+  //     mimetype: 'image/png' 
+  //   }
+  // }
+
+  // You can play with request.files.avatar.stream as You want e.g. save it locally
+
+  const writeStream = createWriteStream(`/path/to/user/avatars/${req.path.id}.png`);
+  request.files.avatar.stream.pipe(writeStream);
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: user
+  }
+})
+
+
+```
+
+3.2.4 Context response
+
+Context.response is always the same as the return type of the route handler
+
+```typescript
+
+interface Response<T>  {
+  title?: string;
+  description?: string;
+  statusCode: number;
+  headers?: Record<string, string>;
+  body?: T
+}
+
+```
+
+3.3 Route handler
+
+The route handler is the function that implements the following contract:
+
+```typescript
+
+(request: Request) => Response<T> | Promise<Response<T>>;
+
+```
+
+Despite having a strict contract for the return type, 
+the response body can be an object (for application/json content-type), text, or even a stream
+
+```typescript
+interface UserDto {
+  id: number;
+  name: string;
+}
+
+const handlerWithJSONBody = (request: Request): Response<UserDto> => {
+  const body: UserDto = {
+    id: 1,
+    name: 'John Doe'
+  }
+  return {
+    statusCode: 200,
+    headers: {'Content-Type': 'application/json' },
+    body
+  }
+}
+
+
+const handlerWithStringBody = (request: Request): Response<string> => {
+  const body: string = 'Not Found'
+  return {
+    statusCode: 404,
+    headers: {'Content-Type': 'text/plain' },
+    body
+  }
+}
+
+const handlerWithStreamBody = (request: Request): Response<ReadStream> => {
+  const body = createReadStream('/path/to/image.png')
+  return {
+    statusCode: 200,
+    headers: {'Content-Type': 'image/png' },
+    body
+  }
+}
+
+```
+
+4. Running
+
+
+```typescript
+
+app.start(() => console.log('Your awesome application has been successfully launched'));
+
+// And stop the application when needed
+app.stop(() => console.log('Your awesome application has been successfully launched'));
+
+```
+Don't forget to check swagger at the defined above options.openApiDoc.route 

package/accets/swagger-initializer.js

@@ -0,0 +1,20 @@
+window.onload = function() {
+  //<editor-fold desc="Changeable Configuration Block">
+
+  // the following lines will be replaced by docker/configurator, when it runs in a docker-container
+  window.ui = SwaggerUIBundle({
+    url: "/swagger.json",
+    dom_id: '#swagger-ui',
+    deepLinking: true,
+    presets: [
+      SwaggerUIBundle.presets.apis,
+      SwaggerUIStandalonePreset
+    ],
+    plugins: [
+      SwaggerUIBundle.plugins.DownloadUrl
+    ],
+    layout: "StandaloneLayout"
+  });
+
+  //</editor-fold>
+};

package/dist/alado-server/alado-server.d.ts

@@ -0,0 +1,18 @@
+import { AladoServerOptions } from '../options';
+import { Context, Response } from '../dto';
+export declare class AladoServer {
+    private readonly router;
+    private readonly server;
+    private readonly openApiDocObject;
+    private port;
+    private readonly logger?;
+    constructor(options: AladoServerOptions);
+    get(path: string, context: Context<any>, handler: (request: any) => Promise<Response<any>>): void;
+    post(path: string, context: Context<any>, handler: (request: any) => Promise<Response<any>>): void;
+    put(path: string, context: Context<any>, handler: (request: any) => Promise<Response<any>>): void;
+    patch(path: string, context: Context<any>, handler: (request: any) => Promise<Response<any>>): void;
+    delete(path: string, context: Context<any>, handler: (request: any) => Promise<Response<any>>): void;
+    head(path: string, context: Context<any>, handler: (request: any) => Promise<Response<any>>): void;
+    start(cb: () => void): void;
+    stop(cb: (error?: Error) => void): void;
+}

package/dist/alado-server/alado-server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AladoServer = void 0;
+const _const_1 = require("../constants");
+const _router_1 = require("../router");
+const _factory_1 = require("../factory");
+const _helper_1 = require("../helpers");
+class AladoServer {
+    router;
+    server;
+    openApiDocObject;
+    port;
+    logger;
+    constructor(options) {
+        (0, _helper_1.validateAladoOptions)(options);
+        if (options.openApiDoc?.route) {
+            options.openApiDoc.route = `${(0, _helper_1.clearRoute)(options.openApiDoc.route)}`;
+        }
+        this.logger = options.logger || console;
+        this.openApiDocObject = { ..._const_1.defaultOpenApiDocObject, info: options.openApiDoc?.info || {} };
+        this.router = new _router_1.Router({
+            cors: {
+                enable: options.cors?.enable,
+                allowedOrigin: options?.cors?.allowedOrigin || '*',
+                allowedHeaders: options?.cors?.allowedHeaders || [],
+                allowedMethods: new Map,
+                exposeHeaders: options?.cors?.exposeHeaders || [],
+            },
+            openApiDoc: options.openApiDoc,
+            logger: this.logger
+        }, this.openApiDocObject);
+        this.port = options.port;
+        this.server = (0, _factory_1.httpServerFactory)({
+            router: this.router,
+            openApiDoc: options.openApiDoc,
+            enableCors: options.cors?.enable,
+            logger: this.logger
+        }, options.ssl);
+    }
+    get(path, context, handler) {
+        this.router.use(_const_1.HttpMethod.GET, path, context, handler);
+    }
+    post(path, context, handler) {
+        this.router.use(_const_1.HttpMethod.POST, path, context, handler);
+    }
+    put(path, context, handler) {
+        this.router.use(_const_1.HttpMethod.PUT, path, context, handler);
+    }
+    patch(path, context, handler) {
+        this.router.use(_const_1.HttpMethod.PATCH, path, context, handler);
+    }
+    delete(path, context, handler) {
+        this.router.use(_const_1.HttpMethod.DELETE, path, context, handler);
+    }
+    head(path, context, handler) {
+        this.router.use(_const_1.HttpMethod.HEAD, path, context, handler);
+    }
+    start(cb) {
+        this.server.listen(this.port, cb);
+    }
+    stop(cb) {
+        this.server.close(cb);
+    }
+}
+exports.AladoServer = AladoServer;
+//# sourceMappingURL=alado-server.js.map

package/dist/alado-server/alado-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alado-server.js","sourceRoot":"","sources":["../../src/alado-server/alado-server.ts"],"names":[],"mappings":"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"}

package/dist/alado-server/index.d.ts

@@ -0,0 +1 @@
+export { AladoServer } from './alado-server';

package/dist/alado-server/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AladoServer = void 0;
+var alado_server_1 = require("./alado-server");
+Object.defineProperty(exports, "AladoServer", { enumerable: true, get: function () { return alado_server_1.AladoServer; } });
+//# sourceMappingURL=index.js.map

package/dist/alado-server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/alado-server/index.ts"],"names":[],"mappings":";;;AAAA,+CAA6C;AAApC,2GAAA,WAAW,OAAA"}

package/dist/constants/content-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum ContentType {
+    TEXT_PLAIN = "text/plain",
+    JSON = "application/json",
+    FORM_DATA = "multipart/form-data",
+    X_WWW_FORM_URLENCODED = "application/x-www-form-urlencoded"
+}

package/dist/constants/content-type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["TEXT_PLAIN"] = "text/plain";
+    ContentType["JSON"] = "application/json";
+    ContentType["FORM_DATA"] = "multipart/form-data";
+    ContentType["X_WWW_FORM_URLENCODED"] = "application/x-www-form-urlencoded";
+})(ContentType || (exports.ContentType = ContentType = {}));
+//# sourceMappingURL=content-type.js.map

package/dist/constants/content-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type.js","sourceRoot":"","sources":["../../src/constants/content-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,wCAAyB,CAAA;IACzB,wCAAyB,CAAA;IACzB,gDAAiC,CAAA;IACjC,0EAA2D,CAAA;AAC7D,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB"}

package/dist/constants/default-doc-object.d.ts

@@ -0,0 +1 @@
+export declare const defaultOpenApiDocObject: any;