axe-api 1.0.0-rc9 → 1.0.1

package/build/src/Handlers/ErrorHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (err, req, res, next) => {
+    // Sett the HTTP status code
+    res.statusCode = 500;
+    // Set the default HTTP message
+    res.write(JSON.stringify({
+        error: "Internal server error",
+    }));
+    res.end();
+    next();
+};

package/build/src/Handlers/Helpers.d.ts

@@ -1,17 +1,29 @@
-import { IModelService, IRelation, IQuery, IVersion, IWith, IRequestPack } from "../Interfaces";
+import { IModelService, IRelation, IQuery, IVersion, IWith, IContext, ICacheConfiguration } from "../Interfaces";
 import { Knex } from "knex";
 import { HandlerTypes, HookFunctionTypes, TimestampColumns } from "../Enums";
 import { ModelListService } from "../Services";
 import { SerializationFunction } from "../Types";
-import AxeRequest from "src/Services/AxeRequest";
+import AxeRequest from "../Services/AxeRequest";
 export declare const bindTimestampValues: (formData: Record<string, any>, model: IModelService, columnTypes?: TimestampColumns[]) => void;
 export declare const getMergedFormData: (req: AxeRequest, fillables: string[]) => Record<string, any>;
-export declare const callHooks: (model: IModelService, type: HookFunctionTypes, params: IRequestPack) => Promise<void>;
-export declare const getParentColumn: (relation: IRelation | null) => string | null;
+export declare const callHooks: (model: IModelService, type: HookFunctionTypes, params: IContext) => Promise<void>;
+export declare const getParentColumn: (model: IModelService, relation: IRelation | null) => string | null;
 export declare const checkPrimaryKeyValueType: (model: IModelService, value: any) => void;
 export declare const addForeignKeyQuery: (request: AxeRequest, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
+export declare const getParentIndexQuery: (request: AxeRequest, relation: IRelation | null, parentModel: IModelService | null) => any;
 export declare const serializeData: (version: IVersion, itemArray: any, modelSerializer: SerializationFunction | null, handler: HandlerTypes, request: AxeRequest) => Promise<any[]>;
 export declare const filterHiddenFields: (itemArray: any[], hiddens: string[] | null) => void;
 export declare const addSoftDeleteQuery: (model: IModelService, conditions: IQuery | null, query: Knex.QueryBuilder) => void;
 export declare const getRelatedData: (version: IVersion, data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: AxeRequest) => Promise<void>;
 export declare const isBoolean: (value: any) => boolean;
+export declare const getModelCacheConfiguration: (model: IModelService, apiConfig: ICacheConfiguration, versionConfig: ICacheConfiguration | null, handler: string) => ICacheConfiguration;
+export declare const defaultCacheKeyFunction: (req: AxeRequest) => string;
+export declare const toCacheTagKey: (model: IModelService, primaryKeyValue: string, config?: ICacheConfiguration | null) => string;
+export declare const toCacheKey: (context: IContext) => string;
+export declare const putCache: (context: IContext, data: any) => Promise<void>;
+export declare const deleteCacheTagMembers: (key: string) => Promise<void>;
+export declare const cleanRelatedCachedObjectByModel: (model: IModelService, config?: ICacheConfiguration | null) => Promise<void>;
+export declare const clearCacheTags: (tag: string) => Promise<void>;
+export declare const toCachePrefix: (value: string | undefined | null) => string;
+export declare const getForeignKeyValueErrors: (context: IContext) => Promise<(string | null)[]>;
+export declare const getSearchData: (model: IModelService, item: any) => Record<string, any>;

package/build/src/Handlers/Helpers.js

@@ -12,7 +12,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBoolean = exports.getRelatedData = exports.addSoftDeleteQuery = exports.filterHiddenFields = exports.serializeData = exports.addForeignKeyQuery = exports.checkPrimaryKeyValueType = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
+exports.getSearchData = exports.getForeignKeyValueErrors = exports.toCachePrefix = exports.clearCacheTags = exports.cleanRelatedCachedObjectByModel = exports.deleteCacheTagMembers = exports.putCache = exports.toCacheKey = exports.toCacheTagKey = exports.defaultCacheKeyFunction = exports.getModelCacheConfiguration = exports.isBoolean = exports.getRelatedData = exports.addSoftDeleteQuery = exports.filterHiddenFields = exports.serializeData = exports.getParentIndexQuery = exports.addForeignKeyQuery = exports.checkPrimaryKeyValueType = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
+const crypto_1 = __importDefault(require("crypto"));
 const change_case_1 = require("change-case");
 const Enums_1 = require("../Enums");
 const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
@@ -50,18 +51,18 @@ 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);
     }
 });
 exports.callHooks = callHooks;
