axe-api 1.0.0-rc8 → 1.0.0

package/build/index.d.ts

@@ -6,4 +6,5 @@ import { IoCService, allow, deny, App, AxeRequest, AxeResponse } from "./src/Ser
 import { rateLimit } from "./src/Middlewares/RateLimit";
 export * from "./src/Enums";
 export * from "./src/Interfaces";
+export * from "./src/Types";
 export { App, AxeRequest, AxeResponse, Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, rateLimit, };

package/build/index.js

@@ -38,3 +38,4 @@ const RateLimit_1 = require("./src/Middlewares/RateLimit");
 Object.defineProperty(exports, "rateLimit", { enumerable: true, get: function () { return RateLimit_1.rateLimit; } });
 __exportStar(require("./src/Enums"), exports);
 __exportStar(require("./src/Interfaces"), exports);
+__exportStar(require("./src/Types"), exports);

package/build/src/Builders/IndexBuilder.d.ts

@@ -0,0 +1,7 @@
+import { IVersion } from "../Interfaces";
+declare class IndexBuilder {
+    private version;
+    constructor(version: IVersion);
+    build(): Promise<void>;
+}
+export default IndexBuilder;

package/build/src/Builders/IndexBuilder.js

@@ -0,0 +1,35 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Services_1 = require("../Services");
+class IndexBuilder {
+    constructor(version) {
+        this.version = version;
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Filtering the models that need Elastic Search index
+            const models = this.version.modelList
+                .get()
+                .filter((model) => model.instance.search);
+            // No need to create any index
+            if (models.length === 0) {
+                return;
+            }
+            const elastic = yield Services_1.IoCService.use("Elastic");
+            // Creating index for each model
+            for (const model of models) {
+                elastic.createIndex(model.name);
+            }
+        });
+    }
+}
+exports.default = IndexBuilder;

package/build/src/Builders/ModelTreeBuilder.js

@@ -59,7 +59,8 @@ class ModelTreeBuilder {
         this.version.modelList.get().forEach((model) => {
             const recursiveRelations = model.relations.filter((relation) => relation.model === model.name);
             if (recursiveRelations.length === 2) {
-                tree.push(Object.assign(Object.assign({}, model), { isRecursive: true, children: [] }));
+                model.setAsRecursive();
+                tree.push(model);
             }
         });
     }

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);
@@ -51,11 +51,11 @@ class RouterBuilder {
     createRoutesByModelTree() {
         return __awaiter(this, void 0, void 0, function* () {
             for (const model of this.version.modelTree) {
-                yield this.createRouteByModel(model);
+                yield this.createRouteByModel(model, []);
             }
         });
     }
-    createRouteByModel(model, urlPrefix = "", parentModel = null, relation = null, allowRecursive = true) {
+    createRouteByModel(model, parentPairs = [], urlPrefix = "", parentModel = null, relation = null, allowRecursive = true) {
         return __awaiter(this, void 0, void 0, function* () {
             if (model.instance.ignore) {
                 return;
@@ -76,9 +76,9 @@ class RouterBuilder {
                     ...model.instance.getMiddlewares(handlerType),
                 ];
                 // Adding the endpoint
-                yield this.addRoute(handlerType, url, middlewares, model, parentModel, relation);
+                yield this.addRoute(handlerType, url, middlewares, model, parentPairs, parentModel, relation);
             }
-            yield this.createChildRoutes(model, resource, urlPrefix);
+            yield this.createChildRoutes(model, resource, urlPrefix, parentPairs);
             yield this.createNestedRoutes(model, allowRecursive, urlPrefix, resource);
         });
     }
@@ -91,11 +91,16 @@ class RouterBuilder {
             const relation = model.relations.find((relation) => relation.model === model.name &&
                 relation.type === Enums_1.Relationships.HAS_MANY);
             if (relation) {
-                yield this.createRouteByModel(model, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation, false);
+                const paramName = (0, change_case_1.camelCase)(`${model.name}-${relation.primaryKey}`);
+                const parentPair = {
+                    model,
+                    paramName,
+                };
+                yield this.createRouteByModel(model, [parentPair], `${urlPrefix}${resource}/:${paramName}/`, model, relation, false);
             }
         });
     }
-    createChildRoutes(model, resource, urlPrefix) {
+    createChildRoutes(model, resource, urlPrefix, parentPairs) {
         return __awaiter(this, void 0, void 0, function* () {
             if (model.children.length === 0) {
                 return;
@@ -106,12 +111,18 @@ class RouterBuilder {
                 const child = model.children.find((item) => item.name === relation.model);
                 // It should be recursive
                 if (child) {
-                    yield this.createRouteByModel(child, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation);
+                    const paramName = (0, change_case_1.camelCase)(`${model.name}-${relation.primaryKey}`);
+                    // Setting the new parent pair depth
+                    const parentPair = {
+                        model,
+                        paramName,
+                    };
+                    yield this.createRouteByModel(child, [...parentPairs, parentPair], `${urlPrefix}${resource}/:${paramName}/`, model, relation);
                 }
             }
         });
     }
-    addRoute(handlerType, url, middlewares, model, parentModel, relation) {
+    addRoute(handlerType, url, middlewares, model, parentPairs, parentModel, relation) {
         return __awaiter(this, void 0, void 0, function* () {
             const docs = Services_1.DocumentationService.getInstance();
             const data = {
@@ -122,9 +133,9 @@ class RouterBuilder {
                 relation,
             };
             // Adding the route
-            yield URLService_1.default.add(constants_1.HANDLER_METHOD_MAP[handlerType], url, data, middlewares);
+            yield URLService_1.default.add(constants_1.HANDLER_METHOD_MAP[handlerType], url, data, middlewares, parentPairs);
             // Documentation
-            docs.push(this.version, handlerType, constants_1.HANDLER_METHOD_MAP[handlerType], url, model);
+            docs.push(this.version, handlerType, constants_1.HANDLER_METHOD_MAP[handlerType], url, model, parentModel);
         });
     }
     getResourcePath(model, relation) {

package/build/src/Builders/SwaggerBuilder.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<any>;
+export default _default;