axe-api 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Release Notes
 
+## [0.22.0 (2023-01-29)](https://github.com/axe-api/axe-api/compare/0.22.0...0.21.0)
+
+### Features
+
+- Added Soft-Deleting feature [#41](https://github.com/axe-api/axe-api/issues/41)
+
+### Fixed
+
+- Fixed model relation route URLs [#141](https://github.com/axe-api/axe-api/issues/141)
+
 ## [0.21.0 (2022-12-28)](https://github.com/axe-api/axe-api/compare/0.21.0...0.20.4)
 
 ### Features

package/build/src/Builders/RouterBuilder.js

@@ -113,13 +113,12 @@ class RouterBuilder {
                 return;
             }
             // We should different parameter name for child routes
-            const primaryKey = this.getPrimaryKeyName(model);
             const subRelations = model.relations.filter((item) => item.type === Enums_1.Relationships.HAS_MANY);
             for (const relation of subRelations) {
                 const child = model.children.find((item) => item.name === relation.model);
                 // It should be recursive
                 if (child) {
-                    yield this.createRouteByModel(child, modelList, `${urlPrefix}${resource}/:${primaryKey}/`, model, relation);
+                    yield this.createRouteByModel(child, modelList, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation);
                 }
             }
         });
@@ -140,6 +139,10 @@ class RouterBuilder {
                     app.delete(url, middlewares, handler);
                     docs.push(Enums_1.HttpMethods.DELETE, url, model);
                     break;
+                case Enums_1.HandlerTypes.FORCE_DELETE:
+                    app.delete(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.DELETE, url, model);
+                    break;
                 case Enums_1.HandlerTypes.INSERT:
                     app.post(url, middlewares, handler);
                     docs.push(Enums_1.HttpMethods.POST, url, model);

package/build/src/Enums.d.ts

@@ -24,6 +24,7 @@ export declare enum HandlerTypes {
     SHOW = "show",
     UPDATE = "update",
     DELETE = "destroy",
+    FORCE_DELETE = "force_delete",
     PATCH = "patch",
     ALL = "all"
 }
@@ -33,6 +34,8 @@ export declare enum HookFunctionTypes {
     onBeforeUpdate = "onBeforeUpdate",
     onBeforeDeleteQuery = "onBeforeDeleteQuery",
     onBeforeDelete = "onBeforeDelete",
+    onBeforeForceDeleteQuery = "onBeforeForceDeleteQuery",
+    onBeforeForceDelete = "onBeforeForceDelete",
     onBeforePaginate = "onBeforePaginate",
     onBeforeAll = "onBeforeAll",
     onBeforeShow = "onBeforeShow",
@@ -41,6 +44,8 @@ export declare enum HookFunctionTypes {
     onAfterUpdate = "onAfterUpdate",
     onAfterDeleteQuery = "onAfterDeleteQuery",
     onAfterDelete = "onAfterDelete",
+    onAfterForceDeleteQuery = "onAfterForceDeleteQuery",
+    onAfterForceDelete = "onAfterForceDelete",
     onAfterPaginate = "onAfterPaginate",
     onAfterAll = "onAfterAll",
     onAfterShow = "onAfterShow"

package/build/src/Enums.js

@@ -30,6 +30,7 @@ var HandlerTypes;
     HandlerTypes["SHOW"] = "show";
     HandlerTypes["UPDATE"] = "update";
     HandlerTypes["DELETE"] = "destroy";
+    HandlerTypes["FORCE_DELETE"] = "force_delete";
     HandlerTypes["PATCH"] = "patch";
     HandlerTypes["ALL"] = "all";
 })(HandlerTypes = exports.HandlerTypes || (exports.HandlerTypes = {}));
@@ -40,6 +41,8 @@ var HookFunctionTypes;
     HookFunctionTypes["onBeforeUpdate"] = "onBeforeUpdate";
     HookFunctionTypes["onBeforeDeleteQuery"] = "onBeforeDeleteQuery";
     HookFunctionTypes["onBeforeDelete"] = "onBeforeDelete";
+    HookFunctionTypes["onBeforeForceDeleteQuery"] = "onBeforeForceDeleteQuery";
+    HookFunctionTypes["onBeforeForceDelete"] = "onBeforeForceDelete";
     HookFunctionTypes["onBeforePaginate"] = "onBeforePaginate";
     HookFunctionTypes["onBeforeAll"] = "onBeforeAll";
     HookFunctionTypes["onBeforeShow"] = "onBeforeShow";
@@ -48,6 +51,8 @@ var HookFunctionTypes;
     HookFunctionTypes["onAfterUpdate"] = "onAfterUpdate";
     HookFunctionTypes["onAfterDeleteQuery"] = "onAfterDeleteQuery";
     HookFunctionTypes["onAfterDelete"] = "onAfterDelete";
+    HookFunctionTypes["onAfterForceDeleteQuery"] = "onAfterForceDeleteQuery";
+    HookFunctionTypes["onAfterForceDelete"] = "onAfterForceDelete";
     HookFunctionTypes["onAfterPaginate"] = "onAfterPaginate";
     HookFunctionTypes["onAfterAll"] = "onAfterAll";
     HookFunctionTypes["onAfterShow"] = "onAfterShow";

package/build/src/Handlers/AllHandler.js

@@ -20,6 +20,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const conditions = queryParser.get(req.query);
     // Creating a new database query
     const query = database.from(model.instance.table);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, conditions, query);
     // Users should be able to select some fields to show.
     queryParser.applyFields(query, conditions.fields);
     // Binding parent id if there is.

