axe-api 1.0.0-rc9 → 1.0.0

package/build/src/Interfaces.d.ts

@@ -3,24 +3,31 @@
 import { Knex } from "knex";
 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 { HandlerTypes, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType, CacheStrategies } from "./Enums";
 import Model from "./Model";
-import { AdaptorTypes, HandlerFunction, HookFunctions, MiddlewareFunction, StepTypes, PhaseFunction, SerializationFunction } from "./Types";
+import { AdaptorType, AxeFunction, GeneralFunction, HandlerFunction, ModelHooks, PhaseFunction, SerializationFunction } from "./Types";
 import { ModelListService, QueryService } from "./Services";
 import AxeRequest from "./Services/AxeRequest";
 import AxeResponse from "./Services/AxeResponse";
 import App from "./Services/App";
 import { LoggerOptions } from "pino";
 import { IncomingMessage } from "http";
+import { ErrorHandleFunction } from "connect";
+import { RedisClientOptions } from "redis";
+import { ClientOptions } from "@elastic/elasticsearch";
 export interface IColumn extends Column {
     table_name: string;
 }
 export interface IConfig {
 }
 export interface IHandlerBasedTransactionConfig {
-    handler: HandlerTypes | HandlerTypes[];
+    handlers: HandlerTypes[];
     transaction: boolean;
 }