-const getParentColumn = (relation) => {
+const getParentColumn = (model, relation) => {
     if (!relation) {
         return null;
     }
-    return (0, change_case_1.camelCase)(relation.foreignKey);
+    return (0, change_case_1.camelCase)(`${model.name}-${relation.primaryKey}`);
 };
 exports.getParentColumn = getParentColumn;
 const checkPrimaryKeyValueType = (model, value) => {
@@ -75,13 +76,24 @@ const checkPrimaryKeyValueType = (model, value) => {
 exports.checkPrimaryKeyValueType = checkPrimaryKeyValueType;
 const addForeignKeyQuery = (request, query, relation, parentModel) => {
     if (relation && parentModel) {
-        const parentColumn = (0, exports.getParentColumn)(relation);
+        const parentColumn = (0, exports.getParentColumn)(parentModel, relation);
         if (parentColumn) {
             query.where(relation.foreignKey, request.params[parentColumn]);
         }
     }
 };
 exports.addForeignKeyQuery = addForeignKeyQuery;
+const getParentIndexQuery = (request, relation, parentModel) => {
+    const result = {};
+    if (relation && parentModel) {
+        const parentColumn = (0, exports.getParentColumn)(parentModel, relation);
+        if (parentColumn) {
+            result[relation.foreignKey] = request.params[parentColumn];
+        }
+    }
+    return result;
+};
+exports.getParentIndexQuery = getParentIndexQuery;
 const getPrimaryOrForeignKeyByRelation = (relation, dataField) => {
     if (dataField === "primaryKey") {
         return relation.primaryKey;
@@ -221,6 +233,10 @@ const getRelatedData = (version, data, withArray, model, modelList, database, ha
         }
         // Fetching related records by foreignKey and primary key values.
         let relatedRecords = yield foreignModelQuery.whereIn(searchFieldKey, parentPrimaryKeyValues);
+        // Adding related data source to the request tags to set cache tag values
+        const { primaryKey } = foreignModel.instance;
+        const cacheConfig = foreignModel.getCacheConfiguration(handler);
+        request.original.tags.push(...relatedRecords.map((i) => (0, exports.toCacheTagKey)(foreignModel, i[primaryKey], cacheConfig)));
         // We should serialize related data if there is any serialization function
         relatedRecords = yield (0, exports.serializeData)(version, relatedRecords, foreignModel.serialize, handler, request);
         // We should hide hidden fields if there is any
@@ -251,3 +267,184 @@ const isBoolean = (value) => {
     return false;
 };
 exports.isBoolean = isBoolean;
+const getModelCacheConfiguration = (model, apiConfig, versionConfig, handler) => {
+    let base = Object.assign(Object.assign({}, constants_1.DEFAULT_CACHE_CONFIGURATION), apiConfig);
+    if (model.instance.cache) {
+        const data = model.instance.cache;
+        if (Array.isArray(data)) {
+            const handlerBasedConfigs = data;
+            for (const item of handlerBasedConfigs) {
+                const isFound = item.handlers.map((i) => i).includes(handler);
+                if (isFound) {
+                    base = Object.assign(Object.assign({}, base), item.cache);
+                    return base;
+                }
+            }
+        }
+        else {
+            base = Object.assign(Object.assign({}, base), data);
+            return base;
+        }
+    }
+    if (versionConfig) {
+        base = Object.assign(Object.assign({}, base), versionConfig);
+    }
+    return base;
+};
+exports.getModelCacheConfiguration = getModelCacheConfiguration;
+const defaultCacheKeyFunction = (req) => {
+    return JSON.stringify({
+        url: req.url,
+        method: req.method,
+        headers: {
+            Accept: req.header("Accept"),
+            "Accept-Encoding": req.header("Accept-Encoding"),
+            "Accept-Language": req.header("Accept-Language"),
+            Authorization: req.header("Authorization"),
+            Host: req.header("Host"),
+            Origin: req.header("Origin"),
+            Referer: req.header("Referer"),
+            "User-Agent": req.header("User-Agent"),
+        },
+    });
+};
+exports.defaultCacheKeyFunction = defaultCacheKeyFunction;
+const toCacheTagKey = (model, primaryKeyValue, config) => {
+    const prefix = (0, exports.toCachePrefix)(config === null || config === void 0 ? void 0 : config.cachePrefix);
+    const tagPrefix = (config === null || config === void 0 ? void 0 : config.tagPrefix) ? config === null || config === void 0 ? void 0 : config.tagPrefix : "";
+    const modelName = model.name.toLowerCase();
+    return `${prefix}:${tagPrefix}:${modelName}:${primaryKeyValue}`;
+};
+exports.toCacheTagKey = toCacheTagKey;
+const toCacheKey = (context) => {
+    const { model, handlerType } = context;
+    const config = model.getCacheConfiguration(handlerType);
+    const keyData = (config === null || config === void 0 ? void 0 : config.cacheKey)
+        ? config.cacheKey(context.req)
+        : (0, exports.defaultCacheKeyFunction)(context.req);
+    const key = crypto_1.default.createHash("sha256").update(keyData).digest("hex");
+    const prefix = (0, exports.toCachePrefix)(config === null || config === void 0 ? void 0 : config.cachePrefix);
+    const modelName = model.name.toLowerCase();
+    return `${prefix}:${modelName}:${key}`;
+};
+exports.toCacheKey = toCacheKey;
+const putCache = (context, data) => __awaiter(void 0, void 0, void 0, function* () {
+    // Getting the correct configuration
+    const { model, handlerType } = context;
+    const config = model.getCacheConfiguration(handlerType);
+    // Check if the cache enable for this handler
+    if (!(config === null || config === void 0 ? void 0 : config.enable)) {
+        return;
+    }
+    // Getting the redis service
+    const redis = yield Services_1.IoCService.use("Redis");
+    // Generating the cache key
+    const key = (0, exports.toCacheKey)(context);
+    // Setting the tags if the cache configuration of the model has been set as
+    // tag-based cache invalidation strategy. Which means, the key cached value
+    // can be deleted if the tagged items updated/delete
+    if (config.invalidation === Enums_1.CacheStrategies.TagBased) {
+        redis.tags(context.req.original.tags, key);
+    }
+    // Putting the cache data
+    redis.set(key, JSON.stringify(data), config.ttl || 1000);
+    if (config.responseHeader) {
+        context.res.header(config.responseHeader, "Missed");
+    }
+    // Logging
+    Services_1.LogService.debug(`\t🔄 redis.cache(${key},${config.ttl})`);
+});
+exports.putCache = putCache;
+const deleteCacheTagMembers = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const redis = yield Services_1.IoCService.use("Redis");
+    const members = yield redis.getTagMemebers(key);
+    yield redis.delete(members);
+});
+exports.deleteCacheTagMembers = deleteCacheTagMembers;
+const cleanRelatedCachedObjectByModel = (model, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const redis = yield Services_1.IoCService.use("Redis");
+    const prefix = (0, exports.toCachePrefix)(config === null || config === void 0 ? void 0 : config.cachePrefix);
+    const tagPrefix = (config === null || config === void 0 ? void 0 : config.tagPrefix) ? config === null || config === void 0 ? void 0 : config.tagPrefix : "";
+    const modelName = model.name.toLowerCase();
+    const searchKey = `${prefix}:${tagPrefix}:${modelName}:*`;
+    // Logging
+    Services_1.LogService.debug(`\t🔄 redis.cleaByTag(${searchKey})`);
+    const { keys } = yield redis.searchTags(searchKey);
+    const tasks = keys.map((key) => (0, exports.deleteCacheTagMembers)(key));
+    Promise.all(tasks);
+});
+exports.cleanRelatedCachedObjectByModel = cleanRelatedCachedObjectByModel;
+const clearCacheTags = (tag) => __awaiter(void 0, void 0, void 0, function* () {
+    const redis = yield Services_1.IoCService.use("Redis");
+    const members = yield redis.getTagMemebers(tag);
+    if (members.length > 0) {
+        yield redis.delete(members);
+    }
+});
+exports.clearCacheTags = clearCacheTags;
+const toCachePrefix = (value) => {
+    return value ? value : "";
+};
+exports.toCachePrefix = toCachePrefix;
+const validateForeignValues = (database, version, relation, value) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!value) {
+        return true;
+    }
+    const foreignModel = version.modelList
+        .get()
+        .find((model) => model.name === relation.model);
+    if (!foreignModel) {
+        throw new Error(`The model not found: ${relation.model}`);
+    }
+    const found = yield database(foreignModel.instance.table)
+        .where(foreignModel.instance.primaryKey, value)
+        .first();
+    return !!found;
+});
+const getForeignKeyValueErrors = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const { model, database, version } = context;
+    // Getting all foreign rules.
+    const foreignRelations = model.relations.filter((relation) => relation.type === Enums_1.Relationships.HAS_ONE);
+    const tasks = [];
+    for (const relation of foreignRelations) {
+        const value = context.formData[relation.foreignKey];
+        tasks.push({
+            data: {
+                value,
+                relation,
+            },
+            promise: validateForeignValues(database, version, relation, value),
+        });
+    }
+    const results = yield Promise.all(tasks.map((promise) => promise.promise));
+    return results
+        .map((result, index) => {
+        if (result) {
+            return null;
+        }
+        const data = tasks[index].data;
+        return `Invalid value: ${data.relation.foreignKey} = ${data.value}`;
+    })
+        .filter((error) => error);
+});
+exports.getForeignKeyValueErrors = getForeignKeyValueErrors;
+const getSearchData = (model, item) => {
+    const result = {};
+    if (model.instance.search) {
+        for (const field of model.instance.search) {
+            result[field] = item[field];
+        }
+    }
+    // If there is a deleted at column, we should put it to the index data
+    if (model.instance.deletedAtColumn) {
+        result[model.instance.deletedAtColumn] =
+            item[model.instance.deletedAtColumn];
+    }
+    // We should add the parent relations if there is any
+    const relations = model.relations.filter((relation) => relation.type === Enums_1.Relationships.HAS_ONE);
+    for (const relation of relations) {
+        result[relation.foreignKey] = item[relation.foreignKey];
+    }
+    return result;
+};
+exports.getSearchData = getSearchData;