package/build/src/Handlers/DestroyHandler.js

@@ -20,6 +20,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const query = database
         .from(model.instance.table)
         .where(model.instance.primaryKey, req.params[model.instance.primaryKey]);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, null, query);
     // If there is a relation, we should bind it
     (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeDeleteQuery, Object.assign(Object.assign({}, pack), { query }));
@@ -31,7 +33,15 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         item }));
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeDelete, Object.assign(Object.assign({}, pack), { query,
         item }));
-    yield query.delete();
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    if (model.instance.deletedAtColumn) {
+        yield query.update({
+            [model.instance.deletedAtColumn]: new Date(),
+        });
+    }
+    else {
+        yield query.delete();
+    }
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterDelete, Object.assign(Object.assign({}, pack), { item }));
     return res.json();
 });

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

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../Interfaces";
+declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
+export default _default;

package/build/src/Handlers/ForceDestroyHandler.js

@@ -0,0 +1,41 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("./Helpers");
+const Enums_1 = require("../Enums");
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const { model, req, res, database, relation, parentModel } = pack;
+    const query = database
+        .from(model.instance.table)
+        .where(model.instance.primaryKey, req.params[model.instance.primaryKey]);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    if (model.instance.deletedAtColumn === null) {
+        throw new ApiError_1.default("You can use force delete only soft-delete supported models.");
+    }
+    // If there is a relation, we should bind it
+    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeForceDeleteQuery, Object.assign(Object.assign({}, pack), { query }));
+    const item = yield query.first();
+    if (!item) {
+        throw new ApiError_1.default(`The item is not found on ${model.name}.`);
+    }
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterForceDeleteQuery, Object.assign(Object.assign({}, pack), { query,
+        item }));
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeForceDelete, Object.assign(Object.assign({}, pack), { query,
+        item }));
+    yield query.delete();
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterForceDelete, Object.assign(Object.assign({}, pack), { item }));
+    return res.json();
+});

package/build/src/Handlers/HandlerFactory.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const AllHandler_1 = __importDefault(require("./AllHandler"));
 const DestroyHandler_1 = __importDefault(require("./DestroyHandler"));
+const ForceDestroyHandler_1 = __importDefault(require("./ForceDestroyHandler"));
 const PaginateHandler_1 = __importDefault(require("./PaginateHandler"));
 const PatchHandler_1 = __importDefault(require("./PatchHandler"));
 const UpdateHandler_1 = __importDefault(require("./UpdateHandler"));