+export interface IHandlerBasedCacheConfig {
+    handlers: HandlerTypes[];
+    cache: ICacheConfiguration;
+}
 interface IHandlerBasedSerializer {
     handler: HandlerTypes[];
     serializer: ((data: any, request: AxeRequest) => void)[];
@@ -39,42 +46,53 @@ export interface IQueryConfig {
     limits: Array<IQueryLimitConfig[]>;
     defaults?: IQueryDefaultConfig;
 }
-export interface IRedisOptions {
-    host?: string;
-    port?: number;
-    password?: string;
-    db?: number;
-}
-export interface IRateLimitAdaptorConfig {
-    type: AdaptorTypes;
-    redis?: IRedisOptions;
-}
 export interface IRateLimitOptions {
     maxRequests: number;
     windowInSeconds: number;
 }
 export interface IRateLimitConfig extends IRateLimitOptions {
     enabled: boolean;
-    adaptor: IRateLimitAdaptorConfig;
+    adaptor: AdaptorType;
     trustProxyIP: boolean;
     keyGenerator?: (req: IncomingMessage) => string;
 }
-export interface IVersionConfig {
+export interface AxeVersionConfig {
     transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
     serializers: ((data: any, request: AxeRequest) => void)[] | IHandlerBasedSerializer[];
     supportedLanguages: string[];
     defaultLanguage: string;
     query: IQueryConfig;
     formidable: FormOptions;
-}
-export interface IApplicationConfig extends IConfig {
+    cache: ICacheConfiguration | null;
+}
+export type IVersionConfig = Partial<AxeVersionConfig>;
+export interface ICacheConfiguration {
+    enable?: boolean;
+    ttl?: number;
+    invalidation?: CacheStrategies;
+    cachePrefix?: string;
+    tagPrefix?: string;
+    responseHeader?: string | null;
+    cacheKey?: (req: AxeRequest) => string;
+}
+export interface ISearchConfigutation {
+    indexPrefix: string;
+}
+export interface AxeConfig extends IConfig {
     env: string;
     port: number;
     prefix: string;
-    database: IDatabaseConfig;
+    database: Knex.Config;
     pino: LoggerOptions;
     rateLimit: IRateLimitConfig;
-}
+    errorHandler: ErrorHandleFunction;
+    docs: boolean;
+    redis: RedisClientOptions | undefined;
+    cache: ICacheConfiguration;
+    elasticSearch: ClientOptions;
+    search: ISearchConfigutation;
+}
+export type IApplicationConfig = Partial<AxeConfig>;
 export interface ILanguage {
     title: string;
     language: string;
@@ -84,7 +102,6 @@ export interface IAcceptedLanguage {
     language: ILanguage;
     quality: number;
 }
-export type IDatabaseConfig = Knex.Config;
 export interface IVersionFolder {
     root: string;
     config: string;
@@ -96,7 +113,7 @@ export interface IVersionFolder {
 }
 export interface IVersion {
     name: string;
-    config: IVersionConfig;
+    config: AxeVersionConfig;
     folders: IVersionFolder;
     modelList: ModelListService;
     modelTree: IModelService[];
@@ -105,7 +122,7 @@ export interface IAPI {
     rootFolder: string;
     appFolder: string;
     versions: IVersion[];
-    config: IApplicationConfig;
+    config: AxeConfig;
 }
 export interface IGeneralHooks {
     onBeforeInit: (app: App) => void | null;
@@ -113,16 +130,12 @@ export interface IGeneralHooks {
 }
 export interface IHandlerBaseMiddleware {
     handler: HandlerTypes[];
-    middleware: StepTypes;
-}
-export interface IMethodBaseConfig {
-    [HttpMethods.POST]?: string[];
-    [HttpMethods.PUT]?: string[];
-    [HttpMethods.PATCH]?: string[];
+    middleware: AxeFunction;
 }
-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;
@@ -130,8 +143,8 @@ export interface IModelService {
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: HookFunctions;
-    events: HookFunctions;
+    hooks: ModelHooks;
+    events: ModelHooks;
     isRecursive: boolean;
     children: IModelService[];
     queryLimits: IQueryLimitConfig[];
@@ -140,6 +153,9 @@ export interface IModelService {
     setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: PhaseFunction): void;
     setQueryLimits(limits: IQueryLimitConfig[]): void;
     setSerialization(callback: SerializationFunction): void;
+    setCacheConfiguration(handler: string, cache: ICacheConfiguration): void;
+    getCacheConfiguration(handler: HandlerTypes): ICacheConfiguration | null;
+    setAsRecursive(): void;
 }
 export interface IRelation {
     type: Relationships;
@@ -155,11 +171,12 @@ export interface IRouteData {
     parentModel: IModelService | null;
     relation: IRelation | null;
 }
-export interface IRequestPack extends IRouteData {
+export interface IContext extends IRouteData {
     api: IAPI;
     req: AxeRequest;
     res: AxeResponse;
     database: Knex | Knex.Transaction;
+    isTransactionOpen: boolean;
     queryParser?: QueryService;
     conditions?: IQuery;
     query?: Knex.QueryBuilder;
@@ -171,6 +188,8 @@ export interface IRequestPack extends IRouteData {
 export interface IRouteDocumentation {
     version: string;
     handler: string;
+    modelService: IModelService;
+    parentModel: IModelService | null;
     model: string;
     table: string;
     columns: IColumn[];
@@ -183,6 +202,10 @@ export interface IRouteDocumentation {
     queryLimits: IQueryLimitConfig[];
     queryDefaults: IQueryDefaultConfig;
 }
+export interface ICustomRouteDocumentation {
+    method: HttpMethods;
+    url: string;
+}
 export interface IRawQuery {
     q: string | null;
     page: string | null;
@@ -210,6 +233,7 @@ export interface IQuery {
     fields: string[];
     with: IWith[];
     trashed: boolean;
+    text: string | null;
 }
 export interface IWhere {
     prefix: string | null;
@@ -236,7 +260,51 @@ export interface AxeRequestResponsePair {
     axeResponse: AxeResponse;
 }
 export interface MiddlewareResolution {
-    middlewares: (MiddlewareFunction | HandlerFunction)[];
+    middlewares: GeneralFunction[];
     handler: HandlerFunction;
 }
+export interface IStepDefinition {
+    name: string;
+    get(model: IModelService): PhaseFunction;
+    isAsync(): boolean;
+}
+export interface ICacheAdaptor {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string, ttl: number): Promise<void>;
+}
+export interface IRateLimitResponse {
+    success: boolean;
+    limit: number;
+    remaining: number;
+}
+export interface IURLPair {
+    method: string;
+    pattern: string;
+    data: IRouteData;
+    phases: IPhaseDefinition[];
+    hasTransaction: boolean;
+    params?: any;
+    parentPairs: IRouteParentPair[];
+    customHandler?: HandlerFunction;
+}
+export interface BulkTask<DataType, ReturnType> {
+    data: DataType;
+    promise: Promise<ReturnType>;
+}
+export interface IForeignKeyTask {
+    relation: IRelation;
+    value: any;
+}
+export interface IRouteParentPair {
+    model: IModelService;
+    paramName: string;
+}
+export interface IElasticSearchParameters {
+    req: AxeRequest;
+    model: IModelService;
+    relation: IRelation | null;
+    parentModel: IModelService | null;
+    text: string;
+}
 export {};

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

@@ -1,6 +1,6 @@
-import { AdaptorTypes } from "../../Types";
+import { AdaptorType } from "../../Types";
 import RedisAdaptor from "./RedisAdaptor";
 import MemoryAdaptor from "./MemoryAdaptor";
-import { IRedisOptions } from "src/Interfaces";
-declare const _default: (adaptor: AdaptorTypes, redisOptions: IRedisOptions | undefined, prefix: string) => RedisAdaptor | MemoryAdaptor;
+import { RedisClientOptions } from "redis";
+declare const _default: (adaptor: AdaptorType, redisOptions: RedisClientOptions | undefined, prefix: string) => RedisAdaptor | MemoryAdaptor;
 export default _default;

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

@@ -1,5 +1,5 @@
-import IAdaptor from "./IAdaptor";
-declare class MemoryAdaptor implements IAdaptor {
+import { ICacheAdaptor } from "src/Interfaces";
+declare class MemoryAdaptor implements ICacheAdaptor {
     private client;
     private prefix;
     constructor(prefix: string);

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

@@ -1,11 +1,19 @@
-import IAdaptor from "./IAdaptor";
-import { IRedisOptions } from "../../Interfaces";
-declare class RedisAdaptor implements IAdaptor {
+import { createClient } from "redis";
+import { ICacheAdaptor } from "../../Interfaces";
+type RedisClientOptions = Parameters<typeof createClient>[0];
+declare class RedisAdaptor implements ICacheAdaptor {
     private client;
     private prefix;
-    constructor(options: IRedisOptions | undefined, prefix: string);
+    constructor(options: RedisClientOptions | undefined, prefix: string);
     get(key: string): Promise<string | null>;
     set(key: string, value: string, ttl: number): Promise<void>;
+    tags(keys: string[], value: string): Promise<void>;
+    getTagMemebers(tag: string): Promise<string[]>;
+    delete(keys: string[]): Promise<number>;
     decr(key: string): Promise<void>;
+    searchTags(pattern: string): Promise<{
+        cursor: number;
+        keys: string[];
+    }>;
 }
 export default RedisAdaptor;

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

@@ -26,10 +26,34 @@ class RedisAdaptor {
             yield this.client.setEx(`${this.prefix}${key}`, ttl, value);
         });
     }
+    tags(keys, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            keys.forEach((key) => {
+                this.client.sAdd(key, [value]);
+            });
+        });
+    }
+    getTagMemebers(tag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.sMembers(tag);
+        });
+    }
+    delete(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.del(keys);
+        });
+    }
     decr(key) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.client.decr(`${this.prefix}${key}`);
         });
     }
+    searchTags(pattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.scan(0, {
+                MATCH: pattern,
+            });
+        });
+    }
 }
 exports.default = RedisAdaptor;

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

@@ -1,6 +1,25 @@
+/// <reference types="node" />
+/// <reference types="express" />
 import { IncomingMessage, ServerResponse } from "http";
-import { IApplicationConfig, IRateLimitOptions, IRequestPack } from "../../Interfaces";
-export declare const setupRateLimitAdaptors: (config: IApplicationConfig) => void;
-export declare const rateLimit: (options?: IRateLimitOptions) => (context: IRequestPack) => Promise<void>;
+import { AxeConfig, IRateLimitOptions, IContext } 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: IContext) => 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* () {
@@ -64,11 +65,28 @@ const getClientKeyByConfigurations = (req, config) => {
     return `axe-api-rate-limit:${req.socket.remoteAddress || ""}`;
 };
 const setupRateLimitAdaptors = (config) => {
-    var _a, _b;
+    var _a;
     // Creating the correct adaptor by the configuration
-    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, "");
+    adaptor = (0, AdaptorFactory_1.default)(((_a = config.rateLimit) === null || _a === void 0 ? void 0 : _a.adaptor) || "memory", config.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." });
         }
     });
 };