package/build/src/Handlers/RequestHandler.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+/// <reference types="express" />
 import { IncomingMessage, ServerResponse } from "http";
-declare const _default: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+import { NextFunction } from "connect";
+declare const _default: (request: IncomingMessage, response: ServerResponse, next: NextFunction) => Promise<void>;
 export default _default;

package/build/src/Handlers/RequestHandler.js

@@ -15,30 +15,49 @@ 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 api = Services_1.APIService.getInstance();
 const return404 = (response) => {
     response.statusCode = 404;
     response.write(JSON.stringify({ error: "Resource not found" }));
     response.end();
 };
-const callPhases = (phases, pack, match, trx, axeResponse) => __awaiter(void 0, void 0, void 0, function* () {
-    for (const phase of phases) {
+exports.default = (request, response, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const api = Services_1.APIService.getInstance();
+    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.info("\t🛢 DBTransaction: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(pack);
+            Services_1.LogService.debug(`\t🔄 ${phase.name}()`);
+            phase.callback(context);
             continue;
         }
         // Middleware and hook calls
         try {
-            Services_1.LogService.debug(`\t${phase.name}()`);
-            yield phase.callback(pack);
+            Services_1.LogService.debug(`\t🔄 ${phase.name}()`);
+            yield phase.callback(context);
         }
         catch (error) {
-            Services_1.LogService.error(`\t${error.message} ${phase.callback}`);
+            Services_1.LogService.error(error);
             // Rollback transaction
             if (match.hasTransaction && trx) {
-                Services_1.LogService.warn("\tDB transaction rollback");
+                Services_1.LogService.info("\t🛢 DBTransaction:rollback()");
                 trx.rollback();
             }
             if (error.type === "ApiError") {
@@ -47,53 +66,30 @@ const callPhases = (phases, pack, match, trx, axeResponse) => __awaiter(void 0,
                     .status(apiError.status)
                     .json({ error: apiError.message });
             }
-            // TODO: We need an error handler.
-            axeResponse.status(500).json({ error: error.toString() });
+            next(error);
             break;
         }
         // If the response is not created, we should go to the next phase
-        if (pack.res.isResponded() === false) {
+        if (context.res.isResponded() === false) {
             continue;
         }
         // If the response is an error, and we have an active transaction,
         // we should rollback it before the HTTP request end.
-        if (pack.res.statusCode() >= 400 && pack.res.statusCode() < 599) {
+        if (context.res.statusCode() >= 400 && context.res.statusCode() < 599) {
             if (match.hasTransaction && trx) {
-                Services_1.LogService.warn("\tDB transaction rollback");
+                Services_1.LogService.info("\t🛢 DBTransaction:rollback()");
                 trx.rollback();
             }
-            Services_1.LogService.debug(`\tResponse ${pack.res.statusCode()}`);
+            Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
             break;
         }
-        // If there is a valid transaction, we should commit it
+        // We should commit the transaction if there is any
         if (match.hasTransaction && trx) {
-            Services_1.LogService.warn("\tDB transaction commit");
+            Services_1.LogService.info("\t🛢 DBTransaction:commit()");
             trx.commit();
         }
-        Services_1.LogService.debug(`\tResponse ${pack.res.statusCode()}`);
+        Services_1.LogService.debug(`\t🟢 Response ${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 pack = 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, pack, match, trx, axeResponse);
-});

package/build/src/Handlers/{DocsHTMLHandler.js → SwaggerHandler.js}

@@ -8,17 +8,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const CLOUD_FRONT_DOMAIN = "https://dw7lgbuj348m4.cloudfront.net/v1";
+const SwaggerBuilder_1 = __importDefault(require("../Builders/SwaggerBuilder"));
+const Services_1 = require("../Services");
 exports.default = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const result = yield fetch(`${CLOUD_FRONT_DOMAIN}/index.html`);
-        const content = (yield result.text())
-            .replaceAll(`src="`, `src="${CLOUD_FRONT_DOMAIN}`)
-            .replaceAll(`href="`, `href="${CLOUD_FRONT_DOMAIN}`);
-        res.send(content);
+        res.json(yield (0, SwaggerBuilder_1.default)());
     }
     catch (error) {
-        res.send("404");
+        Services_1.LogService.error(error);
+        res.status(500).json({ error: error.message });
     }
 });