@@ -18,6 +19,8 @@ class HandlerFactory {
                 return AllHandler_1.default;
             case Enums_1.HandlerTypes.DELETE:
                 return DestroyHandler_1.default;
+            case Enums_1.HandlerTypes.FORCE_DELETE:
+                return ForceDestroyHandler_1.default;
             case Enums_1.HandlerTypes.INSERT:
                 return StoreHandler_1.default;
             case Enums_1.HandlerTypes.PAGINATE:

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

@@ -1,5 +1,5 @@
 import { Request } from "express";
-import { IModelService, IRelation, IHookParameter } from "../Interfaces";
+import { IModelService, IRelation, IHookParameter, IQuery } from "../Interfaces";
 import { Knex } from "knex";
 import { IWith } from "../Interfaces";
 import { HandlerTypes, HookFunctionTypes, TimestampColumns } from "../Enums";
@@ -11,4 +11,5 @@ export declare const getParentColumn: (relation: IRelation | null) => string | n
 export declare const addForeignKeyQuery: (request: Request, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
 export declare const serializeData: (itemArray: any[] | any, modelSerializer: (data: any, request: Request) => void, handler: HandlerTypes, request: Request) => 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: (data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: Request) => Promise<void>;

package/build/src/Handlers/Helpers.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelatedData = exports.filterHiddenFields = exports.serializeData = exports.addForeignKeyQuery = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
+exports.getRelatedData = exports.addSoftDeleteQuery = exports.filterHiddenFields = exports.serializeData = exports.addForeignKeyQuery = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
 const change_case_1 = require("change-case");
 const Enums_1 = require("../Enums");
 const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
@@ -138,6 +138,14 @@ const filterHiddenFields = (itemArray, hiddens) => {
     });
 };
 exports.filterHiddenFields = filterHiddenFields;
+const addSoftDeleteQuery = (model, conditions, query) => {
+    // TODO: Trashed feature will be implemented later
+    // (conditions === null || conditions?.trashed === false)
+    if (model.instance.deletedAtColumn) {
+        query.whereNull(model.instance.deletedAtColumn);
+    }
+};
+exports.addSoftDeleteQuery = addSoftDeleteQuery;
 const getRelatedData = (data, withArray, model, modelList, database, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
     if (withArray.length === 0) {
         return;
@@ -192,10 +200,13 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
             selectColumns.push(...requiredForeignKeys);
         }
         selectColumns = uniqueByMap(selectColumns);
+        const foreignModelQuery = database(foreignModel.instance.table).select(selectColumns);
+        // If the model is supported soft-delete we should check the data.
+        if (foreignModel.instance.deletedAtColumn) {
+            foreignModelQuery.whereNull(foreignModel.instance.deletedAtColumn);
+        }
         // Fetching related records by foreignKey and primary key values.
-        let relatedRecords = yield database(foreignModel.instance.table)
-            .select(selectColumns)
-            .whereIn(searchFieldKey, parentPrimaryKeyValues);
+        let relatedRecords = yield foreignModelQuery.whereIn(searchFieldKey, parentPrimaryKeyValues);
         // We should serialize related data if there is any serialization function
         relatedRecords = yield (0, exports.serializeData)(relatedRecords, foreignModel.instance.serialize, handler, request);
         // We should hide hidden fields if there is any

package/build/src/Handlers/PaginateHandler.js

@@ -20,6 +20,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const conditions = queryParser.get(req.query);
     // Creating a new database query
     const query = database.from(model.instance.table);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, conditions, query);
     // Users should be able to select some fields to show.
     queryParser.applyFields(query, conditions.fields);
     // Binding parent id if there is.

package/build/src/Handlers/PatchHandler.js

@@ -21,6 +21,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const query = database.from(model.instance.table);
     // If there is a relation, we should bind it
     (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, null, query);
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeUpdateQuery, Object.assign(Object.assign({}, pack), { query }));
     let item = yield query
         .where(model.instance.primaryKey, req.params[model.instance.primaryKey])

package/build/src/Handlers/ShowHandler.js

@@ -24,6 +24,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const conditions = queryParser.get(req.query);
     // Fetching item
     const query = database.from(model.instance.table);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, conditions, query);
     // Users should be able to select some fields to show.
     queryParser.applyFields(query, conditions.fields);
     // If there is a relation, we should bind it

package/build/src/Handlers/UpdateHandler.js

