axe-api 1.0.0-rc10 → 1.0.0-rc11

package/build/src/Builders/RouterBuilder.js

@@ -36,7 +36,7 @@ class RouterBuilder {
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
-            const app = yield Services_1.IoCService.useByType("App");
+            const app = yield Services_1.IoCService.use("App");
             const generalHooks = yield new Resolvers_1.GeneralHookResolver(this.version).resolve();
             if (generalHooks.onBeforeInit) {
                 generalHooks.onBeforeInit(app);

package/build/src/Handlers/Helpers.js

@@ -50,7 +50,7 @@ const callHooks = (model, type, params) => __awaiter(void 0, void 0, void 0, fun
         // we don't await for the events. If the developer uses the transaction and
         // try to commit something, it would be lost cause the transaction could be
         // already completed.
-        const database = (yield Services_1.IoCService.use("Database"));
+        const database = yield Services_1.IoCService.use("Database");
         params.database = database;
         // Calling the events
         model.events[type](params);

package/build/src/Handlers/RequestHandler.js

@@ -15,24 +15,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Services_1 = require("../Services");
 const URLService_1 = __importDefault(require("../Services/URLService"));
 const ConverterService_1 = require("../Services/ConverterService");
+const Enums_1 = require("../Enums");
 const api = Services_1.APIService.getInstance();
 const return404 = (response) => {
     response.statusCode = 404;
     response.write(JSON.stringify({ error: "Resource not found" }));
     response.end();
 };
-const callPhases = (phases, context, match, trx, axeResponse) => __awaiter(void 0, void 0, void 0, function* () {
-    for (const phase of phases) {
+exports.default = (request, response) => __awaiter(void 0, void 0, void 0, function* () {
+    Services_1.LogService.debug(`${request.method} ${request.url}`);
+    const { axeRequest, axeResponse } = (0, ConverterService_1.toAxeRequestResponsePair)(request, response);
+    const match = URLService_1.default.match(axeRequest);
+    if (!match) {
+        Services_1.LogService.warn(`The URL is not matched! ${request.method} ${request.url}`);
+        return return404(response);
+    }
+    // We should set the params
+    axeRequest.params = match.params;
+    const database = yield Services_1.IoCService.use("Database");
+    // Prepare the database by the transaction option
+    let trx = null;
+    if (match.hasTransaction) {
+        Services_1.LogService.warn("\tDB transaction created");
+        trx = yield database.transaction();
+    }
+    const context = Object.assign(Object.assign({}, match.data), { params: match.params, api, req: axeRequest, res: axeResponse, isTransactionOpen: match.hasTransaction, database: match.hasTransaction && trx ? trx : database });
+    response.setHeader("Content-Type", "application/json");
+    response.setHeader("x-powered-by", "Axe API");
+    for (const phase of match.phases) {
         // If there is an non-async phase, it should be an Event function
         if (phase.isAsync === false) {
-            Services_1.LogService.debug(`\t${phase.name}()`);
-            yield phase.callback(context);
+            phase.callback(context);
+            Services_1.LogService.debug(`\t${phase.name}()✓`);
             continue;
         }
         // Middleware and hook calls
         try {
-            Services_1.LogService.debug(`\t${phase.name}()`);
             yield phase.callback(context);
+            Services_1.LogService.debug(`\t✓ ${phase.name}()`);
         }
         catch (error) {
             Services_1.LogService.error(`\t${error.message} ${phase.callback}`);
@@ -48,7 +68,9 @@ const callPhases = (phases, context, match, trx, axeResponse) => __awaiter(void
                     .json({ error: apiError.message });
             }
             // TODO: We need an error handler.
-            axeResponse.status(500).json({ error: error.toString() });
+            axeResponse
+                .status(Enums_1.StatusCodes.INTERNAL_SERVER_ERROR)
+                .json({ error: error.toString() });
             break;
         }
         // If the response is not created, we should go to the next phase
@@ -65,35 +87,8 @@ const callPhases = (phases, context, match, trx, axeResponse) => __awaiter(void
             Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
             break;
         }
-        // If there is a valid transaction, we should commit it
-        if (match.hasTransaction && trx) {
-            Services_1.LogService.warn("\tDB transaction commit");
-            trx.commit();
-        }
         Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
         // We should brake the for-loop
         break;
     }
 });
-exports.default = (request, response) => __awaiter(void 0, void 0, void 0, function* () {
-    Services_1.LogService.debug(`${request.method} ${request.url}`);
-    const { axeRequest, axeResponse } = (0, ConverterService_1.toAxeRequestResponsePair)(request, response);
-    const match = URLService_1.default.match(axeRequest);
-    if (!match) {
-        Services_1.LogService.warn(`The URL is not matched! ${request.method} ${request.url}`);
-        return return404(response);
-    }
-    // We should set the params
-    axeRequest.params = match.params;
-    const database = (yield Services_1.IoCService.use("Database"));
-    // Prepare the database by the transaction option
-    let trx = null;
-    if (match.hasTransaction) {
-        Services_1.LogService.warn("\tDB transaction created");
-        trx = yield database.transaction();
-    }
-    const context = Object.assign(Object.assign({}, match.data), { params: match.params, api, req: axeRequest, res: axeResponse, database: match.hasTransaction && trx ? trx : database });
-    response.setHeader("Content-Type", "application/json");
-    response.setHeader("x-powered-by", "Axe API");
-    yield callPhases(match.phases, context, match, trx, axeResponse);
-});

package/build/src/Interfaces.d.ts

@@ -5,7 +5,7 @@ import { Options as FormOptions } from "formidable";
 import { Column } from "knex-schema-inspector/lib/types/column";
 import { HandlerTypes, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
 import Model from "./Model";
-import { AdaptorTypes, HandlerFunction, HookFunctions, MiddlewareFunction, StepTypes, PhaseFunction, SerializationFunction } from "./Types";
+import { AdaptorTypes, HandlerFunction, HookFunctions, MiddlewareFunction, PhaseFunction, SerializationFunction } from "./Types";
 import { ModelListService, QueryService } from "./Services";
 import AxeRequest from "./Services/AxeRequest";
 import AxeResponse from "./Services/AxeResponse";
@@ -18,7 +18,7 @@ export interface IColumn extends Column {
 export interface IConfig {
 }
 export interface IHandlerBasedTransactionConfig {
-    handler: HandlerTypes | HandlerTypes[];
+    handlers: HandlerTypes[];
     transaction: boolean;
 }
 interface IHandlerBasedSerializer {
@@ -72,7 +72,7 @@ export interface AxeConfig extends IConfig {
     env: string;
     port: number;
     prefix: string;
-    database: IDatabaseConfig;
+    database: Knex.Config;
     pino: LoggerOptions;
     rateLimit: IRateLimitConfig;
 }
@@ -86,7 +86,6 @@ export interface IAcceptedLanguage {
     language: ILanguage;
     quality: number;
 }
-export type IDatabaseConfig = Knex.Config;
 export interface IVersionFolder {
     root: string;
     config: string;
@@ -113,18 +112,14 @@ export interface IGeneralHooks {
     onBeforeInit: (app: App) => void | null;
     onAfterInit: (app: App) => void | null;
 }
-export interface IHandlerBaseMiddleware {
+export interface IHandlerBaseConfig<T> {
     handler: HandlerTypes[];
-    middleware: StepTypes;
+    middleware: T;
 }
-export interface IMethodBaseConfig {
-    [HttpMethods.POST]?: string[];
-    [HttpMethods.PUT]?: string[];
-    [HttpMethods.PATCH]?: string[];
-}
-export interface IMethodBaseValidations {
-    [HttpMethods.POST]?: Record<string, string>;
-    [HttpMethods.PUT]?: Record<string, string>;
+export interface IMethodBaseConfig<T> {
+    [HttpMethods.POST]?: T;
+    [HttpMethods.PUT]?: T;
+    [HttpMethods.PATCH]?: T;
 }
 export interface IModelService {
     name: string;
@@ -162,6 +157,7 @@ export interface IRequestPack extends IRouteData {
     req: AxeRequest;
     res: AxeResponse;
     database: Knex | Knex.Transaction;
+    isTransactionOpen: boolean;
     queryParser?: QueryService;
     conditions?: IQuery;
     query?: Knex.QueryBuilder;

package/build/src/Middlewares/RateLimit/index.d.ts

@@ -1,6 +1,23 @@
 import { IncomingMessage, ServerResponse } from "http";
 import { AxeConfig, IRateLimitOptions, IRequestPack } from "../../Interfaces";
 export declare const setupRateLimitAdaptors: (config: AxeConfig) => void;
+/**
+ * Add a rate limit with the `IRateLimitOptions`
+ *
+ * @param options
+ * @returns
+ * @example
+ *  class User extends Model {
+ *    get middlewares() {
+ *      return [
+ *        {
+ *          handler: [HandlerTypes.INSERT],
+ *          middleware: rateLimit({ maxRequests: 200, windowInSeconds: 5 }),
+ *        },
+ *      ];
+ *    }
+ *  }
+ */
 export declare const rateLimit: (options?: IRateLimitOptions) => (context: IRequestPack) => Promise<void>;
 declare const _default: (req: IncomingMessage, res: ServerResponse, next: any) => Promise<any>;
 export default _default;

package/build/src/Middlewares/RateLimit/index.js

@@ -16,6 +16,7 @@ exports.rateLimit = exports.setupRateLimitAdaptors = void 0;
 const AdaptorFactory_1 = __importDefault(require("./AdaptorFactory"));
 const Services_1 = require("../../Services");
 const nanoid_1 = require("nanoid");
+const Enums_1 = require("../../Enums");
 let adaptor;
 const checkRateLimit = function (clientKey, options) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -69,6 +70,23 @@ const setupRateLimitAdaptors = (config) => {
     adaptor = (0, AdaptorFactory_1.default)(((_a = config.rateLimit) === null || _a === void 0 ? void 0 : _a.adaptor.type) || "memory", (_b = config.rateLimit) === null || _b === void 0 ? void 0 : _b.adaptor.redis, "");
 };
 exports.setupRateLimitAdaptors = setupRateLimitAdaptors;
+/**
+ * Add a rate limit with the `IRateLimitOptions`
+ *
+ * @param options
+ * @returns
+ * @example
+ *  class User extends Model {
+ *    get middlewares() {
+ *      return [
+ *        {
+ *          handler: [HandlerTypes.INSERT],
+ *          middleware: rateLimit({ maxRequests: 200, windowInSeconds: 5 }),
+ *        },
+ *      ];
+ *    }
+ *  }
+ */
 const rateLimit = (options) => {
     // For each model middleware, we should use a different ID for the cache key
     const id = (0, nanoid_1.nanoid)();
@@ -88,7 +106,9 @@ const rateLimit = (options) => {
         // Sending an error message if there is an error
         if (isAllowed.success === false) {
             Services_1.LogService.warn(`Rate limit exceeded: ${context.req.url}`);
-            context.res.status(429).json({ error: "Rate limit exceeded." });
+            context.res
+                .status(Enums_1.StatusCodes.TOO_MANY_REQUESTS)
+                .json({ error: "Rate limit exceeded." });
         }
     });
 };

package/build/src/Model.d.ts

@@ -1,26 +1,228 @@
-import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBasedTransactionConfig, IQueryLimitConfig } from "./Interfaces";
+import { IRelation, IMethodBaseConfig, IQueryLimitConfig, IHandlerBasedTransactionConfig } from "./Interfaces";
 import { HandlerTypes, HttpMethods } from "./Enums";
 import { FieldList, ModelMiddlewareDefinition, StepTypes, ModelValidation } from "./Types";
 declare class Model {
+    /**
+     * The primary key of the model. By default, it is `id`. But you can choose
+     * another name like `uuid`.
+     *
+     * @example
+     *  get primaryKey() {
+     *    return "id"
+     *  }
+     * @type {string}
+     * @tutorial https://axe-api.com/reference/model-primary-key.html
+     */
     get primaryKey(): string;
+    /**
+     * The database table name of the model. By default, Axe API uses the plural
+     * version of the model(`User.ts` => `users`) name. You can specify a custom
+     * name like `my_users`.
+     *
+     * @example
+     *  get table() {
+     *    return "my_users_table"
+     *  }
+     * @type {string}
+     * @tutorial https://axe-api.com/reference/model-table.html
+     */
     get table(): string;
-    get fillable(): FieldList | IMethodBaseConfig;
-    get validations(): IMethodBaseValidations | ModelValidation;
+    /**
+     * By this method, you can define which fields can be filled by the HTTP client.
+     * If you do not define, the HTTP client can not fill any field.
+     *
+     * @example
+     *  get fillable() {
+     *    return ["name", "email", "password"]
+     *  }
+     * @type {(FieldList | IMethodBaseConfig)}
+     * @tutorial https://axe-api.com/reference/model-fillable.html
+     */
+    get fillable(): FieldList | IMethodBaseConfig<FieldList>;
+    /**
+     * You can define the validation rules of the model. Method-based validations
+     * are also acceptable.
+     *
+     * @example
+     *  get validations() {
+     *    return {
+     *      "name": "required|min:1|max:100",
+     *      "email": "required|email",
+     *    }
+     *  }
+     * @type {(ModelValidation | IMethodBaseConfig<ModelValidation>)}
+     * @tutorial https://axe-api.com/reference/model-validations.html
+     */
+    get validations(): ModelValidation | IMethodBaseConfig<ModelValidation>;
+    /**
+     * You can define acceptable handlers here.
+     *
+     * The default value is `DEFAULT_HANDLERS`
+     *
+     * @example
+     *  get handlers() {
+     *    return [HandlerTypes.PAGINATE]
+     *  }
+     * @type {HandlerTypes[]}
+     * @tutorial https://axe-api.com/reference/model-handlers.html
+     */
     get handlers(): HandlerTypes[];
+    /**
+     * You can define a special handler for the model here. `MiddlewareFunction`,
+     * `HandlerFunction`, and `PhaseFunction` are acceptable middlewares.
+     *
+     * Also, you can define handler-based middlewares.
+     *
+     * @example
+     *  get middlewares() {
+     *    return [
+     *      {
+     *        handler: [HandlerTypes.DELETE],
+     *        middleware: isAdminMiddleware,
+     *      }
+     *    ]
+     *  }
+     * @type {ModelMiddlewareDefinition}
+     * @tutorial https://axe-api.com/reference/model-middlewares.html
+     */
     get middlewares(): ModelMiddlewareDefinition;
+    /**
+     * You can define which fields will be hiding in HTTP responses. The selected
+     * fields will not be listed in any response.
+     *
+     * You should mark as hidden sensitive data fields such as `password`, `token`, etc.
+     *
+     * @example
+     *  get hiddens() {
+     *    return ["password_salt", "password_hash", "github_token"]
+     *  }
+     * @type {FieldList}
+     * @tutorial https://axe-api.com/reference/model-hiddens.html
+     */
     get hiddens(): FieldList;
+    /**
+     * The `created_at` column name is in the database table. The default value is
+     * `created_at`. You can specify with a custom field name.
+     *
+     * It should be null if the table doesn't have a `created_at` column.
+     *
+     * @example
+     *  get createdAtColumn() {
+     *    return "created_at"
+     *  }
+     * @type {(string | null)}
+     * @tutorial https://axe-api.com/reference/model-created-at-column.html
+     */
     get createdAtColumn(): string | null;
+    /**
+     * The `updated_at` column name is in the database table. The default value is
+     * `updated_at`. You can specify with a custom field name.
+     *
+     * It should be null if the table doesn't have a `updated_at` column.
+     *
+     * @example
+     *  get updatedAtColumn() {
+     *    return "updated_at"
+     *  }
+     * @type {(string | null)}
+     * @tutorial https://axe-api.com/reference/model-updated-at-column.html
+     */
     get updatedAtColumn(): string | null;
+    /**
+     * The `deleted_at` column name is in the database table. The default value is
+     * `null`. You can specify with a custom field name.
+     *
+     * If you provide a name, that means your model supports the soft delete feature.
+     *
+     * @example
+     *  get deletedAtColumn() {
+     *    return "deleted_at"
+     *  }
+     * @type {(string | null)}
+     * @tutorial https://axe-api.com/reference/model-deleted-at-column.html
+     */
     get deletedAtColumn(): string | null;
-    get transaction(): boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[] | null;
+    /**
+     * The transaction configuration on the model. The database transaction can
+     * be started for all endpoints on the model as well as handler-based.
+     *
+     * Creating, rollbacking, and committing a transaction is managed by Axe API.
+     *
+     * @example
+     *  get transaction() {
+     *    return [
+     *      {
+     *        handlers: [HandlerTypes.INSERT],
+     *        transaction: true
+     *      }
+     *    ]
+     *  }
+     * @type {(boolean | IHandlerBasedTransactionConfig[])}
+     * @tutorial https://axe-api.com/learn/database-transactions.html#model-based-transactions
+     */
+    get transaction(): boolean | IHandlerBasedTransactionConfig[];
+    /**
+     * You can completely ignore the model. Axe API doesn't create the routes
+     * automatically.
+     *
+     * @example
+     *  get ignore() {
+     *    return true
+     *  }
+     * @type {boolean}
+     * @tutorial https://axe-api.com/reference/model-ignore.html
+     */
     get ignore(): boolean;
+    /**
+     * You can limit query features such as `select.*` or `LIKE`, etc.
+     *
+     * @example
+     *  get limits() {
+     *    return [
+     *      allow(QueryFeature.WhereLike),
+     *      deny(QueryFeature.FieldsAll)
+     *    ];
+     * }
+     * @type {Array<IQueryLimitConfig[]>}
+     * @tutorial https://axe-api.com/reference/model-limits.html
+     */
     get limits(): Array<IQueryLimitConfig[]>;
-    getFillableFields(methodType: HttpMethods): string[];
-    getValidationRules(methodType: HttpMethods): ModelValidation | null;
-    getMiddlewares(handlerType: HandlerTypes): StepTypes[];
+    /**
+     * Model relationship definition. Axe API creates `hasMany` routes automatically.
+     *
+     * @example
+     *  get relationName() {
+     *    return this.hasMany("Post", "id", "user_id")
+     * }
+     * @type {Array<IQueryLimitConfig[]>}
+     * @tutorial https://axe-api.com/learn/routing.html#model-relations
+     */
     hasMany(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
+    /**
+     * Model relationship definition.
+     *
+     * @example
+     *  get relationName() {
+     *    return this.hasOne("User", "id", "user_id")
+     * }
+     * @type {Array<IQueryLimitConfig[]>}
+     * @tutorial https://axe-api.com/learn/routing.html#model-relations
+     */
     hasOne(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
+    /**
+     * Model relationship definition.
+     *
+     * @example
+     *  get relationName() {
+     *    return this.belongsTo("User", "user_id", "id")
+     * }
+     * @type {Array<IQueryLimitConfig[]>}
+     * @tutorial https://axe-api.com/learn/routing.html#model-relations
+     */
     belongsTo(relatedModel: string, primaryKey: string, foreignKey: string): IRelation;
+    getFillableFields(methodType: HttpMethods): string[];
+    getValidationRules(methodType: HttpMethods): ModelValidation | null;
+    getMiddlewares(handlerType: HandlerTypes): StepTypes[];
     private hasStringValue;
 }
 export default Model;