@@ -21,6 +21,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const query = database.from(model.instance.table);
     // If there is a relation, we should bind it
     (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, null, query);
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeUpdateQuery, Object.assign(Object.assign({}, pack), { query }));
     let item = yield query
         .where(model.instance.primaryKey, req.params[model.instance.primaryKey])

package/build/src/Interfaces.d.ts

@@ -120,6 +120,7 @@ export interface IRawQuery {
     sort: string | null;
     fields: string | null;
     with: string | null;
+    trashed: string | null;
 }
 export interface ISortField {
     name: string;
@@ -138,6 +139,7 @@ export interface IQuery {
     sort: ISortField[];
     fields: string[];
     with: IWith[];
+    trashed: boolean;
 }
 export interface IWhere {
     prefix: string | null;

package/build/src/Model.d.ts

@@ -11,6 +11,7 @@ declare class Model {
     get hiddens(): string[];
     get createdAtColumn(): string | null;
     get updatedAtColumn(): string | null;
+    get deletedAtColumn(): string | null;
     get transaction(): boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[] | null;
     get ignore(): boolean;
     getFillableFields(methodType: HttpMethods): string[];

package/build/src/Model.js

@@ -35,6 +35,9 @@ class Model {
     get updatedAtColumn() {
         return "updated_at";
     }
+    get deletedAtColumn() {
+        return null;
+    }
     get transaction() {
         return null;
     }

package/build/src/Services/QueryService.js

@@ -175,6 +175,9 @@ class QueryService {
             sort: this.parseSortingOptions(sections.sort),
             q: this.parseCondition(sections.q),
             with: withQueryResolver.resolve((sections === null || sections === void 0 ? void 0 : sections.with) || ""),
+            trashed: (sections === null || sections === void 0 ? void 0 : sections.trashed)
+                ? sections.trashed.trim() === "true" || sections.trashed.trim() === "1"
+                : false,
         };
         this.addRelationColumns(query.with);
         return query;

package/build/src/Services/SchemaValidatorService.js

@@ -57,6 +57,9 @@ class SchemaValidatorService {
             if (model.instance.updatedAtColumn) {
                 columns.push(model.instance.updatedAtColumn);
             }
+            if (model.instance.deletedAtColumn) {
+                columns.push(model.instance.deletedAtColumn);
+            }
             return columns;
         };
         this.checkHasManyRelation = (modelList, model, relation) => {

package/build/src/constants.d.ts

@@ -20,4 +20,5 @@ export declare const API_ROUTE_TEMPLATES: {
     update: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
     patch: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
     destroy: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
+    force_delete: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
 };

package/build/src/constants.js

@@ -46,6 +46,7 @@ exports.DEFAULT_METHODS_OF_MODELS = [
     "hiddens",
     "createdAtColumn",
     "updatedAtColumn",
+    "deletedAtColumn",
     "transaction",
     "ignore",
     "getFillableFields",
@@ -59,4 +60,5 @@ exports.API_ROUTE_TEMPLATES = {
     [Enums_1.HandlerTypes.UPDATE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
     [Enums_1.HandlerTypes.PATCH]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
     [Enums_1.HandlerTypes.DELETE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
+    [Enums_1.HandlerTypes.FORCE_DELETE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}/force`,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "AXE API is a simple tool which has been created based on Express and Knex.js to create Rest APIs quickly.",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/readme.md

@@ -145,30 +145,6 @@ If you can see that response, it means that your project is running properly.
 
 Axe API has great documentation. Please [check it out in here](https://axe-api.com/).
 
-## How To Run Integration Tests
-
-> You have to have **Docker** and **Docker Compose** on your local development environment to run integration tests.
-
-Execute the following commands to prepare the integration app
-
-```sh
-cd tests/integrations && npm install && npm ci && npm run build --if-present
-```
-
-Execute the following commands to prepare the database;
-
-```sh
-docker-compose -f "./tests/integrations/docker-compose.mysql8.yml" up -d --build
-```
-
-> To down the database, you can use the following command; `docker-compose -f "./tests/integrations/docker-compose.mysql8.yml" up -d --build`
-
-You can execute the following command to execute tests;
-
-```sh
-npm run test:integration:mysql8
-```
-
 ## License
 
 [MIT License](LICENSE)